Code Sample | Software by Default

Posts Tagged 'Code Sample'

C# How to: Image Edge Detection

Article Purpose

The objective of this article is to explore various edge detection algorithms. The types of edge detection discussed are: Laplacian, Laplacian of Gaussian, Sobel, Prewitt and Kirsch. All instances are implemented by means of Image Convolution.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Using the Sample Application

The concepts explored in this article can be easily replicated by making use of the Sample Application, which forms part of the associated sample source code accompanying this article.

When using the Image Edge Detection sample application you can specify a input/source image by clicking the Load Image button. The dropdown combobox towards the bottom middle part of the screen relates the various edge detection methods discussed.

If desired a user can save the resulting edge detection image to the local file system by clicking the Save Image button.

The following image is screenshot of the Image Edge Detection sample application in action:

Edge Detection

A good description of edge detection forms part of the main Edge Detection article on Wikipedia:

Edge detection is the name for a set of mathematical methods which aim at identifying points in a digital image at which the image brightness changes sharply or, more formally, has discontinuities. The points at which image brightness changes sharply are typically organized into a set of curved line segments termed edges. The same problem of finding discontinuities in 1D signals is known as step detection and the problem of finding signal discontinuities over time is known as change detection. Edge detection is a fundamental tool in image processing, machine vision and computer vision, particularly in the areas of feature detection and feature extraction.

Image Convolution

A good introduction article to Image Convolution can be found at: http://homepages.inf.ed.ac.uk/rbf/HIPR2/convolve.htm. From the article we learn the following:

Convolution is a simple mathematical operation which is fundamental to many common image processing operators. Convolution provides a way of `multiplying together’ two arrays of numbers, generally of different sizes, but of the same dimensionality, to produce a third array of numbers of the same dimensionality. This can be used in image processing to implement operators whose output pixel values are simple linear combinations of certain input pixel values.

In an image processing context, one of the input arrays is normally just a graylevel image. The second array is usually much smaller, and is also two-dimensional (although it may be just a single pixel thick), and is known as the kernel.

Single Matrix Convolution

The sample source code implements the ConvolutionFilter method, an extension method targeting the Bitmap class. The ConvolutionFilter method is intended to apply a user defined matrix and optionally covert an image to grayscale. The implementation as follows:

private static Bitmap ConvolutionFilter(Bitmap sourceBitmap, 
                                     double[,] filterMatrix, 
                                          double factor = 1, 
                                               int bias = 0, 
                                     bool grayscale = false) 
{
    BitmapData sourceData = 
                   sourceBitmap.LockBits(new Rectangle(0, 0,
                   sourceBitmap.Width, sourceBitmap.Height),
                                     ImageLockMode.ReadOnly, 
                                PixelFormat.Format32bppArgb);

  
    byte[] pixelBuffer = new byte[sourceData.Stride *
                                  sourceData.Height];

 
    byte[] resultBuffer = new byte[sourceData.Stride *
                                   sourceData.Height];

  
    Marshal.Copy(sourceData.Scan0, pixelBuffer, 0,
                               pixelBuffer.Length);

 
    sourceBitmap.UnlockBits(sourceData);

  
    if(grayscale == true)
    {
        float rgb = 0;

  
        for(int k = 0; k < pixelBuffer.Length; k += 4)
        {
            rgb = pixelBuffer[k] * 0.11f;
            rgb += pixelBuffer[k + 1] * 0.59f;
            rgb += pixelBuffer[k + 2] * 0.3f;

  
            pixelBuffer[k] = (byte)rgb;
            pixelBuffer[k + 1] = pixelBuffer[k];
            pixelBuffer[k + 2] = pixelBuffer[k];
            pixelBuffer[k + 3] = 255;
        }
    }

  
    double blue = 0.0;
    double green = 0.0;
    double red = 0.0;

  
    int filterWidth = filterMatrix.GetLength(1);
    int filterHeight = filterMatrix.GetLength(0);

  
    int filterOffset = (filterWidth-1) / 2;
    int calcOffset = 0;

  
    int byteOffset = 0;

  
    for(int offsetY = filterOffset; offsetY < 
        sourceBitmap.Height - filterOffset; offsetY++)
    {
        for(int offsetX = filterOffset; offsetX < 
            sourceBitmap.Width - filterOffset; offsetX++)
        {
            blue = 0;
            green = 0;
            red = 0;

  
            byteOffset = offsetY * 
                         sourceData.Stride + 
                         offsetX * 4;

  
            for(int filterY = -filterOffset; 
                filterY <= filterOffset; filterY++)
            {
                for(int filterX = -filterOffset;
                    filterX <= filterOffset; filterX++)
               {

  
                   calcOffset = byteOffset + 
                                (filterX * 4) + 
                                (filterY * sourceData.Stride);

  
                   blue += (double)(pixelBuffer[calcOffset]) *
                           filterMatrix[filterY + filterOffset, 
                                        filterX + filterOffset];

  
                   green += (double)(pixelBuffer[calcOffset+1]) *
                            filterMatrix[filterY + filterOffset, 
                                         filterX + filterOffset];

  
                   red += (double)(pixelBuffer[calcOffset+2]) *
                          filterMatrix[filterY + filterOffset, 
                                       filterX + filterOffset];
                }
            }

  
            blue = factor * blue + bias;
            green = factor * green + bias;
            red = factor * red + bias;

  
            if(blue > 255)
            { blue = 255;}
            else if(blue < 0)
            { blue = 0;}

  
            if(green > 255)
            { green = 255;}
            else if(green < 0)
            { green = 0;}

  
            if(red > 255)
            { red = 255;}
            else if(red < 0)
            { red = 0;}

  
            resultBuffer[byteOffset] = (byte)(blue);
            resultBuffer[byteOffset + 1] = (byte)(green);
            resultBuffer[byteOffset + 2] = (byte)(red);
            resultBuffer[byteOffset + 3] = 255;
        }
    }

  
    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, 
                                    sourceBitmap.Height);

  
    BitmapData resultData =
               resultBitmap.LockBits(new Rectangle(0, 0,
               resultBitmap.Width, resultBitmap.Height),
                                ImageLockMode.WriteOnly,
                            PixelFormat.Format32bppArgb);

  
    Marshal.Copy(resultBuffer, 0, resultData.Scan0,
                               resultBuffer.Length);
    resultBitmap.UnlockBits(resultData);

  
    return resultBitmap;
}

Horizontal and Vertical Matrix Convolution

The ConvolutionFilter extension method has been overloaded to accept two matrices, representing a vertical matrix and a horizontal matrix. The implementation as follows:

public static Bitmap ConvolutionFilter(this Bitmap sourceBitmap,
                                        double[,] xFilterMatrix,
                                        double[,] yFilterMatrix,
                                              double factor = 1,
                                                   int bias = 0,
                                         bool grayscale = false)
{
    BitmapData sourceData = 
                   sourceBitmap.LockBits(new Rectangle(0, 0,
                   sourceBitmap.Width, sourceBitmap.Height),
                                     ImageLockMode.ReadOnly,
                                PixelFormat.Format32bppArgb);

  
    byte[] pixelBuffer = new byte[sourceData.Stride * 
                                  sourceData.Height];

  
    byte[] resultBuffer = new byte[sourceData.Stride *
                                   sourceData.Height];

  
    Marshal.Copy(sourceData.Scan0, pixelBuffer, 0,
                               pixelBuffer.Length);

  
    sourceBitmap.UnlockBits(sourceData);

  
    if (grayscale == true)
    {
        float rgb = 0;

  
        for (int k = 0; k < pixelBuffer.Length; k += 4)
        {
            rgb = pixelBuffer[k] * 0.11f;
            rgb += pixelBuffer[k + 1] * 0.59f;
            rgb += pixelBuffer[k + 2] * 0.3f;

  
            pixelBuffer[k] = (byte)rgb;
            pixelBuffer[k + 1] = pixelBuffer[k];
            pixelBuffer[k + 2] = pixelBuffer[k];
            pixelBuffer[k + 3] = 255;
        }
    }

  
    double blueX = 0.0;
    double greenX = 0.0;
    double redX = 0.0;

  
    double blueY = 0.0;
    double greenY = 0.0;
    double redY = 0.0;

  
    double blueTotal = 0.0;
    double greenTotal = 0.0;
    double redTotal = 0.0;

  
    int filterOffset = 1;
    int calcOffset = 0;

  
    int byteOffset = 0;

  
    for (int offsetY = filterOffset; offsetY <
        sourceBitmap.Height - filterOffset; offsetY++)
    {
        for (int offsetX = filterOffset; offsetX <
            sourceBitmap.Width - filterOffset; offsetX++)
        {
            blueX = greenX = redX = 0;
            blueY = greenY = redY = 0;

  
            blueTotal = greenTotal = redTotal = 0.0;

  
            byteOffset = offsetY *
                         sourceData.Stride +
                         offsetX * 4;

  
            for (int filterY = -filterOffset;
                filterY <= filterOffset; filterY++)
            {
                for (int filterX = -filterOffset;
                    filterX <= filterOffset; filterX++)
                {
                    calcOffset = byteOffset +
                                 (filterX * 4) +
                                 (filterY * sourceData.Stride);

  
                    blueX += (double)
                              (pixelBuffer[calcOffset]) *
                              xFilterMatrix[filterY + 
                                            filterOffset,
                                            filterX + 
                                            filterOffset];

  
                    greenX += (double)
                          (pixelBuffer[calcOffset + 1]) *
                              xFilterMatrix[filterY +
                                            filterOffset,
                                            filterX +
                                            filterOffset];

  
                    redX += (double)
                          (pixelBuffer[calcOffset + 2]) *
                              xFilterMatrix[filterY +
                                            filterOffset,
                                            filterX +
                                            filterOffset];

  
                    blueY += (double)
                              (pixelBuffer[calcOffset]) *
                              yFilterMatrix[filterY +
                                            filterOffset,
                                            filterX +
                                            filterOffset];

  
                    greenY += (double)
                          (pixelBuffer[calcOffset + 1]) *
                              yFilterMatrix[filterY +
                                            filterOffset,
                                            filterX +
                                            filterOffset];

  
                    redY += (double)
                          (pixelBuffer[calcOffset + 2]) *
                              yFilterMatrix[filterY +
                                            filterOffset,
                                            filterX +
                                            filterOffset];
                }
            }

  
            blueTotal = Math.Sqrt((blueX * blueX) +
                                  (blueY * blueY));

  
            greenTotal = Math.Sqrt((greenX * greenX) +
                                   (greenY * greenY));

  
            redTotal = Math.Sqrt((redX * redX) +
                                 (redY * redY));

  
            if (blueTotal > 255)
            { blueTotal = 255; }
            else if (blueTotal < 0)
            { blueTotal = 0; }

  
            if (greenTotal > 255)
            { greenTotal = 255; }
            else if (greenTotal < 0)
            { greenTotal = 0; }

  
            if (redTotal > 255)
            { redTotal = 255; }
            else if (redTotal < 0)
            { redTotal = 0; }

  
            resultBuffer[byteOffset] = (byte)(blueTotal);
            resultBuffer[byteOffset + 1] = (byte)(greenTotal);
            resultBuffer[byteOffset + 2] = (byte)(redTotal);
            resultBuffer[byteOffset + 3] = 255;
        }
    }

  
    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width,
                                     sourceBitmap.Height);

  
    BitmapData resultData =
               resultBitmap.LockBits(new Rectangle(0, 0,
               resultBitmap.Width, resultBitmap.Height),
                                ImageLockMode.WriteOnly,
                            PixelFormat.Format32bppArgb);

  
    Marshal.Copy(resultBuffer, 0, resultData.Scan0,
                               resultBuffer.Length);
    resultBitmap.UnlockBits(resultData);

  
    return resultBitmap;
}

Original Sample Image

The original source image used to create all of the edge detection sample images in this article has been licensed under the Creative Commons Attribution-Share Alike 3.0 Unported, 2.5 Generic, 2.0 Generic and 1.0 Generic license. The original image is attributed to Kenneth Dwain Harrelson and can be downloaded from Wikipedia.

Laplacian Edge Detection

The Laplacian method of edge detection counts as one of the commonly used edge detection implementations. From Wikipedia we gain the following definition:

Discrete Laplace operator is often used in image processing e.g. in edge detection and motion estimation applications. The discrete Laplacian is defined as the sum of the second derivatives Laplace operator Coordinate expressions and calculated as sum of differences over the nearest neighbours of the central pixel.

A number of matrix/kernel variations may be applied with results ranging from slight to fairly pronounced. In the following sections of this article we explore two common matrix implementations, 3×3 and 5×5.

Laplacian 3×3

When implementing a 3×3 Laplacian matrix you will notice little difference between colour and grayscale result images.

public static Bitmap 
Laplacian3x3Filter(this Bitmap sourceBitmap, 
                      bool grayscale = true)
{
    Bitmap resultBitmap = 
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                                Matrix.Laplacian3x3,
                                  1.0, 0, grayscale);

 
    return resultBitmap;
}

public static double[,] Laplacian3x3
{ 
   get   
   { 
       return new double[,]
       { { -1, -1, -1, },  
         { -1,  8, -1, },  
         { -1, -1, -1, }, }; 
   } 
}

Laplacian 3×3

Laplacian 3×3 Grayscale

Laplacian 5×5

The 5×5 Laplacian matrix produces result images with a noticeable difference between colour and grayscale images. The detected edges are expressed in a fair amount of fine detail, although the Laplacian matrix has a tendency to be sensitive to image noise.

public static Bitmap 
Laplacian5x5Filter(this Bitmap sourceBitmap, 
                      bool grayscale = true)
{
    Bitmap resultBitmap =
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                                Matrix.Laplacian5x5,
                                  1.0, 0, grayscale);

 
    return resultBitmap;
}

public static double[,] Laplacian5x5 
{ 
    get   
    { 
       return new double[,]
       { { -1, -1, -1, -1, -1, },  
         { -1, -1, -1, -1, -1, },  
         { -1, -1, 24, -1, -1, },  
         { -1, -1, -1, -1, -1, },  
         { -1, -1, -1, -1, -1  } }; 
    } 
}

Laplacian 5×5

Laplacian 5×5 Grayscale

Laplacian of Gaussian

The Laplacian of Gaussian (LoG) is a common variation of the Laplacian filter. Laplacian of Gaussian is intended to counter the noise sensitivity of the regular Laplacian filter.

Laplacian of Gaussian attempts to remove image noise by implementing image smoothing by means of a Gaussian blur. In order to optimize performance we can calculate a single matrix representing a Gaussian blur and Laplacian matrix.

public static Bitmap 
LaplacianOfGaussian(this Bitmap sourceBitmap)
{
    Bitmap resultBitmap =
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                         Matrix.LaplacianOfGaussian, 
                                       1.0, 0, true);

 
    return resultBitmap;
}

public static double[,] LaplacianOfGaussian
{ 
    get   
    { 
        return new double[,]
        { {  0,  0, -1,  0,  0 },  
          {  0, -1, -2, -1,  0 },  
          { -1, -2, 16, -2, -1 }, 
          {  0, -1, -2, -1,  0 }, 
          {  0,  0, -1,  0,  0 } };
    } 
}

Laplacian of Gaussian

Laplacian (3×3) of Gaussian (3×3)

Different matrix variations can be combined in an attempt to produce results best suited to the input image. In this case we first apply a 3×3 Gaussian blur followed by a 3×3 Laplacian filter.

public static Bitmap 
Laplacian3x3OfGaussian3x3Filter(this Bitmap sourceBitmap)
{
    Bitmap resultBitmap =
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                                 Matrix.Gaussian3x3,
                                1.0 / 16.0, 0, true);

 
    resultBitmap = ExtBitmap.ConvolutionFilter(resultBitmap, 
                         Matrix.Laplacian3x3, 1.0, 0, false);

 
    return resultBitmap;
}

public static double[,] Laplacian3x3
{ 
   get   
   { 
       return new double[,]
       { { -1, -1, -1, },  
         { -1,  8, -1, },  
         { -1, -1, -1, }, }; 
   } 
}

public static double[,] Gaussian3x3
{ 
   get   
   { 
       return new double[,]
       { { 1, 2, 1, },  
         { 2, 4, 2, },  
         { 1, 2, 1, } }; 
   } 
}

Laplacian 3×3 Of Gaussian 3×3

Laplacian (3×3) of Gaussian (5×5 – Type 1)

In this scenario we apply a variation of a 5×5 Gaussian blur followed by a 3×3 Laplacian filter.

public static Bitmap 
Laplacian3x3OfGaussian5x5Filter1(this Bitmap sourceBitmap)
{
    Bitmap resultBitmap = 
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                            Matrix.Gaussian5x5Type1,
                               1.0 / 159.0, 0, true);

 
    resultBitmap = ExtBitmap.ConvolutionFilter(resultBitmap, 
                         Matrix.Laplacian3x3, 1.0, 0, false);

 
    return resultBitmap;
}

public static double[,] Laplacian3x3
{ 
   get   
   { 
       return new double[,]
       { { -1, -1, -1, },  
         { -1,  8, -1, },  
         { -1, -1, -1, }, }; 
   } 
}

public static double[,] Gaussian5x5Type1 
{ 
   get   
   { 
       return new double[,]   
       { { 2, 04, 05, 04, 2 },  
         { 4, 09, 12, 09, 4 },  
         { 5, 12, 15, 12, 5 }, 
         { 4, 09, 12, 09, 4 }, 
         { 2, 04, 05, 04, 2 }, }; 
   } 
}

Laplacian 3×3 Of Gaussian 5×5 – Type 1

Laplacian (3×3) of Gaussian (5×5 – Type 2)

The following implementation is very similar to the previous implementation. Applying a variation of a 5×5 Gaussian blur results in slight differences.

public static Bitmap 
Laplacian3x3OfGaussian5x5Filter2(this Bitmap sourceBitmap)
{
    Bitmap resultBitmap = 
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                            Matrix.Gaussian5x5Type2,
                               1.0 / 256.0, 0, true);

 
    resultBitmap = ExtBitmap.ConvolutionFilter(resultBitmap, 
                         Matrix.Laplacian3x3, 1.0, 0, false);

 
    return resultBitmap;
}

public static double[,] Laplacian3x3
{ 
   get   
   { 
       return new double[,]
       { { -1, -1, -1, },  
         { -1,  8, -1, },  
         { -1, -1, -1, }, }; 
   } 
}

public static double[,] Gaussian5x5Type2 
{ 
   get   
   {
       return new double[,]  
       { {  1,   4,  6,  4,  1 },  
         {  4,  16, 24, 16,  4 },  
         {  6,  24, 36, 24,  6 }, 
         {  4,  16, 24, 16,  4 }, 
         {  1,   4,  6,  4,  1 }, }; 
   }
}

Laplacian 3×3 Of Gaussian 5×5 – Type 2

Laplacian (5×5) of Gaussian (3×3)

This variation of the Laplacian of Gaussian filter implements a 3×3 Gaussian blur, followed by a 5×5 Laplacian matrix. The resulting image appears significantly brighter when compared to a 3×3 Laplacian matrix.

public static Bitmap 
Laplacian5x5OfGaussian3x3Filter(this Bitmap sourceBitmap)
{
    Bitmap resultBitmap = 
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                                 Matrix.Gaussian3x3,
                                1.0 / 16.0, 0, true);

 
    resultBitmap = ExtBitmap.ConvolutionFilter(resultBitmap,
                         Matrix.Laplacian5x5, 1.0, 0, false);

 
    return resultBitmap;
}

public static double[,] Laplacian5x5 
{ 
    get   
    { 
       return new double[,]
       { { -1, -1, -1, -1, -1, },  
         { -1, -1, -1, -1, -1, },  
         { -1, -1, 24, -1, -1, },  
         { -1, -1, -1, -1, -1, },  
         { -1, -1, -1, -1, -1  } }; 
    } 
}

public static double[,] Gaussian3x3
{ 
   get   
   { 
       return new double[,]
       { { 1, 2, 1, },  
         { 2, 4, 2, },  
         { 1, 2, 1, } }; 
   } 
}

Laplacian 5×5 Of Gaussian 3×3

Laplacian (5×5) of Gaussian (5×5 – Type 1)

Implementing a larger Gaussian blur matrix results in a higher degree of image smoothing, equating to less image noise.

public static Bitmap 
Laplacian5x5OfGaussian5x5Filter1(this Bitmap sourceBitmap)
{
    Bitmap resultBitmap = 
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                            Matrix.Gaussian5x5Type1,
                               1.0 / 159.0, 0, true);

 
    resultBitmap = ExtBitmap.ConvolutionFilter(resultBitmap,
                         Matrix.Laplacian5x5, 1.0, 0, false);

 
    return resultBitmap;
}

public static double[,] Laplacian5x5 
{ 
    get   
    { 
       return new double[,]
       { { -1, -1, -1, -1, -1, },  
         { -1, -1, -1, -1, -1, },  
         { -1, -1, 24, -1, -1, },  
         { -1, -1, -1, -1, -1, },  
         { -1, -1, -1, -1, -1  } }; 
    } 
}

public static double[,] Gaussian5x5Type1 
{ 
   get   
   { 
       return new double[,]   
       { { 2, 04, 05, 04, 2 },  
         { 4, 09, 12, 09, 4 },  
         { 5, 12, 15, 12, 5 }, 
         { 4, 09, 12, 09, 4 }, 
         { 2, 04, 05, 04, 2 }, }; 
   } 
}

Laplacian 5×5 Of Gaussian 5×5 – Type 1

Laplacian (5×5) of Gaussian (5×5 – Type 2)

The variation of Gaussian blur most applicable when implementing a Laplacian of Gaussian filter depends on image noise expressed by a source image. In this scenario the first variations (Type 1) appears to result in less image noise.

public static Bitmap 
Laplacian5x5OfGaussian5x5Filter2(this Bitmap sourceBitmap)
{
    Bitmap resultBitmap = 
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                            Matrix.Gaussian5x5Type2, 
                               1.0 / 256.0, 0, true);

 
    resultBitmap = 
           ExtBitmap.ConvolutionFilter(resultBitmap, 
                                Matrix.Laplacian5x5, 
                                      1.0, 0, false);

 
    return resultBitmap;
}

public static double[,] Laplacian5x5 
{ 
    get   
    { 
       return new double[,]
       { { -1, -1, -1, -1, -1, },  
         { -1, -1, -1, -1, -1, },  
         { -1, -1, 24, -1, -1, },  
         { -1, -1, -1, -1, -1, },  
         { -1, -1, -1, -1, -1  } }; 
    } 
}

public static double[,] Gaussian5x5Type2 
{ 
   get   
   {
       return new double[,]  
       { {  1,   4,  6,  4,  1 },  
         {  4,  16, 24, 16,  4 },  
         {  6,  24, 36, 24,  6 }, 
         {  4,  16, 24, 16,  4 }, 
         {  1,   4,  6,  4,  1 }, }; 
   }
}

Laplacian 5×5 Of Gaussian 5×5 – Type 2

Sobel Edge Detection

Sobel edge detection is another common implementation of edge detection. We gain the following quote from Wikipedia:

The Sobel operator is used in image processing, particularly within edge detection algorithms. Technically, it is a discrete differentiation operator, computing an approximation of the gradient of the image intensity function. At each point in the image, the result of the Sobel operator is either the corresponding gradient vector or the norm of this vector. The Sobel operator is based on convolving the image with a small, separable, and integer valued filter in horizontal and vertical direction and is therefore relatively inexpensive in terms of computations. On the other hand, the gradient approximation that it produces is relatively crude, in particular for high frequency variations in the image.

Unlike the Laplacian filters discussed earlier, Sobel filter results differ significantly when comparing colour and grayscale images. The Sobel filter tends to be less sensitive to image noise compared to the Laplacian filter. The detected edge lines are not as finely detailed/granular as the detected edge lines resulting from Laplacian filters.

public static Bitmap 
Sobel3x3Filter(this Bitmap sourceBitmap, 
                  bool grayscale = true)
{
    Bitmap resultBitmap =
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                          Matrix.Sobel3x3Horizontal, 
                            Matrix.Sobel3x3Vertical, 
                                  1.0, 0, grayscale);

 
    return resultBitmap;
}

 
public static double[,] Sobel3x3Horizontal
{ 
   get   
   {
       return new double[,]  
       { { -1,  0,  1, },  
         { -2,  0,  2, },  
         { -1,  0,  1, }, }; 
   } 
}

public static double[,] Sobel3x3Vertical 
{ 
   get   
   { 
       return new double[,]  
       { {  1,  2,  1, },  
         {  0,  0,  0, },  
         { -1, -2, -1, }, }; 
   } 
}

Sobel 3×3

Sobel 3×3 Grayscale

Prewitt Edge Detection

As with the other methods of edge detection discussed in this article the Prewitt edge detection method is also a fairly common implementation. From Wikipedia we gain the following quote:

The Prewitt operator is used in image processing, particularly within edge detection algorithms. Technically, it is a discrete differentiation operator, computing an approximation of the gradient of the image intensity function. At each point in the image, the result of the Prewitt operator is either the corresponding gradient vector or the norm of this vector. The Prewitt operator is based on convolving the image with a small, separable, and integer valued filter in horizontal and vertical direction and is therefore relatively inexpensive in terms of computations. On the other hand, the gradient approximation which it produces is relatively crude, in particular for high frequency variations in the image. The Prewitt operator was developed by Judith M. S. Prewitt.

In simple terms, the operator calculates the gradient of the image intensity at each point, giving the direction of the largest possible increase from light to dark and the rate of change in that direction. The result therefore shows how "abruptly" or "smoothly" the image changes at that point, and therefore how likely it is that that part of the image represents an edge, as well as how that edge is likely to be oriented. In practice, the magnitude (likelihood of an edge) calculation is more reliable and easier to interpret than the direction calculation.

Similar to the Sobel filter, resulting images express a significant difference when comparing colour and grayscale images.

public static Bitmap 
PrewittFilter(this Bitmap sourceBitmap, 
                 bool grayscale = true)
{
    Bitmap resultBitmap =
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                        Matrix.Prewitt3x3Horizontal, 
                          Matrix.Prewitt3x3Vertical, 
                                  1.0, 0, grayscale);

 
    return resultBitmap;
}

public static double[,] Prewitt3x3Horizontal 
{ 
   get   
   { 
       return new double[,]  
       { { -1,  0,  1, },  
         { -1,  0,  1, },  
         { -1,  0,  1, }, }; 
   } 
}

  
public static double[,] Prewitt3x3Vertical 
{ 
   get   
   { 
       return new double[,]  
       { {  1,  1,  1, },  
         {  0,  0,  0, },  
         { -1, -1, -1, }, }; 
   }
}

Prewitt

Prewitt Grayscale

Kirsch Edge Detection

The Kirsch edge detection method is often implemented in the form of Compass edge detection. In the following scenario we only implement two components: Horizontal and Vertical. Resulting images tend to have a high level of brightness.

public static Bitmap 
KirschFilter(this Bitmap sourceBitmap, 
                bool grayscale = true)
{
    Bitmap resultBitmap =
           ExtBitmap.ConvolutionFilter(sourceBitmap, 
                         Matrix.Kirsch3x3Horizontal, 
                           Matrix.Kirsch3x3Vertical, 
                                  1.0, 0, grayscale);

 
    return resultBitmap;
}

public static double[,] Kirsch3x3Horizontal 
{ 
   get   
   {
       return new double[,]  
       { {  5,  5,  5, },  
         { -3,  0, -3, },  
         { -3, -3, -3, }, }; 
   } 
}

public static double[,] Kirsch3x3Vertical
{ 
   get   
   { 
       return new double[,]  
       { {  5, -3, -3, },  
         {  5,  0, -3, },  
         {  5, -3, -3, }, }; 
   } 
}

Kirsch

Kirsch Grayscale

C# How to: Image Convolution

Published May 1, 2013 Augmented Reality , C# , Code Samples , Extension Methods , Generics , Graphic Filters , Graphics , How to , Image Convolution , Image Filters , Microsoft , Opensource , Wikipedia 31 Comments
Tags: Alpha Red Green Blue, Augmented Reality, Bitmap ARGB, Bitmap Filters, Bitmap.LockBits, BitmapData, Blur, C#, C# Convolution, Code Sample, Convolution filters, Convolution Kernel, Convolution matrix, Edge Detect, Emboss, Gaussian Blur, Graphic Filters, High pass, Image Manipulation, Image Noise, Image Transform, Matrix, Motion Blur, Pixel Filters, Pixel Manipulation, Sharpen

Article Purpose

This article is intended to serve as an introduction to the concepts related to creating and processing convolution filters being applied on images. The Convolution filters discussed are: Blur, Gaussian Blur, Soften, Motion Blur, High Pass, Edge Detect, Sharpen and Emboss.

Sample Source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Using the Sample Application

A Sample Application has been included with this article’s sample source code. The Sample Application has been developed to target the Windows Forms platform. Using the Sample Application users are able to select a source/input image from the local file system and from a drop down ComboBox select a Convolution filter to apply. Filtered images can be saved to the local file system when a user clicks the ‘Save’ button.

The following screenshot shows the Image Convolution Filter sample application in action.

Image Convolution

Before delving into discussions on technical implementation details it is important to have a good understanding of the concepts behind Image Convolution.

In relation to image processing Convolution can be considered as algorithms being implemented resulting in translating input/source images. Algorithms being applied generally take the form of accepting two input values and producing a third value considered to be a modified version of one of the input values.

Image Convolution can be implemented to produce image filters such as: Blurring, Smoothing, Edge Detection, Sharpening and Embossing. The resulting filtered images still bares a relation to the input source image.

Convolution Matrix

In this article we will be implementing Convolution through means of a matrix or kernel representing the algorithms required to produce resulting filtered images. A Matrix should be considered as a two dimensional array or grid. It is required that the number or rows and columns be of an equal size, which is furthermore required to not be a factor of two. Examples of valid matrix dimensions could be 3×3 or 5×5. Dimensions such as 2×2 or 4×4 would not be valid. Generally the sum total of all the values expressed in a matrix equates to one, although it is not a strict requirement.

The following table represents an example matrix/kernel:

2	0	0
0	-1	0
0	0	-1

An important aspect to keep in mind: When implementing a convolution matrix the value of a pixel will be determined by the values of the pixel’s neighbouring pixels. The values contained in a matrix represent factor values intended to be multiplied with pixel values. In a convolution matrix the centre pixel represents the pixel currently being modified. Neighbouring matrix values express the factor to be applied to the corresponding neighbouring pixels in regards to the pixel currently being modified.

The ConvolutionFilterBase class

The sample code defines the abstract class ConvolutionFilterBase. This class is intended to represent the minimum requirements of a convolution matrix. When defining a convolution matrix we will be inheriting from the ConvolutionFilterBase class. Because this class and its members have been defined as abstract, implementing classes are required to implement all defined abstract members.

The following code snippet details the ConvolutionFilterBase definition:

public abstract class ConvolutionFilterBase 
{ 
    public abstract string FilterName 
    {
        get; 
    }

           
    public abstract double Factor 
    {
        get; 
    } 

   
    public abstract double Bias 
    { 
        get; 
    } 

   
    public abstract double[,] FilterMatrix 
    {
        get; 
    } 
}

As to be expected the member property FilterMatrix is intended to represent a two dimensional array containing a convolution matrix. In some instances when the sum total of matrix values do not equate to 1 a filter might implement a Factor value other than the default of 1. Additionally some filters may also require a Bias value to be added the final result value when calculating the matrix.

Calculating a Convolution Filter

Calculating convolution filters and creating the resulting Bitmap images can be achieved by invoking the ConvolutionFilter method. This method is defined as an extension method targeting the Bitmap class. The definition of the ConvolutionFilter extension method as follows:

 public static Bitmap ConvolutionFilter<T>(this Bitmap sourceBitmap, T filter)  
                                 where T : ConvolutionFilterBase 
{ 
    BitmapData sourceData = sourceBitmap.LockBits(new Rectangle (0, 0, 
                                sourceBitmap.Width, sourceBitmap.Height), 
                                ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

  
    byte[] pixelBuffer = new byte[sourceData.Stride * sourceData.Height]; 
    byte[] resultBuffer = new byte[sourceData.Stride * sourceData.Height]; 

    
    Marshal.Copy(sourceData.Scan0, pixelBuffer, 0, pixelBuffer.Length); 

    
    sourceBitmap.UnlockBits(sourceData); 

    
    double blue = 0.0; 
    double green = 0.0; 
    double red = 0.0; 

    
    int filterWidth = filter.FilterMatrix.GetLength(1); 
    int filterHeight = filter.FilterMatrix.GetLength(0); 

    
    int filterOffset = (filterWidth-1) / 2; 
    int calcOffset = 0; 

    
    int byteOffset = 0; 

    
    for (int offsetY = filterOffset; offsetY <  
         sourceBitmap.Height - filterOffset; offsetY++) 
    { 
        for (int offsetX = filterOffset; offsetX <  
             sourceBitmap.Width - filterOffset; offsetX++) 
        { 
            blue = 0; 
            green = 0; 
            red = 0; 

    
            byteOffset = offsetY *  
                            sourceData.Stride +  
                            offsetX * 4; 

    
            for (int filterY = -filterOffset;  
                 filterY <= filterOffset; filterY++) 
            {
                for (int filterX = -filterOffset; 
                     filterX <= filterOffset; filterX++) 
                { 

    
                    calcOffset = byteOffset +  
                                 (filterX * 4) +  
                                 (filterY * sourceData.Stride); 

    
                    blue += (double)(pixelBuffer[calcOffset]) *  
                             filter.FilterMatrix[filterY + filterOffset,  
                             filterX + filterOffset]; 

    
                    green += (double)(pixelBuffer[calcOffset + 1]) *  
                              filter.FilterMatrix[filterY + filterOffset,  
                              filterX + filterOffset]; 

    
                    red += (double)(pixelBuffer[calcOffset + 2]) *  
                            filter.FilterMatrix[filterY + filterOffset,  
                            filterX + filterOffset]; 
                } 
            }

    
            blue = filter.Factor * blue + filter.Bias; 
            green = filter.Factor * green + filter.Bias; 
            red = filter.Factor * red + filter.Bias; 

    
            if (blue > 255) 
            { blue = 255; } 
             else if (blue < 0) 
            { blue = 0; } 

    
            if (green > 255) 
            { green = 255; } 
             else if (green < 0) 
            { green = 0; } 

    
            if (red > 255) 
            { red = 255; } 
             else if (red < 0) 
            { red = 0; } 

    
            resultBuffer[byteOffset] = (byte)(blue); 
            resultBuffer[byteOffset + 1] = (byte)(green); 
            resultBuffer[byteOffset + 2] = (byte)(red); 
            resultBuffer[byteOffset + 3] = 255; 
        } 
    } 

    
    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height); 

    
    BitmapData resultData = resultBitmap.LockBits(new Rectangle(0, 0, 
                            resultBitmap.Width, resultBitmap.Height), 
                            ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); 

    
    Marshal.Copy(resultBuffer, 0, resultData.Scan0, resultBuffer.Length); 
    resultBitmap.UnlockBits(resultData); 

    
    return resultBitmap; 
}

The following section provides a detailed discussion of the ConvolutionFilter extension method.

ConvolutionFilter<T> – Method Signature

public static Bitmap ConvolutionFilter<T>
                     (this Bitmap sourceBitmap,
                      T filter)  
                      where T : ConvolutionFilterBase

The ConvolutionFilter method defines a generic type T constrained by the requirement to be of type ConvolutionFilterBase. The filter parameter being of generic type T has to be of type ConvolutionFilterBase or a type which inherits from the ConvolutionFilterBase class.

Notice how the sourceBitmap parameter type definition is preceded by the this keyword indicating the method can be implemented as an extension method. Keep in mind extension methods are required to be declared as static.

The sourceBitmap parameter represents the source/input Bitmap upon which the filter is to be applied. Note that the ConvolutionFilter method is implemented as immutable. The input parameter values are not modified, instead a new Bitmap instance will be created and returned.

ConvolutionFilter<T> – Creating the Data Buffer

BitmapData sourceData = sourceBitmap.LockBits
                             (new Rectangle(0, 0,
                             sourceBitmap.Width, 
                             sourceBitmap.Height),
                             ImageLockMode.ReadOnly,
                             PixelFormat.Format32bppArgb);

  
byte[] pixelBuffer = new byte[sourceData.Stride *
                              sourceData.Height];

  
byte[] resultBuffer = new byte[sourceData.Stride *
                               sourceData.Height]; 

    
Marshal.Copy(sourceData.Scan0, pixelBuffer,
             0, pixelBuffer.Length);

    
sourceBitmap.UnlockBits(sourceData);

In order to access the underlying ARGB values from a Bitmap object we first need to lock the Bitmap into memory by invoking the Bitmap.LockBits method. Locking a Bitmap into memory prevents the Garbage Collector from moving a Bitmap object to a new location in memory.

When invoking the Bitmap.LockBits method the source code instantiates a BitmapData object from the return value. The BitmapData.Stride property represents the number of bytes in a single Bitmap pixel row. In this scenario the BitmapData.Stride property should be equal to the Bitmap’s width in pixels multiplied by four seeing as every pixel consists of four bytes: Alpha, Red, Green and Blue.

The ConvolutionFilter method defines two byte buffers, of which the size is set to equal the size of the Bitmap’s underlying data. The BitmapData property BitmapData.Scan0 of type IntPtr represents the memory address of the first byte value of a Bitmap’s underlying byte buffer. Using the Marshal.Copy method we specify the starting point memory address from where to start copying the Bitmap’s byte buffer.

Important to remember is the next operation being performed: invoking the Bitmap.UnlockBits method. If a Bitmap has been locked into memory ensure releasing the lock by invoking the Bitmap.UnlockBits method.

ConvolutionFilter<T> – Iterating Rows and Columns

double blue = 0.0; 
double green = 0.0; 
double red = 0.0; 

    
int filterWidth = filter.FilterMatrix.GetLength(1); 
int filterHeight = filter.FilterMatrix.GetLength(0); 

    
int filterOffset = (filterWidth-1) / 2; 
int calcOffset = 0; 

    
int byteOffset = 0; 

    
for (int offsetY = filterOffset; offsetY <  
     sourceBitmap.Height - filterOffset; offsetY++) 
{ 
    for (int offsetX = filterOffset; offsetX <  
         sourceBitmap.Width - filterOffset; offsetX++) 
    { 
         blue = 0; 
         green = 0; 
         red = 0; 

    
         byteOffset = offsetY *  
                      sourceData.Stride +  
                      offsetX * 4;

The ConvolutionFilter method employs two for loops in order to iterate each pixel represented in the ARGB data buffer. Defining two for loops to iterate a one dimensional array simplifies the concept of accessing the array in terms of rows and columns.

Note that the inner loop is limited to the width of the source/input Bitmap parameter, in other words the number of horizontal pixels. Remember that the data buffer represents four bytes, Alpha, Red, Green and Blue, for each pixel. The inner loop therefore iterates entire pixels.

As discussed earlier the filter matrix has to be declared as a two dimensional array with the same odd number of rows and columns. If the current pixel being processed relates to the element at the centre of the matrix, the width of the matrix less one divided by two equates to the neighbouring pixel index values.

The index of the current pixel can be calculated by multiplying the current row index (offsetY) and the number of ARGB byte values per row of pixels (sourceData.Stride), to which is added the current column/pixel index (offsetX) multiplied by four.

ConvolutionFilter<T> – Iterating the Matrix

for (int filterY = -filterOffset;  
     filterY <= filterOffset; filterY++) 
{
    for (int filterX = -filterOffset; 
         filterX <= filterOffset; filterX++) 
    { 
        calcOffset = byteOffset +  
                     (filterX * 4) +  
                     (filterY * sourceData.Stride); 

    
        blue += (double)(pixelBuffer[calcOffset]) *  
                 filter.FilterMatrix[filterY + filterOffset,  
                 filterX + filterOffset]; 

    
        green += (double)(pixelBuffer[calcOffset + 1]) *  
                  filter.FilterMatrix[filterY + filterOffset,  
                  filterX + filterOffset]; 

    
        red += (double)(pixelBuffer[calcOffset + 2]) *  
                filter.FilterMatrix[filterY + filterOffset,  
                filterX + filterOffset]; 
    } 
}

The ConvolutionFilter method iterates the two dimensional matrix by implementing two for loops, iterating rows and for each row iterating columns. Both loops have been declared to have a starting point equal to the negative value of half the matrix length (filterOffset). Initiating the loops with negative values simplifies implementing the concept of neighbouring pixels.

The first statement performed within the inner loop calculates the index of the neighbouring pixel in relation to the current pixel. Next the matrix value is applied as a factor to the corresponding neighbouring pixel’s individual colour components. The results are added to the totals variables blue, green and red.

In regards to each iteration iterating in terms of an entire pixel, to access individual colour components the source code adds the required colour component offset. Note: ARGB colour components are in fact expressed in reversed order: Blue, Green, Red and Alpha. In other words, a pixel’s first byte (offset 0) represents Blue, the second (offset 1) represents Green, the third (offset 2) represents Red and the last (offset 3) representing the Alpha component.

ConvolutionFilter<T> – Applying the Factor and Bias

blue = filter.Factor * blue + filter.Bias; 
green = filter.Factor * green + filter.Bias; 
red = filter.Factor * red + filter.Bias; 

    
if (blue > 255) 
{ blue = 255; } 
 else if (blue < 0) 
{ blue = 0; } 

    
if (green > 255) 
{ green = 255; } 
 else if (green < 0) 
{ green = 0; } 

    
if (red > 255) 
{ red = 255; } 
 else if (red < 0) 
{ red = 0; } 

    
resultBuffer[byteOffset] = (byte)(blue); 
resultBuffer[byteOffset + 1] = (byte)(green); 
resultBuffer[byteOffset + 2] = (byte)(red); 
resultBuffer[byteOffset + 3] = 255;

After iterating the matrix and calculating the matrix values of the current pixel’s Red, Green and Blue colour components we apply the Factor and add the Bias defined by the filter parameter.

Colour components may only contain a value ranging from 0 to 255 inclusive. Before we assign the newly calculated colour component value we ensure that the value falls within the required range. Values which exceed 255 are set to 255 and values less than 0 are set to 0. Note that assignment is implemented in terms of the result buffer, the original source image buffer remains unchanged.

ConvolutionFilter<T> – Returning the Result

Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, 
                                 sourceBitmap.Height); 

    
BitmapData resultData = resultBitmap.LockBits(
                        new Rectangle(0, 0, 
                        resultBitmap.Width,
                        resultBitmap.Height), 
                        ImageLockMode.WriteOnly,
                        PixelFormat.Format32bppArgb); 

    
Marshal.Copy(resultBuffer, 0, resultData.Scan0, 
                              resultBuffer.Length);

  
resultBitmap.UnlockBits(resultData); 

    
return resultBitmap;

The final steps performed by the ConvolutionFilter method involves creating a new Bitmap object instance and copying the calculated result buffer. In a similar fashion to reading underlying pixel data we copy the result buffer to the Bitmap object.

Creating Filters

The main requirement when creating a filter is to inherit from the abstract ConvolutionBaseFilter class. The following sections of this article will discuss various filter types and variations where applicable.

To illustrate the different effects resulting from applying filters all of the filters discussed make use of the same source image. The original image file is licensed under the Creative Commons Attribution 2.0 Generic license and can be downloaded from:

http://commons.wikimedia.org/wiki/File:Ara_macao_-on_a_small_bicycle-8.jpg

Blur Filters

Image blurring is typically used to reduce image noise and detail. The filter’s matrix size affects the level of blurring. A larger matrix results in higher level of blurring, whereas a smaller matrix results in a lesser level of blurring.

Blur3x3Filter

The Blur3x3Filter results in a slight to medium level of image blurring. The matrix consists of 9 elements in a 3×3 configuration.

public class Blur3x3Filter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "Blur3x3Filter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 0.0, 0.2, 0.0, },  
                        { 0.2, 0.2, 0.2, },  
                        { 0.0, 0.2, 0.2, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Blur5x5Filter

The Blur5x5Filter results in a medium level of image blurring. The matrix consists of 25 elements in a 5×5 configuration. Notice the factor of 1.0 / 13.0.

public class Blur5x5Filter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "Blur5x5Filter"; } 
    }

   
    private double factor = 1.0 / 13.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 0, 0, 1, 0, 0, }, 
                        { 0, 1, 1, 1, 0, }, 
                        { 1, 1, 1, 1, 1, }, 
                        { 0, 1, 1, 1, 0, }, 
                        { 0, 0, 1, 0, 0, }, };  

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Gaussian3x3BlurFilter

The Gaussian3x3BlurFilter implements a Gaussian blur through a matrix of 9 elements in a 3×3 configuration. The sum total of all matrix elements equal 16, therefore the Factor is defined as 1.0 / 16.0. Applying this filter results in a slight to medium level of blurring.

public class Gaussian3x3BlurFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "Gaussian3x3BlurFilter"; } 
    }

   
    private double factor = 1.0 / 16.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 1, 2, 1, },  
                        { 2, 4, 2, },  
                        { 1, 2, 1, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Gaussian5x5BlurFilter

The Gaussian5x5BlurFilter implements a Gaussian blur through a matrix of 25 elements in a 5×5 configuration. The sum total of all matrix elements equal 159, therefore the Factor is defined as 1.0 / 159.0. Applying this filter results in a medium level of blurring.

public class Gaussian5x5BlurFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "Gaussian5x5BlurFilter"; } 
    }

   
    private double factor = 1.0 / 159.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 2, 04, 05, 04, 2, }, 
                        { 4, 09, 12, 09, 4, }, 
                        { 5, 12, 15, 12, 5, }, 
                        { 4, 09, 12, 09, 4, }, 
                        { 2, 04, 05, 04, 2, }, };  

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

MotionBlurFilter

By implementing the MotionBlurFilter resulting images indicate the appearance of a high level of blurring associated with motion/movement. This filter is a combination of left to right and right to left motion blurring. The matrix consists of 81 elements in a 9×9 configuration.

public class MotionBlurFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "MotionBlurFilter"; } 
    }

   
    private double factor = 1.0 / 18.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 1, 0, 0, 0, 0, 0, 0, 0, 1, }, 
                        { 0, 1, 0, 0, 0, 0, 0, 1, 0, },
                        { 0, 0, 1, 0, 0, 0, 1, 0, 0, },
                        { 0, 0, 0, 1, 0, 1, 0, 0, 0, },
                        { 0, 0, 0, 0, 1, 0, 0, 0, 0, }, 
                        { 0, 0, 0, 1, 0, 1, 0, 0, 0, },
                        { 0, 0, 1, 0, 0, 0, 1, 0, 0, },
                        { 0, 1, 0, 0, 0, 0, 0, 1, 0, },
                        { 1, 0, 0, 0, 0, 0, 0, 0, 1, }, };

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

MotionBlurLeftToRightFilter

The MotionBlurLeftToRightFilter creates the effect of blurring as a result of left to right movement. The matrix consists of 81 elements in a 9×9 configuration.

public class MotionBlurLeftToRightFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "MotionBlurLeftToRightFilter"; } 
    }

   
    private double factor = 1.0 / 9.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 1, 0, 0, 0, 0, 0, 0, 0, 0, }, 
                        { 0, 1, 0, 0, 0, 0, 0, 0, 0, },
                        { 0, 0, 1, 0, 0, 0, 0, 0, 0, },
                        { 0, 0, 0, 1, 0, 0, 0, 0, 0, },
                        { 0, 0, 0, 0, 1, 0, 0, 0, 0, }, 
                        { 0, 0, 0, 0, 0, 1, 0, 0, 0, },
                        { 0, 0, 0, 0, 0, 0, 1, 0, 0, },
                        { 0, 0, 0, 0, 0, 0, 0, 1, 0, },
                        { 0, 0, 0, 0, 0, 0, 0, 0, 1, }, };

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

MotionBlurRightToLeftFilter

The MotionBlurRightToLeftFilter creates the effect of blurring as a result of right to left movement. The matrix consists of 81 elements in a 9×9 configuration.

public class MotionBlurRightToLeftFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "MotionBlurRightToLeftFilter"; } 
    }

   
    private double factor = 1.0 / 9.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 0, 0, 0, 0, 0, 0, 0, 0, 1, }, 
                        { 0, 0, 0, 0, 0, 0, 0, 1, 0, },
                        { 0, 0, 0, 0, 0, 0, 1, 0, 0, },
                        { 0, 0, 0, 0, 0, 1, 0, 0, 0, },
                        { 0, 0, 0, 0, 1, 0, 0, 0, 0, }, 
                        { 0, 0, 0, 1, 0, 0, 0, 0, 0, },
                        { 0, 0, 1, 0, 0, 0, 0, 0, 0, },
                        { 0, 1, 0, 0, 0, 0, 0, 0, 0, },
                        { 1, 0, 0, 0, 0, 0, 0, 0, 0, }, };

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Soften Filter

The SoftenFilter can be used to smooth or soften an image. The matrix consists of 9 elements in a 3×3 configuration.

public class SoftenFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "SoftenFilter"; } 
    }

   
    private double factor = 1.0 / 8.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 1, 1, 1, },  
                        { 1, 1, 1, },  
                        { 1, 1, 1, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Sharpen Filters

Sharpening an image does not add additional detail to an image but rather adds emphasis to existing image details. Image sharpness is sometimes referred to as image crispness.

SharpenFilter

This filter is intended as a general usage sharpen filter. In a variety of scenarios this filter should provide a reasonable level of image sharpening depending on source image quality.

public class SharpenFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "SharpenFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { -1, -1, -1, },  
                        { -1,  9, -1, },  
                        { -1, -1, -1, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Sharpen3x3Filter

The Sharpen3x3Filter results in a medium level of image sharpness, less intense when compared to the SharpenFilter discussed previously.

public class Sharpen3x3Filter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "Sharpen3x3Filter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { {  0, -1,  0, },  
                        { -1,  5, -1, },  
                        {  0, -1,  0, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Sharpen3x3FactorFilter

The Sharpen3x3FactorFilter provides a level of image sharpness similar to the Sharpen3x3Filter explored previously. Both filters define a 9 element 3×3 matrix. The filters differ in regards to Factor values. The Sharpen3x3Filter matrix values equate to a sum total of 1, the Sharpen3x3FactorFilter in contrast equate to a sum total of 3. The Sharpen3x3FactorFilter defines a Factor of 1 / 3, resulting in matrix sum total being negated to 1.

public class Sharpen3x3FactorFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "Sharpen3x3FactorFilter"; } 
    }

   
    private double factor = 1.0 / 3.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { {  0, -2,  0, },  
                        { -2, 11, -2, },  
                        {  0, -2,  0, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Sharpen5x5Filter

The Sharpen5x5Filter matrix defines 25 elements in a 5×5 configuration. The level of image sharpness resulting from implementing this filter to a greater extent is depended on the source image. In some scenarios result images may appear slightly softened.

public class Sharpen5x5Filter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "Sharpen5x5Filter"; } 
    }

   
    private double factor = 1.0 / 8.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { -1, -1, -1, -1, -1, }, 
                        { -1,  2,  2,  2, -1, },
                        { -1,  2,  8,  2,  1, },
                        { -1,  2,  2,  2, -1, },
                        { -1, -1, -1, -1, -1, }, };

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

IntenseSharpenFilter

The IntenseSharpenFilter produces result images with overly emphasized edge lines.

public class IntenseSharpenFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "IntenseSharpenFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 1,  1, 1, },  
                        { 1, -7, 1, },  
                        { 1,  1, 1, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Edge Detection Filters

Edge detection is the first step towards feature detection and feature extraction in digital image processing. Edges are generally perceived in images in areas exhibiting sudden differences in brightness.

EdgeDetectionFilter

The EdgeDetectionFilter is intended to be used as a general purpose edge detection filter, considered appropriate in the majority of scenarios applied.

public class EdgeDetectionFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "EdgeDetectionFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { -1, -1, -1, },  
                        { -1,  8, -1, },  
                        { -1, -1, -1, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

EdgeDetection45DegreeFilter

The EdgeDetection45DegreeFilter has the ability to detect edges at 45 degree angles more effectively than other edge detection filters.

public class EdgeDetection45DegreeFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "EdgeDetection45DegreeFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { -1,  0,  0,  0,  0, }, 
                        {  0, -2,  0,  0,  0, },
                        {  0,  0,  6,  0,  0, },
                        {  0,  0,  0, -2,  0, },
                        {  0,  0,  0,  0, -1, }, };

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

HorizontalEdgeDetectionFilter

The HorizontalEdgeDetectionFilter has the ability to detect horizontal edges more effectively than other edge detection filters.

public class HorizontalEdgeDetectionFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "HorizontalEdgeDetectionFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { {  0,  0,  0,  0,  0, }, 
                        {  0,  0,  0,  0,  0, },
                        { -1, -1,  2,  0,  0, },
                        {  0,  0,  0,  0,  0, },
                        {  0,  0,  0,  0,  0, }, };

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

VerticalEdgeDetectionFilter

The VerticalEdgeDetectionFilter has the ability to detect vertical edges more effectively than other edge detection filters.

public class VerticalEdgeDetectionFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "VerticalEdgeDetectionFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 0,  0, -1,  0,  0, }, 
                        { 0,  0, -1,  0,  0, },
                        { 0,  0,  4,  0,  0, },
                        { 0,  0, -1,  0,  0, },
                        { 0,  0, -1,  0,  0, }, };

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

EdgeDetectionTopLeftBottomRightFilter

This filter closely resembles an embossed image indicating object depth whilst still providing a reasonable level of edge detection detail.

public class EdgeDetectionTopLeftBottomRightFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "EdgeDetectionTopLeftBottomRightFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 0.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { -5,  0,  0, },  
                        {  0,  0,  0, },  
                        {  0,  0,  5, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Emboss Filters

Emboss filters produce result images with an emphasis on depth, based on lines/edges expressed in an input/source image. Result images give the impression of being three dimensional to a varying extent, depended on image details defined by input images.

EmbossFilter

The EmbossFilter is intended as a general application emboss filter. Take note of the Bias value of 128. Without a bias value, result images would be very dark or mostly black.

public class EmbossFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "EmbossFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 128.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { 2,  0,  0, },  
                        { 0, -1,  0, },  
                        { 0,  0, -1, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

Emboss45DegreeFilter

The Emboss45DegreeFilter has the ability to produce result images with good emphasis on 45 degree edges/lines.

public class Emboss45DegreeFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "Emboss45DegreeFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 128.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { -1, -1,  0, },  
                        { -1,  0,  1, },  
                        {  0,  1,  1, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

EmbossTopLeftBottomRightFilter

The EmbossTopLeftBottomRightFilter provides a more subtle level of embossed result images.

public class EmbossTopLeftBottomRightFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "EmbossTopLeftBottomRightFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 128.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { -1, 0, 0, },  
                        {  0, 0, 0, },  
                        {  0, 0, 1, }, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

IntenseEmbossFilter

When implementing the IntenseEmbossFilter result images provide a good three dimensional/depth level. A drawback of this filter can sometimes be noticed in a reduction image detail.

public class IntenseEmbossFilter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "IntenseEmbossFilter"; } 
    }

   
    private double factor = 1.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 128.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { -1, -1, -1, -1,  0, }, 
                        { -1, -1, -1,  0,  1, },
                        { -1, -1,  0,  1,  1, },
                        { -1,  0,  1,  1,  1, },
                        {  0,  1,  1,  1,  1, }, };

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

High Pass

High pass filters produce result images where only high frequency components are retained.

public class HighPass3x3Filter : ConvolutionFilterBase 
{
    public override string FilterName 
    {
        get { return "HighPass3x3Filter"; } 
    }

   
    private double factor = 1.0 / 16.0; 
    public override double Factor 
    { 
        get { return factor; } 
    }

   
    private double bias = 128.0; 
    public override double Bias 
    { 
        get { return bias; }
    } 

   
    private double[,] filterMatrix = 
        new double[,] { { -1, -2, -1, },  
                        { -2, 12, -2, },  
                        { -1, -2, -1,, }; 

   
    public override double[,] FilterMatrix 
    { 
        get { return filterMatrix; } 
    }
}

C# How to: Image Arithmetic

Published April 27, 2013 Augmented Reality , C# , Code Samples , Extension Methods , Generics , Graphic Filters , Graphics , How to , Image Arithmetic , Image Filters , Microsoft , Opensource , Tip 34 Comments
Tags: Alpha Red Green Blue, ARGB, Augmented Reality, Bitmap, Bitmap Blending, Bitmap.LockBits, BitmapData, C#, C# GDI, Code Sample, Converting Bitmaps, Converting Images, Graphic Filters, Image Add, Image Amplitude, Image Arithmetic, Image Average, Image Difference, Image Filters, Image Multiply, Image Subtract, Image Transform

Article Purpose

The objective of this article is to illustrate Image Arithmetic being implemented when blending/combining two separate images into a single result image. The types of Image Arithmetic discussed are: Average, Add, SubtractLeft, SubtractRight, Difference, Multiply, Min, Max and Amplitude.

I created the following image by implementing Image Arithmetic using as input images a photo of a friend’s ear and a photograph taken at a live concert performance by The Red Hot Chili Peppers.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Using the Sample Application

The Sample source code accompanying this article includes a Sample Application developed on a Windows Forms platform. The Sample Application is indented to provide an implementation of the various types of Image Arithmetic explored in this article.

The Image Arithmetic sample application allows the user to select two source/input images from the local file system. The user interface defines a ComboBox dropdown populated with entries relating to types of Image Arithmetic.

The following image is a screenshot taken whilst creating the “Red Hot Chili Peppers Concert – Side profile Ear” blended image illustrated in the first image shown in this article. Notice the stark contrast when comparing the source/input preview images. Implementing Image Arithmetic allows us to create a smoothly blended result image:

Newly created images can be saved to the local file system by clicking the ‘Save Image’ button.

Image Arithmetic

In simple terms Image Arithmetic involves the process of performing calculations on two images’ corresponding pixel colour components. The values resulting from performing calculations represent a single image which is combination of the two original source/input images. The extent to which a source/input image will be represented in the resulting image is dependent on the type of Image Arithmetic employed.

The ArithmeticBlend Extension method

In this article Image Arithmetic has been implemented as a single extension method targeting the Bitmap class. The ArithmeticBlend extension method expects as parameters two source/input Bitmap objects and a enumeration value indicating the type of Image Arithmetic to perform.

The ColorCalculationType enum defines an enumeration value for each type of Image Arithmetic supported. The definition as follows:

public enum ColorCalculationType 
{ 
   Average, 
   Add, 
   SubtractLeft, 
   SubtractRight, 
   Difference, 
   Multiply, 
   Min, 
   Max, 
   Amplitude 
}

It is only within the ArithmeticBlend extension method that we perform Image Arithmetic. This method accesses the underlying pixel data of each sample image and creates copies stored in byte arrays. Each element within the byte array data buffer represents a single colour component, either Alpha, Red, Green or Blue.

The following code snippet details the implementation of the ArithmeticBlend extension method:

 public static Bitmap ArithmeticBlend(this Bitmap sourceBitmap, Bitmap blendBitmap,  
                                 ColorCalculator.ColorCalculationType calculationType) 
{ 
    BitmapData sourceData = sourceBitmap.LockBits(new Rectangle (0, 0, 
                            sourceBitmap.Width, sourceBitmap.Height), 
                            ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

   
    byte[] pixelBuffer = new byte[sourceData.Stride * sourceData.Height]; 
    Marshal.Copy(sourceData.Scan0, pixelBuffer, 0, pixelBuffer.Length); 
    sourceBitmap.UnlockBits(sourceData); 

   
    BitmapData blendData = blendBitmap.LockBits(new Rectangle (0, 0, 
                           blendBitmap.Width, blendBitmap.Height), 
                           ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

   
    byte[] blendBuffer = new byte [blendData.Stride * blendData.Height]; 
    Marshal.Copy(blendData.Scan0, blendBuffer, 0, blendBuffer.Length); 
    blendBitmap.UnlockBits(blendData); 

   
    for (int k = 0; (k + 4 < pixelBuffer.Length) && 
                    (k + 4 < blendBuffer.Length); k += 4) 
    { 
        pixelBuffer[k] = ColorCalculator.Calculate(pixelBuffer[k],  
                            blendBuffer[k], calculationType); 

   
        pixelBuffer[k + 1] = ColorCalculator.Calculate(pixelBuffer[k + 1],  
                                blendBuffer[k + 1], calculationType); 

   
        pixelBuffer[k + 2] = ColorCalculator.Calculate(pixelBuffer[k + 2],  
                                blendBuffer[k + 2], calculationType); 
    } 

   
    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height); 

   
    BitmapData resultData = resultBitmap.LockBits(new Rectangle (0, 0, 
                            resultBitmap.Width, resultBitmap.Height), 
                            ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); 

   
    Marshal.Copy(pixelBuffer, 0, resultData.Scan0, pixelBuffer.Length); 
    resultBitmap.UnlockBits(resultData); 

   
    return resultBitmap; 
}

We access and copy the underlying pixel data of each input bitmap by making use of the Bitmap.LockBits method and also the Marshal.Copy method.

The method iterates both byte array data buffers simultaneously, having set the for loop condition to regard the array size of both byte arrays. Scenarios where byte array data buffers will differ in size occurs when the source images specified are not equal in terms of size dimensions.

Notice how each iteration increments the loop counter by a factor of four allowing us to treat each iteration as a complete pixel value. Remember that each data buffer element represents an individual colour component. Every four elements represents a single pixel consisting of the components: Alpha, Red, Green and Blue.

Take Note: The ordering of colour components are the exact opposite of the expected order. Each pixel’s colour components are ordered: Blue, Green, Red, Alpha. Since we are iterating an entire pixel with each iteration the for loop counter value will always equate to an element index representing the Blue colour component. In order to access the Red and Green colour components we simply add the values one and two respectively to the for loop counter value, depending on whether accessing the Green or Red colour components.

The task of performing the actual arithmetic has been encapsulated within the static Calculate method, a public member of the static class ColorCalculator. The Calculate method is more detail in the following section of this article.

The final task performed by the ArithmeticBlend method involves creating a new instance of the Bitmap class which is then updated/populated using the resulting byte array data buffer previously modified.

The ColorCalculator.Calculate method

The algorithms implemented in Image Arithmetic are encapsulated within the ColorCalculator.Calculate method. When implementing this method no knowledge of the technical implementation details are required. The parameters required are two byte values each representing a single colour component, one from each source image. The only other required parameter is an enum value of type ColorCalculationType which will indicate which type of Image Arithmetic should be implemented using the byte parameters as operands.

The following code snippet details the full implementation of the ColorCalculator.Calculate method:

 public static byte Calculate(byte color1, byte color2, 
                   ColorCalculationType calculationType) 
{ 
    byte resultValue = 0; 
    int intResult = 0; 

  
    if (calculationType == ColorCalculationType.Add) 
    { 
        intResult = color1 + color2; 
    } 
    else if (calculationType == ColorCalculationType.Average) 
    { 
        intResult = (color1 + color2) / 2; 
    }
    else if (calculationType == ColorCalculationType.SubtractLeft) 
    {
        intResult = color1 - color2; 
    } 
    else if (calculationType == ColorCalculationType.SubtractRight) 
    { 
        intResult = color2 - color1; 
    }
    else if (calculationType == ColorCalculationType.Difference) 
    { 
        intResult = Math.Abs(color1 - color2); 
    }
    else if (calculationType == ColorCalculationType.Multiply) 
    {
        intResult = (int)((color1 / 255.0 * color2 / 255.0) * 255.0); 
    }
    else if (calculationType == ColorCalculationType.Min) 
    {
        intResult = (color1 < color2 ? color1 : color2); 
    } 
    else if (calculationType == ColorCalculationType.Max) 
    {
        intResult = (color1 > color2 ? color1 : color2); 
    }
    else if (calculationType == ColorCalculationType.Amplitude) 
    {
        intResult = (int)(Math.Sqrt(color1 * color1 + color2 * color2) 
                                                    / Math .Sqrt(2.0)); 
    } 

  
    if (intResult < 0) 
    {
        resultValue = 0; 
    } 
    else if (intResult > 255) 
    {
         resultValue = 255; 
    } 
    else 
    { 
        resultValue = (byte)intResult; 
    }

  
    return resultValue; 
}

The bulk of the ColorCalculator.Calculate method’s implementation is set around a series of if/else if statements evaluating the enum method parameter passed when the method had been invoked.

Colour component values can only range from 0 to 255 inclusive. Calculations performed might result in values which do not fall within the valid range of values. Calculated values less than zero are set to zero and values exceeding 255 are set to 255, sometimes this is referred to clamping.

The following sections of this article provides an explanation of each type of Image Arithmetic implemented.

Image Arithmetic: Add

if (calculationType == ColorCalculationType.Add)
{
    intResult = color1 + color2;
}

The Add algorithm is straightforward, simply adding together the two colour component values. In other words the resulting colour component will be set to equal the sum of both source colour component, provided the total does not exceed 255.

Sample Image

Image Arithmetic: Average

if (calculationType == ColorCalculationType.Average)
{
    intResult = (color1 + color2) / 2;
}

The Average algorithm calculates a simple average by adding together the two colour components and then dividing the result by two.

Sample Image

Image Arithmetic: SubtractLeft

if (calculationType == ColorCalculationType.SubtractLeft)
{
    intResult = color1 - color2;
}

The SubtractLeft algorithm subtracts the value of the second colour component parameter from the first colour component parameter.

Sample Image

Image Arithmetic: SubtractRight

if (calculationType == ColorCalculationType.SubtractRight)
{
    intResult = color2 - color1;
}

The SubtractRight algorithm, in contrast to SubtractLeft, subtracts the value of the first colour component parameter from the second colour component parameter.

Sample Image

Image Arithmetic: Difference

if (calculationType == ColorCalculationType.Difference)
{
    intResult = Math.Abs(color1 - color2);
}

The Difference algorithm subtracts the value of the second colour component parameter from the first colour component parameter. By passing the result of the subtraction as a parameter to the Math.Abs method the algorithm ensures only calculating absolute/positive values. In other words calculating the difference in value between colour component parameters.

Sample Image

Image Arithmetic: Multiply

if (calculationType == ColorCalculationType.Multiply)
{
    intResult = (int)((color1 / 255.0 * color2 / 255.0) * 255.0);
}

The Multiply algorithm divides each colour component parameter by a value of 255 and the proceeds to multiply the results of the division, the result is then further multiplied by a value of 255.

Sample Image

Image Arithmetic: Min

if (calculationType == ColorCalculationType.Min)
{
    intResult = (color1 < color2 ? color1 : color2);
}

The Min algorithm simply compares the two colour component parameters and returns the smallest value of the two.

Sample Image

Image Arithmetic: Max

if (calculationType == ColorCalculationType.Max)
{
    intResult = (color1 > color2 ? color1 : color2);
}

The Max algorithm, as can be expected, will produce the exact opposite result when compared to the Min algorithm. This algorithm compares the two colour component parameters and returns the larger value of the two.

Sample Image

Image Arithmetic: Amplitude

 else if (calculationType == ColorCalculationType.Amplitude) 
{ 
         intResult = (int)(Math.Sqrt(color1 * color1 +
                                     color2 * color2) /
                                     Math.Sqrt(2.0)); 
}

The Amplitude algorithm calculates the amplitude of the two colour component parameters by multiplying each colour component by itself and then sums the results. The last step divides the result thus far by the square root of two.

Sample Image

C# How to: Generating Icons from Images

Published March 16, 2013 C# , Code Samples , Extension Methods , Graphic Filters , Graphics , How to , Image Filters , Microsoft , Opensource , Update 42 Comments
Tags: Application Icons, Bitmap Icons, Bitmap.GetHicon, C#, C# GDI, Code Sample, Converting Icons, Desktop Icons, Extension Methods, Generating Icons, Graphic Filters, ico, Icon Generator, Icon.FromHandle, Icons, Icons from Images, Image Filters, Image Manipulation, Image Transform, Images to Icons, Render Icons, Shortcut Icons, System.Drawing, System.Drawing.Bitmap, System.Drawing.Icon, Windows Forms

Article Purpose

This article illustrates the process of generating icon files (*.ico) from user specified input images. The accompanying Sample Source Code implements a Windows Forms application, allowing for easily testing the icon generation process.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Using the sample Application

The Sample Application can be used to test/implement the concepts described in this article. The user interface enables the user to browse and select an Image file from the file system, which loads as a scaled preview. In addition, the user can select an icon size from a list of standard icon dimensions: 16×16, 24×24, 32×32, 48×48, 64×64, 96×96 and 128×128 pixels. When a user clicks on the “Save Icon” button the sample application generates an icon in memory based on the specified size converting and scaling the provided input image. If an icon was successfully generated, the in-memory representation will be saved to the file system, based on the filename and file path specified by the user.

The image below is screenshot of the Image to Icon Generator application in action:

The source image features Bellis perennis also known as the common European Daisy (see Wikipedia). The image file is licensed under the Creative Commons Attribution-Share Alike 2.5 Generic license. The original image can be downloaded from Wikipedia.

The resulting icon file generated by the sample application:

Scaling and Aspect Ratio

Icons conform to a set of standard dimensions, all of which equate to a square image due to the width and height values being equal. A potential issue exists in that the specified source image might not have exact square dimensions. In other words, the width and height values of specified source images might differ. The solution lies in creating a square image based on the specified source image. Consider the concept of a square canvas onto which is drawn the source image whilst maintaining its aspect ratio, implementing center alignment from the horizontal and vertical aspect. Listed below is the implementation of an extension method defined as CopyToSquareCanvas, targeting the Bitmap class.

public static Bitmap CopyToSquareCanvas(this Bitmap sourceBitmap, Color canvasBackground)
{
    int maxSide = sourceBitmap.Width > sourceBitmap.Height ? sourceBitmap.Width : sourceBitmap.Height;

 
    Bitmap bitmapResult = new Bitmap(maxSide, maxSide, PixelFormat.Format32bppArgb);

 
    using (Graphics graphicsResult = Graphics.FromImage(bitmapResult))
   {
        graphicsResult.Clear(canvasBackground);

 
        int xOffset = (sourceBitmap.Width - maxSide) / 2;
        int yOffset = (sourceBitmap.Height - maxSide) / 2;

 
        graphicsResult.DrawImage(sourceBitmap, new Point(xOffset, xOffset));
   }

 
    return bitmapResult;
}

The size of the resulting Bitmap image is determined by the source image’s longest side, either width or height. To ensure middle alignment both vertically and horizontally the source image is drawn at an offset, determined by the additional buffer area added by the canvas.

Generating the Icon

Once we have created an image conforming to exact square dimensions the next step would be to scale said image to the desired icon size. A convenient method of quickly scaling source images to icon dimensions comes in the form of creating thumbnails.

The sample source code defines the enumeration IconSizeDimensions, which serves to provide a developer friendly reference coupled with actual dimension values by means of specifying explicit enumeration values. Consider the following code snippet:

public enum IconSizeDimensions
{
    IconSize16x16Pixels = 16,
    IconSize24x24Pixels = 24,
    IconSize32x32Pixels = 32,
    IconSize48x48Pixels = 48,
    IconSize64x64Pixels = 64,
    IconSize96x96Pixels = 96,
    IconSize128x128Pixels = 128
}

The crux of this article and sample source code can considered to be the definition of the CreateIcon extension method, which targets the Bitmap class. The definition is as follows:

public static Icon CreateIcon(this Bitmap sourceBitmap, IconSizeDimensions iconSize)
{
    Bitmap squareCanvas = sourceBitmap.CopyToSquareCanvas(Color.Transparent);
    squareCanvas = (Bitmap)squareCanvas.GetThumbnailImage((int)iconSize, (int)iconSize, null, new IntPtr());

 
    Icon iconResult = Icon.FromHandle(squareCanvas.GetHicon());

 
    return iconResult;
}

As discussed the first step is to ensure that the source image conforms to square dimensions, implemented here by invoking the CopyToSquareCanvas extension method. Next the source code implements image scaling by creating a thumbnail image of which the size is based on the specified IconSizeDimensions enum value. The Bitmap.GetHicon method returns a handle to an Icon in the form of an IntPtr, which serves as a parameter to the Icon.FromHandle static method, which returns an instance of the Icon class.

The Implementation

When the user clicks the “Save” button the Sample Application will present the user with a file save dialog. After the user specifies a file name and file path the Sample Application creates a Bitmap reference of the source image by casting the picturebox’s Image property to type Bitmap.

private void btnSaveIcon_Click(object sender, EventArgs e)
{
    if (picSource.Image != null)
    {
        SaveFileDialog sfd = new SaveFileDialog();
        sfd.Title = "Specify a file name and file path";
        sfd.Filter = "Icon Files(*.ico)|*.ico"; 
 
        if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
        {
            System.Drawing.Icon tempIcon = ((Bitmap)picSource.Image).CreateIcon(
                                             (IconSizeDimensions)cmbIconSize.SelectedItem);
 
 
            using (StreamWriter streamWriter = new StreamWriter(sfd.FileName, false))
            {
                tempIcon.Save(streamWriter.BaseStream); 
 
                streamWriter.Flush();
                streamWriter.Close();
            }
        }
    }
}

When the CreateIcon extension method is invoked, the Icon dimensions selected through the user interface will be passed as a parameter. The last step performed involves persisting the in-memory Icon data to the file system.

C# How to: Bitmap Colour Substitution implementing thresholds

Published March 16, 2013 Augmented Reality , C# , Code Samples , Extension Methods , Graphic Filters , Graphics , How to , Image Arithmetic , Image Filters , Image Processing , Learn Everyday , Microsoft , New Version , Opensource , Tip 41 Comments
Tags: 32Bit Argb, Alpha Red Green Blue, ARGB, ARGB Blending, Bitmap Filters, Bitmap.LockBits, BitmapData, C#, C# GDI, Code Sample, Color Filters, Color Substitution, Computer vision, Extension Methods, GDI, Graphic Filters, How to, Image Add, Image Algorithms, Image Filters, Image Manipulation, Image Transform, Machine vision, Open source, Pixel Manipulation, System.Drawing, System.Drawing.Bitmap

Article Purpose

This article is aimed at detailing how to implement the process of substituting the colour values that form part of a Bitmap image. Colour substitution is implemented by means of a threshold value. By implementing a threshold a range of similar colours can be substituted.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Using the sample Application

The provided sample source code builds a Windows Forms application which can be used to test/implement the concepts described in this article. The sample application enables the user to load an image file from the file system, the user can then specify the colour to replace, the replacement colour and the threshold to apply. The following image is a screenshot of the sample application in action.

The scenario detailed in the above screenshot shows the sample application being used to create an image where the sky has more of a bluish hue when compared to the original image.

Notice how replacement colour does not simply appear as a solid colour applied throughout. The replacement colour gets implemented matching the intensity of the colour being substituted.

The colour filter options:

The colour to replace was taken from the original image, the replacement colour is specified through a colour picker dialog. When a user clicks on either image displayed, the colour of the image pixel clicked on sets the value of the replacement colour. By adjusting the threshold value the user can specify how wide or narrow the range of colours to replace should be. The higher the threshold value, the wider the range of colours that will be replaced.

The resulting image can be saved by clicking the “Save Result” button. In order to apply another colour substitution on the resulting image click the button labelled “Set Result as Source”.

Colour Substitution Filter Data

The sample source code provides the definition for the ColorSubstitutionFilter class. The purpose of this class is to contain data required when applying colour substitution. The ColorSubstitutionFilter class is defined as follows:

public class ColorSubstitutionFilter
{
    private int thresholdValue = 10;
    public int ThresholdValue
    {
        get { return thresholdValue; }
        set { thresholdValue = value; }
    }

 
    private Color sourceColor = Color.White;
    public Color SourceColor
    {
        get { return sourceColor; }
        set { sourceColor = value; }
    }

 
    private Color newColor = Color.White;
    public Color NewColor
    {
        get { return newColor; }
        set { newColor = value; }
    }
}

To implement a colour substitution filter we first have to create an object instance of type ColorSubstitutionFilter. A colour substitution requires specifying a SourceColor, which is the colour to replace/substitute and a NewColour, which defines the colour that will replace the SourceColour. Also required is a ThresholdValue, which determines a range of colours based on the SourceColor.

Colour Substitution implemented as an Extension method

The sample source code defines the ColorSubstitution extension method which targets the Bitmap class. Invoking the ColorSubstitution extension method requires passing a parameter of type ColorSubstitutionFilter, which defines how colour substitution is to be implemented. The following code snippet contains the definition of the ColorSubstitution method.

public static Bitmap ColorSubstitution(this Bitmap sourceBitmap, ColorSubstitutionFilter filterData)
{
    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height, PixelFormat.Format32bppArgb);

 
    BitmapData sourceData = sourceBitmap.LockBits(new Rectangle(0, 0, sourceBitmap.Width, sourceBitmap.Height),
                                                  ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
    BitmapData resultData = resultBitmap.LockBits(new Rectangle(0, 0, resultBitmap.Width, resultBitmap.Height),
                                                  ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

 
    byte[] resultBuffer = new byte[resultData.Stride * resultData.Height];
    Marshal.Copy(sourceData.Scan0, resultBuffer, 0, resultBuffer.Length);

 
    sourceBitmap.UnlockBits(sourceData);

 
    byte sourceRed = 0, sourceGreen = 0, sourceBlue = 0, sourceAlpha = 0;
    int resultRed = 0, resultGreen = 0, resultBlue = 0;

 
    byte newRedValue = filterData.NewColor.R;
    byte newGreenValue = filterData.NewColor.G;
    byte newBlueValue = filterData.NewColor.B;

 
    byte redFilter = filterData.SourceColor.R;
    byte greenFilter = filterData.SourceColor.G;
    byte blueFilter = filterData.SourceColor.B;

 
    byte minValue = 0;
    byte maxValue = 255;

 
    for (int k = 0; k < resultBuffer.Length; k += 4)
   {
        sourceAlpha = resultBuffer[k + 3];

 
        if (sourceAlpha != 0)
       {
            sourceBlue = resultBuffer[k];
            sourceGreen = resultBuffer[k + 1];
            sourceRed = resultBuffer[k + 2];

 
            if ((sourceBlue < blueFilter + filterData.ThresholdValue &&
                    sourceBlue > blueFilter - filterData.ThresholdValue) &&

 
                (sourceGreen < greenFilter + filterData.ThresholdValue &&
                    sourceGreen > greenFilter - filterData.ThresholdValue) &&

 
                (sourceRed < redFilter + filterData.ThresholdValue &&
                    sourceRed > redFilter - filterData.ThresholdValue))
           {
                resultBlue = blueFilter - sourceBlue + newBlueValue;

 
                if (resultBlue > maxValue)
               { resultBlue = maxValue;}
                else if (resultBlue < minValue)
               { resultBlue = minValue;}

 
                resultGreen = greenFilter - sourceGreen + newGreenValue;

 
                if (resultGreen > maxValue)
               { resultGreen = maxValue;}
                else if (resultGreen < minValue)
               { resultGreen = minValue;}

 
                resultRed = redFilter - sourceRed + newRedValue;

 
                if (resultRed > maxValue)
               { resultRed = maxValue;}
                else if (resultRed < minValue)
               { resultRed = minValue;}

 
                resultBuffer[k] = (byte)resultBlue;
                resultBuffer[k + 1] = (byte)resultGreen;
                resultBuffer[k + 2] = (byte)resultRed;
                resultBuffer[k + 3] = sourceAlpha;
           }
       }
   }

 
    Marshal.Copy(resultBuffer, 0, resultData.Scan0, resultBuffer.Length);
    resultBitmap.UnlockBits(resultData);

 
    return resultBitmap;
}

The ColorSubstitution method can be labelled as immutable due to its implementation. Being immutable implies that the source/input data will not be modified, instead a new instance will be created reflecting the source data as modified by the operations performed in the particular method.

The first statement defined in the ColorSubstitution method body instantiates an instance of a new Bitmap, matching the size dimensions of the source Bitmap object. Next the method invokes the Bitmap.LockBits method on the source and result Bitmap instances. When invoking Bitmap.LockBits the underlying data representing a Bitmap will be locked in memory. Being locked in memory can also be described as signalling/preventing the Garbage Collector to not move around in memory the data being locked. Invoking Bitmap.UnlockBits results in the Garbage Collector functioning as per normal, moving data in memory and updating the relevant memory references when required.

The source code continues by copying all the bytes representing the source Bitmap to an array of bytes that represents the resulting Bitmap. At this stage the source and result Bitmaps are exactly identical and as yet unmodified. In order to determine which pixels based on colour should be modified the source code iterates through the byte array associated with the result Bitmap.

Notice how the for loop increments by 4 with each loop. The underlying data represents a 32 Bits per pixel Argb image, which equates to 8 bits/1 byte representing an individual colour component, either Alpha, Red, Green or Blue. Defining the for loop to increment by 4 results in each loop iterating 4 bytes or 32 bits, in essence 1 pixel.

Within the for loop we determine if the colour expressed by the current pixel adjusted by the threshold value forms part of the colour range that should be updated. It is important to remember that an individual colour component is a byte value and can only be set to a value between 0 and 255 inclusive.

The Implementation

The ColorSubstitution method is implemented by the sample source code through a Windows Forms application. The ColorSubstitution method requires that the source Bitmap specified must be formatted as a 32 Bpp Argb image. When the user loads a source image from the file system the sample application attempts to convert the selected image file by invoking the extension method Format32bppArgbCopy which targets the Bitmap class. The definition is as follows:

public static Bitmap Format32bppArgbCopy(this Bitmap sourceBitmap)
{
    Bitmap copyBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height, PixelFormat.Format32bppArgb);

             
    using (Graphics graphicsObject = Graphics.FromImage(copyBitmap))
    {
        graphicsObject.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
        graphicsObject.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
        graphicsObject.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
        graphicsObject.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;

                 
        graphicsObject.DrawImage(sourceBitmap, new Rectangle(0, 0, sourceBitmap.Width, sourceBitmap.Height),
         new Rectangle(0, 0, sourceBitmap.Width, sourceBitmap.Height), GraphicsUnit.Pixel);
    }

 
    return copyBitmap;
}

Colour Substitution Examples

The following section illustrates a few examples of colour substitution result images. The source image features Bellis perennis also known as the common European Daisy (see Wikipedia). The image file is licensed under the Creative Commons Attribution-Share Alike 2.5 Generic license. The original image can be downloaded here. The following image is a scaled down version of the original:

Light Blue Colour Substitution

Colour Component	Source Colour	Substitute Colour
Red	255	121
Green	223	188
Blue	224	255

Medium Blue Colour Substitution

Colour Component	Source Colour	Substitute Colour
Red	255	34
Green	223	34
Blue	224	255

Medium Green Colour Substitution

Colour Component	Source Colour	Substitute Colour
Red	255	0
Green	223	128
Blue	224	0

Purple Colour Substitution

Colour Component	Source Colour	Substitute Colour
Red	255	128
Green	223	0
Blue	224	255

Posts Tagged 'Code Sample'

Article Purpose

Sample source code

Using the Sample Application

Edge Detection

Image Convolution

Single Matrix Convolution

Horizontal and Vertical Matrix Convolution

Original Sample Image

Laplacian Edge Detection

Laplacian 3×3

Laplacian 5×5

Laplacian of Gaussian

Laplacian (3×3) of Gaussian (3×3)

Laplacian (3×3) of Gaussian (5×5 – Type 1)

Laplacian (3×3) of Gaussian (5×5 – Type 2)

Laplacian (5×5) of Gaussian (3×3)

Laplacian (5×5) of Gaussian (5×5 – Type 1)

Laplacian (5×5) of Gaussian (5×5 – Type 2)

Sobel Edge Detection

Prewitt Edge Detection

Kirsch Edge Detection

Related Articles and Feedback

Rate this:

Share this:

Article Purpose

Sample Source code

Using the Sample Application

Image Convolution

Convolution Matrix

The ConvolutionFilterBase class

Calculating a Convolution Filter

ConvolutionFilter<T> – Method Signature

ConvolutionFilter<T> – Creating the Data Buffer

ConvolutionFilter<T> – Iterating Rows and Columns

ConvolutionFilter<T> – Iterating the Matrix

ConvolutionFilter<T> – Applying the Factor and Bias

ConvolutionFilter<T> – Returning the Result

Creating Filters

Blur Filters

Blur3x3Filter

Blur5x5Filter

Gaussian3x3BlurFilter

Gaussian5x5BlurFilter

MotionBlurFilter

MotionBlurLeftToRightFilter

MotionBlurRightToLeftFilter

Soften Filter

Sharpen Filters

SharpenFilter

Sharpen3x3Filter

Sharpen3x3FactorFilter

Sharpen5x5Filter

IntenseSharpenFilter

Edge Detection Filters

EdgeDetectionFilter

EdgeDetection45DegreeFilter

HorizontalEdgeDetectionFilter

VerticalEdgeDetectionFilter

EdgeDetectionTopLeftBottomRightFilter

Emboss Filters

EmbossFilter

Emboss45DegreeFilter

EmbossTopLeftBottomRightFilter

IntenseEmbossFilter

High Pass

Related Articles and Feedback

Rate this:

Share this:

Article Purpose

Sample source code

Using the Sample Application

Image Arithmetic

The ArithmeticBlend Extension method

The ColorCalculator.Calculate method

Image Arithmetic: Add

Image Arithmetic: Average

Image Arithmetic: SubtractLeft

Image Arithmetic: SubtractRight

Image Arithmetic: Difference