Specialeffekter och spelutveckling i Java(TM) - Filter 

av Anibal Wainstein

7.1 Filter

Om du någon gång får för dig att börja konkurrera med Adobe's eller JASC's bildbehandlingsprogram så kan det vara bra att veta hur man skapar filter. Filtrering betyder att du använder dig av de tre RGB-komponenterna för att sedan utföra en beräkning på dem. Det kan t.ex. vara att du gör bilden ljusare eller mörkare (adderar eller drar bort ett värde), sätter någon av dem till noll (BlueComponent exemplet), gör om till gråskala m.m. Möjligheterna begränsas bara av din kreativitet. Du kan göra en stor del av bildbehandling i real-tid, och då använda dessa i animationer. Man kan därför göra specialeffekter som konkurerrar med filmbolagens, med skillnaden att dessa effekter kan användas på din hemsida.

7.1.1 Hur man kommer åt varje färgkomponent

För att kunna göra mer avancerad bildbehandling så behöver du ibland komma åt en eller flera av RGB-komponenterna i ett pixelvärde för att kunna manipulera dem. I avsnitt 7.0.5 så gick jag igenom hur man kan maskera bort komponenter ur ett färgvärde. Nu kanske du tycker att det enda du behöver göra är att maska bort alla andra komponenter, inklusive alfa-kanalen, för att kunna komma åt den komponent du vill ha. Detta fungerar för blåkomponenten, men röd- och blåkomponenterna kommer att vara skiftade med 2 resp. 1 byte (16 resp 8 bitar). Här kan vi nu använda högerskiftoperatorn ">>" som man kan använda för att flytta på bitarna i talet åt vänster, den dividerar i steg med 2 för varje värde på operatorns högra argument. Du kanske undrar, varför använda högerskiftoperatorn när vi kan dividera med 256 på samma sätt som vi multiplicerade med 256 förut när vi byggde upp ett värde? Division i Java är mycket mer krävande än att skifta med skiftoperatorena (<< och >>), man bör alltså använda skiftoperatorer för att snabba upp beräkningarna. Följande exempel illustrerar dess funktion:

0x12345678 >> 16 = 0x00001234
0x12345678 >> 8  = 0x00123456
0xffffffff >> 24 = 0x000000ff

I exemplen ovan så flyttar vi bitarna med 16, 8 resp. 24 steg åt höger (det motsvarar en förflyttning av 2, 1 resp. 3 bytes). Processen går till så att först maskerar vi bort alla komponenter förutom den vi vill manipulera och efter det använder högerskiftoperatorn. Anta att vi har ett pixelvärde 0xff2f3f4f och vi vill kunna arbeta med varje komponent, varje komponent kan man då komma åt med följande rader:

int pixelvalue=0xff2f3f4f;

//alfa-kanalen kan vara bra att komma åt i den händelse
//att du vill undersöka om bilden är transparent.
int alfa=(pixelvalue&0xff000000)>>24;

//Rödkomponenten (värdet 2f) kommer man åt så här.
int r=(pixelvalue&0x00ff0000)>>16;

//Grönkomponenten (värdet 3f).
int g=(pixelvalue&0x0000ff00)>>8;

//Blåkomponenten (värdet 4f) behöver inte skiftas.
int b=pixelvalue&0x000000ff;

Efter det här, och när beräkningarna är färdiga, då kan du använda följande rad för att bygga ihop färgvärdet igen:

//Nu använder vi vänsterskiftoperatorn (<<) för att bygga 
//upp färgvärdet igen, istället för att multiplicera i 
//steg med 256.
pixelvalue=(alfa<<24)+(r<<16)+(g<<8)+b;

Här kan man använda vänsteskiftoperatorn (<<) istället för att multiplicera. Observera att parenteserna kring skiftuttrycken är livsviktiga (annars utförs summeringen FÖRE skiftningen). Om du fortfarande inte förstår hur skiftoperatorn fungerar så kan du se att följande rad ger exakt samma resultat som raden ovan:

//Det ser mycket krångligare ut om man använder
//multiplikation.
pixelvalue=(alfa*256*256*256)+(r*256*256)+(g*256)+b;

Vänsterskiftoperatorn är dock snabbare än multiplikation, så vi kommer att använda den istället.

Nästa sida >>