Transparency related calculation I can't figure out

Hi! Is anyone here really good with maths? Basically, I have:

* This image:


* ...and this image:


They're the same image, but one has a black background, and the other one has a white one. Assuming I wanted to replace the background with an alpha channel, I can compare the difference between the first and second image. This will produce this image:


...so now I know what to put in the alpha channel. The problem is to figure out what to put in the RGB channels, it's not as easy as it sounds, because I need the colour of every pixel, unaffected by the black or white background. I understand that it's probably impossible to calculate the exact colour, but a close enough approximisation would work.

The image I'm after would have to look like this:


If I could figure that out (which I have no idea how to do) I'd have enough information to successfully create an image with an alpha channel out of the two source images that doesn't have one.

Something like this:

The resulting background color of a transparant image should be:
result_image_color = (alpha * original_image_color) + ((1 - alpha) * background_color)

^{Where:
alpha = 0..1
original_image_color = your last image (the value you want)
background_color = white, or black
result_image_color = the result of background + original image (your first or second image)}


Thus, if you know the background color, say it's FFFFFF, and the resulting image color is AABBCC:
(alpha * original_image_color) + ((1 - alpha) * FFFFFF) = AABBCC

You know the alpha, that's the normalized color value from your third image. Say it's 0.3
(0.3 * original_image_color) + ((1 - 0.3) * FFFFFF) = AABBCC

Then, uhh:
original_image_color = (AABBCC - ((1 - 0.3) * FFFFFF)) / 0.3

That should be it, I guess.

layer masks.....?

layer masks.....?

That would work in an image editor, but I think Nifflas wants to program this feature.

Normally you would proceed like this:
You have 2 steps.

First you draw the light image with a multiply mask, then you draw the dark image with a lighten mask to compensate for too much darkness caused by the earlier mask.

A multiply mask compares the pixel below with the new pixel. It does an average of both pixels (Rvalue + Bvalue + Gvalue)/3 and sees which one of both is higher. The pixel with the lower average will be used. If both averages are the same, the pixel from the new image will be used.

A lighten mas compares the pixel below with the new pixel. The pixel below does include the previous mask. We will only correct the dark pixels here. It also does an average of both pixels and sees which one of both is higher. The pixel with the higher average will be used. If both averages are the same, then use the average of the older image.

I hope that helps.

Thanks a lot for this help! I've tried these solutions, but either I must have done something wrong, or they didn't produce the result I was after.

I figured out a working solution though, in Photoshop I used "Difference" on image #1 and #2 to produce the alpha chanel, and then layered that above the second image with black background. I used the "color dodge" blending. That produced the correct image (as I expected, the colour of the nearly transparent pixels could only be approximated and didn't turn out perfect).

Now I only need to google for "color dodge", to find it's maths, that won't be a problem!

LPChip, I'm not sure I can agree with your "multiply mask" description. Doesn't it just do (a*b)/255, hence the name "Multiply"?

http://www.nathanm.com/photoshop-blending-math/
#define ChannelBlend_ColorDodge(B,L)  ((uint8)((B == 255) ? B:min(255, ((L << 8 ) / (255 - B)))))

Great that you found a solution!