Famous Otsu Thresholding in C#

• Download source code - 285 KB

Introduction

Thresholding is a very basic operation in image processing. And, a good algorithm always begins with a good basis! Otsu thresholding is a simple yet effective global automatic thresholding method for binarizing grayscale images such as foregrounds and backgrounds.

Background

In image processing, Otsu’s thresholding method (1979) is used for automatic binarization level decision, based on the shape of the histogram. The algorithm assumes that the image is composed of two basic classes: Foreground and Background. It then computes an optimal threshold value that minimizes the weighted within class variances of these two classes. It is mathematically proven that minimizing the within class variance is same as maximizing the between class variance.

Otsu threshold is used in many applications from medical imaging to low level computer vision. It has many advantages and assumptions.

Advantages

• Speed: Because Otsu threshold operates on histograms (which are integer or float arrays of length 256), it’s quite fast.
• Ease of coding: Approximately 80 lines of very easy stuff.

Disadvantages

• Assumption of uniform illumination.
• Histogram should be bimodal (hence the image).
• It doesn’t use any object structure or spatial coherence.
• The non-local version assumes uniform statistics.

Mathematical Formulation

Where q1 and q2 represent the estimate of class probabilities defined as:

   and  

and sigmas are the individual class variances defined as:

   and  

and the class means:

   and  

Here, P represents the image histogram. The problem of minimizing within class variance can be expressed as a maximization problem of the between class variance. It can be written as a difference of total variance and within class variance:

   =  

Finally, this expression can safely be maximized and the solution is t that is maximizing .

Algorithm

Now, let's take a look at Otsu's thresholding from a more algorithmic point of view. Here are the steps of the algorithm:

For each potential threshold T, we:

1. Separate the pixels into two clusters according to the threshold.
2. Find the mean of each cluster.
3. Square the difference between the means.
4. Multiply by the number of pixels in one cluster times the number in the other.

If we incorporate a little math into that simple step-wise algorithm, such an explanation evolves:

1. Compute histogram and probabilities of each intensity level.
2. Set up initial qi(0) and μi(0).
3. Step through all possible thresholds maximum intensity.
4. Update qi and μi.
5. Compute .
6. Desired threshold corresponds to the maximum.

Another Perception

Since Otsu operates over the histograms, it's very wise to analyze the image histogram and decision of threshold level. I think this simple image will be enough to summarize the story (the threshold value is marked by the red arrow):

Using the Code

It's pretty simple to use the code. Otsu Thresholding works on grayscale images. So firstly, we have to convert our image into a gray scale one. After that, we can obtain our Otsu threshold value by solving for maximal t. Finally, we threshold our image using this t value. In short, the usage looks like this:

Bitmap temp = (Bitmap)org.Clone();
ot.Convert2GrayScaleFast(temp);
int otsuThreshold= ot.getOtsuThreshold((Bitmap)temp);
ot.threshold(temp,otsuThreshold);
textBox1.Text = otsuThreshold.ToString();
pictureBox1.Image = temp;

If we look inside the getOtsuThreshold function, it looks like this:

public int getOtsuThreshold(Bitmap bmp)
{
    byte t=0;
    float[] vet=new float[256];
    int[] hist=new int[256];
    vet.Initialize();

    float p1,p2,p12;
    int k;

    BitmapData bmData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height),
    ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
    unsafe
    {
        byte* p = (byte*)(void*)bmData.Scan0.ToPointer();

        getHistogram(p,bmp.Width,bmp.Height,bmData.Stride, hist);

        
        for (k = 1; k != 255; k++)
        {
            p1 = Px(0, k, hist);
            p2 = Px(k + 1, 255, hist);
            p12 = p1 * p2;
            if (p12 == 0) 
                p12 = 1;
            float diff=(Mx(0, k, hist) * p2) - (Mx(k + 1, 255, hist) * p1);
            vet[k] = (float)diff * diff / p12;
            
        }
    }
    bmp.UnlockBits(bmData);

    t = (byte)findMax(vet, 256);

    return t;
}

For more information on how to efficiently process images in C#, please refer to my older articles such as "Image Processing Basics in C#".

Points of Interest

Otsu thresholding doesn't claim to be the best automatic thresholding ever, but there are many applicable uses in computer vision and medical imaging. It's a first step to get non-parametrized, adaptive algorithms. Addition to that, there may be faster implementations available (such as recursive algorithms).

Also, Otsu threshold can be extended to a multi-level thresholding which could result in segmentation. Such research is present in the literature. This may be a further article. Please check:

• http://www.iis.sinica.edu.tw/page/jise/2001/200109_01.pdf

History

• Version 1.0.

Reference

• Otsu, N., "A Threshold Selection Method from Gray-Level Histograms," IEEE Transactions on Systems, Man, and Cybernetics, Vol. 9, No. 1, 1979, pp. 62-66.