### How To Use Median Filter On Images – C# Guide

Median filter is one of the order-statistic filters for processing image data in spatial domain. This guide shows how to apply it with C#.

Filter by Category

- C# Tutorial(85)
- C# Image Processing(69)
- Morphological Processes(20)
- Image Processing(16)
- Image Restoration and Reconstruction(16)
- Image Segmentation(13)
- C# Data Structures And Algorithms(11)
- Color Image Processing(8)
- Frequency Domain Filtering(8)
- Image Noise(6)
- Grayscale Morphology(5)
- Thresholding(4)
- Order-Statistic Filters(4)
- Mean Filters(4)
- Sorting Algorithms(4)
- Morphological Reconstruction(3)
- Edge Detection(3)
- Simple Lists(2)
- RGB to HSI Color Model(2)
- Adaptive Filters(2)
- Tone and Color Corrections(2)
- Linked Lists(2)
- Stacks(1)
- Queues(1)
- Point Detection(1)
- Line Detection(1)
- C# Arrays(1)
- Region Segmentation Using Superpixels(1)
- Region Segmentation With K Means Clustering(1)
- Region Splitting And Merging(1)
- Sorted Lists(1)
- Region Growing Segmentation(1)
- Digital Image Watermarking(1)
- Using Color In Image Segmentation(1)
- Social Games(1)
- Bandreject Filters(1)
- Bandpass filters(1)
- Notch Filters(1)
- Landing Pages(1)
- Intensity Slicing and Color Coding(1)
- Color Slicing(1)
- Histogram Processing Color Images(1)
- Color Image Smoothing And Sharpening(1)
- C# Basics(1)

Back to Latest Articles
###
How To Use Median Filter On Images – C# Guide

###
How To Use Contraharmonic Mean Filter – C# Guide

###
How To Use Harmonic Mean Filter On Images – C# Guide

###
How To Use Geometric Mean Filter On Image – C# Guide

###
How To Use Arithmetic Mean Filter On Images – C# Guide

###
How To Add Salt And Pepper Noise On Image – C# Guide

###
How To Make Uniform Noise On Images – C# Guide

###
How To Make Exponential Noise On Image – C# Guide

###
How To Make Gamma Noise On Images – C# Guide

###
How To Make Rayleigh Noise On Image – C# Guide

Order-Statistic Filters

Median filter is one of the order-statistic filters for processing image data in spatial domain. This guide shows how to apply it with C#.

Mean Filters

We can use contraharmonic mean filter to process image data in spatial domain. It's most effective against salt and pepper noise.

Mean Filters

Harmonic mean filter is of mean filters we can use to process image data in spatial domain. This guide shows how to apply it with C#.

Mean Filters

Geometric mean filter is one of mean filters we can use processing images in spatial domain. We use C# programming language to apply it here.

Mean Filters

Arithmetic mean filter is one of the simplest mean filters we could use to reduce noise from an image. Learn more about spatial filtering.

Image Noise

Salt and pepper noise or impulse noise is one of the noise models we can use to simulate image data corruption in real life.

Image Noise

Uniform noise is one of the noise models we can use to simulate real life data corruption. This guide shows how to make in on images.

Image Noise

Exponential noise is one of the noise models we can use to simulate corruption of data. This guide show how to use it on images.

Image Noise

Gamma noise is one of the noise models we use to simulate practical data corruption. This guide shows how to apply it on images.

Image Noise

Rayleigh noise is one of the noise models with which we can simulate data corruption. Guide to making noise from PDF and image histogram.

How To Use Median Filter On Images –...

Median filter is one of order specific filters we can use to process image data in spatial domain. Therefore, we will need to use a kernel, which will encompass image pixels to process them further.

Order specific filters output values by ordering them in a specific way and picking one that satisfies the condition of the filter. We also mentioned we will need a kernel or filter, which will allow us to sort and pick output pixel intensity values locally.

We will get our output image by moving our filter across the entire input image, we wish to process, one pixel at a time. It is also worth mentioning that each filter location will produce only one output value. Therefore, we will end up with an image that has slightly smaller dimensions.

To compensate for this loss, we could use zero padding to add pixels with 0 intensity around the image before we filter it.

As its name implies, median filter outputs pixel with median intensity value from local set of pixels. In case you’re not entirely familiar with what median actually is, don’t worry I’ll explain it now. Median is the middle value in a set of sorted values.

Median is not mean. The difference between the two is that we calculate mean from a set of values. While with median we pick out a value that already exists in that set.

This filter is particularly useful for removing salt and pepper noise. We demonstrated harmonic and contraharmonic mean filters to remove this kind of noise before. However, we never got as good result with them as we got it with median filter.

Following formula does what we described above.

The *g(s, t)* represents pixel intensity value that’s located with *s* and *t* coordinates inside the kernel.

```
public static Bitmap MedianFilter(this Bitmap image)
{
int w = image.Width;
int h = image.Height;
```` BitmapData image_data = image.LockBits(`

` new Rectangle(0, 0, w, h),`

` ImageLockMode.ReadOnly,`

` PixelFormat.Format24bppRgb);`

` int bytes = image_data.Stride * image_data.Height;`

` byte[] buffer = new byte[bytes];`

` Marshal.Copy(image_data.Scan0, buffer, 0, bytes);`

` image.UnlockBits(image_data);`

` int r = 1;`

` int wres = w - 2 * r;`

` int hres = h - 2 * r;`

` Bitmap result_image = new Bitmap(wres, hres);`

` BitmapData result_data = result_image.LockBits(`

` new Rectangle(0, 0, wres, hres),`

` ImageLockMode.WriteOnly,`

` PixelFormat.Format24bppRgb);`

` int res_bytes = result_data.Stride * result_data.Height;`

` byte[] result = new byte[res_bytes];`

` for (int x = r; x < w - r; x++)`

` {`

` for (int y = r; y < h - r; y++)`

` {`

` int pixel_location = x * 3 + y * image_data.Stride;`

` int res_pixel_loc = (x - r) * 3 + (y - r) * result_data.Stride;`

` double[] median = new double[3];`

` byte[][] neighborhood = new byte[3][];`

` for (int c = 0; c < 3; c++)`

` {`

` neighborhood[c] = new byte[(int)Math.Pow(2 * r + 1, 2)];`

` int added = 0;`

` for (int kx = -r; kx <= r; kx++)`

` {`

` for (int ky = -r; ky <= r; ky++)`

` {`

` int kernel_pixel = pixel_location + kx * 3 + ky * image_data.Stride;`

` neighborhood[c][added] = buffer[kernel_pixel + c];`

` added++;`

` }`

` }`

` }`

` for (int c = 0; c < 3; c++)`

` {`

` result[res_pixel_loc + c] = (byte)(neighborhood[c].median());`

` }`

` }`

` }`

` Marshal.Copy(result, 0, result_data.Scan0, res_bytes);`

` result_image.UnlockBits(result_data);`

` return result_image;`

` }`

Median filter is just one of order statistic filters, but it really works for images that have random distributed noise like impulse noise.

I hope this guide was helpful. You can also **download the entire project** and try it out on your own images.