5 Effective Techniques for Detecting White and Black Dots Using OpenCV in Python

by

💡 Problem Formulation: Detecting white and black dots in images is a common requirement in various computer vision tasks, such as object tracking, feature recognition, or quality control in manufacturing. Using OpenCV with Python, we aim to identify and locate these dots within an image efficiently. For instance, given an image with a white background and various black and white dots scattered across, the goal is to output the coordinates or highlight each detected dot.

Method 1: Thresholding and Contour Detection

This method involves converting the image to grayscale, applying binary thresholding to create a mask for dots, and then detecting contours which gives us the location of each dot. The cv2.threshold function helps to isolate dots based on pixel intensity, and cv2.findContours retrieves contours from the binary image.

Here’s an example:

import cv2
import numpy as np

# Load image, convert to grayscale and blur
image = cv2.imread('dots.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (5, 5), 0)

# Apply binary thresholding
_, binary = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)

# Find contours (dots)
contours, _ = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# Draw contours on the original image
result = image.copy()
cv2.drawContours(result, contours, -1, (0, 255, 0), 2)
cv2.imshow('Detected Dots', result)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output would be the original image with green outlines around the detected white and black dots.

In this snippet, the image is preprocessed to enhance dot detection, with contours marked and drawn on the original image. By modifying the thresholding value, different dot intensities can be captured, giving users the flexibility to tune the detection as required. However, this method may fail if dots have a gradient or are not uniformly colored.

Method 2: Blob Detection using SimpleBlobDetector

OpenCV’s SimpleBlobDetector is designed specifically for detecting blobs (i.e., white and black dots) based on various parameters such as size, shape, and color. It’s a straightforward way to handle dot detection without the need for thresholding and contour detection.

Here’s an example:

import cv2

# Read image
image = cv2.imread('dots.jpg')

# Set up SimpleBlobDetector parameters
params = cv2.SimpleBlobDetector_Params()
params.filterByColor = True
params.blobColor = 255 # Detect white dots

# Create a detector with the parameters
detector = cv2.SimpleBlobDetector_create(params)

# Detect blobs
keypoints = detector.detect(image)

# Draw detected blobs as red circles
blank = np.zeros((1, 1)) 
blobs = cv2.drawKeypoints(image, keypoints, blank, (0, 0, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)

cv2.imshow("Detected Dots", blobs)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output is the original image with red circles around each detected white dot.

This code initializes a SimpleBlobDetector with specific parameters to detect white dots. The keypoints represent the center of the dots, and the cv2.drawKeypoints function visualizes the detected dots. Adjusting parameters allows for tailored detection, but this method might require significant parameter tuning for varied dot profiles.

Method 3: Hough Circle Transform

Hough Circle Transform is a feature extraction technique for detecting circles in images. This method works well for dot detection because dots can be approximated as circles with a small radius. By adjusting the resolution parameters and minimum and maximum radius, one can detect dots of different sizes.

Here’s an example:

import cv2
import numpy as np

image = cv2.imread('dots.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Detect circles
circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp=1, minDist=20, param1=50, param2=30, minRadius=0, maxRadius=10)

if circles is not None:
    circles = np.uint16(np.around(circles))

    # Draw circles on the original image
    for i in circles[0, :]:
        center = (i[0], i[1])
        radius = i[2]
        cv2.circle(image, center, radius, (0, 255, 0), 2)

cv2.imshow('Detected Dots', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output would be the original image with green circles around the detected dots.

This snippet applies the Hough Circle Transform to detect circles which represent the dots. Detected circles are then drawn onto the original image for visualization. This method has the advantage of discerning circular shapes specifically, but may have false positives if there are other circular patterns present.

Method 4: Adaptive Thresholding and Contour Detection

This method combines adaptive thresholding with contour detection to improve dot detection in images with varying light conditions or dot intensities. By dynamically adjusting the threshold, it can better handle different lighting scenarios as opposed to global thresholding.

Here’s an example:

import cv2
import numpy as np

image = cv2.imread('dots.jpg')
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Adaptive thresholding
adaptive_thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)

# Detect contours
contours, _ = cv2.findContours(adaptive_thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

# Draw contours
result = image.copy()
cv2.drawContours(result, contours, -1, (0, 255, 0), 2)

cv2.imshow('Detected Dots', result)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output visualizes the detected dots with green outlines on the original image.

Adaptive thresholding is applied to the grayscale image before extracting contours. The contours are drawn onto a copy of the original image, highlighting detected dots. This approach is more robust to varying lighting but can be computationally expensive compared to simple thresholding.

Bonus One-Liner Method 5: Simple Color Segmentation

This one-liner uses logical operations to quickly extract white or black dots based on their color characteristics. It’s less robust than other methods but can be efficient for simple, high-contrast images.

Here’s an example:

cv2.imshow('Detected Dots', (cv2.imread('dots.jpg') // 255 * np.array([0, 0, 1])).astype(np.uint8) * 255)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output shows the original image with only the blue channel, effectively segmenting out white dots.

In this one-liner, the image is divided by 255 and then multiplied by a vector to keep only the blue channel. This acts as a color segmentation for high-contrast white dots. It is very quick and easy but far from reliable for more complex or nuanced images.

Summary/Discussion

  • Method 1: Thresholding and Contour Detection. Good for simple images. May struggle with varied dot intensities or non-uniform dot colors.
  • Method 2: Blob Detection with SimpleBlobDetector. Straightforward blob detection but requires careful parameter tuning for accuracy.
  • Method 3: Hough Circle Transform. Effective for perfectly circular dots and can adjust for size. Prone to false positives in patterns or textures resembling circles.
  • Method 4: Adaptive Thresholding and Contour Detection. More dynamic and robust to lighting variations but computationally heavier.
  • Method 5: Simple Color Segmentation. Quick and suitable for high-contrast dot detection, but not reliable for complex images.