OpenCV Tennis balls recognizing tutorial - Revision history

Polto: OpenCV moved to OpenCV Tennis balls recognizing tutorial

2010-07-27T09:56:03Z

OpenCV moved to OpenCV Tennis balls recognizing tutorial

← Older revision	Revision as of 09:56, 27 July 2010
(No difference)

Andy753421 at 16:10, 20 June 2009

2009-06-20T16:10:20Z

← Older revision		Revision as of 16:10, 20 June 2009
Line 45:		Line 45:
	[[Image:Tennis-hsv.jpg\|thumb\|Example HSV output]]		[[Image:Tennis-hsv.jpg\|thumb\|Example HSV output]]

	A good first step in many CV algorithms is to convert the image to [http://en.wikipedia.org/wiki/HSL_and_HSV HSV] (or another similar [http://en.wikipedia.org/wiki/Color_space color space]). This ~~make~~ picking out objects based on colors a bit simpler as will be seen later. We'll make a copy of the original image so that we can display it at the end. Note that OpenCV stores images in BGR format by default.		A good first step in many CV algorithms is to convert the image to [http://en.wikipedia.org/wiki/HSL_and_HSV HSV] (or another similar [http://en.wikipedia.org/wiki/Color_space color space]). This makes picking out objects based on colors a bit simpler, as will be seen later. We'll make a copy of the original image so that we can display the original at the end. Note that OpenCV stores images in BGR format by default.
	<pre>		<pre>
	CvSize size = cvGetSize(img);		CvSize size = cvGetSize(img);
Line 55:		Line 55:
	[[Image:Tennis-mask.png\|thumb\|Example mask]]		[[Image:Tennis-mask.png\|thumb\|Example mask]]

	The next step is to select all pixels that we think might be part of a tennis ball. We'll do this based purely on their HSV values. OpenCV provides a InRanage function that can be used to pick out pixels based on their values. This generates a [http://en.wikipedia.org/wiki/Mask_(computing) mask]; a binary image where the foreground (white) ~~pixels~~ were ~~with in~~ the specified range. We're done with the HSV image after this, so we can free it's memory.		The next step is to select all pixels that we think might be part of a tennis ball. We'll do this based purely on their HSV values. OpenCV provides a InRanage function that can be used to pick out pixels based on their values. This generates a [http://en.wikipedia.org/wiki/Mask_(computing) mask]; a binary image where the foreground pixels (white) were within the specified range. We're done with the HSV image after this, so we can free it's memory.

	Picking the ranges for creating ~~mask~~ is one of the more complicated parts of a CV algorithm. For now, manually tuning the ~~values~~ is easiest. You ~~could~~ also use a machine learning ~~algorithm~~ to pick the ranges automatically.		Picking the ranges for creating masks is one of the more complicated parts of a CV algorithm. For now, manually tuning the ranges is easiest. You might also use one of the OpenCV machine learning algorithms to pick the ranges automatically.

	<pre>		<pre>
Line 76:		Line 76:
	\| Dilate \|\| Expand the foreground		\| Dilate \|\| Expand the foreground
	\|-		\|-
	\| Erode \|\| ~~contract~~ the foreground (~ expand background)		\| Erode \|\| Contract the foreground (~ expand background)
	\|-		\|-
	\| Close \|\| Dilation followed by erosion, removes specks of background, fills in foreground areas.		\| Close \|\| Dilation followed by erosion, removes specks of background, fills in foreground areas.
Line 85:		Line 85:
	Morphological operations are performed with a [http://en.wikipedia.org/wiki/Structuring_element Structuring Element]. In computer vision, this is typically a oval or a rectangle of some specific size. Note that using rectangles results in faster code but can also cause poorer results.		Morphological operations are performed with a [http://en.wikipedia.org/wiki/Structuring_element Structuring Element]. In computer vision, this is typically a oval or a rectangle of some specific size. Note that using rectangles results in faster code but can also cause poorer results.

	Below, we use a large rectangular structuring element along with a close to remove the black lines that show up in the tennis balls. Afterwards we perform an open with a smaller structuring element to eliminate some additional nose from the image.		Below, we use a large rectangular structuring element along with a close to remove the black lines that show up in the tennis balls. Afterwards, we perform an open with a smaller structuring element to eliminate some additional nose from the image.

	<pre>		<pre>
	IplConvKernel *se21 = cvCreateStructuringElementEx(21, 21, 10, 10, CV_SHAPE_RECT, NULL);		IplConvKernel *se21 = cvCreateStructuringElementEx(21, 21, 10, 10, CV_SHAPE_RECT, NULL);
	IplConvKernel *se11 = cvCreateStructuringElementEx(11, 11, 5, 5, CV_SHAPE_RECT, NULL);		IplConvKernel *se11 = cvCreateStructuringElementEx(11, 11, 5, 5, CV_SHAPE_RECT, NULL);
	cvClose(mask, mask, se21);		cvClose(mask, mask, se21); // See completed example for cvClose definition
	cvOpen(mask, mask, se11);		cvOpen(mask, mask, se11); // See completed example for cvOpen definition
	cvReleaseStructuringElement(&se21);		cvReleaseStructuringElement(&se21);
	cvReleaseStructuringElement(&se11);		cvReleaseStructuringElement(&se11);
Line 97:		Line 97:

	=== Hough transform ===		=== Hough transform ===
	The real work in finding tennis balls is done by a [http://en.wikipedia.org/wiki/Hough_transform Hough transform]. The specifics of this are beyond the scope of this tutorial. We'll just treat it as a black box function that finds circular objects in ~~a gray~~ input image.		The real work in finding tennis balls is done by a [http://en.wikipedia.org/wiki/Hough_transform Hough transform]. The specifics of this are beyond the scope of this tutorial. We'll just treat it as a black box function that finds circular objects in an input image.

	The OpenCV Hough function performs a [http://en.wikipedia.org/wiki/Canny_edge_detector Canny edge detection] on the input image before ~~doing running~~ the actual Hough transform. Due to this and the way the Hough transform works, it is beneficial to do quite a bit of smoothing to get a nice gradient around the edge of the circles before passing the image to the Hough function. Many of the parameters to the Hough function can also be tuned to provide better results.		The OpenCV Hough function performs a [http://en.wikipedia.org/wiki/Canny_edge_detector Canny edge detection] on the input image before the actual Hough transform. Due to this and the way the Hough transform works, it is beneficial to do quite a bit of smoothing to get a nice gradient around the edge of the circles before passing the image to the Hough function. Many of the parameters to the Hough function can also be tuned to provide better results.

	<pre>		<pre>
	/* Copy mask into a ~~gray scale~~ image */		/* Copy mask into a grayscale image */
	IplImage *hough_in = cvCreateImage(size, 8, 1);		IplImage *hough_in = cvCreateImage(size, 8, 1);
	cvCopy(mask, hough_in, NULL);		cvCopy(mask, hough_in, NULL);

Andy753421 at 14:40, 18 June 2009

2009-06-18T14:40:06Z

← Older revision		Revision as of 14:40, 18 June 2009
Line 45:		Line 45:
	[[Image:Tennis-hsv.jpg\|thumb\|Example HSV output]]		[[Image:Tennis-hsv.jpg\|thumb\|Example HSV output]]

	A good first step in many CV algorithms is to convert the image to HSV (or another similar color space). This make picking out objects based on colors a bit simpler as will be seen later. We'll make a copy of the original image so that we can display it at the end. Note that OpenCV stores images in BGR format by default.		A good first step in many CV algorithms is to convert the image to [http://en.wikipedia.org/wiki/HSL_and_HSV HSV] (or another similar [http://en.wikipedia.org/wiki/Color_space color space]). This make picking out objects based on colors a bit simpler as will be seen later. We'll make a copy of the original image so that we can display it at the end. Note that OpenCV stores images in BGR format by default.
	<pre>		<pre>
	CvSize size = cvGetSize(img);		CvSize size = cvGetSize(img);
Line 55:		Line 55:
	[[Image:Tennis-mask.png\|thumb\|Example mask]]		[[Image:Tennis-mask.png\|thumb\|Example mask]]

	The next step is to select all pixels that we think might be part of a tennis ball. We'll do this based purely on their HSV values. OpenCV provides a InRanage function that can be used to pick out pixels based on their values. This generates a mask; a binary image where the foreground (white) pixels were with in the specified range. We're done with the HSV image after this, so we can free it's memory.		The next step is to select all pixels that we think might be part of a tennis ball. We'll do this based purely on their HSV values. OpenCV provides a InRanage function that can be used to pick out pixels based on their values. This generates a [http://en.wikipedia.org/wiki/Mask_(computing) mask]; a binary image where the foreground (white) pixels were with in the specified range. We're done with the HSV image after this, so we can free it's memory.

	Picking the ranges for creating mask is one of the more complicated parts of a CV algorithm. For now, manually tuning the values is easiest. You could also use a machine learning algorithm to pick the ranges automatically.		Picking the ranges for creating mask is one of the more complicated parts of a CV algorithm. For now, manually tuning the values is easiest. You could also use a machine learning algorithm to pick the ranges automatically.
Line 69:		Line 69:
	[[Image:Tennis-morph.png\|thumb\|Mask after morphological operations]]		[[Image:Tennis-morph.png\|thumb\|Mask after morphological operations]]

	No matter how good your ranges are when generating a mask, there will almost always be noise in the mask. In our example, the white lines on the tennis ball don't show up because they don't fit the hue range. Much of this nose can be eliminated by using a series of morphological operations. Two commonly uses operation are [http://en.wikipedia.org/wiki/Opening_(morphology) opening] and [http://en.wikipedia.org/wiki/Closing_(morphology) closing], which are in turn comprised of [http://en.wikipedia.org/wiki/Dilation_(morphology) dilate] and [http://en.wikipedia.org/wiki/Erosion_(morphology) erode] operations. The table below summarizes these operations.		No matter how good your ranges are when generating a mask, there will almost always be noise in the mask. In our example, the white lines on the tennis ball don't show up because they don't fit the hue range. Much of this nose can be eliminated by using a series of [http://en.wikipedia.org/wiki/Mathematical_morphology morphological operations]. Two commonly uses operation are [http://en.wikipedia.org/wiki/Opening_(morphology) opening] and [http://en.wikipedia.org/wiki/Closing_(morphology) closing], which are in turn comprised of [http://en.wikipedia.org/wiki/Dilation_(morphology) dilate] and [http://en.wikipedia.org/wiki/Erosion_(morphology) erode] operations. The table below summarizes these operations.

	{\| border=1		{\| border=1
Line 97:		Line 97:

	=== Hough transform ===		=== Hough transform ===
	The real work in finding tennis balls is done by a Hough transform. The specifics of this are beyond the scope of this tutorial. We'll just treat it as a black box function that finds circular objects in a gray input image.		The real work in finding tennis balls is done by a [http://en.wikipedia.org/wiki/Hough_transform Hough transform]. The specifics of this are beyond the scope of this tutorial. We'll just treat it as a black box function that finds circular objects in a gray input image.

	The OpenCV Hough function performs a Canny edge detection on the input image before doing running the actual Hough transform. Due to this and the way the Hough transform works, it is beneficial to do quite a bit of smoothing to get a nice gradient around the edge of the circles before passing the image to the Hough function. Many of the parameters to the Hough function can also be tuned to provide better results.		The OpenCV Hough function performs a [http://en.wikipedia.org/wiki/Canny_edge_detector Canny edge detection] on the input image before doing running the actual Hough transform. Due to this and the way the Hough transform works, it is beneficial to do quite a bit of smoothing to get a nice gradient around the edge of the circles before passing the image to the Hough function. Many of the parameters to the Hough function can also be tuned to provide better results.

	<pre>		<pre>

Andy753421 at 14:30, 18 June 2009

2009-06-18T14:30:15Z

← Older revision		Revision as of 14:30, 18 June 2009
Line 1:		Line 1:
	This tutorial demonstrates how to use an Elphel (or perhaps another) camera to perform some basic computer vision tasks, such as identifying objects. For this example, we will be recognizing tennis balls.		This tutorial demonstrates how to use an Elphel (or perhaps another) camera to perform some basic computer vision tasks, such as identifying objects. For this example, we will be recognizing tennis balls. A [[Image:Tennis.tar.gz\|finished example]] is available for GNU/Linux systems.

	== Prerequisites ==		== Prerequisites ==
Line 10:		Line 10:

	== Image acquisition ==		== Image acquisition ==
			[[Image:Tennis-input.jpg\|thumb\|Example input image]]

	The first step is to get some images into OpenCV and display them. This assumes you have AVLD and V4L already set up. Below is a fairly minimal example that captures and displays images. It can be compiled with '''gcc -o main main.c $(pkg-config --libs --cflags opencv)'''.		The first step is to get some images into OpenCV and display them. This assumes you have AVLD and V4L already set up. Below is a fairly minimal example that captures and displays images. It can be compiled with '''gcc -o main main.c $(pkg-config --libs --cflags opencv)'''.

Line 41:		Line 43:
	== Processing ==		== Processing ==
	=== Color space ===		=== Color space ===
			[[Image:Tennis-hsv.jpg\|thumb\|Example HSV output]]

	A good first step in many CV algorithms is to convert the image to HSV (or another similar color space). This make picking out objects based on colors a bit simpler as will be seen later. We'll make a copy of the original image so that we can display it at the end. Note that OpenCV stores images in BGR format by default.		A good first step in many CV algorithms is to convert the image to HSV (or another similar color space). This make picking out objects based on colors a bit simpler as will be seen later. We'll make a copy of the original image so that we can display it at the end. Note that OpenCV stores images in BGR format by default.
	<pre>		<pre>
Line 49:		Line 53:

	=== Masks ===		=== Masks ===
			[[Image:Tennis-mask.png\|thumb\|Example mask]]

	The next step is to select all pixels that we think might be part of a tennis ball. We'll do this based purely on their HSV values. OpenCV provides a InRanage function that can be used to pick out pixels based on their values. This generates a mask; a binary image where the foreground (white) pixels were with in the specified range. We're done with the HSV image after this, so we can free it's memory.		The next step is to select all pixels that we think might be part of a tennis ball. We'll do this based purely on their HSV values. OpenCV provides a InRanage function that can be used to pick out pixels based on their values. This generates a mask; a binary image where the foreground (white) pixels were with in the specified range. We're done with the HSV image after this, so we can free it's memory.

Line 61:		Line 67:

	=== Morphological operations ===		=== Morphological operations ===
			[[Image:Tennis-morph.png\|thumb\|Mask after morphological operations]]

	No matter how good your ranges are when generating a mask, there will almost always be noise in the mask. In our example, the white lines on the tennis ball don't show up because they don't fit the hue range. Much of this nose can be eliminated by using a series of morphological operations. Two commonly uses operation are [http://en.wikipedia.org/wiki/Opening_(morphology) opening] and [http://en.wikipedia.org/wiki/Closing_(morphology) closing], which are in turn comprised of [http://en.wikipedia.org/wiki/Dilation_(morphology) dilate] and [http://en.wikipedia.org/wiki/Erosion_(morphology) erode] operations. The table below summarizes these operations.		No matter how good your ranges are when generating a mask, there will almost always be noise in the mask. In our example, the white lines on the tennis ball don't show up because they don't fit the hue range. Much of this nose can be eliminated by using a series of morphological operations. Two commonly uses operation are [http://en.wikipedia.org/wiki/Opening_(morphology) opening] and [http://en.wikipedia.org/wiki/Closing_(morphology) closing], which are in turn comprised of [http://en.wikipedia.org/wiki/Dilation_(morphology) dilate] and [http://en.wikipedia.org/wiki/Erosion_(morphology) erode] operations. The table below summarizes these operations.

Line 107:		Line 115:

	== Output ==		== Output ==
			[[Image:Tennis-output.jpg\|thumb\|Example output on a particularly nice image]]

	The output of the Hough function can then be used in a variety of ways. For now we'll just draw some circles and centers onto the original input image before displaying it.		The output of the Hough function can then be used in a variety of ways. For now we'll just draw some circles and centers onto the original input image before displaying it.

Andy753421: /* Acknowledgments */

2009-06-18T13:55:21Z

Acknowledgments

← Older revision		Revision as of 13:55, 18 June 2009
Line 124:		Line 124:

	== Acknowledgments ==		== Acknowledgments ==
			Some of the code provided as part of this example was developed by Jon Nibert and Andy Spencer as part of the Image Recognition course taught at Rose-Hulman Institute of Technology. All examples are provided under the GNU GPLv3.

Andy753421: /* Output */

2009-06-18T13:51:46Z

Output

← Older revision		Revision as of 13:51, 18 June 2009
Line 107:		Line 107:

	== Output ==		== Output ==
			The output of the Hough function can then be used in a variety of ways. For now we'll just draw some circles and centers onto the original input image before displaying it.

			<pre>
			int i;
			for (i = 0; i < circles->total; i++) {
			float p = (float)cvGetSeqElem(circles, i);
			CvPoint center = cvPoint(cvRound(p[0]),cvRound(p[1]));
			CvScalar val = cvGet2D(mask, center.y, center.x);
			if (val.val[0] < 1) continue;
			cvCircle(img, center, 3, CV_RGB(0,255,0), -1, CV_AA, 0);
			cvCircle(img, center, cvRound(p[2]), CV_RGB(255,0,0), 3, CV_AA, 0);
			cvCircle(mask, center, 3, CV_RGB(0,255,0), -1, CV_AA, 0);
			cvCircle(mask, center, cvRound(p[2]), CV_RGB(255,0,0), 3, CV_AA, 0);
			}
			</pre>

	== Acknowledgments ==		== Acknowledgments ==

Andy753421: /* Processing */

2009-06-18T13:49:26Z

Processing

@@ Line 41: / Line 41: @@
 == Processing ==
 === Color space ===
 === Masks ===
 === Morphological operations ===
 === Hough transform ===
 == Output ==

Andy753421 at 13:06, 18 June 2009

2009-06-18T13:06:13Z

@@ Line 2: / Line 2: @@
 == Prerequisites ==
-=== OpenCV ===
+;OpenCV
-=== V4L/AVLD ===
+:[http://opencv.willowgarage.com/wiki/ OpenCV] is a C library designed to help with computer vision programs. It provides quite a few useful functions that can save a lot typing when performing operations on images.
 == Image acquisition ==
 == Processing ==
@@ Line 12: / Line 44: @@
 === Morphological operations ===
 === Hough transform ===
 == Output ==
 == Acknowledgments ==

Andy753421: templating some things out

2009-06-18T12:42:03Z

templating some things out

New page

This tutorial demonstrates how to use an Elphel (or perhaps another) camera to perform some basic computer vision tasks, such as identifying objects. For this example, we will be recognizing tennis balls.

== Prerequisites ==
=== OpenCV ===
=== V4L/AVLD ===

== Image acquisition ==

== Processing ==
=== Color space ===
=== Masks ===
=== Morphological operations ===
=== Hough transform ===

== Output ==

== Acknowledgments ==