Feature Detection


Canny(image, edges, threshold1, threshold2, aperture_size=3) → None

Implements the Canny algorithm for edge detection.

  • image (CvArr) – Single-channel input image
  • edges (CvArr) – Single-channel image to store the edges found by the function
  • threshold1 (float) – The first threshold
  • threshold2 (float) – The second threshold
  • aperture_size (int) – Aperture parameter for the Sobel operator (see Sobel )

The function finds the edges on the input image image and marks them in the output image edges using the Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking, the largest value is used to find the initial segments of strong edges.


CornerEigenValsAndVecs(image, eigenvv, blockSize, aperture_size=3) → None

Calculates eigenvalues and eigenvectors of image blocks for corner detection.

  • image (CvArr) – Input image
  • eigenvv (CvArr) – Image to store the results. It must be 6 times wider than the input image
  • blockSize (int) – Neighborhood size (see discussion)
  • aperture_size (int) – Aperture parameter for the Sobel operator (see Sobel )

For every pixel, the function cvCornerEigenValsAndVecs considers a \texttt{blockSize} \times \texttt{blockSize} neigborhood S(p). It calcualtes the covariation matrix of derivatives over the neigborhood as:

M =  \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 &  \sum _{S(p)}(dI/dx  \cdot dI/dy)^2  \\ \sum _{S(p)}(dI/dx  \cdot dI/dy)^2 &  \sum _{S(p)}(dI/dy)^2 \end{bmatrix}

After that it finds eigenvectors and eigenvalues of the matrix and stores them into destination image in form (\lambda_1, \lambda_2, x_1, y_1, x_2, y_2) where

  • \lambda_1, \lambda_2

    are the eigenvalues of M ; not sorted

  • x_1, y_1

    are the eigenvectors corresponding to \lambda_1

  • x_2, y_2

    are the eigenvectors corresponding to \lambda_2


CornerHarris(image, harris_dst, blockSize, aperture_size=3, k=0.04) → None

Harris edge detector.

  • image (CvArr) – Input image
  • harris_dst (CvArr) – Image to store the Harris detector responses. Should have the same size as image
  • blockSize (int) – Neighborhood size (see the discussion of CornerEigenValsAndVecs )
  • aperture_size (int) – Aperture parameter for the Sobel operator (see Sobel ).
  • k (float) – Harris detector free parameter. See the formula below

The function runs the Harris edge detector on the image. Similarly to CornerMinEigenVal and CornerEigenValsAndVecs , for each pixel it calculates a 2\times2 gradient covariation matrix M over a \texttt{blockSize} \times \texttt{blockSize} neighborhood. Then, it stores

det(M) - k  \, trace(M)^2

to the destination image. Corners in the image can be found as the local maxima of the destination image.


CornerMinEigenVal(image, eigenval, blockSize, aperture_size=3) → None

Calculates the minimal eigenvalue of gradient matrices for corner detection.

  • image (CvArr) – Input image
  • eigenval (CvArr) – Image to store the minimal eigenvalues. Should have the same size as image
  • blockSize (int) – Neighborhood size (see the discussion of CornerEigenValsAndVecs )
  • aperture_size (int) – Aperture parameter for the Sobel operator (see Sobel ).

The function is similar to CornerEigenValsAndVecs but it calculates and stores only the minimal eigen value of derivative covariation matrix for every pixel, i.e. min(\lambda_1, \lambda_2) in terms of the previous function.


class CvSURFPoint

A SURF keypoint, represented as a tuple ((x, y), laplacian, size, dir, hessian) .

x-coordinate of the feature within the image
y-coordinate of the feature within the image
-1, 0 or +1. sign of the laplacian at the point. Can be used to speedup feature comparison since features with laplacians of different signs can not match
size of the feature
orientation of the feature: 0..360 degrees
value of the hessian (can be used to approximately estimate the feature strengths; see also params.hessianThreshold)


ExtractSURF(image, mask, storage, params)-> (keypoints, descriptors)

Extracts Speeded Up Robust Features from an image.

  • image (CvArr) – The input 8-bit grayscale image
  • mask (CvArr) – The optional input 8-bit mask. The features are only found in the areas that contain more than 50 % of non-zero mask pixels
  • keypoints (CvSeq of CvSURFPoint) – sequence of keypoints.
  • descriptors (CvSeq of list of float) – sequence of descriptors. Each SURF descriptor is a list of floats, of length 64 or 128.
  • storage (CvMemStorage) – Memory storage where keypoints and descriptors will be stored
  • params (CvSURFParams) –

    Various algorithm parameters in a tuple (extended, hessianThreshold, nOctaves, nOctaveLayers) :

    • extended 0 means basic descriptors (64 elements each), 1 means extended descriptors (128 elements each)
    • hessianThreshold only features with hessian larger than that are extracted. good default value is ~300-500 (can depend on the average local contrast and sharpness of the image). user can further filter out some features based on their hessian values and other characteristics.
    • nOctaves the number of octaves to be used for extraction. With each next octave the feature size is doubled (3 by default)
    • nOctaveLayers The number of layers within each octave (4 by default)

The function cvExtractSURF finds robust features in the image, as described in [Bay06] . For each feature it returns its location, size, orientation and optionally the descriptor, basic or extended. The function can be used for object tracking and localization, image stitching etc.

To extract strong SURF features from an image

>>> import cv
>>> im = cv.LoadImageM("building.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE)
>>> (keypoints, descriptors) = cv.ExtractSURF(im, None, cv.CreateMemStorage(), (0, 30000, 3, 1))
>>> print len(keypoints), len(descriptors)
6 6
>>> for ((x, y), laplacian, size, dir, hessian) in keypoints:
...     print "x=%d y=%d laplacian=%d size=%d dir=%f hessian=%f" % (x, y, laplacian, size, dir, hessian)
x=30 y=27 laplacian=-1 size=31 dir=69.778503 hessian=36979.789062
x=296 y=197 laplacian=1 size=33 dir=111.081039 hessian=31514.349609
x=296 y=266 laplacian=1 size=32 dir=107.092300 hessian=31477.908203
x=254 y=284 laplacian=1 size=31 dir=279.137360 hessian=34169.800781
x=498 y=525 laplacian=-1 size=33 dir=278.006592 hessian=31002.759766
x=777 y=281 laplacian=1 size=70 dir=167.940964 hessian=35538.363281


FindCornerSubPix(image, corners, win, zero_zone, criteria) → corners

Refines the corner locations.

  • image (CvArr) – Input image
  • corners (sequence of (float, float)) – Initial coordinates of the input corners as a list of (x, y) pairs
  • win (CvSize) – Half of the side length of the search window. For example, if win =(5,5), then a 5*2+1 \times 5*2+1 = 11 \times 11 search window would be used
  • zero_zone (CvSize) – Half of the size of the dead region in the middle of the search zone over which the summation in the formula below is not done. It is used sometimes to avoid possible singularities of the autocorrelation matrix. The value of (-1,-1) indicates that there is no such size
  • criteria (CvTermCriteria) – Criteria for termination of the iterative process of corner refinement. That is, the process of corner position refinement stops either after a certain number of iterations or when a required accuracy is achieved. The criteria may specify either of or both the maximum number of iteration and the required accuracy

The function iterates to find the sub-pixel accurate location of corners, or radial saddle points, as shown in on the picture below. It returns the refined coordinates as a list of (x, y) pairs.


Sub-pixel accurate corner locator is based on the observation that every vector from the center q to a point p located within a neighborhood of q is orthogonal to the image gradient at p subject to image and measurement noise. Consider the expression:

\epsilon _i = {DI_{p_i}}^T  \cdot (q - p_i)

where {DI_{p_i}} is the image gradient at the one of the points p_i in a neighborhood of q . The value of q is to be found such that \epsilon_i is minimized. A system of equations may be set up with \epsilon_i set to zero:

\sum _i(DI_{p_i}  \cdot {DI_{p_i}}^T) q =  \sum _i(DI_{p_i}  \cdot {DI_{p_i}}^T  \cdot p_i)

where the gradients are summed within a neighborhood (“search window”) of q . Calling the first gradient term G and the second gradient term b gives:

q = G^{-1}  \cdot b

The algorithm sets the center of the neighborhood window at this new center q and then iterates until the center keeps within a set threshold.


GetStarKeypoints(image, storage, params) → keypoints

Retrieves keypoints using the StarDetector algorithm.

  • image (CvArr) – The input 8-bit grayscale image
  • storage (CvMemStorage) – Memory storage where the keypoints will be stored
  • params (CvStarDetectorParams) –

    Various algorithm parameters in a tuple (maxSize, responseThreshold, lineThresholdProjected, lineThresholdBinarized, suppressNonmaxSize) :

    • maxSize maximal size of the features detected. The following values of the parameter are supported: 4, 6, 8, 11, 12, 16, 22, 23, 32, 45, 46, 64, 90, 128
    • responseThreshold threshold for the approximatd laplacian, used to eliminate weak features
    • lineThresholdProjected another threshold for laplacian to eliminate edges
    • lineThresholdBinarized another threshold for the feature scale to eliminate edges
    • suppressNonmaxSize linear size of a pixel neighborhood for non-maxima suppression

The function GetStarKeypoints extracts keypoints that are local scale-space extremas. The scale-space is constructed by computing approximate values of laplacians with different sigma’s at each pixel. Instead of using pyramids, a popular approach to save computing time, all of the laplacians are computed at each pixel of the original high-resolution image. But each approximate laplacian value is computed in O(1) time regardless of the sigma, thanks to the use of integral images. The algorithm is based on the paper Agrawal08 , but instead of a square, hexagon or octagon it uses an 8-end star shape, hence the name, consisting of overlapping upright and tilted squares.

Each keypoint is represented by a tuple ((x, y), size, response) :

  • x, y Screen coordinates of the keypoint
  • size feature size, up to maxSize
  • response approximated laplacian value for the keypoint


GoodFeaturesToTrack(image, eigImage, tempImage, cornerCount, qualityLevel, minDistance, mask=NULL, blockSize=3, useHarris=0, k=0.04) → corners

Determines strong corners on an image.

  • image (CvArr) – The source 8-bit or floating-point 32-bit, single-channel image
  • eigImage (CvArr) – Temporary floating-point 32-bit image, the same size as image
  • tempImage (CvArr) – Another temporary image, the same size and format as eigImage
  • cornerCount (int) – number of corners to detect
  • qualityLevel (float) – Multiplier for the max/min eigenvalue; specifies the minimal accepted quality of image corners
  • minDistance (float) – Limit, specifying the minimum possible distance between the returned corners; Euclidian distance is used
  • mask (CvArr) – Region of interest. The function selects points either in the specified region or in the whole image if the mask is NULL
  • blockSize (int) – Size of the averaging block, passed to the underlying CornerMinEigenVal or CornerHarris used by the function
  • useHarris (int) – If nonzero, Harris operator ( CornerHarris ) is used instead of default CornerMinEigenVal
  • k (float) – Free parameter of Harris detector; used only if ( \texttt{useHarris} != 0 )

The function finds the corners with big eigenvalues in the image. The function first calculates the minimal eigenvalue for every source image pixel using the CornerMinEigenVal function and stores them in eigImage . Then it performs non-maxima suppression (only the local maxima in 3\times 3 neighborhood are retained). The next step rejects the corners with the minimal eigenvalue less than \texttt{qualityLevel} \cdot max(\texttt{eigImage}(x,y)) . Finally, the function ensures that the distance between any two corners is not smaller than minDistance . The weaker corners (with a smaller min eigenvalue) that are too close to the stronger corners are rejected.

Note that the if the function is called with different values A and B of the parameter qualityLevel , and A > {B}, the array of returned corners with qualityLevel=A will be the prefix of the output corners array with qualityLevel=B .


HoughLines2(image, storage, method, rho, theta, threshold, param1=0, param2=0) → lines

Finds lines in a binary image using a Hough transform.

  • image (CvArr) – The 8-bit, single-channel, binary source image. In the case of a probabilistic method, the image is modified by the function
  • storage (CvMemStorage) – The storage for the lines that are detected. It can be a memory storage (in this case a sequence of lines is created in the storage and returned by the function) or single row/single column matrix (CvMat*) of a particular type (see below) to which the lines’ parameters are written. The matrix header is modified by the function so its cols or rows will contain the number of lines detected. If storage is a matrix and the actual number of lines exceeds the matrix size, the maximum possible number of lines is returned (in the case of standard hough transform the lines are sorted by the accumulator value)
  • method (int) –

    The Hough transform variant, one of the following:

    • CV_HOUGH_STANDARD classical or standard Hough transform. Every line is represented by two floating-point numbers (\rho, \theta) , where \rho is a distance between (0,0) point and the line, and \theta is the angle between x-axis and the normal to the line. Thus, the matrix must be (the created sequence will be) of CV_32FC2 type
    • CV_HOUGH_PROBABILISTIC probabilistic Hough transform (more efficient in case if picture contains a few long linear segments). It returns line segments rather than the whole line. Each segment is represented by starting and ending points, and the matrix must be (the created sequence will be) of CV_32SC4 type
    • CV_HOUGH_MULTI_SCALE multi-scale variant of the classical Hough transform. The lines are encoded the same way as CV_HOUGH_STANDARD
  • rho (float) – Distance resolution in pixel-related units
  • theta (float) – Angle resolution measured in radians
  • threshold (int) – Threshold parameter. A line is returned by the function if the corresponding accumulator value is greater than threshold
  • param1 (float) –

    The first method-dependent parameter:

    • For the classical Hough transform it is not used (0).
    • For the probabilistic Hough transform it is the minimum line length.
    • For the multi-scale Hough transform it is the divisor for the distance resolution \rho . (The coarse distance resolution will be \rho and the accurate resolution will be (\rho / \texttt{param1}) ).
  • param2 (float) –

    The second method-dependent parameter:

    • For the classical Hough transform it is not used (0).
    • For the probabilistic Hough transform it is the maximum gap between line segments lying on the same line to treat them as a single line segment (i.e. to join them).
    • For the multi-scale Hough transform it is the divisor for the angle resolution \theta . (The coarse angle resolution will be \theta and the accurate resolution will be (\theta / \texttt{param2}) ).

The function implements a few variants of the Hough transform for line detection.


PreCornerDetect(image, corners, apertureSize=3) → None

Calculates the feature map for corner detection.

  • image (CvArr) – Input image
  • corners (CvArr) – Image to store the corner candidates
  • apertureSize (int) – Aperture parameter for the Sobel operator (see Sobel )

The function calculates the function

D_x^2 D_{yy} + D_y^2 D_{xx} - 2 D_x D_y D_{xy}

where D_? denotes one of the first image derivatives and D_{??} denotes a second image derivative.

The corners can be found as local maximums of the function below:

import cv

def precornerdetect(image):
    # assume that the image is floating-point 
    corners = cv.CloneMat(image)
    cv.PreCornerDetect(image, corners, 3)

    dilated_corners = cv.CloneMat(image)
    cv.Dilate(corners, dilated_corners, None, 1)

    corner_mask = cv.CreateMat(image.rows, image.cols, cv.CV_8UC1)
    cv.Sub(corners, dilated_corners, corners)
    cv.CmpS(corners, 0, corner_mask, cv.CV_CMP_GE)
    return (corners, corner_mask)