Finds edges in an image using the [Canny86] algorithm.
void Canny
(InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false )¶
cv2.
Canny
(image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]]) → edges¶
void cvCanny
(const CvArr* image, CvArr* edges, double threshold1, double threshold2, int aperture_size=3 )¶
cv.
Canny
(image, edges, threshold1, threshold2, aperture_size=3) → None¶Parameters: 


The function finds edges in the input image image
and marks them in the output map edges
using the Canny algorithm. The smallest value between threshold1
and threshold2
is used for edge linking. The largest value is used to find initial segments of strong edges. See
http://en.wikipedia.org/wiki/Canny_edge_detector
Note
Calculates eigenvalues and eigenvectors of image blocks for corner detection.
void cornerEigenValsAndVecs
(InputArray src, OutputArray dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT )¶
cv2.
cornerEigenValsAndVecs
(src, blockSize, ksize[, dst[, borderType]]) → dst¶
void cvCornerEigenValsAndVecs
(const CvArr* image, CvArr* eigenvv, int block_size, int aperture_size=3 )¶
cv.
CornerEigenValsAndVecs
(image, eigenvv, blockSize, aperture_size=3) → None¶Parameters: 


For every pixel
, the function cornerEigenValsAndVecs
considers a blockSize
blockSize
neighborhood
. It calculates the covariation matrix of derivatives over the neighborhood as:
where the derivatives are computed using the
Sobel()
operator.
After that, it finds eigenvectors and eigenvalues of and stores them in the destination image as where
The output of the function can be used for robust edge or corner detection.
See also
Note
Harris edge detector.
void cornerHarris
(InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT )¶
cv2.
cornerHarris
(src, blockSize, ksize, k[, dst[, borderType]]) → dst¶
void cvCornerHarris
(const CvArr* image, CvArr* harris_response, int block_size, int aperture_size=3, double k=0.04 )¶
cv.
CornerHarris
(image, harris_dst, blockSize, aperture_size=3, k=0.04) → None¶Parameters: 


The function runs the Harris edge detector on the image. Similarly to
cornerMinEigenVal()
and
cornerEigenValsAndVecs()
, for each pixel
it calculates a
gradient covariance matrix
over a
neighborhood. Then, it computes the following characteristic:
Corners in the image can be found as the local maxima of this response map.
Calculates the minimal eigenvalue of gradient matrices for corner detection.
void cornerMinEigenVal
(InputArray src, OutputArray dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT )¶
cv2.
cornerMinEigenVal
(src, blockSize[, dst[, ksize[, borderType]]]) → dst¶
void cvCornerMinEigenVal
(const CvArr* image, CvArr* eigenval, int block_size, int aperture_size=3 )¶
cv.
CornerMinEigenVal
(image, eigenval, blockSize, aperture_size=3) → None¶Parameters: 


The function is similar to
cornerEigenValsAndVecs()
but it calculates and stores only the minimal eigenvalue of the covariance matrix of derivatives, that is,
in terms of the formulae in the
cornerEigenValsAndVecs()
description.
Refines the corner locations.
void cornerSubPix
(InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria)¶
cv2.
cornerSubPix
(image, corners, winSize, zeroZone, criteria) → None¶
void cvFindCornerSubPix
(const CvArr* image, CvPoint2D32f* corners, int count, CvSize win, CvSize zero_zone, CvTermCriteria criteria)¶
cv.
FindCornerSubPix
(image, corners, win, zero_zone, criteria) → corners¶Parameters: 


The function iterates to find the subpixel accurate location of corners or radial saddle points, as shown on the figure below.
Subpixel accurate corner locator is based on the observation that every vector from the center to a point located within a neighborhood of is orthogonal to the image gradient at subject to image and measurement noise. Consider the expression:
where is an image gradient at one of the points in a neighborhood of . The value of is to be found so that is minimized. A system of equations may be set up with set to zero:
where the gradients are summed within a neighborhood (“search window”) of . Calling the first gradient term and the second gradient term gives:
The algorithm sets the center of the neighborhood window at this new center and then iterates until the center stays within a set threshold.
Determines strong corners on an image.
void goodFeaturesToTrack
(InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04 )¶
cv2.
goodFeaturesToTrack
(image, maxCorners, qualityLevel, minDistance[, corners[, mask[, blockSize[, useHarrisDetector[, k]]]]]) → corners¶
void cvGoodFeaturesToTrack
(const CvArr* image, CvArr* eig_image, CvArr* temp_image, CvPoint2D32f* corners, int* corner_count, double quality_level, double min_distance, const CvArr* mask=NULL, int block_size=3, int use_harris=0, double k=0.04 )¶
cv.
GoodFeaturesToTrack
(image, eigImage, tempImage, cornerCount, qualityLevel, minDistance, mask=None, blockSize=3, useHarris=0, k=0.04) → cornerCount¶Parameters: 


The function finds the most prominent corners in the image or in the specified image region, as described in [Shi94]:
cornerMinEigenVal()
or
cornerHarris()
.maxDistance
.The function can be used to initialize a pointbased tracker of an object.
Note
If the function is called with different values A
and B
of the parameter qualityLevel
, and A
> {B}, the vector of returned corners with qualityLevel=A
will be the prefix of the output vector with qualityLevel=B
.
Finds circles in a grayscale image using the Hough transform.
void HoughCircles
(InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0 )¶
CvSeq* cvHoughCircles
(CvArr* image, void* circle_storage, int method, double dp, double min_dist, double param1=100, double param2=100, int min_radius=0, int max_radius=0 )¶
cv2.
HoughCircles
(image, method, dp, minDist[, circles[, param1[, param2[, minRadius[, maxRadius]]]]]) → circles¶Parameters: 


The function finds circles in a grayscale image using a modification of the Hough transform.
Example:
#include <cv.h>
#include <highgui.h>
#include <math.h>
using namespace cv;
int main(int argc, char** argv)
{
Mat img, gray;
if( argc != 2 && !(img=imread(argv[1], 1)).data)
return 1;
cvtColor(img, gray, CV_BGR2GRAY);
// smooth it, otherwise a lot of false circles may be detected
GaussianBlur( gray, gray, Size(9, 9), 2, 2 );
vector<Vec3f> circles;
HoughCircles(gray, circles, CV_HOUGH_GRADIENT,
2, gray>rows/4, 200, 100 );
for( size_t i = 0; i < circles.size(); i++ )
{
Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
int radius = cvRound(circles[i][2]);
// draw the circle center
circle( img, center, 3, Scalar(0,255,0), 1, 8, 0 );
// draw the circle outline
circle( img, center, radius, Scalar(0,0,255), 3, 8, 0 );
}
namedWindow( "circles", 1 );
imshow( "circles", img );
return 0;
}
Note
Usually the function detects the centers of circles well. However, it may fail to find correct radii. You can assist to the function by specifying the radius range ( minRadius
and maxRadius
) if you know it. Or, you may ignore the returned radius, use only the center, and find the correct radius using an additional procedure.
See also
Note
Finds lines in a binary image using the standard Hough transform.
void HoughLines
(InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0 )¶
cv2.
HoughLines
(image, rho, theta, threshold[, lines[, srn[, stn]]]) → lines¶
CvSeq* cvHoughLines2
(CvArr* image, void* line_storage, int method, double rho, double theta, int threshold, double param1=0, double param2=0 )¶
cv.
HoughLines2
(image, storage, method, rho, theta, threshold, param1=0, param2=0) → lines¶Parameters: 


The function implements the standard or standard multiscale Hough transform algorithm for line detection. See http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm for a good explanation of Hough transform.
See also the example in HoughLinesP()
description.
Note
Finds line segments in a binary image using the probabilistic Hough transform.
void HoughLinesP
(InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0 )¶
cv2.
HoughLinesP
(image, rho, theta, threshold[, lines[, minLineLength[, maxLineGap]]]) → lines¶Parameters: 


The function implements the probabilistic Hough transform algorithm for line detection, described in [Matas00]. See the line detection example below:
/* This is a standalone program. Pass an image name as the first parameter
of the program. Switch between standard and probabilistic Hough transform
by changing "#if 1" to "#if 0" and back */
#include <cv.h>
#include <highgui.h>
#include <math.h>
using namespace cv;
int main(int argc, char** argv)
{
Mat src, dst, color_dst;
if( argc != 2  !(src=imread(argv[1], 0)).data)
return 1;
Canny( src, dst, 50, 200, 3 );
cvtColor( dst, color_dst, CV_GRAY2BGR );
#if 0
vector<Vec2f> lines;
HoughLines( dst, lines, 1, CV_PI/180, 100 );
for( size_t i = 0; i < lines.size(); i++ )
{
float rho = lines[i][0];
float theta = lines[i][1];
double a = cos(theta), b = sin(theta);
double x0 = a*rho, y0 = b*rho;
Point pt1(cvRound(x0 + 1000*(b)),
cvRound(y0 + 1000*(a)));
Point pt2(cvRound(x0  1000*(b)),
cvRound(y0  1000*(a)));
line( color_dst, pt1, pt2, Scalar(0,0,255), 3, 8 );
}
#else
vector<Vec4i> lines;
HoughLinesP( dst, lines, 1, CV_PI/180, 80, 30, 10 );
for( size_t i = 0; i < lines.size(); i++ )
{
line( color_dst, Point(lines[i][0], lines[i][1]),
Point(lines[i][2], lines[i][3]), Scalar(0,0,255), 3, 8 );
}
#endif
namedWindow( "Source", 1 );
imshow( "Source", src );
namedWindow( "Detected Lines", 1 );
imshow( "Detected Lines", color_dst );
waitKey(0);
return 0;
}
This is a sample picture the function parameters have been tuned for:
And this is the output of the above program in case of the probabilistic Hough transform:
Calculates a feature map for corner detection.
void preCornerDetect
(InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT )¶
cv2.
preCornerDetect
(src, ksize[, dst[, borderType]]) → dst¶
void cvPreCornerDetect
(const CvArr* image, CvArr* corners, int aperture_size=3 )¶
cv.
PreCornerDetect
(image, corners, apertureSize=3) → None¶Parameters: 


The function calculates the complex spatial derivativebased function of the source image
where ,:math:D_y are the first image derivatives, ,:math:D_{yy} are the second image derivatives, and is the mixed derivative.
The corners can be found as local maximums of the functions, as shown below:
Mat corners, dilated_corners;
preCornerDetect(image, corners, 3);
// dilation with 3x3 rectangular structuring element
dilate(corners, dilated_corners, Mat(), 1);
Mat corner_mask = corners == dilated_corners;
[Canny86] 

[Matas00]  Matas, J. and Galambos, C. and Kittler, J.V., Robust Detection of Lines Using the Progressive Probabilistic Hough Transform. CVIU 78 1, pp 119137 (2000) 
[Shi94] 

[Yuen90]  Yuen, H. K. and Princen, J. and Illingworth, J. and Kittler, J., Comparative study of Hough transform methods for circle finding. Image Vision Comput. 8 1, pp 71–77 (1990) 