Navigation

Related Articles

Back to Latest Articles

How To Make A Basic Global Thresholding Algorithm – C#

This tutorial demonstrates how to get optimal threshold value for basic global thresholding operation for segmentation in image processing.


Andraz Krzisnik
How To Make A Basic Global Thresholding...

We used global thresholding process when we worked with edge detection segmentation operations. However, we’re going in a little deeper with this tutorial, where I’m going to introduce it a little more formally.

When I used thresholding in other guides, I basically just set the threshold value experimentally. Therefore, results that I got from those algorithms were more or less tailored for the example images I demonstrated with.

But you could still get good results using different images, as long their intensity distribution was similar to example ones. Thresholding in general is a process, where we split intensity values based on their distribution.

When we use global thresholding, we set a single intensity value as a threshold. Furthermore, we can get a more clear idea how we’re splitting pixels into two sets by looking at the image histogram. If we have a gap between object and background pixel intensities, we can split them pretty easily.

It get’s complicated when the image has considerable amount of noise which can cause intensity distribution to blend into one. At that point we need to do some preprocessing or different type of thresholding.

How does basic global thresholding work?

In order to find a suitable threshold for each image, we need to use an algorithm for estimating it. It’s basically an iterative process, where we set a condition which checks if the estimated value changed for less than or equal to some predefined amount before stoping the iterations.

In other words, it searches for most optimal value for each specific image.

I’m going to separate this iterative process into 4 steps. First of all, we need to set the initial threshold value. We can just set it by our choice or we can use the average intensity value of the whole image. In the example I made for this post I used the average.

Secondly, we split pixel values into two sets, to pixels with intensities below the threshold and above it.

For the third step, we’re going to compute mean intensity values for each of the set.

And lastly, we’re going to get the average intensity of the set means we calculated in the previous step. In other words, we’ll sum the means together and divide them by 2. Furthermore, this value will serve as our new initial thresholding value.

All we have to do now is just repeat this process until the change between the old and the new initial thershold value is lower than some predefined value. In case you’re dealing with images which have a distinct gap between intensity distributions, we can set it also to 0.

After we get our optimal value, we use it to segment the image. This part is more familiar as we used it before in other segmentation processes. Intensities below the threshold are set to 0 and those above it to 255.

Code

public static Bitmap GlobalThresholding(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];
         byte[] result = new byte[bytes];

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

         //Getting threshold intensity value
         int[] converted = buffer.Select(x => (int)x).ToArray();
         int init = converted.Sum() / bytes;
         int delta = 1;

         while (delta > 0)
         {
             int[] histogram = new int[255];
             for (int i = 0; i < bytes; i += 3)
             {
                 histogram[buffer[i]]++;
             }

             int mean1 = 0;
             int mean2 = 0;
             int sum1 = 0;
             int sum2 = 0;

             for (int i = 0; i < 255; i++)
             {
                 if (i <= init)
                 {
                     mean1 += histogram[i] * i;
                     sum1 += histogram[i];
                 }
                 else
                 {
                     mean2 += histogram[i] * i;
                     sum2 += histogram[i];
                 }
             }

             mean1 /= sum1;
             mean2 /= sum2;
             delta = init;
             init = (mean1 + mean2) / 2;
             delta = Math.Abs(delta - init);
         }

         //Thresholding
         for (int i = 0; i < bytes; i++)
         {
             result[i] = (byte)(buffer[i] >= init ? 255 : 0);
         }

         Bitmap res_img = new Bitmap(w, h);
         BitmapData res_data = res_img.LockBits(
             new Rectangle(0, 0, w, h),
             ImageLockMode.WriteOnly,
             PixelFormat.Format24bppRgb);
         Marshal.Copy(result, 0, res_data.Scan0, bytes);
         res_img.UnlockBits(res_data);

         return res_img;
     }

Conclusion

I hope this tutorial on global thresholding was helpful.

You can also download the demo project and try it out yourself.

Related Articles

C# Tutorial

Intensity Level Slicing With C# – Explore Image Processing

In this tutorial we will be talking about intensity level slicing in image processing. What is Intensity Level Slicing It’s a process that highlights pixels in an arbitrary...

Posted on by Andraz Krzisnik
Image Noise

How To Make Gamma Noise On Images – C# Guide

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

Posted on by Andraz Krzisnik