Understanding Hysteresis Thresholding with Scikit-learn in Python

Rate this post

πŸ’‘ Problem Formulation: Hysteresis thresholding is an advanced image processing technique for edge detection, often used to suppress noise in the final edge output. The challenge is to distinguish between true edge pixels and noise. In this article, we will explore how to implement hysteresis thresholding in Python using Scikit-learn, with an example where the input is a grayscale image and the desired output is a binary image highlighting the edges.

Method 1: Using Canny Edge Detection from Skimage

The Canny edge detection algorithm in the Skimage (Scikit-image) library encapsulates the process of hysteresis thresholding. This method automatically computes the high and low threshold values based on the median of the image pixel intensities and applies them to detect edges.

Here’s an example:

from skimage import io, feature

image = io.imread('path_to_image')
edges = feature.canny(image, sigma=3)


The output is a binary image with edges highlighted.

The above code snippet reads an image from a file, uses the canny function to apply the Canny edge detection algorithm with hysteresis thresholding, and finally, displays the result. Adjusting the sigma parameter can help refine the results based on image noise levels.

Method 2: Determining Thresholds Manually

In situations where automatic threshold calculation does not yield the desired results, one can manually set the high and low thresholds based on prior knowledge about the image. This approach offers more control over the edge detection output.

Here’s an example:

from skimage import filters

image = io.imread('path_to_image')
edges = feature.canny(image, low_threshold=50, high_threshold=150)


The output is a binary image with manually determined edges.

This snippet demonstrates the canny edge detector with manually specified thresholds. By adjusting the low_threshold and high_threshold parameters, we gain precision control over edge strength and noise suppression.

Method 3: Adaptive Threshold Computation

If an image has varying illumination, adaptive threshold computation can be used. The adaptive method calculates thresholds for different regions of an image, which is beneficial for images with varying lighting conditions.

Here’s an example:

from skimage.filters import threshold_local

block_size = 35
adaptive_thresh = threshold_local(image, block_size, offset=10)
binary_adaptive = image > adaptive_thresh


The output is a binary image with edges based on local illumination.

This code uses Skimage’s threshold_local function to compute local thresholds and create a binary image. The block size determines the region for local thresholding, offering adaptability to different parts of the image.

Method 4: Otsu’s Thresholding After Gaussian Blurring

Otsu’s method is an automatic threshold selection from grayscale histograms. Applying Gaussian blur can reduce noise and details, thus aiding in more robust thresholding when used in conjunction with Otsu’s method.

Here’s an example:

from skimage.filters import threshold_otsu, gaussian

image_blurred = gaussian(image, sigma=2)
thresh_otsu = threshold_otsu(image_blurred)
binary_otsu = image_blurred > thresh_otsu


The output is a noise-reduced binary image with edges.

Here, gaussian function applies the Gaussian blur, and threshold_otsu calculates the Otsu’s threshold. The binary image is obtained by comparing the blurred image to the threshold.

Bonus One-Liner Method 5: Quick Thresholding with Lambdas

For a simple and quick thresholding application, lambda functions can be used. This is less sophisticated than other methods but can be implemented with a single line of code.

Here’s an example:

binary_quick = (lambda x: x > np.mean(x))(image)


The output is a binary image obtained by a quick thresholding operation based on the mean pixel value.

This compact code uses a lambda function to create a binary image by comparing the original image to its mean pixel value. It’s a fast approach suitable for simple applications.


  • Method 1: Canny Edge Detection from Skimage. This method is powerful and effective as it leverages the sophisticated Canny algorithm. However, it may not provide an optimal result for all cases without parameter tuning.
  • Method 2: Determining Thresholds Manually. Offers great control and precision, useful for experts who understand the image content. Can be time-consuming and less effective for variable image conditions.
  • Method 3: Adaptive Threshold Computation. Excellently handles images with uneven lighting but could be computationally intensive for large images or real-time applications.
  • Method 4: Otsu’s Thresholding After Gaussian Blurring. Provides a good balance between noise reduction and edge detection, though it may erase finer details in the process.
  • Bonus Method 5: Quick Thresholding with Lambdas. Simple and efficient for straightforward applications where precision is not critical.