 # Finding Circles Using OpenCV | python

Basics of Circle Detection

A circle can be described by the following equation: To detect circles, we can fix point (x, y). Now we need to find 3 parameters: a, b and r. So the problem is in the 3D search space. To find possible circles, the algorithm uses a three-dimensional matrix called the Accumulator Matrix to store the potential values ​​of a, b, and r. The value of a (center x coordinate) can range from 1 to rows, b (center y coordinate) can range from 1 to columns, and r can range from 1 to maxRadius = ,

Below are the steps of the algorithm.

• Accumulator matrix initialization: Dimension row matrix initialization * cols * maxRadius with zeros.
• Image preprocessing: Apply to the image blur, grayscale and edge detector. This is done to make the circles look like darkened edges of the image.
• Loop through points: select point in the image.
• Fixing r and looping through a and b: use a double nested loop to find the value of r by varying a and b in the given ranges.

 ` for ` ` a ` ` in ` ` range ` ` (rows): ` ` for ` ` b ` ` in ` ` range ` ` (cols): ` ` ` ` r ` ` = ` ` ma th.sqrt ((xi ` ` - ` ` a) ` ` * ` ` * ` ` 2 ` ` + ` ` (yi ` ` - ` ` b) ` ` * ` ` * ` ` 2 ` `) ` ` accum_matrix [a] [b] [r] ` ` + ` ` = ` ` 1 `

• Voting: Select the points in the battery matrix with the maximum value. These are strengths that indicate the existence of a circle with parameters a, b and r. This gives us the space of the circles.
• Finding circles: Finally, using the above circles as candidates, vote according to the image. The maximum circle of voted in the accumulator matrix gives us a circle.

The ` HoughCircles ` function in OpenCV has the following parameters, which can be changed according to the image.

Detection Method: OpenCV has an advanced implementation, HOUGH_GRADIENT, which uses gradient of the edges instead of filling up the entire 3D accumulator matrix, thereby speeding up the process.
dp: This is the ratio of the resolution of original image to the accumulator matrix.
minDist: This parameter controls the minimum distance between detected circles.
Param1: Canny edge detection requires two parameters – minVal and maxVal. Param1 is the higher threshold of the two. The second one is set as Param1 / 2.
Param2: This is the accumulator threshold for the candidate detected circles. By increasing this threshold value, we can ensure that only the best circles, corresponding to larger accumulator values, are returned.
 ` import ` ` cv2 ` ` import ` ` numpy as np `   ` # Read the image. ` ` img ` ` = ` ` cv2.imread (` ` `eyes.jpg` ` `, cv2.IMREAD_COLOR) ` ` `  ` # Convert to from shades of gray. ` ` gray ` ` = ` ` cv2. cvtColor (img, cv2.COLOR_BGR2GRAY) `   ` # Blur using core 3 * 3. ` ` gray_blurred ` ` = ` ` cv2.blur (gray, (` ` 3 ` `, ` ` 3 ` `)) `   ` # Apply Hough transform to blurry image . ` ` detected_circles ` ` = ` ` cv2.HoughCircles ( gray_blurred, ` ` cv2.HOUGH_GRADIENT, ` ` 1 ` `, ` ` 20 ` `, param1 ` = ` 50 ` `, ` ` ` ` param2 ` ` = ` ` 30 ` `, minRadius ` ` = ` ` 1 ` `, maxRadius = 40 ) ````   # Draw the circles that are found. if detected_circles is not None :     # Convert circle parameters a, b and r to integers.   detected_circles = np.uint16 (np.around (detected_circles))   for pt in detected_circles [ 0 ,:]: a, b, r = pt [ 0 ], pt [ 1 ], pt [ 2 ]   # Draw a circle. cv2.circle (img, (a, b), r, ( 0 , 255 , 0 ), 2 )     # Draw a small circle (radius 1) to show the center. cv2.circle (img, (a, b), 1 , ( 0 , 0 , 255 ), 3 ) cv2.imshow ( "Detected Circle" , img)   cv2.waitKey ( 0 ) ``` 