Tag Archives: global thresholding

Balanced histogram thresholding

In the previous blogs, we discussed different methods for automatically finding the global threshold for an image. For instance, the iterative method, Otsu’s method, etc. In this blog, we will discuss another very simple approach for automatic thresholding – Balanced histogram thresholding. As clear from the name, this method tries to automatically find the threshold by balancing the image histogram. Let’s understand this method in detail.

Note: This method assumes that the image histogram is bimodal and a reasonable contrast ratio exists between the background and the region of interest.

Concept

Suppose you have a perfectly balanced histogram i.e. a histogram where the distribution of the background and the roi is the same. If you place such a histogram over the lever, it will be balanced. And the optimum threshold will be at the center of the lever as shown in the figure below

This is the main idea behind the Balanced Histogram Thresholding. This method tries to balance the image histogram and then infer the threshold value from that.

But in real-life situations, we don’t encounter images with such perfectly balanced histograms. So, let’s see how this method balances the unbalanced histograms.

First, it places the histogram over the lever and calculates the center point.
Then this calculates the left side and right side weights from the center point.
Removes weight from the heavier side and adjust the center.
Repeat the above two steps until the starting and the endpoints are equal to the center.

The whole procedure can be summed up in the below gif (taken from Wikipedia)

**Credits: By Power3d – Own work, CC BY-SA 3.0**

Below is the python code for this. Here, i_s, i_e are the starting and the endpoints of the histogram and i_m is the center

def balanced_hist_thresholding(b):
    # Starting point of histogram
    i_s = np.min(np.where(b[0]>0))
    # End point of histogram
    i_e = np.max(np.where(b[0]>0))
    # Center of histogram
    i_m = (i_s + i_e)//2
    # Left side weight
    w_l = np.sum(b[0][0:i_m+1])
    # Right side weight
    w_r = np.sum(b[0][i_m+1:i_e+1])
    # Until starting point not equal to endpoint
    while (i_s != i_e):
        # If right side is heavier
        if (w_r > w_l):
            # Remove the end weight
            w_r -= b[0][i_e]
            i_e -= 1
            # Adjust the center position and recompute the weights
            if ((i_s+i_e)//2) < i_m:
                w_l -= b[0][i_m]
                w_r += b[0][i_m]
                i_m -= 1
        else:
            # If left side is heavier, remove the starting weight
            w_l -= b[0][i_s]
            i_s += 1
            # Adjust the center position and recompute the weights
            if ((i_s+i_e)//2) >= i_m:
                w_l += b[0][i_m+1]
                w_r -= b[0][i_m+1]
                i_m += 1
    return i_m

def balanced_hist_thresholding(b):

# Starting point of histogram

i_s = np.min(np.where(b[0]>0))

# End point of histogram

i_e = np.max(np.where(b[0]>0))

# Center of histogram

i_m = (i_s + i_e)//2

# Left side weight

w_l = np.sum(b[0][0:i_m+1])

# Right side weight

w_r = np.sum(b[0][i_m+1:i_e+1])

# Until starting point not equal to endpoint

while (i_s != i_e):

# If right side is heavier

if (w_r > w_l):

# Remove the end weight

w_r -= b[0][i_e]

i_e -= 1

# Adjust the center position and recompute the weights

if ((i_s+i_e)//2) < i_m:

w_l -= b[0][i_m]

w_r += b[0][i_m]

i_m -= 1

else:

# If left side is heavier, remove the starting weight

w_l -= b[0][i_s]

i_s += 1

# Adjust the center position and recompute the weights

if ((i_s+i_e)//2) >= i_m:

w_l += b[0][i_m+1]

w_r -= b[0][i_m+1]

i_m += 1

return i_m

The above function takes the image histogram as the input and returns the optimum threshold. Let’s take an example to check how this works.

import cv2
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
np.random.seed(7)

# Create a sample image
img = np.random.normal(40,10,size=(500,500)).astype('uint8')
img[img>100]=40
img[100:400,100:400] = np.random.normal(150,20,size=(300,300)).astype('uint8')

# Plot the histogram
b1 = plt.hist(img.ravel(),256,[0,256])
plt.show()

import cv2

import numpy as np

import matplotlib.pyplot as plt

%matplotlib inline

np.random.seed(7)

# Create a sample image

img = np.random.normal(40,10,size=(500,500)).astype('uint8')

img[img>100]=40

img[100:400,100:400] = np.random.normal(150,20,size=(300,300)).astype('uint8')

# Plot the histogram

b1 = plt.hist(img.ravel(),256,[0,256])

plt.show()

Below is the histogram of the image constructed.

Now, let’s apply the Balanced Histogram thresholding method to check what threshold value this outputs.

thresh_value = balanced_hist_thresholding(b1)
>>> 87

1 2	thresh_value = balanced_hist_thresholding(b1) >>> 87

87 looks like a reasonable threshold, check the image histogram above. So, that’s all for this time. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Improving Global Thresholding

Leave a reply

In the previous blog, we discussed otsu’s method for automatic image thresholding. Then we also discussed the limitations of the otsu’s method. In this blog, we will discuss how to handle these limitations so as to produce satisfactory thresholding results. So, let’s get started.

Case-1: When the noise is present in the image

If the noise is present in the image, then this tends to change the modality of the histogram. The sharp valleys between the peaks of the bimodal histogram start degrading. In that case, the otsu’s method or any other global thresholding method will fail. So, in order to find the global threshold, one should first remove the noise using any smoothing filters like Gaussian, etc. and then apply any automatic thresholding method like otsu, etc.

Case-2: When the object area is small compared to the background area

In this case, the image histogram will be dominated by a large background area. This will increase the probability of any pixel belonging to the background. So, the histogram will no longer exhibit bimodality and thus otsu will result in segmentation error. To prevent this, one should only consider pixels that lie on or near the edges between the objects and the background. Doing so will result in an image histogram with peaks of approximately the same size. Then we can apply any automatic thresholding method like otsu, etc. Below are the steps to implement the above procedure.

Calculate the edge image using any high pass filter like Sobel, Laplacian, etc.
Select any threshold value (T).
Threshold the above edge image to produce a binary mask.
Apply the mask image on the input image using any bitwise operations or any other method.
This results in only those pixels where the mask image was white.
Compute the histogram of only those pixels
Finally, apply any automatic global thresholding method like otsu, etc.

Case-3: When the image is taken under non-uniform illumination conditions

In this case, the histogram no longer remains bimodal and thus we will not be able to segment the image satisfactorily. One of the simplest approaches is to subdivide the image into non-overlapping images/rectangles. The size of these rectangles is chosen such that the illumination is nearly constant in each of these rectangles. Then we will apply any global thresholding technique like otsu for each of these rectangles.

The above procedure only works when the size of the object and the background are comparable in the rectangle. This is quite intuitive as only then we will have a bimodal histogram. Taking care of the background and the object sizes in each rectangle is a tedious task.

So, in the next blog, we will discuss adaptive thresholding that works pretty well for the above conditions. That’s all for this blog. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Global Thresholding

Leave a reply

In the previous blog, we discussed image thresholding and when to use this for image segmentation. We also learned that thresholding can be global or adaptive depending upon how the threshold value is selected.

In this blog, we will discuss

global thresholding
OpenCV function for global thresholding
How to choose threshold value using the iterative algorithm

In global thresholding, each pixel value in the image is compared with a single (global) threshold value. Below is the code for this.

def global_threshold(image, thres_value, val_high, val_low):
    img = image.copy()
    for i in range(image.shape[0]):
        for j in range(image.shape[1]):
            if image[i,j] > thres_value:
                img[i,j] = val_high
            else:
                img[i,j] = val_low
    return img

def global_threshold(image, thres_value, val_high, val_low):

img = image.copy()

for i in range(image.shape[0]):

for j in range(image.shape[1]):

if image[i,j] > thres_value:

img[i,j] = val_high

else:

img[i,j] = val_low

return img

Here, we assign a value of “val_high” to all the pixels greater than the threshold otherwise “val_low“. OpenCV also provides a builtin function for thresholding the image. So, let’s take a look at that function.

OpenCV

cv2.threshold(src, thresh, maxval, type) → retval, dst

1	cv2.threshold(src, thresh, maxval, type) → retval, dst

This function returns the thresholded image(dst) and the threshold value(retval). Its arguments are

src: input greyscale image (8-bit or 32-bit floating point)
thresh: global threshold value
type: Different types that decide “val_high” and “val_low“. In other words, these types decide what value to assign for pixels greater than and less than the threshold. Below figure shows different thresholding types available.
maxval: maximum value to be used with THRESH_BINARY and THRESH_BINARY_INV. Check the below image.

To specify the thresholding type, write “cv2.” as the prefix. For instance, write cv2.THRESH_BINARY if you want to use this type. Let’s take an example

import cv2
# Load an image in the greyscale
img = cv2.imread('D:/downloads/opencv_logo1.PNG',cv2.IMREAD_GRAYSCALE)
# threshold the image
ret, thresh = cv2.threshold(img,75,255,cv2.THRESH_BINARY)

import cv2

# Load an image in the greyscale

img = cv2.imread('D:/downloads/opencv_logo1.PNG',cv2.IMREAD_GRAYSCALE)

# threshold the image

ret, thresh = cv2.threshold(img,75,255,cv2.THRESH_BINARY)

Similarly, you can apply other thresholding types to check how they work. Till now we discussed how to threshold an image using a global threshold value. But we didn’t discuss how to get this threshold value. So, in the next section, let’s discuss this.

How to choose the threshold value?

As already discussed, that global thresholding is a suitable approach only when intensity distributions of the background and the ROI are sufficiently distinct. In other words, there is a clear valley between the peaks of the histogram. We can easily select the threshold value in that situation. But what if we have a number of images. In that case, we don’t manually want to first check the image histogram and then deciding the threshold value. We want something that can automatically estimate the threshold value for each image. Below is the algorithm that can be used for this purpose.

Below is the code for the above algorithm.

def thres_finder(img, thres=20,delta_T=1.0):
    
    # Step-2: Divide the images in two parts
    x_low, y_low = np.where(img<=thres)
    x_high, y_high = np.where(img>thres)
    
    # Step-3: Find the mean of two parts
    mean_low = np.mean(img[x_low,y_low])
    mean_high = np.mean(img[x_high,y_high])
    
    # Step-4: Calculate the new threshold
    new_thres = (mean_low + mean_high)/2
    
    # Step-5: Stopping criteria, otherwise iterate
    if abs(new_thres-thres)< delta_T:
        return new_thres
    else:
        return thres_finder(img, thres=new_thres,delta_T=1.0)

def thres_finder(img, thres=20,delta_T=1.0):

# Step-2: Divide the images in two parts

x_low, y_low = np.where(img<=thres)

x_high, y_high = np.where(img>thres)

# Step-3: Find the mean of two parts

mean_low = np.mean(img[x_low,y_low])

mean_high = np.mean(img[x_high,y_high])

# Step-4: Calculate the new threshold

new_thres = (mean_low + mean_high)/2

# Step-5: Stopping criteria, otherwise iterate

if abs(new_thres-thres)< delta_T:

return new_thres

else:

return thres_finder(img, thres=new_thres,delta_T=1.0)

Now, let’s take an example to check how’s this working.

import cv2
# Load an image in the greyscale
img = cv2.imread('D:/downloads/opencv_logo1.PNG',cv2.IMREAD_GRAYSCALE)
# apply threshold finder
vv1 = thres_finder1(img, thres=30,delta_T=1.0)
# threshold the image
ret, thresh = cv2.threshold(img,vv1,255,cv2.THRESH_BINARY)
# Display the image side by side
out = cv2.hconcat([img,thresh])
cv2.imshow('threshold',out)
cv2.waitKey(0)

import cv2

# Load an image in the greyscale

img = cv2.imread('D:/downloads/opencv_logo1.PNG',cv2.IMREAD_GRAYSCALE)

# apply threshold finder

vv1 = thres_finder1(img, thres=30,delta_T=1.0)

# threshold the image

ret, thresh = cv2.threshold(img,vv1,255,cv2.THRESH_BINARY)

# Display the image side by side

out = cv2.hconcat([img,thresh])

cv2.imshow('threshold',out)

cv2.waitKey(0)

That’s all for this blog. In the next blog, we will discuss how to perform optimum global thresholding using Otsu’s method. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

Image Thresholding

Leave a reply

Image Segmentation is the process of subdividing an image into its constituent regions or objects. In many computer vision applications, image segmentation is very useful to detect the region of interest. For instance, in medical imaging where we have to locate tumors, or in object detection like self-driving cars have to detect pedestrians, traffic signals, etc or for video surveillance, etc. There are a number of methods available to perform image segmentation. For instance, thresholding, clustering methods, graph partitioning methods, and convolutional methods to mention a few.

In this blog, we will discuss Image Thresholding which is one of the simplest methods for image segmentation. In this, we partition the images directly into regions based on the intensity values. So, let’s discuss image thresholding in greater detail.

Concept

If the pixel value is greater than a threshold value, it is assigned one value (maybe white), else it is assigned another value (maybe black).

In other words, if f(x,y) is the input image then the segmented image g(x,y) is given by

If the threshold value T remains constant over the entire image, then this is known as global thresholding. When the value of T changes over the entire image or depends upon the pixel neighborhood, then this is known as adaptive thresholding. We will cover both these types in greater detail in the following blogs.

Applicability Condition

Thresholding is only guaranteed to work when a good contrast ratio between the region of interest and the background exists. Otherwise, the thresholding will not be able to fully detect the region of interest. Let’s understand this by an example.

Suppose we have two images from which we want to segment the square region (our region of interest) from the background.

Let’s plot the histogram of these two images.

Clearly as expected for “A“, the histogram is showing two peaks corresponding to the square and the background. The separation between the peaks shows that the background and ROI have a good contrast ratio. By choosing a threshold value between the peaks, we will be able to segment out the ROI. While for “B”, the intensity distribution of the ROI and the background is not that distinct. Thus we may not be able to fully segment the ROI.

Thresholded images are shown below (How to choose a threshold value will be discussed in the next blog).

So, always plot the image histogram to check the contrast ratio between the background and the ROI. Only if the contrast ratio is good, choose the thresholding method for image segmentation. Otherwise, look for other methods.

In the next blog, we will discuss global thresholding and how to choose the threshold value using the iterative method. Hope you enjoy reading.

If you have any doubt/suggestion please feel free to ask and I will do my best to help or improve myself. Good-bye until next time.

TheAILearner

Mastering Artificial Intelligence

Tag Archives: global thresholding

Balanced histogram thresholding

Concept

Improving Global Thresholding

Case-1: When the noise is present in the image

Case-2: When the object area is small compared to the background area

Case-3: When the image is taken under non-uniform illumination conditions

Global Thresholding

OpenCV

How to choose the threshold value?

Image Thresholding

Concept

Applicability Condition