HoughCircles circle detection not working?

Question

I have been trying to write a program that can detect circles on my screen.

This is my screen before code processing

As you can see on the image, there are three circles that the code should detect. I am using HoughCircles function from OpenCV library to achieve this task. My code is below.

ss = gui.screenshot()

img = cv2.cvtColor(np.array(ss), cv2.COLOR_RGB2BGR)
output = img.copy()
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, 1.2, 100)

if circles is not None:
    print("circles found", len(circles))

    circles = np.round(circles[0, :]).astype("int")

    for (x, y, r) in circles:

        cv2.circle(output, (x, y), r, (0, 255, 0), 4)
        cv2.rectangle(output, (x - 5, y - 5), (x + 5, y + 5), (0, 128, 255), -1)

    cv2.imshow("output", np.hstack([gray, output]))
    cv2.waitKey(0)

cv2.imshow("output", gray)
cv2.waitKey(0)

I am first taking screenshot of my screen. Then, I convert it to use it for opencv.

However, this code does not detect any circles for the screenshot shown in the first picture. I know this because when ran, my program does not print "circles found". Moreover, to show that I have been taking screenshots and transforming them to grayscale properly, I have this image taken from the last two lines of my code.

picture in a gray scale

To show that my code works with other circle images, here is a picture of a regular circle:

before detection

after detection

Any help would be very appreciated!

Answer 1

Here's an alternative solution to detect the circles without using the Hough Transform. As your input image has a very distinct blue hue to the blobs of interest, you can try to create a segmentation mask based on their HSV values. Then, detect contours and approximate each contour using a circle. The last step can be implemented using the cv2.minEnclosingCircle, which, as its name suggest, can compute the Minimum Enclosing Circle of a contour.

Let's see the code:

# image path
path = "D://opencvImages//"
fileName = "XUzFw.png"

# Reading an image in default mode:
inputImage = cv2.imread(path + fileName)
# Create a deep copy of the input for results:
inputImageCopy = inputImage.copy()

# Convert the image to the HSV color space:
hsvImage = cv2.cvtColor(inputImage, cv2.COLOR_BGR2HSV)

# Set the HSV values:
lowRange = np.array([78, 0, 158])
uppRange = np.array([125, 255, 255])

# Create the HSV mask
mask = cv2.inRange(hsvImage, lowRange, uppRange)

This generates the following segmentation mask:

As you can see, the only blobs that remain are the circles. Now, let's compute the contours and find the minimum enclosing circle:

# Find the circle blobs on the binary mask:
contours, hierarchy = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# Use a list to store the center and radius of the target circles:
detectedCircles = []

# Look for the outer contours:
for i, c in enumerate(contours):

    # Approximate the contour to a circle:
    (x, y), radius = cv2.minEnclosingCircle(c)

    # Compute the center and radius:
    center = (int(x), int(y))
    radius = int(radius)

    # Draw the circles:
    cv2.circle(inputImageCopy, center, radius, (0, 0, 255), 2)

    # Store the center and radius:
    detectedCircles.append([center, radius])

# Let's see the results:
cv2.namedWindow("Circles", cv2.WINDOW_NORMAL)
cv2.imshow("Circles", inputImageCopy)
cv2.waitKey(0)

This is the result of the detection:

Additionally, you can check out the data stored in the detectedCircles list:

# Check out the detected circles:
for i in range(len(detectedCircles)):
    # Get circle data:
    center, r = detectedCircles[i]
    # Print it:
    print("i: "+str(i)+" x: "+str(center[0])+" y: "+str(center[1])+" r: "+str(r))

Which yields:

i: 0 x: 395 y: 391 r: 35
i: 1 x: 221 y: 391 r: 36
i: 2 x: 567 y: 304 r: 35

Answer 2

These are the parameters of houghCircles that works for me. You should also consider running a gaussian blur over the image before trying to find the circles.

I'm not a huge fan of houghCircles. I find it to be really finicky and I don't like how much of what it does is hidden inside the function. It makes tuning it mostly trial-and-error. These parameters work for this particular image, but I wouldn't count on this continuing to work under different lighting conditions or for different colors.

import cv2
import numpy as np

# load image
img = cv2.imread("spheres.png");

# grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY);
gray = cv2.GaussianBlur(gray,(5,5),0);

# circles
circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp = 1, minDist = 100, param1=65, param2=20, minRadius=20, maxRadius=50)

# draw circles
if circles is not None:
    # round to ints
    circles = np.uint16(np.around(circles));
    for circle in circles[0, :]:
        # unpack and draw
        x, y, radius = circle;
        center = (x,y);
        cv2.circle(img, center, radius, (255, 0, 255), 3);

# show
cv2.imshow("Image", img);
cv2.imshow("Gray", gray);
cv2.waitKey(0);