Navigation

Related Articles

Back to Latest Articles

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

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


Andraz Krzisnik
How To Use Arithmetic Mean Filter On Images...

We use arithmetic mean filter for processing images in the spatial domain. Therefore, we will use a kernel and convolution to get our output values.

Mean filters are generally most useful for filtering images, that only have noise degradation. In other words, we don’t need to worry about any other image alteration than that.

We mentioned we will be needing a kernel to filter our image data. In case you’re wondering what is it, it’s basically a small matrix of coefficients. Furthermore, we place this matrix on our image and compute new pixel values with convolution.

And to clearify what convolution is, it’s essentially moving kernel accross the entire image to change every pixel by multiplying it and it’s surrounding pixels with our kernel.

Arithmetic mean filter

This type of mean filter is one of the simplest we could use. However, the noise reduction comes with a cost of blurring the image.

Arithmetic mean filter calculates the average value in a set of pixel values. In other words, we sum up all pixel values within the set and divide them by the size of that set. Convolution works by multiplying each coefficient in the kernel that coincides with the pixel value and summing it all up to form output value in the center of it.

This way our arithmetic mean filter kernel would have the same coefficient in all of it’s fields, which is 1/mn. The m and n represent dimension of our kernel. To simplify all this, the following formula shows how each value in the output image is computed.

Arithmetic mean filter formula
Arithmetic mean filter formula

The g(s, t) function represents pixel value of our corrupted image on s and t coordinates inside the kernel window.

Be aware that this kind of filtering will change the size of the output image. Therefore, in order to prevent that from happening, you should use zero padding to compensate for the size reduction.

C# code

I’ve written several functions in this project, which affect the image in one way or the other. However, the following one does the heavy lifting and applies the arithmetic mean filter. But if you’re interested, I’ve also used image zero padding, and scaling for display purposes.

public static Bitmap ArithmeticMean(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[] mean = new double[3];

                 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;

                         for (int c = 0; c < 3; c++)
                         {
                             mean[c] += buffer[kernel_pixel + c] / Math.Pow(2 * r + 1, 2);
                         }
                     }
                 }

                 for (int c = 0; c < 3; c++)
                 {
                     result[res_pixel_loc + c] = (byte)mean[c];
                 }
             }
         }

         Marshal.Copy(result, 0, result_data.Scan0, res_bytes);
         result_image.UnlockBits(result_data);
         return result_image;
     }

Conclusion

When we’re filtering image data in the spatial domain, we need to get familiar with the standard process of convolution. Once we get the hang of that, understanding how spatial filters work will be a walk in the park.

I hope this guide was helpful and I hope you stick around for more. You can also download the project and try it out yourself.

Show Comments (0)

Comments

Related Articles

Digital Image Watermarking

How To Make Image Watermarking Work With C#

This tutorial shows how image watermarking works by implementing it with C# and we describe various purposes that watermarks have as well.

Posted on by Andraz Krzisnik
Order-Statistic Filters

How To Make Alpha Trimmed Mean Filter For Images

Alpha trimmed mean filter is a combination of mean filters and order-statistic filters. This guide shows how to use them with C#.

Posted on by Andraz Krzisnik