C# How to: Image Median Filter

Article purpose

The objective of this article is focussed on providing a discussion on implementing a Median Filter on an image. This article illustrates varying levels of filter intensity: 3×3, 5×5, 7×7, 9×9, 11×11 and 13×13.

Sample source code

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

Using the Sample Application

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

When using the Image Median Filter sample application you can specify a input/source image by clicking the Load Image button. The dropdown combobox towards the bottom middle part of the screen relates the various levels of filter intensity.

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

The following image is screenshot of the Image Median Filter sample application in action:

What is a Median Filter

From Wikipedia we gain the following quotes:

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 (but see discussion below).

The main idea of the median filter is to run through the signal entry by entry, replacing each entry with the median of neighboring entries. The pattern of neighbors is called the "window", which slides, entry by entry, over the entire signal. For 1D signals, the most obvious window is just the first few preceding and following entries, whereas for 2D (or higher-dimensional) signals such as images, more complex window patterns are possible (such as "box" or "cross" patterns). Note that if the window has an odd number of entries, then the median is simple to define: it is just the middle value after all the entries in the window are sorted numerically. For an even number of entries, there is more than one possible median, see median for more details.

In simple terms, a Median Filter can be applied to images in order to achieve image smoothing or image noise reduction. The Median Filter in contrast to most image smoothing methods, to a degree exhibits edge preservation properties.

Applying a Median Filter

The sample source code defines the MedianFilter extension method targeting the Bitmap class. The matrixSize parameter determines the intensity of the Median Filter being applied.

The MedianFilter extension method iterates each pixel of the source image. When iterating image pixels we determine the neighbouring pixels of the pixel currently being iterated. After having built up a list of neighbouring pixels, the List is then sorted and from there we determine the middle pixel value. The final step involves assigning the determined middle pixel to the current pixel in the resulting image, represented as an array of pixel colour component bytes.

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

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

Sample Images

The sample images illustrated in this article were rendered from the same source image which 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 is attributed to Luc Viatour – www.Lucnix.be and can be downloaded from Wikipedia.

The Original Source Image

Median 3×3 Filter

Median 5×5 Filter

Median 7×7 Filter

Median 9×9 Filter

Median 11×11 Filter

Median 13×13 Filter

Software by Default