Draw Concentric Circles Around Part of Image Matlab

A few days ago, I got an e-mail from a PyImageSearch reader request nearly circle detection. See below for the gist:

Hey Adrian,

Love your blog. I saw your post on detecting rectangles/squares in images, but I was wondering, how practice you notice circles in images using OpenCV?

Cheers.

Great question.

Every bit you lot've probably already found out, detecting circles in images using OpenCV is substantially harder than detecting other shapes with sharp edges.

But don't worry!

In this blog post I'll prove you how to utilize the cv2.HoughCircles role to detect circles in images using OpenCV.

To learn how to detect circles with OpenCV, but go along reading!

Looking for the source code to this mail?

Jump Right To The Downloads Section

The cv2.HoughCircles Function

In gild to find circles in images, you'll need to make use of the cv2.HoughCircles role. Information technology'southward definitely not the easiest part to use, but with a fiddling caption, I recall you'll get the hang of it.

Take a look at the part signature below:

cv2.HoughCircles(image, method, dp, minDist)          

• prototype: 8-bit, single channel image. If working with a colour image, convert to grayscale first.
• method: Defines the method to discover circles in images. Currently, the only implemented method is cv2.HOUGH_GRADIENT, which corresponds to the Yuen et al. paper.
• dp: This parameter is the inverse ratio of the accumulator resolution to the image resolution (come across Yuen et al. for more details). Substantially, the larger the dp gets, the smaller the accumulator assortment gets.
• minDist: Minimum altitude between the center (10, y) coordinates of detected circles. If the minDist is too small, multiple circles in the same neighborhood as the original may be (falsely) detected. If the minDist is too large, then some circles may not be detected at all.
• param1: Gradient value used to handle edge detection in the Yuen et al. method.
• param2: Accumulator threshold value for the cv2.HOUGH_GRADIENT method. The smaller the threshold is, the more than circles volition be detected (including false circles). The larger the threshold is, the more circles will potentially be returned.
• minRadius: Minimum size of the radius (in pixels).
• maxRadius: Maximum size of the radius (in pixels).

If this method seems complicated, don't worry. It's actually not as well bad.

But I will say this — be ready to play effectually with the parameter values from image to image. The minDist parameter is especially important to get right. Without an optimal minDist value, you may finish up missing out on some circles, or yous may detecting many false circles.

Detecting Circles in Images using OpenCV and Hough Circles

Prepare to apply the cv2.HoughCircles function to detect circles in images?

Great. Let's spring into some code:

# import the necessary packages import numpy as np import argparse import cv2  # construct the argument parser and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-i", "--image", required = Truthful, aid = "Path to the prototype") args = vars(ap.parse_args())          

Lines 2-four import the necessary packages we'll need. We'll apply NumPy for numerical processing, argparse for parsing control line arguments, and cv2 for our OpenCV bindings.

Then, on Lines 7-9 we parse our command line arguments. We'll need only a unmarried switch, --prototype, which is the path to the image we want to detect circles in.

Permit'due south get ahead and load the image:

# load the epitome, clone it for output, so convert it to grayscale image = cv2.imread(args["paradigm"]) output = image.copy() grayness = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)          

We load our image off disk on Line 12 and create a copy of it on Line 13 so nosotros can draw our detected circles without destroying the original image.

As nosotros'll see, the cv2.HoughCircles function requires an 8-bit, single channel paradigm, and then we'll become ahead and convert from the RGB color infinite to grayscale on Line xiv.

Okay, time to observe the circles:

# find circles in the image circles = cv2.HoughCircles(grayness, cv2.HOUGH_GRADIENT, 1.2, 100)  # ensure at least some circles were found if circles is non None: 	# convert the (x, y) coordinates and radius of the circles to integers 	circles = np.circular(circles[0, :]).astype("int")  	# loop over the (x, y) coordinates and radius of the circles 	for (x, y, r) in circles: 		# describe the circle in the output epitome, then depict a rectangle 		# respective to the center of the circle 		cv2.circle(output, (x, y), r, (0, 255, 0), 4) 		cv2.rectangle(output, (x - 5, y - v), (x + 5, y + 5), (0, 128, 255), -1)  	# bear witness the output epitome 	cv2.imshow("output", np.hstack([prototype, output])) 	cv2.waitKey(0)          

Detecting the circles is handled by the cv2.HoughCircles function on Line 17. Nosotros pass in the paradigm we want to detect circles as the first statement, the circle detection method every bit the 2nd argument (currently, the cv2.cv.HOUGH_GRADIENT method is the just circle detection method supported by OpenCV and will likely be the only method for some time), an accumulator value of 1.5 as the 3rd statement, and finally a minDist of 100 pixels.

A check is made on Line 20 to ensure at least ane circle was establish in the image.

Line 22 then handles converting our circles from floating point (ten, y) coordinates to integers, assuasive us to depict them on our output prototype.

From there, we start looping over the center (10, y) coordinates and the radius of the circle on Line 25.

We describe the actual detected circumvolve on Line 28 using the cv2.circle function, followed by cartoon a rectangle at the center of the circle on Line 29.

Finally, Lines 32 and 33 brandish our output image.

So there you have information technology — detecting circles in images using OpenCV.

But let'southward get ahead and accept a wait at some results.

Fire up a shell, and execute the following command:

$ python detect_circles.py --image images/uncomplicated.png          

We'll commencement with something unproblematic, detecting a red circle on a black background:

Figure 1: Detecting a simple circumvolve in an image using OpenCV.

Not bad! Our Python script has detected the red circumvolve, outlined it in dark-green, and and then placed an orange foursquare at the center of it.

Permit's motion on to something else:

$ python detect_circles.py --image images/soda.png          

Figure 2: Detecting the summit of a soda can using circle detection with OpenCV.

Again, our Python script is able to find the circular region of the tin.

Now, let'south try the 8 circle trouble.

In this problem we have ane large circle, followed byseven circles placed within the large one.

Since this is a much smaller prototype than the previous ones (and we are detecting multiple circles), I'thou going to adjust the minDist to exist 75 pixels rather than 100.

Figure iii: Detect how cv2.HoughCircles failed to detect the inner-most circle.

Hm. Now it looks like we have ran into a trouble.

The cv2.HoughCircles function was able to detect only vii of the circles instead of alleight, leaving out the one in the eye.

Why did this happen?

It'southward due to the minDist parameter. The centre(10, y) coordinates for the large outer circumvolve are identical to the center inner circle, thus the center inner circumvolve is discarded.

Unfortunately, at that place is not a style around this trouble unless nosotros make minDist unreasonably small, and thus generating many "faux" circumvolve detections.

What's adjacent? I recommend PyImageSearch University.

Class data:
35+ total classes • 39h 44m video • Terminal updated: April 2022
★★★★★ 4.84 (128 Ratings) • 3,000+ Students Enrolled

I strongly believe that if you had the right teacher you could master estimator vision and deep learning.

Do you think learning computer vision and deep learning has to exist time-consuming, overwhelming, and complicated? Or has to involve complex mathematics and equations? Or requires a degree in estimator science?

That'due south non the instance.

All you need to master figurer vision and deep learning is for someone to explain things to y'all in simple, intuitive terms. And that's exactly what I practice. My mission is to change educational activity and how complex Artificial Intelligence topics are taught.

If you're serious about learning computer vision, your next cease should be PyImageSearch University, the most comprehensive computer vision, deep learning, and OpenCV course online today. Here you'll learn how to successfully and confidently use reckoner vision to your piece of work, research, and projects. Join me in computer vision mastery.

Inside PyImageSearch University you'll find:

• ✓ 35+ courses on essential computer vision, deep learning, and OpenCV topics
• ✓ 35+ Certificates of Completion
• ✓ 39+ hours of on-demand video
• ✓ Brand new courses released regularly , ensuring you can keep up with state-of-the-fine art techniques
• ✓ Pre-configured Jupyter Notebooks in Google Colab
• ✓ Run all code examples in your web browser — works on Windows, macOS, and Linux (no dev environs configuration required!)
• ✓ Access to centralized lawmaking repos for all 450+ tutorials on PyImageSearch
• ✓ Piece of cake one-click downloads for code, datasets, pre-trained models, etc.
• ✓ Access on mobile, laptop, desktop, etc.

Click here to join PyImageSearch University

Summary

In this blog post I showed you how to utilise the cv2.HoughCircles function in OpenCV to notice circles in images.

Unlike detecting squares or rectangles in images, detecting circles is essentially harder since nosotros cannot reply on approximating the number of points in a contour.

To assistance us detect circles in images, OpenCV has supplied the cv2.HoughCircles part.

While the cv2.HoughCircles method may seem complicated at beginning, I would argue that the well-nigh of import parameter to play with is the minDist, or the minimum distance between the center (ten, y) coordinates of detected circles.

If yous set minDist too modest, you may stop upwards with many falsely detected circles. On the other mitt, if minDist is too large, then y'all may end upwardly missing some circles. Setting this parameter definitely takes some fine tuning.

Have a Question?

Do y'all have a question well-nigh OpenCV and Python? Just send me a message. And I'll do my best to answer it on this blog.

Download the Source Lawmaking and Free 17-page Resource Guide

Enter your email address below to get a .zip of the code and a FREE 17-page Resource Guide on Computer Vision, OpenCV, and Deep Learning. Inside you'll discover my hand-picked tutorials, books, courses, and libraries to help you master CV and DL!

fritzequabill.blogspot.com

Source: https://pyimagesearch.com/2014/07/21/detecting-circles-images-using-opencv-hough-circles/

Share this post