BitmapData.Stride | Software by Default

Posts Tagged 'BitmapData.Stride'

C# How to: Compass Edge Detection

Article Purpose

This article’s objective is to illustrate concepts relating to Compass Edge Detection. The edge detection methods implemented in this article include: Prewitt, Sobel, Scharr, Kirsch and Isotropic.

Wasp: Scharr 3 x 3 x 8

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 Windows Forms based sample application. When using the sample application users are able to load source/input images from and save result images to the local file system. The user interface provides a combobox which contains the supported methods of Compass Edge Detection. Selecting an item from the combobox results in the related Compass Edge Detection method being applied to the current source/input image. Supported methods are:

Prewitt3x3x4 – 3×3 Prewitt kernels in 4 compass directions
Prewitt3x3x8 – 3×3 Prewitt kernels in 8 compass directions
Prewitt5x5x4 – 5×5 Prewitt kernels in 4 compass directions
Sobel3x3x4 – 3×3 Sobel kernels in 4 compass directions
Sobel3x3x8 – 3×3 Sobel kernels in 8 compass directions
Sobel5x5x4 – 5×5 Sobel kernels in 4 compass directions
Scharr3x3x4 – 3×3 Scharr kernels in 4 compass directions
Scharr3x3x8 – 3×3 Scharr kernels in 8 compass directions
Scharr5x5x4 – 5×5 Scharr kernels in 4 compass directions
Kirsch3x3x4 – 3×3 Kirsch kernels in 4 compass directions
Kirsch3x3x8 – 3×3 Kirsch kernels in 8 compass directions
Isotropic3x3x4 – 3×3 Isotropic kernels in 4 compass directions
Isotropic3x3x8 – 3×3 Isotropic kernels in 8 compass directions

The following image is a screenshot of the Compass Edge Detection Sample Application in action:

Bee: Isotropic 3 x 3 x 8

Compass Edge Detection Overview

Compass Edge Detection as a concept title can be explained through the implementation of compass directions. Compass Edge Detection can be implemented through image convolution, using multiple matrix kernels, each suited to detecting edges in a specific direction. Often the edge directions implemented are:

North
North East
East
South East
South
South West
West
North West

Each of the compass directions listed above differ by 45 degrees. Applying a kernel rotation of 45 degrees to an existing direction specific edge detection kernel results in a new kernel suited to detecting edges in the next compass direction.

Various edge detection kernels can be implemented in Compass Edge Detection. This article and accompanying sample source code implements the following kernel types:

Prewitt
Sobel
Kirsch
Scharr
Isotropic

Prey Mantis: Sobel 3 x 3 x 8

The steps required when implementing Compass Edge Detection can be described as follows:

Determine the compass kernels. When an edge detection kernel suited to a specific direction is known, the edge detection kernels suited to the 7 remaining compass directions can be calculated. Rotating a kernel by 45 degrees around a central axis equates to the kernel suited to the next compass direction. As an example, if the edge detection kernel suited to detect edges in a northerly direction were to be rotated clockwise by 45 degrees around a central axis the result would be an edge detection kernel suited to edges in a North Easterly direction.
Iterate source image pixels. Every pixel forming part of the source/input image should be iterated, implementing convolution using each of the compass kernels.
Determine the most responsive kernel convolution. After having applied each compass kernel to the pixel currently being iterated, the most responsive compass kernel determines the output value. In other words, after having applied convolution eight times on the same pixel using each compass direction the output value should be set to the highest value calculated.
Validate and set output result. Ensure that the highest value returned from convolution does not equate to less than 0 or more than 255. Should a value be less than zero the result should be assigned as zero. In a similar fashion, should a value exceed 255 the result should be assigned as 255.

Prewitt Compass Kernels

LadyBug: Prewitt 3 x 3 x 8

Rotating Convolution Kernels

Kernels can be rotated by implementing a rotate transform. Repeatedly rotating by 45 degrees results in calculating 8 kernels, each suited to a different direction. The algorithm implemented when performing a rotate transform can be expressed as follows:

Rotate Horizontal Algorithm

Rotate Vertical Algorithm

I’ve published an in-depth article on matrix rotation available here: C# How to: Image Transform Rotate

Butterfly: Sobel 3 x 3 x 8

Implementing Kernel Rotation

The sample source code defines the RotateMatrix method. This method accepts as parameter a single kernel, defined as a two dimensional array of type double. In addition the method also expects as a parameter the degree to which the specified kernel should be rotated. The definition as follows:

public static double[, ,] RotateMatrix(double[,] baseKernel,  
                                             double degrees) 
{
    double[, ,] kernel = new double[(int )(360 / degrees),  
        baseKernel.GetLength(0), baseKernel.GetLength(1)]; 

 
    int xOffset = baseKernel.GetLength(1) / 2; 
    int yOffset = baseKernel.GetLength(0) / 2; 

 
    for (int y = 0; y < baseKernel.GetLength(0); y++) 
    { 
        for (int x = 0; x < baseKernel.GetLength(1); x++) 
        { 
            for (int compass = 0; compass <  
                kernel.GetLength(0); compass++) 
            { 
                double radians = compass * degrees * 
                                 Math.PI / 180.0; 

 
                int resultX = (int)(Math.Round((x - xOffset) * 
                           Math.Cos(radians) - (y - yOffset) * 
                           Math.Sin(radians)) + xOffset); 

 
                int resultY = (int )(Math.Round((x - xOffset) * 
                            Math.Sin(radians) + (y - yOffset) * 
                            Math.Cos(radians)) + yOffset); 

 
                kernel[compass, resultY, resultX] = 
                                            baseKernel[y, x]; 
            } 
        } 
    }

 
    return kernel; 
}

Butterfly: Prewitt 3 x 3 x 8

Implementing Compass Edge Detection

The sample source code defines several kernels which are implemented in convolution. The following code snippet provides the definition of all kernels defined:

public static double[, ,] Prewitt3x3x4 
{
    get 
    {
        double[,] baseKernel = new double[,]  
         { {  -1,  0,  1,  },  
           {  -1,  0,  1,  },  
           {  -1,  0,  1,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 90); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Prewitt3x3x8 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {  -1,  0,  1,  },  
           {  -1,  0,  1,  },  
           {  -1,  0,  1,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 45); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Prewitt5x5x4 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {  -2, -1,  0,  1, 2,  },  
           {  -2, -1,  0,  1, 2,  }, 
           {  -2, -1,  0,  1, 2,  }, 
           {  -2, -1,  0,  1, 2,  },  
           {  -2, -1,  0,  1, 2,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 90); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Kirsch3x3x4 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {  -3, -3,  5,  },  
           {  -3,  0,  5,  },  
           {  -3, -3,  5,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 90); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Kirsch3x3x8 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {  -3, -3,  5,  },  
           {  -3,  0,  5,  },  
           {  -3, -3,  5,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 45); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Sobel3x3x4 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {  -1,  0,  1,  },  
           {  -2,  0,  2,  },  
           {  -1,  0,  1,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 90); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Sobel3x3x8 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {  -1,  0,  1,  },  
           {  -2,  0,  2,  },  
           {  -1,  0,  1,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 45); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Sobel5x5x4 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {   -5,  -4,  0,   4,  5,  },  
           {   -8, -10,  0,  10,  8,  }, 
           {  -10, -20,  0,  20, 10,  }, 
           {   -8, -10,  0,  10,  8,  },  
           {   -5,  -4,  0,   4,  5,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 90); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Scharr3x3x4 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {  -1,  0,  1,  },  
           {  -3,  0,  3,  },  
           {  -1,  0,  1,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 90); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Scharr3x3x8 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {  -1,  0,  1,  },  
           {  -3,  0,  3,  },  
           {  -1,  0,  1,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 45); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Scharr5x5x4 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {   -1,  -1,  0,   1,  1,  },  
           {   -2,  -2,  0,   2,  2,  }, 
           {   -3,  -6,  0,   6,  3,  }, 
           {   -2,  -2,  0,   2,  2,  },  
           {   -1,  -1,  0,   1,  1,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 90); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Isotropic3x3x4 
{  
    get 
    {  
        double[,] baseKernel = new double[,]  
         { {             -1,  0,             1,  },  
           {  -Math.Sqrt(2),  0,  Math.Sqrt(2),  },  
           {             -1,  0,             1,  },  }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 90); 

 
        return kernel; 
    }  
}  

 
public static double[, ,] Isotropic3x3x8 
{  
    get 
     {  
        double[,] baseKernel = new double[,]  
         { {             -1,  0,             1,  },  
           {  -Math.Sqrt(2),  0,  Math.Sqrt(2),  },  
           {             -1,  0,             1,  }, }; 

 
        double[, ,] kernel = RotateMatrix(baseKernel, 45); 

  
        return kernel; 
    }  
}

Notice how each property invokes the RotateMatrix method discussed in the previous section.

Butterfly: Scharr 3 x 3 x 8

The CompassEdgeDetectionFilter method is defined as an extension method targeting the Bitmap class. The purpose of this method is to act as a wrapper method encapsulating the technical implementation. The definition as follows:

public static Bitmap CompassEdgeDetectionFilter(this Bitmap sourceBitmap,  
                                    CompassEdgeDetectionType compassType) 
{ 
    Bitmap resultBitmap = null; 

 
    switch (compassType) 
    {
        case CompassEdgeDetectionType.Sobel3x3x4: 
             { 
                resultBitmap =  
                sourceBitmap.ConvolutionFilter(Matrix.Sobel3x3x4, 1.0 / 4.0); 
             } break; 
        case CompassEdgeDetectionType.Sobel3x3x8: 
             { 
                resultBitmap =  
                sourceBitmap.ConvolutionFilter(Matrix.Sobel3x3x8, 1.0/ 4.0); 
             } break; 
        case CompassEdgeDetectionType.Sobel5x5x4: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Sobel5x5x4, 1.0/ 84.0); 
             } break; 
        case CompassEdgeDetectionType.Prewitt3x3x4: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Prewitt3x3x4, 1.0 / 3.0); 
             } break; 
        case CompassEdgeDetectionType.Prewitt3x3x8: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Prewitt3x3x8, 1.0/ 3.0); 
             } break; 
        case CompassEdgeDetectionType.Prewitt5x5x4: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Prewitt5x5x4, 1.0 / 15.0); 
             } break; 
        case CompassEdgeDetectionType.Scharr3x3x4: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Scharr3x3x4, 1.0 / 4.0); 
             } break; 
        case CompassEdgeDetectionType.Scharr3x3x8: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Scharr3x3x8, 1.0 / 4.0); 
             } break; 
        case CompassEdgeDetectionType .Scharr5x5x4: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Scharr5x5x4, 1.0 / 21.0); 
             } break; 
        case CompassEdgeDetectionType.Kirsch3x3x4: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Kirsch3x3x4, 1.0 / 15.0); 
             } break; 
        case CompassEdgeDetectionType.Kirsch3x3x8: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Kirsch3x3x8, 1.0 / 15.0); 
             } break; 
        case CompassEdgeDetectionType.Isotropic3x3x4: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Isotropic3x3x4, 1.0 / 3.4); 
             } break; 
        case CompassEdgeDetectionType.Isotropic3x3x8: 
             { 
                resultBitmap = 
                sourceBitmap.ConvolutionFilter(Matrix.Isotropic3x3x8, 1.0 / 3.4); 
             } break; 
     } 

 
    return resultBitmap; 
}

Rose: Scharr 3 x 3 x 8

Notice from the code snippet listed above, each case statement invokes the ConvolutionFilter method. This method has been defined as an extension method targeting the Bitmap class. The ConvolutionFilter extension method performs the actual task of image convolution. This method implements each kernel passed as a parameter, the highest result value will be determined as the output value. The definition as follows:

private static Bitmap ConvolutionFilter(this Bitmap sourceBitmap,  
                                     double[,,] filterMatrix,  
                                           double factor = 1,  
                                                int bias = 0)  
{
    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; 


    double blueCompass = 0.0; 
    double greenCompass = 0.0; 
    double redCompass = 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 compass = 0; compass <  
                 filterMatrix.GetLength(0); compass++) 
             {


                blueCompass = 0.0; 
                greenCompass = 0.0; 
                redCompass = 0.0; 


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


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


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


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


                blue = (blueCompass > blue ? blueCompass : blue); 
                green = (greenCompass > green ? greenCompass : green); 
                red = (redCompass > red ? redCompass : red); 
             }


            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; 
}

Rose: Isotropic 3 x 3 x 8

Sample Images

This article features a number of sample images. All featured images have been licensed allowing for reproduction. The following image files feature a sample images:

Wasp – Licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license. Download from Wikimedia
Ladybug – Licensed under the Creative Commons Attribution-Share Alike 2.0 Generic license. Download from Wikipedia
Ant – Released into the public domain by its author, Sean.hoyland. This applies worldwide. In some countries this may not be legally possible; if so: Sean.hoyland grants anyone the right to use this work for any purpose, without any conditions, unless such conditions are required by law. Download from Wikipedia
Prey Mantis – Licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license. Download from Wikipedia
Bee – Licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license. Download from Wikipedia
Red Pierrot Butterfly 1– Licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license. Download from WikiMedia
Siproeta Epaphus Butterfly – Licensed under the Creative Commons Attribution 3.0 Unported license. Download from WikiMedia
Red Pierrot Butterfly 2 – Licensed under the Creative Commons Attribution 2.0 Generic license. Download from Wikipedia
Iceberg Rose – Licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license. Attribution: Stan Shebs. Download from Wikipedia
Heidi Klum Rose – Licensed under the Creative Commons Attribution-Share Alike 3.0 Unported, 2.5 Generic, 2.0 Generic and 1.0 Generic license. Download from Wikipedia
Viceroy Butterfly – Licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license. Attributed to D. Gordon E. Robertson. Download from Wikipedia

The Original Image

Butterfly: Isotropic 3 x 3 x 4

Butterfly: Isotropic 3 x 3 x 8

Butterfly: Kirsch 3 x 3 x 4

Butterfly: Kirsch 3 x 3 x 8

Butterfly: Prewitt 3 x 3 x 4

Butterfly: Prewitt 3 x 3 x 8

Butterfly: Prewitt 5 x 5 x 4

Butterfly: Scharr 3 x 3 x 4

Butterfly: Scharr 3 x 3 x 8

Butterfly: Scharr 5 x 5 x 4

Butterfly: Sobel 3 x 3 x 4

Butterfly: Sobel 3 x 3 x 8

Butterfly: Sobel 5 x 5 x 4

C# How to: Image Transform Shear

Published June 16, 2013 Augmented Reality , C# , Code Samples , Extension Methods , Graphic Filters , Graphics , How to , Image Arithmetic , Image Filters , Image Processing , Image Transform , Learn Everyday , Microsoft , New Version , Opensource 29 Comments
Tags: Augmented Reality, Bitmap ARGB, Bitmap Filters, Bitmap.LockBits, BitmapData, BitmapData.Stride, Code Sample, Converting Images, Feature extraction, Graphic Filters, Image, Image Algorithms, Image processing, Image Shear, Image Transform, Machine vision, Pixel Filters, Shear Algorithm, Shear Transform, Shearing

Article Purpose

This article is focussed on illustrating the steps required in performing an image Shear Transformation. All of the concepts explored have been implemented by means of raw pixel data processing, no conventional drawing methods, such as GDI, are required.

Rabbit: Shear X 0.4, Y 0.4

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

This article features a Windows Forms based sample application which is included as part of the accompanying sample source code. The concepts explored in this article can be illustrated in a practical implementation using the sample application.

The sample application enables a user to load source/input images from the local file system when clicking the Load Image button. In addition users are also able to save output result images to the local file system by clicking the Save Image button.

Image Shear Transformations can be applied to either X or Y, or both X and Y pixel coordinates. When using the sample application the user has option of adjusting Shear factors, as indicated on the user interface by the numeric up/down controls labelled Shear X and Shear Y.

The following image is a screenshot of the Image Transform Shear Sample Application in action:

Rabbit: Shear X -0.5, Y -0.25

Image Shear Transformation

A good definition of the term Shear Transformation can be found on the Wikipedia topic related article:

In plane geometry, a shear mapping is a linear map that displaces each point in fixed direction, by an amount proportional to its signed distance from a line that is parallel to that direction.^[1] This type of mapping is also called shear transformation, transvection, or just shearing

A Shear Transformation can be applied as a horizontal shear, a vertical shear or as both. The algorithms implemented when performing a Shear Transformation can be expressed as follows:

Horizontal Shear Algorithm

Vertical Shear Algorithm

The algorithm description:

Shear(x) : The result of a horizontal Shear Transformation – The calculated X-Coordinate representing a Shear Transform.
Shear(y) : The result of a vertical Shear Transformation – The calculated Y-Coordinate representing a Shear Transform.
σ : The lower case version of the Greek alphabet letter Sigma – Represents the Shear Factor.
x : The X-Coordinate originating from the source/input image – The horizontal coordinate value intended to be sheared.
y : The Y-Coordinate originating from the source/input image – The vertical coordinate value intended to be sheared.
H : Source image height in pixels.
W : Source image width in pixels.

Note: When performing a Shear Transformation implementing both the horizontal and vertical planes each coordinate plane can be calculated using a different shearing factor.

The algorithms have been adapted in order to implement a middle pixel offset by means of subtracting the product of the related image plane boundary and the specified Shearing Factor, which will then be divided by a factor of two.

Rabbit: Shear X 1.0, Y 0.1

Implementing a Shear Transformation

The sample source code performs Shear Transformations through the implementation of the extension methods ShearXY and ShearImage.

The ShearXY extension method targets the Point structure. The algorithms discussed in the previous sections have been implemented in this function from a C# perspective. The definition as illustrated by the following code snippet:

public static Point ShearXY(this Point source, double shearX, 
                                               double shearY, 
                                               int offsetX,  
                                               int offsetY) 
{
    Point result = new Point(); 

   
    result.X = (int)(Math.Round(source.X + shearX * source.Y)); 
    result.X -= offsetX; 

   
    result.Y = (int)(Math.Round(source.Y + shearY * source.X)); 
    result.Y -= offsetY; 

   
    return result; 
}

Rabbit: Shear X 0.0, Y 0.5

The ShearImage extension method targets the Bitmap class. This method expects as parameter values a horizontal and a vertical shearing factor. Providing a shearing factor of zero results in no image shearing being implemented in the corresponding direction. The definition as follows:

public static Bitmap ShearImage(this Bitmap sourceBitmap, 
                               double shearX, 
                               double shearY) 
{ 
    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); 

   
    int xOffset = (int )Math.Round(sourceBitmap.Width *  
                                        shearX / 2.0); 

   
    int yOffset = (int )Math.Round(sourceBitmap.Height *  
                                          shearY / 2.0); 

   
    int sourceXY = 0; 
    int resultXY = 0; 

   
    Point sourcePoint = new Point(); 
    Point resultPoint = new Point(); 

   
    Rectangle imageBounds = new Rectangle(0, 0, 
                            sourceBitmap.Width, 
                           sourceBitmap.Height); 

   
    for (int row = 0; row < sourceBitmap.Height; row++) 
    { 
        for (int col = 0; col < sourceBitmap.Width; col++) 
        { 
            sourceXY = row * sourceData.Stride + col * 4; 

   
            sourcePoint.X = col; 
            sourcePoint.Y = row; 

   
            if (sourceXY >= 0 &&  
                sourceXY + 3 < pixelBuffer.Length) 
            { 
                resultPoint = sourcePoint.ShearXY(shearX,  
                                shearY, xOffset, yOffset); 

   
                resultXY = resultPoint.Y * sourceData.Stride + 
                           resultPoint.X * 4; 

   
                if (imageBounds.Contains(resultPoint) && 
                                      resultXY >= 0) 
                { 
                    if (resultXY + 6 <= resultBuffer.Length) 
                    { 
                        resultBuffer[resultXY + 4] = 
                             pixelBuffer[sourceXY]; 

   
                        resultBuffer[resultXY + 5] = 
                             pixelBuffer[sourceXY + 1]; 

   
                        resultBuffer[resultXY + 6] = 
                             pixelBuffer[sourceXY + 2]; 

   
                        resultBuffer[resultXY + 7] = 255; 
                    } 

   
                    if (resultXY - 3 >= 0) 
                    { 
                        resultBuffer[resultXY - 4] = 
                             pixelBuffer[sourceXY]; 

   
                        resultBuffer[resultXY - 3] = 
                             pixelBuffer[sourceXY + 1]; 

   
                        resultBuffer[resultXY - 2] = 
                             pixelBuffer[sourceXY + 2]; 

   
                        resultBuffer[resultXY - 1] = 255; 
                    } 

   
                    if (resultXY + 3 < resultBuffer.Length) 
                    { 
                        resultBuffer[resultXY] = 
                         pixelBuffer[sourceXY]; 

   
                        resultBuffer[resultXY + 1] = 
                         pixelBuffer[sourceXY + 1]; 

   
                        resultBuffer[resultXY + 2] = 
                         pixelBuffer[sourceXY + 2]; 

   
                        resultBuffer[resultXY + 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; 
}

Rabbit: Shear X 0.5, Y 0.0

Sample Images

This article features a number of sample images. All featured images have been licensed allowing for reproduction.

The sample images featuring the image of a Desert Cottontail Rabbit is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license and can be downloaded from Wikipedia. The original author is attributed as Larry D. Moore.

The sample images featuring the image of a Rabbit in Snow is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license and can be downloaded from Wikipedia. The original author is attributed as George Tuli.

The sample images featuring the image of an Eastern Cottontail Rabbit has been released into the public domain by its author. The original image can be downloaded from Wikipedia.

The sample images featuring the image of a Mountain Cottontail Rabbit is in the public domain in the United States because it is a work prepared by an officer or employee of the United States Government as part of that person’s official duties under the terms of Title 17, Chapter 1, Section 105 of the US Code. The original image can be downloaded from Wikipedia.

Rabbit: Shear X 1.0, Y 0.0

Rabbit: Shear X 0.5, Y 0.1

Rabbit: Shear X -0.5, Y -0.25

Rabbit: Shear X -0.5, Y 0.0

Rabbit: Shear X 0.25, Y 0.0

Rabbit: Shear X 0.50, Y 0.0

Rabbit: Shear X 0.0, Y 0.5

Rabbit: Shear X 0.0, Y 0.25

Rabbit: Shear X 0.0, Y 1.0

C# How to: Image Transform Rotate

Published June 16, 2013 Augmented Reality , C# , Code Samples , Extension Methods , Graphic Filters , Graphics , How to , Image Filters , Image Processing , Image Transform , Learn Everyday , Microsoft , New Version , Opensource 29 Comments
Tags: Augmented Reality, Bitmap ARGB, Bitmap Filters, Bitmap.LockBits, BitmapData, BitmapData.Stride, Code Sample, Converting Images, Feature extraction, Graphic Filters, Image, Image Blur, Image processing, Image Rotate, Image Transform, Machine vision, Pixel Filters, Rotate Transform

Article Purpose

This article provides a discussion exploring the concept of image rotation as a geometric transformation. In addition to conventional image rotation this article illustrates the concept of individual colour channel rotation.

Daisy: Rotate Red 0^o, Green 10^o, Blue 20^o

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 in the sample source code that accompanies this article. The sample application serves as an implementation of the concepts discussed throughout this article. Concepts can be easily tested and replicated using the sample application.

Daisy: Rotate Red 15^o, Green 5^o, Blue 10^o

When using the sample application users are able to load source/input images from the local file system by clicking the Load Image button. Required user input via the user interface can be found in the form of three numeric up/down controls labelled Blue, Green and Red respectively. Each control represents the degree to which the related colour component should be rotated. Possible input values range from –360 to 360. Positive values result in clockwise rotation, whereas negative values result in counter clockwise rotation. The sample application enables users to save result images to the local file system by clicking the Save Image button.

The following image is a screenshot of the Image Transform Rotate sample application in action:

Image Rotation Transformation

A rotational transformation applied to an image from a theoretical point of view is based in Transformation Geometry. From Wikipedia we learn the following definition:

In mathematics, transformation geometry (or transformational geometry) is the name of a mathematical and pedagogic approach to the study of geometry by focusing on groups of geometric transformations, and the properties of figures that are invariant under them. It is opposed to the classical synthetic geometry approach of Euclidean geometry, that focus on geometric constructions.

Rose: Rotate Red –20^o, Green 0^o, Blue 20^o

In this article image rotation is implemented through applying a set rotation transform algorithm to the coordinates of each pixel forming part of a source/input image. In the corresponding result image the calculated rotated pixel coordinates in terms of colour channel values will be assigned to the colour channel values of the original pixel.

The algorithms implemented when calculating a pixel’s rotated coordinates can be expressed as follows:

Symbols/variables contained in the algorithms:

R (x) : The result of rotating a pixel’s x-coordinate.
R (y) : The result of rotating a pixel’s y-coordinate.
x : The source pixel’s x-coordinate.
y : The source pixel’s y-coordinate.
W : The width in pixels of the source image.
H : The height in pixels of the source image.
ɑ : The lower case Greek alphabet letter alpha. The value represented by alpha reflects the degree of rotation.

Butterfly: Rotate Red 10^o, Green 0^o, Blue 0^o

In order to apply a rotation transformation each pixel forming part of the source/input image should be iterated. The algorithms expressed above should be applied to each pixel.

The pixel coordinates located at exactly the middle of an image can be calculated through dividing the image width with a factor of two in regards to the X-coordinate. The Y-coordinate can be calculated through dividing the image height also with a factor of two. The algorithms calculate the coordinates of the image middle pixel and implements the coordinates as offsets. Implementing the pixel offsets results in images being rotated around the image’s middle, as opposed to the the top left pixel (0,0).

This article and the associated sample source code extends the concept of traditional rotation through implementing rotation on a per colour channel basis. Through user input the individual degree of rotation can be specified for each colour channel, namely Red, Green and Blue. Functionality has been implemented allowing each colour channel to be rotated to a different degree. In essence the algorithms described above have to be implemented three times per pixel iterated.

Daisy: Rotate Red 30^o, Green 0^o, Blue 180^o

Implementing a Rotation Transformation

The sample source code implements a rotation transformation through the definition of two extension methods: RotateXY and RotateImage.

The RotateXY extension method targets the Point structure. This method serves as an encapsulation of the logic behind calculating rotating coordinates at a specified angle. The practical C# code implementation of the algorithms discussed in the previous section can be found within this method. The definition as follows:

public static Point RotateXY(this Point source, double degrees,
                                       int offsetX, int offsetY)
{ 
   Point result = new Point();
 
   result.X = (int)(Math.Round((source.X - offsetX) *
              Math.Cos(degrees) - (source.Y - offsetY) *
              Math.Sin(degrees))) + offsetX;

   
   result.Y = (int)(Math.Round((source.X - offsetX) *
              Math.Sin(degrees) + (source.Y - offsetY) *
              Math.Cos(degrees))) + offsetY;

    
   return result;
}

Rose: Rotate Red –60^o, Green 0^o, Blue 60^o

The RotateImage extension method targets the Bitmap class. This method expects three rotation degree/angle values, each corresponding to a colour channel. Positive degrees result in clockwise rotation and negative values result in counter clockwise rotation. The definition as follows:

public static Bitmap RotateImage(this Bitmap sourceBitmap,  
                                       double degreesBlue, 
                                      double degreesGreen, 
                                        double degreesRed) 
{ 
    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); 

    
    //Convert to Radians 
    degreesBlue = degreesBlue * Math.PI / 180.0; 
    degreesGreen = degreesGreen * Math.PI / 180.0; 
    degreesRed = degreesRed * Math.PI / 180.0; 

   
    //Calculate Offset in order to rotate on image middle 
    int xOffset = (int )(sourceBitmap.Width / 2.0); 
    int yOffset = (int )(sourceBitmap.Height / 2.0); 

    
    int sourceXY = 0; 
    int resultXY = 0; 

    
    Point sourcePoint = new Point(); 
    Point resultPoint = new Point(); 

    
    Rectangle imageBounds = new Rectangle(0, 0,  
                            sourceBitmap.Width,  
                           sourceBitmap.Height); 

    
    for (int row = 0; row < sourceBitmap.Height; row++) 
    { 
        for (int col = 0; col < sourceBitmap.Width; col++) 
        { 
            sourceXY = row * sourceData.Stride + col * 4; 

    
            sourcePoint.X = col; 
            sourcePoint.Y = row; 

    
            if (sourceXY >= 0 && sourceXY + 3 < pixelBuffer.Length) 
            {
                //Calculate Blue Rotation 

                    
                resultPoint = sourcePoint.RotateXY(degreesBlue,  
                                             xOffset, yOffset); 

    
                resultXY = (int)(Math.Round( 
                      (resultPoint.Y * sourceData.Stride) +  
                      (resultPoint.X * 4.0))); 

    
                if (imageBounds.Contains(resultPoint) &&  
                                      resultXY >= 0) 
                { 
                    if (resultXY + 6 < resultBuffer.Length) 
                    { 
                        resultBuffer[resultXY + 4] =  
                             pixelBuffer[sourceXY]; 

    
                        resultBuffer[resultXY + 7] = 255; 
                    }

    
                    if (resultXY + 3 < resultBuffer.Length) 
                    { 
                        resultBuffer[resultXY] =  
                         pixelBuffer[sourceXY]; 

    
                        resultBuffer[resultXY + 3] = 255; 
                    }
                } 

    
                //Calculate Green Rotation 

    
                resultPoint = sourcePoint.RotateXY(degreesGreen, 
                                             xOffset, yOffset); 

    
                resultXY = (int)(Math.Round( 
                      (resultPoint.Y * sourceData.Stride) + 
                      (resultPoint.X * 4.0))); 

    
                if (imageBounds.Contains(resultPoint) && resultXY >= 0) 
                { 
                    if (resultXY + 6 < resultBuffer.Length) 
                    {
                        resultBuffer[resultXY + 5] =  
                         pixelBuffer[sourceXY + 1]; 

    
                        resultBuffer[resultXY + 7] = 255; 
                    } 

    
                    if (resultXY + 3 < resultBuffer.Length) 
                    {
                        resultBuffer[resultXY + 1] =  
                         pixelBuffer[sourceXY + 1]; 

    
                        resultBuffer[resultXY + 3] = 255; 
                    }
                }

    
                //Calculate Red Rotation 

    
                resultPoint = sourcePoint.RotateXY(degreesRed, 
                                             xOffset, yOffset); 

    
                resultXY = (int)(Math.Round( 
                      (resultPoint.Y * sourceData.Stride) + 
                      (resultPoint.X * 4.0))); 

    
                if (imageBounds.Contains(resultPoint) && resultXY >= 0) 
                { 
                    if (resultXY + 6 < resultBuffer.Length) 
                    {
                        resultBuffer[resultXY + 6] =  
                         pixelBuffer[sourceXY + 2]; 
 
                        resultBuffer[resultXY + 7] = 255; 
                    }

    
                    if (resultXY + 3 < resultBuffer.Length) 
                    { 
                        resultBuffer[resultXY + 2] =  
                         pixelBuffer[sourceXY + 2]; 

    
                        resultBuffer[resultXY + 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; 
}

Daisy: Rotate Red 15^o, Green 5^o, Blue 5^o

Sample Images

This article features a number of sample images. All featured images have been licensed allowing for reproduction.

The sample images featuring an image of a yellow daisy is licensed under the Creative Commons Attribution-Share Alike 2.5 Generic license and can be downloaded from Wikimedia.org.

The sample images featuring an image of a white daisy is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license and can be downloaded from Wikipedia.

The sample images featuring an image of a CPU is licensed under the Creative Commons Attribution-Share Alike 2.0 Generic license. The original author is credited as Andrew Dunn. The original image can be downloaded from Wikipedia.

The sample images featuring an image of a rose is 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 can be downloaded from Wikipedia.

The sample images featuring an image of a butterfly is licensed under the Creative Commons Attribution 3.0 Unported license and can be downloaded from Wikimedia.org.

The Original Image

CPU: Rotate Red 90^o, Green 0^o, Blue –30^o

CPU: Rotate Red 0^o, Green 10^o, Blue 0^o

CPU: Rotate Red –4^o, Green 4^o, Blue 6^o

CPU: Rotate Red 10^o, Green 0^o, Blue 0^o

CPU: Rotate Red 10^o, Green –5^o, Blue 0^o

CPU: Rotate Red 10^o, Green 0^o, Blue 10^o

CPU: Rotate Red –10^o, Green 10^o, Blue 0^o

CPU: Rotate Red 30^o, Green –30^o, Blue 0^o

CPU: Rotate Red 40^o, Green 20^o, Blue 0^o

C# How to: Image Colour Average

Published May 18, 2013 Augmented Reality , C# , Code Samples , Extension Methods , Graphic Filters , Graphics , How to , Image Filters , Learn Everyday , Microsoft , New Version , Opensource , Tip 31 Comments
Tags: Alpha Red Green Blue, ARGB, Augmented Reality, Binary Image, Bitmap, Bitmap ARGB, Bitmap ARGB Array, Bitmap Filters, Bitmap.LockBits, BitmapData, BitmapData.Stride, C#, C# Convolution, Code Sample, Color Filters, Color Substitution, Computer vision, Converting Bitmaps, Converting Images, Convolution filters, Convolution Kernel, Convolution matrix, Extension Methods, Feature extraction, Graphic Filters, Image, Image Average, Image Blending, Image Manipulation, Image processing, Image Transform, Machine vision, Matrix, Open source, Pixel Filters, Pixel Manipulation, Windows Forms

Article purpose

This article’s intension is focussed on providing a discussion on the tasks involved in implementing Image Colour Averaging. Pixel colour averages are calculated from neighbouring pixels.

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 associated with this article includes a Windows Forms based sample application. The sample application is provided with the intention of illustrating the concepts explored in this article. In addition the sample application serves as a means of testing and replicating results.

By clicking the Load Image button users are able to select input/source images from the local file system. On the right hand side of the screen various controls enable the user to control the implementation of colour averaging. The three CheckBoxes labelled Red, Green and Blue relates to whether an individual colour component is to be included in calculating colour averages.

The filter intensity can be specified through selecting a filter size from the dropdown ComboBox, specifying higher values will result in output images expressing more colour averaging intensity.

Additional image filter effects can be achieved through implementing colour component shifting/swapping. When colour components are shifted left the result will be:

Blue is set to the original value of the Red component.
Red is set to the original value of the Green component.
Green is set to the original value of the Blue component.

When colour components are shifted right the result will be:

Red is set to the original value of the Blue component
Blue is set to the original value of the Green component
Green is set to the original value of the Red Component

Resulting images can be saved by the user to the local file system by clicking the Save Image button. The following image is a screenshot of the Image Colour Average sample application in action:

Averaging Colours

In this article and the accompanying sample source code colour averaging is implemented on a per pixel basis. An average colour value is calculated based on a pixel’s neighbouring pixels’ colour. Determining neighbouring pixels in the sample source code has been implemented in much the same method as image convolution. The major difference to image convolution is the absence of a fixed matrix/kernel.

Additional resulting visual effects can be achieved through various options/settings implemented whilst calculating colour averages. Additional options include being able to specify which colour component averages to implement. Furthermore colour components can be swapped/shifted around.

The sample source code implements the AverageColoursFilter extension method, targeting the Bitmap class. The extent or degree to which colour averaging will be evident in resulting images can be controlled through specifying different values set to the matrixSize parameter. The matrixSize parameter in essence determines the number of neighbouring pixels involved in calculating an average colour.

The individual pixel colour components Red, Green and Blue can either be included or excluded in calculating averages. The three method boolean parameters applyBlue, applyGreen and applyRed will determine an individual colour components inclusion in averaging calculations. If a colour component is to be excluded from averaging the resulting image will instead express the original source/input image’s colour component.

The intensity of a specific colour component average can be applied to another colour component by means of swapping/shifting colour components, which is indicated through the shiftType method parameter.

The following code snippet provides the implementation of the AverageColoursFilter extension method:

public static Bitmap AverageColoursFilter(
                            this Bitmap sourceBitmap,  
                            int matrixSize,   
                            bool applyBlue = true, 
                            bool applyGreen = true, 
                            bool applyRed = true, 
                            ColorShiftType shiftType = 
                            ColorShiftType.None)  
{ 
    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); 

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

   
    int byteOffset = 0; 

   
    int blue = 0; 
    int green = 0; 
    int red = 0; 

   
    for (int offsetY = filterOffset; offsetY <  
        sourceBitmap.Height - filterOffset; offsetY++) 
    {
        for (int offsetX = filterOffset; offsetX <  
            sourceBitmap.Width - filterOffset; offsetX++) 
        { 
            byteOffset = offsetY *  
                         sourceData.Stride +  
                         offsetX * 4; 

   
            blue = 0; 
            green = 0; 
            red = 0; 

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

   
                    blue += pixelBuffer[calcOffset]; 
                    green += pixelBuffer[calcOffset + 1]; 
                    red += pixelBuffer[calcOffset + 2]; 
                } 
            }

   
            blue = blue / matrixSize; 
            green = green / matrixSize; 
            red = red / matrixSize; 

   
            if (applyBlue == false) 
            { 
                blue = pixelBuffer[byteOffset]; 
            }

   
            if (applyGreen == false) 
            {
                green = pixelBuffer[byteOffset + 1]; 
            }

   
            if (applyRed == false) 
            { 
                red = pixelBuffer[byteOffset + 2]; 
            } 

   
            if (shiftType == ColorShiftType.None) 
            {
                resultBuffer[byteOffset] = (byte)blue; 
                resultBuffer[byteOffset + 1] = (byte)green; 
                resultBuffer[byteOffset + 2] = (byte)red; 
                resultBuffer[byteOffset + 3] = 255; 
            }
            else if (shiftType == ColorShiftType.ShiftLeft) 
            {
                resultBuffer[byteOffset] = (byte)green; 
                resultBuffer[byteOffset + 1] = (byte)red; 
                resultBuffer[byteOffset + 2] = (byte)blue; 
                resultBuffer[byteOffset + 3] = 255; 
            } 
            else if (shiftType == ColorShiftType.ShiftRight) 
            {
                resultBuffer[byteOffset] = (byte)red; 
                resultBuffer[byteOffset + 1] = (byte)blue; 
                resultBuffer[byteOffset + 2] = (byte)green; 
                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 definition of the ColorShiftType enum:

public enum ColorShiftType  
{
    None, 
    ShiftLeft, 
    ShiftRight 
}

Sample Images

The original image used in generating the sample images that form part of 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 can be downloaded from Wikipedia.

Original Image

Colour Average Blue Size 11

Colour Average Blue Size 11 Shift Left

Colour Average Blue Size 11 Shift Right

Colour Average Green Size 11 Shift Right

Colour Average Green, Blue Size 11

Colour Average Green, Blue Size 11 Shift Left

Colour Average Green, Blue Size 11 Shift Right

Colour Average Red Size 11

Colour Average Red Size 11 Shift Left

Colour Average Red, Blue Size 11

Colour Average Red, Blue Size 11 Shift Left

Colour Average Red, Green Size 11

Colour Average Red, Green Size 11 Shift Left

Colour Average Red, Green Size 11 Shift Right

Colour Average Red, Green, Blue Size 11

Colour Average Red, Green, Blue Size 11 Shift Left

Colour Average Red, Green, Blue Size 11 Shift Right

C# How to: Image Unsharp Mask

Published May 18, 2013 Augmented Reality , C# , Code Samples , Extension Methods , Graphic Filters , Graphics , How to , Image Convolution , Image Filters , Microsoft , Opensource , Tip 32 Comments
Tags: Augmented Reality, Bitmap ARGB, Bitmap Filters, Bitmap.LockBits, BitmapData, BitmapData.Stride, C#, C# Convolution, Code Sample, Computer vision, Convolution filters, Convolution Kernel, Convolution matrix, Edge enhance, Extension Methods, Feature extraction, Gaussian, Gaussian Blur, Graphic Filters, Image Blur, Image processing, Image Sharpness, Image Transform, Machine vision, Matrix, Mean Filter, Pixel Filters, Pixel Manipulation, Unsharp, Unsharp Masking

Article purpose

The purpose of this article is to explore and illustrate the concept of Image Unsharp Masking. This article implements image convolution in the form of a 3×3 Gaussian Blur, 5×5 Gaussian Blur, 3×3 Mean filter and a 5×5 Mean filter.

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 associated with this article includes a Windows Forms based sample application implementing the concepts explored throughout this article.

When using the Image Unsharp Mask sample application users can select a source/input image from the local file system by clicking the Load Image button. The dropdown combobox at the bottom of the screen allows the user to select an unsharp masking variation. On the right hand side of the screen users can specify the level/intensity of resulting image sharpness.

Clicking the Save Image button allows a user to save resulting images to the local file system. The image below is a screenshot of the Image Unsharp Mask sample application in action:

What is Image Unsharp Masking?

A good definition of Image Unsharp Masking can be found on Wikipedia:

Unsharp masking (USM) is an image manipulation technique, often available in digital image processing software.

The "unsharp" of the name derives from the fact that the technique uses a blurred, or "unsharp", positive image to create a "mask" of the original image. The unsharped mask is then combined with the negative image, creating an image that is less blurry than the original. The resulting image, although clearer, probably loses accuracy with respect to the image’s subject. In the context of signal-processing, an unsharp mask is generally a linear or nonlinear filter that amplifies high-frequency components.

In this article we implement Image Unsharp Masking by first creating a blurred copy of a source/input image then subtracting the blurred image from the original image, which is known as the mask. Increased image sharpness is achieved by adding a factor of the mask to the original image.

Applying a Convolution Matrix filter

The sample source code provides the definition for the ConvolutionFilter extension method targeting the Bitmap class. This method is invoked when implementing image blurring. The definition of the ConvolutionFilter extension method 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; 
}

Subtracting and Adding Images

An important step required when implementing Image Unsharp Masking comes in the form of creating a mask by subtracting a blurred copy from the original image and then adding a factor of the mask to the original image. In order to achieve increased performance the sample source code combines the process of creating the mask and adding the mask to the original image.

The SubtractAddFactorImage extension method iterates every pixel that forms part of an image. In a single step the blurred pixel is subtracted from the original pixel, multiplied by a user specified factor and then added to the original pixel. The definition of the SubtractAddFactorImage extension method as follows:

private static Bitmap SubtractAddFactorImage( 
                              this Bitmap subtractFrom, 
                                  Bitmap subtractValue, 
                                   float factor = 1.0f) 
{ 
    BitmapData sourceData =  
               subtractFrom.LockBits(new Rectangle (0, 0, 
               subtractFrom.Width, subtractFrom.Height), 
               ImageLockMode.ReadOnly, 
               PixelFormat.Format32bppArgb); 

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

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

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

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

  
    byte[] subtractBuffer = new byte[subtractData.Stride * 
                                     subtractData.Height]; 

  
    Marshal.Copy(subtractData.Scan0, subtractBuffer, 0, 
                                 subtractBuffer.Length); 

  
    subtractFrom.UnlockBits(sourceData); 
    subtractValue.UnlockBits(subtractData); 

  
    double blue = 0; 
    double green = 0; 
    double red = 0; 

  
    for (int k = 0; k < resultBuffer.Length && 
                   k < subtractBuffer.Length; k += 4) 
    { 
        blue = sourceBuffer[k] +  
              (sourceBuffer[k] - 
               subtractBuffer[k]) * factor; 

  
        green = sourceBuffer[k + 1] +  
               (sourceBuffer[k + 1] - 
                subtractBuffer[k + 1]) * factor; 

  
        red = sourceBuffer[k + 2] +  
             (sourceBuffer[k + 2] - 
              subtractBuffer[k + 2]) * factor; 

  
        blue = (blue < 0 ? 0 : (blue > 255 ? 255 : blue)); 
        green = (green < 0 ? 0 : (green > 255 ? 255 : green)); 
        red = (red < 0 ? 0 : (red > 255 ? 255 : red)); 

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

  
    Bitmap resultBitmap = new Bitmap (subtractFrom.Width,  
                                     subtractFrom.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; 
}

Matrix Definition

The image blurring convolution filters implemented by the sample source code relies on static matrix/kernel values defined in the Matrix class. The variants of blurring implemented are: 3×3 Gaussian, 5×5 Gaussian, 3×3 Mean and 5×5 Mean. The definition of the Matrix class is detailed by the following code snippet:

public static class Matrix
{
    public static double[,] Gaussian3x3
    {
        get
        {
            return new double[,]
            { { 1, 2, 1, }, 
              { 2, 4, 2, }, 
              { 1, 2, 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 }, };
        }
    }

  
    public static double[,] Mean3x3
    {
        get
        {
            return new double[,]
            { { 1, 1, 1, }, 
              { 1, 1, 1, }, 
              { 1, 1, 1, }, };
        }
    }

  
    public static double[,] Mean5x5
    {
        get
        {
            return new double[,]
            { { 1, 1, 1, 1, 1 }, 
              { 1, 1, 1, 1, 1 },
              { 1, 1, 1, 1, 1 },
              { 1, 1, 1, 1, 1 },
              { 1, 1, 1, 1, 1 }, };
        }
    }
}

Implementing Image Unsharpening

This article explores four variants of Image Unsharp Masking, relating to the four types of image blurring discussed in the previous section. The sample source code defines the following Image Unsharp Masking extension methods: UnsharpGaussian3x3, UnsharpGaussian5x5, UnsharpMean3x3 and UnsharpMean5x5. All four methods are defined as extension methods targeting the Bitmap class. When looking at the sample images in the following section you will notice the correlation between increased image blurring and enhanced image sharpness. The definition as follows:

public static Bitmap UnsharpGaussian3x3( 
                                 this Bitmap sourceBitmap,  
                                 float factor = 1.0f) 
{
    Bitmap blurBitmap = ExtBitmap.ConvolutionFilter( 
                                  sourceBitmap,  
                                  Matrix.Gaussian3x3,  
                                  1.0 / 16.0); 

   
    Bitmap resultBitmap =  
           sourceBitmap.SubtractAddFactorImage( 
                        blurBitmap, factor); 

   
    return resultBitmap; 
 } 

   
public static Bitmap UnsharpGaussian5x5( 
                                 this Bitmap sourceBitmap, 
                                 float factor = 1.0f) 
{
    Bitmap blurBitmap = ExtBitmap.ConvolutionFilter( 
                                  sourceBitmap,  
                                  Matrix.Gaussian5x5Type1,  
                                  1.0 / 159.0); 

   
    Bitmap resultBitmap = 
           sourceBitmap.SubtractAddFactorImage( 
                        blurBitmap, factor); 

   
    return resultBitmap; 
} 
 
public static Bitmap UnsharpMean3x3( 
                                 this Bitmap sourceBitmap, 
                                 float factor = 1.0f) 
{ 
    Bitmap blurBitmap = ExtBitmap.ConvolutionFilter( 
                                  sourceBitmap,  
                                  Matrix.Mean3x3,  
                                  1.0 / 9.0); 

   
    Bitmap resultBitmap = 
           sourceBitmap.SubtractAddFactorImage( 
                        blurBitmap, factor); 

   
    return resultBitmap; 
}

   
public static Bitmap UnsharpMean5x5( 
                                 this Bitmap sourceBitmap, 
                                 float factor = 1.0f) 
{ 
    Bitmap blurBitmap = ExtBitmap.ConvolutionFilter( 
                                  sourceBitmap,  
                                  Matrix.Mean5x5,  
                                  1.0 / 25.0); 

   
    Bitmap resultBitmap = 
           sourceBitmap.SubtractAddFactorImage( 
                        blurBitmap, factor); 

   
    return resultBitmap; 
}

Sample Images

The input/source image used in rendering the sample images shown in this article is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license and can be downloaded from Wikipedia:

The Original Image

Unsharp Gaussian 3×3

Unsharp Gaussian 5×5

Unsharp Mean 3×3

Unsharp Gaussian 5×5

Posts Tagged 'BitmapData.Stride'

Article Purpose

Sample Source Code

Using the Sample Application

Compass Edge Detection Overview

Rotating Convolution Kernels

Implementing Kernel Rotation

Implementing Compass Edge Detection

Sample Images

Related Articles and Feedback

Rate this:

Share this:

Article Purpose

Sample Source Code

Using the Sample Application

Image Shear Transformation

Implementing a Shear Transformation

Sample Images

Related Articles and Feedback

Rate this:

Share this:

Article Purpose

Sample Source Code

Using the Sample Application

Image Rotation Transformation

Implementing a Rotation Transformation

Sample Images

Related Articles and Feedback

Rate this:

Share this:

Article purpose

Sample source code

Using the Sample Application

Averaging Colours

Sample Images

Related Articles and Feedback

Rate this:

Share this:

Article purpose

Sample Source code

Using the Sample Application

What is Image Unsharp Masking?

Applying a Convolution Matrix filter

Subtracting and Adding Images

Matrix Definition

Implementing Image Unsharpening

Sample Images

Related Articles and Feedback

Rate this:

Share this:

Dewald Esterhuizen

RSS Feed

Recent Posts

Blog Stats

Follow SoftwareByDefault via Email

Categories

Top Posts & Pages

Archives

C# How to Articles

SoftwareByDefault Online References

MSDN Articles

Categories

Tags