Image transformation: grayscale to color.

Introduction  

This is easy algorithm of image transformation from grayscale image to color. Its far not ideal, but he very simple.

Background

Usually we calculate gray color as:

Gray  = Green * 0.59 + Blue * 0.30 + Red * 0.11;

Each color with structure [Gray, Gray, Gray] has set of colors:

G = [Gray, Gray, Gray]
G -> P = {C}, for each C from P:  Green * 0.59 + Blue * 0.30 + Red * 0.11 = Gray.

First of all, we create set of control points. Control point is equivalent of "gray" color and "full" color. When we have control points set, we can approximate any "gray" color to "full" color. If "gray" color locate between two control points C1 and C2, that his color approximate as:

K = (Gray - C1_Gray)/(C2_Gray - C1_Gray)
Red = C1_Red + K*(C2_Red - C1_Red)
Green = C1_Green + K*(C2_Green - C1_Green)
Blue = C1_Blue + K*(C2._Blue - C1_Blue)

Now we has "full color" equivalent for each "gray" color.

Figure 1. Transformation schema. 

Using the code  

ControlPoint is structure for store data about control points.

    public struct ControlPoint
    {
        private int level;

        public int Level
        {
            get { return level; }
            set { level = value; }
        }
        private Color color;

        public Color Color
        {
            get { return color; }
            set { color = value; }
        }

        public ControlPoint(int level, Color color)
        {
            this.color = color;
            this.level = level;
        }

        public override string ToString()
        {
            return "Level: " + level.ToString() + "; Color: " + color.ToString();
        }
    } 

PointsComparer is class for compare two control points:

    public class PointsComparer: IComparer<ControlPoint>
    {
        #region IComparer<ControlPoint> Members

        public int Compare(ControlPoint x, ControlPoint y)
        {
            if (x.Level > y.Level)
            {
                return 1;
            }
            if (x.Level < y.Level)
            {
                return -1;
            }
            return 0;
        }

        #endregion
    } 

ColorBuilder is class for build color diagram. He return array of 256 Colors - our diagram.

         public static Color[] GetColorDiagram(List<ControlPoint> points)
        {
            Color[] colors = new Color[256];
            points.Sort(new PointsComparer());

            for (int i = 0; i < 256; i++)
            {
                ControlPoint leftColor = new ControlPoint(0, GetNearestLeftColor(points[0].Color)); 
                ControlPoint rightColor = new ControlPoint(255, GetNearestRigthColor(points[points.Count - 1].Color));
                if (i < points[0].Level)
                {
                    rightColor = points[0];
                }
                if (i > points[points.Count - 1].Level)
                {
                    leftColor = points[points.Count - 1];
                }
                else
                {
                    for (int j = 0; j < points.Count - 1; j++)
                    {
                        if ((points[j].Level <= i) & (points[j + 1].Level > i))
                        {
                            leftColor = points[j];
                            rightColor = points[j + 1];
                        }
                    }
                }
                if ((rightColor.Level - leftColor.Level) != 0)
                {
                    double koef = (double)(i - leftColor.Level) / (double)(rightColor.Level - leftColor.Level);
                    int r = leftColor.Color.R + (int)(koef * (rightColor.Color.R - leftColor.Color.R));
                    int g = leftColor.Color.G + (int)(koef * (rightColor.Color.G - leftColor.Color.G));
                    int b = leftColor.Color.B + (int)(koef * (rightColor.Color.B - leftColor.Color.B));
                    colors[i] = Color.FromArgb(r, g, b);
                }
                else
                {
                    colors[i] = leftColor.Color;
                }

            }

            return colors;
        } 

Now we can get color image:

            colorBitmap = new Bitmap(sourceBitmap);
            for (int i = 0; i < sourceBitmap.Width; i++)
            {
                for (int j = 0; j < sourceBitmap.Height; j++)
                {
                    int level = sourceBitmap.GetPixel(i, j).B;
                    colorBitmap.SetPixel(i, j, colors[level]);
                }
            }
            pbxColorImage.Image = colorBitmap;

Figure 2. Simple color dialog. 

 Figure 3. Grayscale image, color image and color diagram.

Points of Interest  

Its algorithms is very easy, and he has many defects. But it is good example for beginners in image processing. 

Update info

1.New formula for grayscale level calculation.

2.Bug with empty list was remove.