使用霍夫圆进行圆检测，找到正确的参数

Question

我有以下问题。 我想在我的 2D 图像（1024x1024 像素）中确定一个圆圈。 我知道我的圆心必须在 (512,512) 左右，我可以看到大致的圆结构。 因此，我在这里使用了一个代码作为指南，并尝试使其适应我的条件。 不幸的是，我总是发现只有“错误”圆心的圆。

我的图像文件的示例说明如下。

我修改后的代码：

import numpy as np
import cv2
import copy
import matplotlib.pyplot as plt

# load the image, clone it for output, and then convert it to grayscale
image = cv2.imread("600.png")
orig_image = np.copy(image)
output = image.copy()
#gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#gray = cv2.medianBlur(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY), 5)
gray = cv2.GaussianBlur(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY), (3,3), 0)

#cv2.imshow("blurred", blurred)
cv2.imshow("gray", gray)
cv2.waitKey(0)

circles = None

minimum_circle_size = 20   #this is the range of possible circle in pixels you want to find
maximum_circle_size = 40   #maximum possible circle size you're willing to find in pixels

guess_dp = 1.0

number_of_circles_expected = 1          # we expect to find just one circle
breakout = False

#hand tune this
max_guess_accumulator_array_threshold = 100     #minimum of 1, no maximum, (max 300?) the quantity of votes 
                                                #needed to qualify for a circle to be found.
circleLog = []

guess_accumulator_array_threshold = max_guess_accumulator_array_threshold

while guess_accumulator_array_threshold > 1 and breakout == False:
    #start out with smallest resolution possible, to find the most precise circle, then creep bigger if none found
    guess_dp = 1.0
    print("resetting guess_dp:" + str(guess_dp))
    while guess_dp < 5 and breakout == False:           #9
        guess_radius = maximum_circle_size
        print("setting guess_radius: " + str(guess_radius))
        print(circles is None)
        while True:

            #HoughCircles algorithm isn't strong enough to stand on its own if you don't
            #know EXACTLY what radius the circle in the image is, (accurate to within 3 pixels) 
            #If you don't know radius, you need lots of guess and check and lots of post-processing 
            #verification.  Luckily HoughCircles is pretty quick so we can brute force.

            print("guessing radius: " + str(guess_radius) + 
                    " and dp: " + str(guess_dp) + " vote threshold: " + 
                    str(guess_accumulator_array_threshold))

            circles = cv2.HoughCircles(gray, 
                cv2.HOUGH_GRADIENT, 
                dp=guess_dp,               #resolution of accumulator array.
                minDist= 600,      #number of pixels center of circles should be from each other, hardcode
                param1=50, #50
                param2=guess_accumulator_array_threshold,
                minRadius=(guess_radius-2),    #HoughCircles will look for circles at minimum this size
                maxRadius=(guess_radius+2)     #HoughCircles will look for circles at maximum this size
                )

            if circles is not None:
                if len(circles[0]) == number_of_circles_expected:
                    print("len of circles: " + str(len(circles)))
                    circleLog.append(copy.copy(circles))
                    print("k1")
                break
                circles = None
            guess_radius -= 5 
            if guess_radius < 20:   #40
                break;

        guess_dp += 1.5

    guess_accumulator_array_threshold -= 2

#Return the circleLog with the highest accumulator threshold

# ensure at least some circles were found
for cir in circleLog:
    # convert the (x, y) coordinates and radius of the circles to integers
    output = np.copy(orig_image)

    if (len(cir) > 1):
        print("FAIL before")
        exit()

    print(cir[0, :])

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

    # loop over the (x, y) coordinates and radius of the circles
    if (len(cir) > 1):
        print("FAIL after")
        exit()

    for (x, y, r) in cir:
        # draw the circle in the output image
        cv2.circle(output, (x, y), r, (0, 0, 255), 2)


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

使用代码中的参数运行的示例为我提供了数组

[[571.25 198.75 25.5 ]], [[571.25 198.75 25.5 ]], [[571.25 198.75 25.5 ]], [[266.25 376.25 35.5 ]], [[531.25 131.25 35.5 ]], [[391.25 516.25 40.5 ]]

其中 [[x,y,r]] 是中心点 (x,y) 的像素坐标，r 是圆的半径。

因此，只检测到根本不是圆的“圆”....

问题是由于参数的选择还是在这种情况下无法应用霍夫圆？ 有没有其他方法可以尽可能准确地确定半径？