Vorbereitungen

Zuerst legen wir ein neues Java-Projekt an und kopieren die zwei Bilder in den Projektordner:

Die vorgegebene Java-Datei wird nun in den "src-Ordner" kopiert. Nach diesen paar Kopiervorgängen aktualisiert man in Eclipse den Package-Explorer (mit F5) und schon erscheinen die zwei Bilder und die Java-Datei.

Farbenlehre

In dieser Aufgabe müssen wir Farbinformationen aus den vorgegebenen Bildern manipulieren. Dies soll alles in der Methode filterRGB der Klasse TestFilter passieren.

filterRGB bekommt bei jedem Aufruf die Farbinformation eines Pixels als Integer-Wert (Variable: pixel) übergeben und soll den veränderten Farbwert in der Variable filteredPixel zurückgeben.

Dies geht einfach, wenn wir die Farbinformationen mit der &-Operation (Bitweises und) verknüpfen.

Also FARBE & FILTER = ERGEBNIS.

Wie geht das?

Der &-Operator vergleicht jedes Bit zweier Bitfolgen und setzt eine "1", wenn beide Bitfolgen an der gleichen Stelle eine "1" haben - und eine "0" wenn dies nicht zutrifft.

(Ein int-Wert hat 32 Bit. Hier soll nur gezeigt werden, wie der &-Operator arbeitet!)

Den Filter schreiben wir in Hexadezimaler Schreibweise:

z. B.: 0xff112233 (Jede "Ziffer" entspricht 4 Bits - int-Zahl hat 32 Bits => 8 "Ziffern" lang)

Die ersten 8 Bits, also "ff" (von links) entsprechen dem Alpha-Wert, also der Transparenz der Farbe.

Die nächsten 8 Bits ("11") repräsentieren den Rot-Anteil der Farbe.

Die vorletzten 8 Bits ("22") repräsentieren den Grün-Anteil der Farbe.

Die letzten 8 Bits ("33") repräsentieren den Blau-Anteil der Farbe.

Jeder dieser Farbanteile hat 8 Bits und kann somit Werte zwischen 0 und 255 (dezimal) oder 00 und ff (hexadezimal) annehmen.

Mit diesem Hintergrundwissen können wir uns nun an die Aufgaben wagen ;)

Farben filtern

Um die entsprechenden Farben aus dem Bild zu filtern, müssen wir lediglich unseren Filter anpassen!

Rot:

Der rote Farbanteil wird in den zweiten 8 Bits gespeichert. Setzen wir diese nun auf "0", da wir diese Farbe im Ergebnis nicht haben wollen. Die restlichen Bits müssen natürlich auf "1" stehen, da diese Farben ja erhalten bleiben sollen.

in Hex-Schreibweise sieht unser Filter dann so aus: 0xff00ffff

filteredPixel = (pixel & 0xff00ffff)

Grün & Blau:

Wenn wir die Grün oder Blauanteile aus dem Bild entfernen wollen, müssen wir statt der roten - die grüne oder blaue Farbinformation beim Filter "auf 0 setzen".

Bild anmalen

Wollen wir jedem Pixel des Bildes die gleiche Farbe verpassen, so weisen wir einfach filteredPixel eine bestimmte Farbe zu! Dies können wir mit einem Hexadezimalen Wert oder mit einem Int-Wert (negativ!) machen.

filteredPixel = (0xff4e56ac)

filteredPixel = -234234

Farbanteile vertauschen

Um bei einem Bild die Farbanteile vertauschen zu können, müssen wir die Farbanteile auslesen und anschließend vertauscht wieder zuweisen.

Hier wird r der rote, g der grüne und b der blaue Farbwert zugewiesen:

        int r = ((pixel & 0xff0000) >> 16);
        int g = ((pixel & 0xff00) >> 8);
        int b = (pixel & 0xff);

Rot muss um 16 Bits nach rechts verschoben werden, damit wir eine int-Zahl erhalten, die zwischen 0 und 255 ist. Grün muss um 8 Bits verschoben werden. Blau muss nicht verschoben werden, da es ja sowieso ganz rechts steht.

Um nun z. B. Rot und Blau zu vertauschen muss man nun die Grün wieder 8 Bits nach links und die Blau um 16 Bits nach links verschieben. Die Rot muss nicht verschoben werden, da sie schon an der "blauen-Position" ist!

Diese Farbinformationen werden mit dem |-Operator (Bitweises oder) verknüpft. Ist ein Bit von A oder von B "1", wird "1" zurückgeliefert.

filteredPixel = (pixel & 0xff000000) | b << 16 | g << 8 | r

Hell oder Dunkel

Um herauszufinden, ob eine Farbe hell oder dunkel ist, brauchen wir ihren Grauwert. (Mittelwert aus r, g und b) Ist dieser Wert über oder unter einem gewissen Schwellenwert, so wird die Farbe des Pixels behalten oder durch Schwarz/Weiß ersetzt.

Hier die Vorgehensweise bei der Darstellung von hellen Bildteilen:

int c = (r + g + b) / 3;
if(c > 127){
    filteredPixel = (0xffffffff);
} else {
    filteredPixel = pixel;
}

Aufhellen

Um ein Bild aufzuhellen müssen nur alle Farbwerte mit einem gewissen Faktor ( > 1) multipliziert werden. Allerdings sollte man beachten, dass der entstandene Wert die 255 nicht überschreitet!

Hier die Aufhellung des blauen Bildanteils:

 b *= 1.5;

if(b > 255){
    b = 255;
}

filteredPixel = (pixel & 0xff000000) | r << 16 | g << 8 | b;

Graue Bilder

Ein Grauwertbild erhält man, in dem man den Mittelwert aller Farbwerte jeder Farbinformation zuweist.

int c = (r + g + b) / 3;
filteredPixel = (pixel & 0xff000000) | c << 16 | c << 8 | c;

Um das Bild Schwarz/Weiß darzustellen müssen wir wie bei der Darstellung der hellen und dunklen Bildteile vorgehen. Also einen Schwellenwert festlegen (> 0 und < 255) und überprüfen ob der Mittelwert der aktuellen Pixelfarbe größer oder kleiner dem Schwellenwert ist. Je nach dem wird das Bild schwarz (0xff000000) oder weiß (0xffffffff) angemalt.