C# How to: Image Blur

Article Purpose

This article serves to provides an introduction and discussion relating to Image Blurring methods and techniques. The Image Blur methods covered in this article include: Box Blur, Gaussian Blur, Mean Filter, Median Filter and Motion Blur.

Daisy: Mean 9×9

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 is accompanied by a sample application, intended to provide a means of testing and replicating topics discussed in this article. The sample application is a Windows Forms based application of which the user interface enables the user to select an Image Blur type to implement.

When clicking the Load Image button users are able to browse the local file system in order to select source/input images. In addition users are also able to save blurred result images when clicking the Save Image button and browsing the local file system.

Daisy: Mean 7×7

The sample application provides the user with the ability to select the method of image blurring to implement. The combobox dropdown located on the right-hand side of the user interface lists all of the supported methods of image blurring. When a user selects an item from the combobox, the associated blur method will be implemented on the preview image.

The image below is a screenshot of the Image Blur Filter sample application in action:

Image Blur Overview

The process of image blurring can be regarded as reducing the sharpness or crispness defined by an image. Image blurring results in image detail/definition being perceived as less distinct. Images are often blurred as a method of smoothing an image.

Images perceived as too crisp/sharp can be softened by applying a variety of image blurring techniques and intensity levels. Often images are smoothed/blurred in order to remove/reduce image noise. In image edge detection implementations better results are often achieved when first implementing noise reduction through smoothing/blurring. Image blurring can even be implemented in a fashion where results reflect image edge detection, a method known as Difference of Gaussians.

In this article and the accompanying sample source code all methods of image blurring supported have been implemented through image convolution, with the exception of the Median filter. Each of the supported methods in essence only represent a different convolution matrix kernel. The image blurring technique capable of achieving optimal results will to varying degrees be dependent on the features present in the specified source/input image. Each method provides a different set of desired properties and compromises. In the following sections an overview of each method will be discussed.

Daisy: Mean 9×9

Mean Filter/Box Blur

The Mean Filter also sometimes referred to as a Box Blur represents a fairly simplistic implementation and definition. A Mean Filter definition can be found on Wikipedia as follows:

A box blur is an image filter in which each pixel in the resulting image has a value equal to the average value of its neighbouring pixels in the input image. It is a form of low-pass ("blurring") filter and is a convolution.

Due to its property of using equal weights it can be implemented using a much simpler accumulation algorithm which is significantly faster than using a sliding window algorithm.

Mean Filter as a title relates to all weight values in a convolution kernel being equal, therefore the alternate title of Box Blur. In most cases a Mean Filter matrix kernel will only contain the value one. When performing image convolution implementing a Mean Filter kernel, the factor value equates to the 1 being divided by the sum of all kernel values.

The following is an example of a 5×5 Mean Filter convolution kernel:

The kernel consist of 25 elements, therefore the factor value equates to one divided by twenty five.

The Mean Filter Blur does not result in the same level of smoothing achieved by other image blur methods. The Mean Filter method can also be susceptible to directional artefacts.

Daisy Mean 5×5

Gaussian Blur

The Gaussian method of image blurring is a popular and often implemented filter. In contrast to the Box Blur method Gaussian Blurring produce resulting images appearing to contain a more uniform level of smoothing. When implementing image edge detection a Gaussian Blur is often applied to source/input images resulting in noise reduction. The Gaussian Blur has a good level of image edge preservation, hence being used in edge detection operations.

From Wikipedia we gain the following description:

A Gaussian blur (also known as Gaussian smoothing) is the result of blurring an image by a Gaussian function. It is a widely used effect in graphics software, typically to reduce image noise and reduce detail. The visual effect of this blurring technique is a smooth blur resembling that of viewing the image through a translucent screen, distinctly different from the bokeh effect produced by an out-of-focus lens or the shadow of an object under usual illumination. Gaussian smoothing is also used as a pre-processing stage in computer vision algorithms in order to enhance image structures at different scales

A potential drawback to implementing a Gaussian blur results from the filter being computationally intensive. The following matrix kernel represents a 5×5 Gaussian Blur. The sum total of all elements in the kernel equate to 159, therefore a factor value of 1.0 / 159.0 will be implemented.

Daisy: Gaussian 5×5

Median Filter Blur

The Median Filter is classified as a non-linear filter. In contrast to the other methods of image blurring discussed in this article the Median Filter implementation does not involve convolution or a predefined matrix kernel. The following description can be found on Wikipedia:

In signal processing, it is often desirable to be able to perform some kind of noise reduction on an image or signal. The median filter is a nonlinear digital filtering technique, often used to remove noise. Such noise reduction is a typical pre-processing step to improve the results of later processing (for example, edge detection on an image). Median filtering is very widely used in digital image processing because, under certain conditions, it preserves edges while removing noise.

Daisy: Median 7×7

As the name implies, the Median Filter operates by calculating the median value of a pixel group also referred to as a window. Calculating a Median value involves a number of steps. The required steps are listed as follows:

Iterate each pixel that forms part of the source/input image.
In relation to the pixel currently being iterated determine neighbouring pixels located within the bounds defined by the window size. The window location should be offset in order to align the window’s middle pixel and the pixel currently being iterated.
Neighbouring pixels located within the bounds defined by the window should be added to a one dimensional neighbourhood array. Once all value have been added, the array should be sorted by value.
The pixel value located at the middle of the sorted neighbourhood array qualifies as the Median value. The newly determined Median value should be assigned to the pixel currently being iterated.
Repeat the steps listed above until all pixels within the source/input image have been iterated.

Similar to the Gaussian Blur filter the Median Filter has the ability to smooth image noise whilst providing edge preservation. Depending on the window size implemented and the physical dimensions of input/source images the Median Filter can be computationally expensive.

Daisy: Median 9×9

Motion Blur

The sample source implements Motion Blur filters. Motion blurring in the traditional sense has been association with photography and video capturing. Motion Blurring can often be observed in scenarios where rapid movements are being captured to photographs or video recording. When recording a single frame, rapid movements could result in the image changing before the frame being captured has completed.

Motion Blurring can be synthetically imitated through the implementation of Digital Motion Blur filters. The size of the matrix kernel provided when implementing image convolution affects the filter intensity perceived in result images. Relating to Motion Blur filters the size of the kernel specified in convolution influences the perception and appearance of how rapidly movement had occurred to have blurred the resulting image. Larger kernels produce the appearance of more rapid motion, whereas smaller kernels result in less rapid motion being perceived.

Daisy: Motion Blur 7×7 135 Degrees

Depending on the kernel specified the ability exists to create the appearance of movement having occurred in a certain direction. The sample source code implements Motion Blur filters at 45 degrees, 135 degrees and in both directions simultaneously.

The kernel listed below represents a 5×5 Motion Blur filter occurring at 45 degrees and 135 degrees:

Image Blur Implementation

The sample source code implements all of the concepts explored throughout this article. The source code definition can be grouped into 4 sections: ImageBlurFilter method, ConvolutionFilter method, MedianFilter method and the Matrix class. The following article sections relate to the 4 main source code sections.

The ImageBlurFilter extension method has the purpose of invoking the correct blur filter method and relevant method parameters. This method acts as a method wrapper providing the technical implementation details required when performing a specified blur filter.

The definition of the ImageBlurFilter extension method as follows:

 public static Bitmap ImageBlurFilter(this Bitmap sourceBitmap,  
                                             BlurType blurType) 
{  
     Bitmap resultBitmap = null; 

       
     switch (blurType) 
     {  
         case BlurType.Mean3x3: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                                Matrix.Mean3x3, 1.0 / 9.0, 0); 
              } break; 
         case BlurType.Mean5x5: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                                Matrix.Mean5x5, 1.0 / 25.0, 0); 
              } break; 
         case BlurType.Mean7x7: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                                Matrix.Mean7x7, 1.0 / 49.0, 0); 
              } break; 
         case BlurType.Mean9x9: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                                Matrix.Mean9x9, 1.0 / 81.0, 0); 
              } break; 
         case BlurType.GaussianBlur3x3: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                         Matrix.GaussianBlur3x3, 1.0 / 16.0, 0); 
              } break; 
         case BlurType.GaussianBlur5x5: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                        Matrix.GaussianBlur5x5, 1.0 / 159.0, 0); 
              } break; 
         case BlurType.MotionBlur5x5: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                           Matrix.MotionBlur5x5, 1.0 / 10.0, 0); 
              } break; 
         case BlurType.MotionBlur5x5At45Degrees: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                 Matrix.MotionBlur5x5At45Degrees, 1.0 / 5.0, 0); 
              } break; 
         case BlurType.MotionBlur5x5At135Degrees: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                 Matrix.MotionBlur5x5At135Degrees, 1.0 / 5.0, 0); 
              } break; 
         case BlurType.MotionBlur7x7: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                 Matrix.MotionBlur7x7, 1.0 / 14.0, 0); 
              } break; 
         case BlurType.MotionBlur7x7At45Degrees: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                 Matrix.MotionBlur7x7At45Degrees, 1.0 / 7.0, 0); 
              } break; 
         case BlurType.MotionBlur7x7At135Degrees: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                 Matrix.MotionBlur7x7At135Degrees, 1.0 / 7.0, 0); 
              } break; 
         case BlurType.MotionBlur9x9: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                 Matrix.MotionBlur9x9, 1.0 / 18.0, 0); 
              } break; 
         case BlurType.MotionBlur9x9At45Degrees: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                 Matrix.MotionBlur9x9At45Degrees, 1.0 / 9.0, 0); 
              } break; 
         case BlurType.MotionBlur9x9At135Degrees: 
              {  
                 resultBitmap = sourceBitmap.ConvolutionFilter( 
                 Matrix.MotionBlur9x9At135Degrees, 1.0 / 9.0, 0); 
              } break; 
         case BlurType.Median3x3: 
              {  
                 resultBitmap = sourceBitmap.MedianFilter(3); 
              } break; 
         case BlurType.Median5x5: 
              {  
                 resultBitmap = sourceBitmap.MedianFilter(5); 
              } break; 
         case BlurType.Median7x7: 
              {  
                 resultBitmap = sourceBitmap.MedianFilter(7); 
              } break; 
         case BlurType.Median9x9: 
              {  
                 resultBitmap = sourceBitmap.MedianFilter(9); 
              } break; 
         case BlurType.Median11x11: 
              {  
                 resultBitmap = sourceBitmap.MedianFilter(11); 
              } break; 
      }  

   
     return resultBitmap; 
}

Daisy: Motion Blur 9×9

The Matrix class serves as a collection of various kernel definitions. The Matrix class and all public properties are defined as static. The definition of the Matrix class as follows:

     public static class Matrix 
    {  
         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 }, }; 
            }  
        }  

    
        public static double[,] Mean7x7 
        {  
             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, 1, 1, 1 }, 
                  {  1, 1, 1, 1, 1, 1, 1 }, 
                  {  1, 1, 1, 1, 1, 1, 1 }, 
                  {  1, 1, 1, 1, 1, 1, 1 }, }; 
             }  
        }  

    
         public static double[,] Mean9x9 
         {  
             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, 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, 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, 1, 1, 1, 1, 1, 1 }, }; 
            }  
        }  

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

    
        public static double[,] GaussianBlur5x5 
        {  
            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[,] MotionBlur5x5 
        {  
             get 
            {  
                return new double[,]   
                { {  1, 0, 0, 0, 1 },  
                  {  0, 1, 0, 1, 0 },  
                  {  0, 0, 1, 0, 0 }, 
                  {  0, 1, 0, 1, 0 }, 
                  {  1, 0, 0, 0, 1 }, }; 
            }  
        }  

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

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

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

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

    
        public static double[,] MotionBlur7x7At135Degrees 
        {  
            get 
            {  
                return new double[,]   
                { {  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 }, }; 
            }  
        }  

    
        public static double[,] MotionBlur9x9 
        {  
            get 
            {  
                return 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 static double[,] MotionBlur9x9At45Degrees 
        {  
             get 
            {  
                return 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 static double[,] MotionBlur9x9At135Degrees 
        {  
             get 
            {  
                return 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, }, }; 
            }  
        }  
    }

Daisy: Median 7×7

The MedianFilter extension method targets the Bitmap class. The MedianFilter method applies a Median Filter using the specified Bitmap and matrix size (window size), returning a new Bitmap representing the filtered image.

The definition of the MedianFilter extension method as follows:

 public static Bitmap MedianFilter(this Bitmap sourceBitmap, 
                                   int matrixSize) 
{ 
     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; 

   
     List<int> neighbourPixels = new List<int>(); 
     byte[] middlePixel; 

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

   
             neighbourPixels.Clear(); 

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

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

   
                     neighbourPixels.Add(BitConverter.ToInt32( 
                                      pixelBuffer, calcOffset)); 
                 } 
             } 

   
             neighbourPixels.Sort(); 
  
             middlePixel = BitConverter.GetBytes( 
                                neighbourPixels[filterOffset]); 

   
             resultBuffer[byteOffset] = middlePixel[0]; 
             resultBuffer[byteOffset + 1] = middlePixel[1]; 
             resultBuffer[byteOffset + 2] = middlePixel[2]; 
             resultBuffer[byteOffset + 3] = middlePixel[3]; 
         } 
     }

   
     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: Motion Blur 9×9

The sample source code performs image convolution by invoking the ConvolutionFilter extension method.

The definition of the ConvolutionFilter extension method 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; 

   
    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; 

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

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

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

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

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 pink daisy is licensed under the Creative Commons Attribution-Share Alike 2.5 Generic license and can be downloaded from Wikipedia.

The sample images featuring an image of a purple daisy is licensed under the Creative Commons Attribution-ShareAlike 3.0 License and can be downloaded from Wikipedia.

The Original Image