[java] alpha blending in images

[Johnny]

Ik wil afbeeldingen geleidelijk in elkaar over laten lopen doormiddel van alpha blending.

De ingevoerde afbeeldingen zijn allemaal helemaal 100% zichtbaar, ze zijn 24 bits zonder alpha kanaal.

Ze moeten echter aan een andere afbeelding worden geplakt met een mooie overgang, daarom moeten de afbeeldingen links 0% zichtbaar worden, en dan geleidelijk naar 100% zichtbaar overlopen voordat hij bovenop de andere afbeelding wordt geplakt.

Zo dus:


Maar wat is de beste manier om dat te doen? Ik heb al wat zitten spelen met Java2D en AlphaComposite, maar daarmee kan ik alleen een heel object een transparantie geven. Ik zou de afbeelding wel in verticale lijnen kunnen knippen en dan iedere lijn een andere hoeveelheid transparantie geven, dat lijkt me niet de beste manier.

Het handigst zou zijn om afhankelijk van de locatie van een pixel een alpha waarde toe te kennen, maar waarmee doe ik dat?

[FendtVario]

Is Jimi niets voor je?

[tjerkw]

Dit is wel mogelijk met Java2D,

hoe precies kan ik je niet 123 zeggen,

mischien heb je hier wat aan:
http://www.apl.jhu.edu/~h...D-Tutorial-Paint-Example1

[Johnny]

Het is me inmiddels gelukt!

Er is nog een nadeel in mijn implementatie, de overloop van onzichtbaar naar zichtbaar moet een lengte hebben van 16, 32, 64, 128, 256, enz pixels omdat dan de stappen gelijkmatig blijven.

Het kleurnummer wat je terug krijgt is namelijk een 32 bits hexadecimaal getal in het volgende formaat: 0xAARRGGBB

Om het Alpha kanaal te wijzigen tel ik dus 0x01000000 daar bij op waardoor de transparantie steeds verder verloopt. Dat werkt alleen echter als de verloop ook 256 pixels lang is, anders stopt hij halfverwege. Als ik echter een meervoud van 0x01000000 doe kan ik echter ook kortere verlopen doen, door iedere keer 0x02000000 er bij op te tellen heb ik er nog maar 128 pixels nodig.

Dus als iemand nog een manier weet om ook andere lengtes te kunnen gebruiken...

Java:

private BufferedImage getBlendedImage(BufferedImage image) {

    int imageWidth = image.getWidth();
    int imageHeight = image.getHeight();

//variabel
    int scanWidth = 70;
    
    int factor = 1;
    int newScanWidth = 0;
    
    //zorg dat de fade-lengte altijd een factor2 getal is 
    while(newScanWidth <= scanWidth) {
        
        newScanWidth = factor * 2;
        
        factor = factor * 2;
    }
    
    scanWidth = newScanWidth / 2;
    
    int scanHeight = imageHeight;
    
    int[] rgbArray = new int[scanWidth * scanHeight];
    
    image.getRGB(0, 0, scanWidth, scanHeight, rgbArray, 0, scanWidth);

    int increment = 0x0000000;
    
    int posX = 0;
    
    int amount = 0x00000000;
    
    int amountCounter = (256 / scanWidth);

    //zet de hoeveelheid transparantie voor iedere stap
    for(int i = 0; i < amountCounter; i++) {
        
        amount += 0x01000000;
    }
    

    for(int i = 0; i < rgbArray.length; i++) {

        if(posX < scanWidth) {
        increment += amount;
        } else {
        increment = 0x01000000;
        posX = 0;
        }
        
        rgbArray[i] += increment;
        
        posX++;
    }
    
    image.setRGB(0, 0, scanWidth, scanHeight, rgbArray, 0, scanWidth);

    return image;
    }

En nee, de code is (nog) niet netjes. Ik ben al lang blij dat het werkt. Nu moet ik nog uitzoeken hoe je twee afbeeldingen met elkaar vergelijkt.

[ Voor 4% gewijzigd door Johnny op 24-02-2005 00:59 ]