Achieving transparency using RGB values

Newbie & Debugging Questions
#1

Hi!
I am trying to draw a black box with transparency. You know… a black box with like 50% opacity. And I’m not really sure how to do it, I have tried using http://en.wikipedia.org/wiki/Alpha_compositing , but I had no luck. Could anyone explain to me how to do it?
If you are wondering, here is what I have so far which is basically nothing:


public void fillAlpha() {
		int x = 50;
		int y = 50;
		int w = 70;
		int h = 70;
		int background = 0x000000;
		
		for (int yy = y; yy < h + y; yy++) {
			for (int xx = x; xx < w + x; xx++) {
				
				pixels[xx + yy * width] = 0x000000;
				
			}
		}
	}

I have removed the formulas from the wikipedia page because I couldn’t make them work.

#2

Try 0x7F000000

And btw, no matter how transparent the black is, it’s not going to show on a black background. :wink:

#3

Sorry for not explaining very well.
I need to transform the one pixel to a darker pixel thus creating an illusion of transparency. I believe 0x7F000000 will not work because I am using 1 BufferedImage to render things.

The last image on the second row.

#4

The answer depends on a lot of details which you have omitted. The simple case is that the pixels array is the backing array of an opaque BufferedImage and what you really want to do is just a per-pixel blending calculation on top of the existing opaque colour. A more complicated case would be that the image supports an alpha channel, in which case the blending also needs to generate an alpha value, and the calculation for the colour channels depends on whether it’s a pre-multiplied image or not. In both cases the ColorModel also matters, and in the more complicated case the precise API calls linking the image and the pixel array matter because they’ll control whether you can do the alpha and colour calculations with a single array or whether you’ll need to use a separate Raster for the alpha channel.

In the simplest case (opaque image) the (optimised) blending calculation is


    // b_rrggbb is the current value of the pixel
    // We're blending a_rrggbb over with an alpha value out of 256
    static int blendedPixel(int a_rrggbb, int b_rrggbb, int alpha) {
        int a_rr00bb = a_rrggbb & 0xff00ff;
        int a_gg00 = a_rrggbb & 0xff00;
        int b_rr00bb = b_rrggbb & 0xff00ff;
        int b_gg00 = b_rrggbb & 0xff00;

        int blend_rr00bb00 = (a_rr00bb * alpha + b_rr00bb * (256 - alpha)) & 0xff00ff00;
        int blend_gg0000 = (a_gg00 * alpha + b_gg00 * (256 - alpha)) & 0xff0000;
        // In the unlikely event of getting transparency, add 0xff000000
        return (blend_rr00bb00 | blend_gg0000) >>> 8;
    }
#5

Just draw the shapes with alpha values in the colours. :point:

Seriously, why wouldn’t you?

#6

A real man likes a challenge!

@ pjt33
This is exactly what I needed. Thank you!

#7

It’s not a challenge if you ask someone else for the answer. :cranky:

#8

True :smiley:
I’ve been trying to do it for like 5 hours and it didn’t work for me :frowning:

It’s only a challenge if you can figure it out. :smiley: