I have to admit I was VERY nervous, but the trip was amazing. Anyone who has the ability to do something like this should do it without hesitation. I've divided the pictures up into three sections to make navigating them a little easier.

The basic process is to base each pixel's alpha value on its euclidean distance from the transparent color. You could do that directly to the 8-bit alpha channel of a 32bpp ARGB image, but I forsaw a little more math down the line, so I chose to do the processing to a 2 dimensional array of doubles the same size as the image.

Here's the code to generate the map:

public static double[][] GetDistanceMap(Bitmap bm, Color c)
{
    double[][] distanceMap = new double[bm.Width][];

    for (int x = 0; x < bm.Width; x++)
    {
        distanceMap[x] = new double[bm.Height];
        for (int y = 0; y < bm.Height; y++)
        {
            distanceMap[x][y] = GetEuclideanDistance(c, bm.GetPixel(x, y));
        }
    }

    return distanceMap;
}

private static double GetEuclideanDistance(Color c1, Color c2)
{
    int r1 = Convert.ToInt32(c1.R);
    int g1 = Convert.ToInt32(c1.G);
    int b1 = Convert.ToInt32(c1.B);
    int r2 = Convert.ToInt32(c2.R);
    int g2 = Convert.ToInt32(c2.G);
    int b2 = Convert.ToInt32(c2.B);
    return Math.Sqrt(((r1 * r1) - (r2 * r2)) + 
                     ((g1 * g1) - (g2 * g2)) + 
                     ((b1 * b1) - (b2 * b2)));
}

If you wanted to apply this directly to an image's alpha channel, you would certainly get improved results over GDI+'s MakeTransparent method which just finds a color and turns a pixel on or off. This, on the otherhand, will turn pixels more opaque the farther they are away from the chosen transparent color.

In order to apply our double precision values to an 8-bit (256 value) channel of an image, we're going to need to scale the numbers to the theoretical maximum Euclidean distance. We can calculate that if we know the number of bits per color (not pixel) which were used in our source image. For now, I'm going to assume that we'll be working with 24 bit RGB images and anything that is not will be converted beforehand.

     D_max = SQRT(255² + 255² + 255²)

And here's the code we'll use to apply a distance map to an image:

public static Bitmap ApplyDistanceMap(Bitmap sourcebm, double[][] distanceMap)
{
    Bitmap bm = new Bitmap(sourcebm.Width, sourcebm.Height,
                                 PixelFormat.Format32bppArgb);
    double maxDistance = GetMaxDistance(bm);

    for (int x = 0; x < bm.Width; x++)
    {
        for (int y = 0; y < bm.Height; y++)
        {			
            Color c = sourcebm.GetPixel(x, y);
            int val = ScaleDoubleTo255(distanceMap[x][y], maxDistance);
            bm.SetPixel(x, y, Color.FromArgb(val, c));
        }
    }

    return bm;
}

This will turn the following image with a white background into the one with the red background. NOTE: You can't see the transparent layer of the PNG unless your browser supports it. You're out of luck, IE users. Go get Firefox.

Original:

Original with alpha channel:

Not bad. The transparency is smooth, but there's still a halo of white around it. Next time I'll show how to improve on that just a tad.

Jack needs to be able to upload an image in any reasonable format (gif, jpeg, tiff, png) and have it converted to a png. That's easy enough, but then he needs to be able to supply an x,y coordinate and have the color of that pixel be made transparent. Again, that's not so difficult in and of itself, but to make it look GOOD, you need to make sure that you grab not only that color, but a range of colors.

That's all well and good, but by the time someone is uploading an image, it's most likely got some anti-aliasing between the color you want to be transparent and the colors you want to keep. That will certainly cause some artifacts that we want to try to avoid...

So here's my plan of attack:

1. Calcualte the Euclidean distance of each of the pixels from the color to be made transparent. There are a number of good websites with information about this. The formula is:

     d = SQRT((R₁ - R₂)² + (G₁ - G₂)² + (B₁ - B₂)²)

This will effectively make a grayscale bitmap whose pixels are black if the colors are exactly the same as the target color and get lighter as they stray away.

2. The next step is similar to what you do when you tweak the histogram of an image in Photoshop. Any pixel whose value is less than a given threshold will be made completely transparent (alpha value of 0%). Any pixel whose value is greater than another number becomes fully opaque (alpha 100%). In between, the values are weighted to a scale from 0-100%

3. Producing a transparent PNG from there is a simple matter of applying that grayscale image to the alpa channel of the original image! Getting that image into Flash 7 is another matter. (But that's another show)

What about Bitmap.MakeTransparent(Color c) I hear you say? I'll be it works great on images you have full control over and started off as bitmaps, but what about jpegs which need to be supplied by anyone and their dog? Here's what MakeTransparent does to a jpeg: (NOTE: this sample doesn't work with IE because it doesn't properly display alpha channels for PNGs)

Original:

Original with MakeTransparent(Color.White):