Funktionsweise:

Ich lese die RGBA Daten von vier aneinander liegenden Pixeln aus. z.B. Pixel 1 = 0xFF00FF00. Immer zwei Zeichen stehen für eine Information, also FF = Rotanteil, ... bis 00 = Alphawert.
Nun will ich diese vier Pixel auf einen Pixel legen und muss dazu ja diese vier Uint32 "mischen", also ihren Mittelwert bilden.

Das habe ich folgendermaßen versucht (wahrscheinlich greift ihr euch jetzt an den Kopf, aber ich weiß es nicht besser):

farbeDesNeuenPixels = (farbe1 + farbe2 + farbe3 + farbe4) / 4;

Das funktioniert nicht . Aus 4 Weißen Pixeln wurde ein türkiser Pixel.

Dann habe ich hier im Forum eine Möglichkeit gefunden, die lange Uint32 in 4 Uint8 mit den einzelnen Daten zu zerlegen:

rot1 = farbe1 & 0xff;
gruen1 = (farbe1 >> 8) & 0xff;
blau1 = (farbe1 >> 16) & 0xff;
alpha1 = (farbe1 >> 24) & 0xff;

Was exakt das 0xff darin bewirkt, weiß ich nicht, es sorgt irgendwie dafür, dass egal auf welchem Computer die Uint32 immer von vorne gelesen wird. Ka, wie.

Dann habe ich versucht, die Farben folgendermaßen zu mischen (hier nur ein Ausschnitt):

Zwischenfarbe1 = SDL_MapRGB(arbeitsflaeche->format, (rot1+rot2)/2, (gruen1+gruen2)/2, (blau1+blau2)/2);

Aber dann erscheint gar nichts, oder eventuell schwarze oder transparente Pixel auf dem Bildschirm. Im Grunde mache ich ja auch den selben Fehler wie am Anfang, dass ich die Integer addiere und durch ihre Anzahl teile. Aber wie stelle ich denn den Mittelwert zweier Uint32 oder 8 fest?

So solls eigentlich sein:

Uint32 Farbe1 = 0xFFCC66FF;
Uint32 Farbe2 = 0xDDEE88BB;

//Irgendwas

Uint32 Mischfarbe = 0xEEDD77DD;

Ich denke, für die Leute, die C++ richtig können, ist das wahrscheinlich eine leichte Aufgabe. Aber für mich ist das echt schwer, weil ich einfach nicht weiß, wie das gehen soll. Genauso wenig, wie ich weiß, wie ich die Uint8 wieder zu einer Uint32 zusammenhänge. Ich hoffe jemand kann mir das erklären.

Mittelwert(A,B) = (A+B)/2 = A - (A - B)/2

benutzen. Das ist zwar eine Adddition mehr, aber dafür spart man sich die eventuell Zeitraubende Verwendung eines größeren Types.

edit: Das kann man bestimmt auch verallgemeinern, aber ich habe gerade keine Lust zu rechnen, das Wetter ist so schlecht.

Von daher würde ich eher zu einem Cast raten ( int statt char sollte für die temporäre Aktion wohl drinliegen, ist wahrscheinlich auch am schnellsten). Mir fällt gerade ein, zuerst dividieren ist auch nicht gut, da man dadurch Informationen verliert.

Uint32 Farbe1;
Uint32 Farbe2;
int Zwischenspeicher = Farbe1;
Uint32 Mischfarbe = (Zwischenspeicher + Farbe2)/2;

Funktioniert das?

Uint32 Farbe1;
Uint32 Farbe2;
Uint32 Mischfarbe = Farbe1 / 2.0 + Farbe2 / 2.0;

Uint8 r1,g1,b1,a1; // deine 8-Bit-Werte der ersten Farbe
Uint8 r2,g2,b2,a2; // die der zweiten Farbe

// Misch-Einzelfarben in grösseren Typen (16 Bit reicht für Addition)
Uint16 rm = (r1 + r2) / 2;
Uint16 gm = (g1 + g2) / 2;
// analog b, a

Du musst ja nicht so viele Variablen anlegen, ich hab das hier der Einfachheit halber gemacht. Statt des Uint16 könntest du einfach in einem Ausdruck casten, das hier war nur zur Verdeutlichung. Du kannst das auch auf 4 Farben ausdehnen.

Aber wie bekomme ich die Uint16 dann wieder in eine Uint8

Durch einen ganz normalen Cast. Der zusätzliche Platz wird ja nur temporär gebraucht.

Little Programmer schrieb:

und die 4 RGBA Uint8 zu einer Uint32?

Zum Beispiel durch Bitshifts.

SeppJ, deine Idee ist an sich nicht schlecht, nur musst du bedenken, dass A - B unter Umständen zu einem Unterlauf führt. Nicht viel besser als ein Überlauf.

einfach die groessere zahl als 'A' nehmen:

if(A > B)
    return A - (A-B)/2;
else
    return B - (B-A)/2;

mit mehr als zwei Zahlen ist diese Methode allerdings nicht mehr so gut, wegen zu grossem overhead.

Mit Bitshifts kenne ich mich zwar nciht aus, aber ich werd mich mal darüber schlau machen. Ich glaub' dieses Variablenumformungen sind die beste Idee.

Danke euch allen.