Structural Analysis and Shape Descriptors
Calculates all of the moments up to the third order of a polygon or rasterized shape.
C++: Moments moments(InputArray array, bool binaryImage=false )
Python: cv2.moments(array[, binaryImage]) → retval
C: void cvMoments(const CvArr* arr, CvMoments* moments, int binary=0 )
- array – Raster image (single-channel, 8-bit or floating-point 2D array) or an array ( or ) of 2D points (Point or Point2f ).
- binaryImage – If it is true, all non-zero image pixels are treated as 1’s. The parameter is used for images only.
- moments – Output moments.
The function computes moments, up to the 3rd order, of a vector shape or a rasterized shape. The results are returned in the structure Moments defined as:
Moments(double m00, double m10, double m01, double m20, double m11,
double m02, double m30, double m21, double m12, double m03 );
Moments( const CvMoments& moments );
operator CvMoments() const;
// spatial moments
double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
// central moments
double mu20, mu11, mu02, mu30, mu21, mu12, mu03;
// central normalized moments
double nu20, nu11, nu02, nu30, nu21, nu12, nu03;
In case of a raster image, the spatial moments are computed as:
The central moments
are computed as:
is the mass center:
The normalized central moments
are computed as:
, hence the values are not stored.
The moments of a contour are defined in the same way but computed using the Green’s formula (see http://en.wikipedia.org/wiki/Green_theorem). So, due to a limited raster resolution, the moments computed for a contour are slightly different from the moments computed for the same rasterized contour.
Since the contour moments are computed using Green formula, you may get seemingly odd results for contours with self-intersections, e.g. a zero area (m00) for butterfly-shaped contours.
Calculates seven Hu invariants.
C++: void HuMoments(const Moments& m, OutputArray hu)
C++: void HuMoments(const Moments& moments, double hu)
Python: cv2.HuMoments(m[, hu]) → hu
C: void cvGetHuMoments(CvMoments* moments, CvHuMoments* hu_moments)
- moments – Input moments computed with moments() .
- hu – Output Hu invariants.
The function calculates seven Hu invariants (introduced in [Hu62]; see also
http://en.wikipedia.org/wiki/Image_moment) defined as:
These values are proved to be invariants to the image scale, rotation, and reflection except the seventh one, whose sign is changed by reflection. This invariance is proved with the assumption of infinite image resolution. In case of raster images, the computed Hu invariants for the original and transformed images are a bit different.
computes the connected components labeled image of boolean image image with 4 or 8 way connectivity - returns N, the total number of labels [0, N-1] where 0 represents the background label. ltype specifies the output label image type, an important consideration based on the total number of labels or alternatively the total number of pixels in the source image.
C++: int connectedComponents(InputArray image, OutputArray labels, int connectivity=8, int ltype=CV_32S)
C++: int connectedComponentsWithStats(InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, int connectivity=8, int ltype=CV_32S)
- image – the image to be labeled
- labels – destination labeled image
- connectivity – 8 or 4 for 8-way or 4-way connectivity respectively
- ltype – output image label type. Currently CV_32S and CV_16U are supported.
- statsv –
statistics output for each label, including the background label, see below for available statistics. Statistics are accessed via statsv(label, COLUMN) where available columns are defined below.
- CC_STAT_LEFT The leftmost (x) coordinate which is the inclusive start of the bounding box in the horizontal
- CC_STAT_TOP The topmost (y) coordinate which is the inclusive start of the bounding box in the vertical
- CC_STAT_WIDTH The horizontal size of the bounding box
- CC_STAT_HEIGHT The vertical size of the bounding box
- CC_STAT_AREA The total area (in pixels) of the connected component
- centroids – floating point centroid (x,y) output for each label, including the background label
Finds contours in a binary image.
C++: void findContours(InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())
C++: void findContours(InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())
Python: cv2.findContours(image, mode, method[, contours[, hierarchy[, offset]]]) → image, contours, hierarchy
The function retrieves contours from the binary image using the algorithm
[Suzuki85]. The contours are a useful tool for shape analysis and object detection and recognition. See squares.c in the OpenCV sample directory.
Source image is modified by this function. Also, the function does not take into account 1-pixel border of the image (it’s filled with 0’s and used for neighbor analysis in the algorithm), therefore the contours touching the image border will be clipped.
If you use the new Python interface then the CV_ prefix has to be omitted in contour retrieval mode and contour approximation method parameters (for example, use cv2.RETR_LIST and cv2.CHAIN_APPROX_NONE parameters). If you use the old Python interface then these parameters have the CV_ prefix (for example, use cv.CV_RETR_LIST and cv.CV_CHAIN_APPROX_NONE).
- An example using the findContour functionality can be found at opencv_source_code/samples/cpp/contours2.cpp
- An example using findContours to clean up a background segmentation result at opencv_source_code/samples/cpp/segment_objects.cpp
- (Python) An example using the findContour functionality can be found at opencv_source/samples/python2/contours.py
- (Python) An example of detecting squares in an image can be found at opencv_source/samples/python2/squares.py
Approximates a polygonal curve(s) with the specified precision.
C++: void approxPolyDP(InputArray curve, OutputArray approxCurve, double epsilon, bool closed)
Python: cv2.approxPolyDP(curve, epsilon, closed[, approxCurve]) → approxCurve
The functions approxPolyDP approximate a curve or a polygon with another curve/polygon with less vertices so that the distance between them is less or equal to the specified precision. It uses the Douglas-Peucker algorithm
See https://github.com/Itseez/opencv/tree/master/samples/cpp/contours2.cpp for the function usage model.
Approximates Freeman chain(s) with a polygonal curve.
C: CvSeq* cvApproxChains(CvSeq* src_seq, CvMemStorage* storage, int method=CV_CHAIN_APPROX_SIMPLE, double parameter=0, int minimal_perimeter=0, int recursive=0 )
- src_seq – Pointer to the approximated Freeman chain that can refer to other chains.
- storage – Storage location for the resulting polylines.
- method – Approximation method (see the description of the function FindContours() ).
- parameter – Method parameter (not used now).
- minimal_perimeter – Approximates only those contours whose perimeters are not less than minimal_perimeter . Other chains are removed from the resulting structure.
- recursive – Recursion flag. If it is non-zero, the function approximates all chains that can be obtained from chain by using the h_next or v_next links. Otherwise, the single input chain is approximated.
This is a standalone contour approximation routine, not represented in the new interface. When FindContours() retrieves contours as Freeman chains, it calls the function to get approximated contours, represented as polygons.
Calculates a contour perimeter or a curve length.
C++: double arcLength(InputArray curve, bool closed)
Python: cv2.arcLength(curve, closed) → retval
C: double cvArcLength(const void* curve, CvSlice slice=CV_WHOLE_SEQ, int is_closed=-1 )
- curve – Input vector of 2D points, stored in std::vector or Mat.
- closed – Flag indicating whether the curve is closed or not.
The function computes a curve length or a closed contour perimeter.
Calculates the up-right bounding rectangle of a point set.
C++: Rect boundingRect(InputArray points)
Python: cv2.boundingRect(points) → retval
C: CvRect cvBoundingRect(CvArr* points, int update=0 )
- points – Input 2D point set, stored in std::vector or Mat.
The function calculates and returns the minimal up-right bounding rectangle for the specified point set.
Calculates a contour area.
C++: double contourArea(InputArray contour, bool oriented=false )
Python: cv2.contourArea(contour[, oriented]) → retval
C: double cvContourArea(const CvArr* contour, CvSlice slice=CV_WHOLE_SEQ, int oriented=0 )
- contour – Input vector of 2D points (contour vertices), stored in std::vector or Mat.
- oriented – Oriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine orientation of a contour by taking the sign of an area. By default, the parameter is false, which means that the absolute value is returned.
The function computes a contour area. Similarly to
moments() , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using
fillPoly() , can be different.
Also, the function will most certainly give a wrong results for contours with self-intersections.
double area0 = contourArea(contour);
approxPolyDP(contour, approx, 5, true);
double area1 = contourArea(approx);
cout << "area0 =" << area0 << endl <<
"area1 =" << area1 << endl <<
"approx poly vertices" << approx.size() << endl;
Finds the convex hull of a point set.
C++: void convexHull(InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true )
Python: cv2.convexHull(points[, hull[, clockwise[, returnPoints]]]) → hull
C: CvSeq* cvConvexHull2(const CvArr* input, void* hull_storage=NULL, int orientation=CV_CLOCKWISE, int return_points=0 )
- points – Input 2D point set, stored in std::vector or Mat.
- hull – Output convex hull. It is either an integer vector of indices or vector of points. In the first case, the hull elements are 0-based indices of the convex hull points in the original array (since the set of convex hull points is a subset of the original point set). In the second case, hull elements are the convex hull points themselves.
- hull_storage – Output memory storage in the old API (cvConvexHull2 returns a sequence containing the convex hull points or their indices).
- clockwise – Orientation flag. If it is true, the output convex hull is oriented clockwise. Otherwise, it is oriented counter-clockwise. The assumed coordinate system has its X axis pointing to the right, and its Y axis pointing upwards.
- orientation – Convex hull orientation parameter in the old API, CV_CLOCKWISE or CV_COUNTERCLOCKWISE.
- returnPoints – Operation flag. In case of a matrix, when the flag is true, the function returns convex hull points. Otherwise, it returns indices of the convex hull points. When the output array is std::vector, the flag is ignored, and the output depends on the type of the vector: std::vector<int> implies returnPoints=true, std::vector<Point> implies returnPoints=false.
The functions find the convex hull of a 2D point set using the Sklansky’s algorithm
O(N logN) complexity in the current implementation. See the OpenCV sample convexhull.cpp that demonstrates the usage of different function variants.
- An example using the convexHull functionality can be found at opencv_source_code/samples/cpp/convexhull.cpp
Finds the convexity defects of a contour.
C++: void convexityDefects(InputArray contour, InputArray convexhull, OutputArray convexityDefects)
Python: cv2.convexityDefects(contour, convexhull[, convexityDefects]) → convexityDefects
C: CvSeq* cvConvexityDefects(const CvArr* contour, const CvArr* convexhull, CvMemStorage* storage=NULL )
- contour – Input contour.
- convexhull – Convex hull obtained using convexHull() that should contain indices of the contour points that make the hull.
- convexityDefects – The output vector of convexity defects. In C++ and the new Python/Java interface each convexity defect is represented as 4-element integer vector (a.k.a. cv::Vec4i): (start_index, end_index, farthest_pt_index, fixpt_depth), where indices are 0-based indices in the original contour of the convexity defect beginning, end and the farthest point, and fixpt_depth is fixed-point approximation (with 8 fractional bits) of the distance between the farthest contour point and the hull. That is, to get the floating-point value of the depth will be fixpt_depth/256.0. In C interface convexity defect is represented by CvConvexityDefect structure - see below.
- storage – Container for the output sequence of convexity defects. If it is NULL, the contour or hull (in that order) storage is used.
The function finds all convexity defects of the input contour and returns a sequence of the CvConvexityDefect structures, where CvConvexityDetect is defined as:
CvPoint* start; // point of the contour where the defect begins
CvPoint* end; // point of the contour where the defect ends
CvPoint* depth_point; // the farthest from the convex hull point within the defect
float depth; // distance between the farthest point and the convex hull
The figure below displays convexity defects of a hand contour:
Fits an ellipse around a set of 2D points.
C++: RotatedRect fitEllipse(InputArray points)
Python: cv2.fitEllipse(points) → retval
C: CvBox2D cvFitEllipse2(const CvArr* points)
The function calculates the ellipse that fits (in a least-squares sense) a set of 2D points best of all. It returns the rotated rectangle in which the ellipse is inscribed. The algorithm [Fitzgibbon95] is used.
Developer should keep in mind that it is possible that the returned ellipse/rotatedRect data contains negative indices, due to the data points being close to the border of the containing Mat element.
- An example using the fitEllipse technique can be found at opencv_source_code/samples/cpp/fitellipse.cpp
Fits a line to a 2D or 3D point set.
C++: void fitLine(InputArray points, OutputArray line, int distType, double param, double reps, double aeps)
Python: cv2.fitLine(points, distType, param, reps, aeps[, line]) → line
C: void cvFitLine(const CvArr* points, int dist_type, double param, double reps, double aeps, float* line)
- points – Input vector of 2D or 3D points, stored in std::vector<> or Mat.
- line – Output line parameters. In case of 2D fitting, it should be a vector of 4 elements (like Vec4f) - (vx, vy, x0, y0), where (vx, vy) is a normalized vector collinear to the line and (x0, y0) is a point on the line. In case of 3D fitting, it should be a vector of 6 elements (like Vec6f) - (vx, vy, vz, x0, y0, z0), where (vx, vy, vz) is a normalized vector collinear to the line and (x0, y0, z0) is a point on the line.
- distType – Distance used by the M-estimator (see the discussion below).
- param – Numerical parameter ( C ) for some types of distances. If it is 0, an optimal value is chosen.
- reps – Sufficient accuracy for the radius (distance between the coordinate origin and the line).
- aeps – Sufficient accuracy for the angle. 0.01 would be a good default value for reps and aeps.
The function fitLine fits a line to a 2D or 3D point set by minimizing
is a distance between the
point, the line and
is a distance function, one of the following:
The algorithm is based on the M-estimator (
) technique that iteratively fits the line using the weighted least-squares algorithm. After each iteration the weights
are adjusted to be inversely proportional to
Tests a contour convexity.
C++: bool isContourConvex(InputArray contour)
Python: cv2.isContourConvex(contour) → retval
C: int cvCheckContourConvexity(const CvArr* contour)
The function tests whether the input contour is convex or not. The contour must be simple, that is, without self-intersections. Otherwise, the function output is undefined.
Finds a rotated rectangle of the minimum area enclosing the input 2D point set.
C++: RotatedRect minAreaRect(InputArray points)
Python: cv2.minAreaRect(points) → retval
C: CvBox2D cvMinAreaRect2(const CvArr* points, CvMemStorage* storage=NULL )
The function calculates and returns the minimum-area bounding rectangle (possibly rotated) for a specified point set. See the OpenCV sample minarea.cpp .
Developer should keep in mind that the returned rotatedRect can contain negative indices when data is close the the containing Mat element boundary.
Finds the four vertices of a rotated rect. Useful to draw the rotated rectangle.
C++: void boxPoints(RotatedRect box, OutputArray points)
Python: cv2.boxPoints(box[, points]) → points
C: void cvBoxPoints(CvBox2D box, CvPoint2D32f pt)
- box – The input rotated rectangle. It may be the output of .. ocv:function:: minAreaRect.
- points – The output array of four vertices of rectangles.
The function finds the four vertices of a rotated rectangle. This function is useful to draw the rectangle. In C++, instead of using this function, you can directly use box.points() method. Please visit the tutorial on bounding rectangle for more information.
Finds a triangle of minimum area enclosing a 2D point set and returns its area.
C++: double minEnclosingTriangle(InputArray points, OutputArray triangle)
Python: cv2.minEnclosingTriangle(points[, triangle]) → retval, triangle
The function finds a triangle of minimum area enclosing the given set of 2D points and returns its area. The output for a given 2D point set is shown in the image below. 2D points are depicted in red and the enclosing triangle in yellow.
The implementation of the algorithm is based on O’Rourke’s [ORourke86] and Klee and Laskowski’s [KleeLaskowski85] papers. O’Rourke provides a
algorithm for finding the minimal enclosing triangle of a 2D convex polygon with n vertices. Since the minEnclosingTriangle() function takes a 2D point set as input an additional preprocessing step of computing the convex hull of the 2D point set is required. The complexity of the convexHull() function is
which is higher than
Thus the overall complexity of the function is
See opencv_source/samples/cpp/minarea.cpp for a usage example.
Finds a circle of the minimum area enclosing a 2D point set.
C++: void minEnclosingCircle(InputArray points, Point2f& center, float& radius)
Python: cv2.minEnclosingCircle(points) → center, radius
C: int cvMinEnclosingCircle(const CvArr* points, CvPoint2D32f* center, float* radius)
The function finds the minimal enclosing circle of a 2D point set using an iterative algorithm. See the OpenCV sample minarea.cpp .
Compares two shapes.
C++: double matchShapes(InputArray contour1, InputArray contour2, int method, double parameter)
Python: cv2.matchShapes(contour1, contour2, method, parameter) → retval
C: double cvMatchShapes(const void* object1, const void* object2, int method, double parameter=0 )
- object1 – First contour or grayscale image.
- object2 – Second contour or grayscale image.
- method – Comparison method: CV_CONTOURS_MATCH_I1 , CV_CONTOURS_MATCH_I2 or CV_CONTOURS_MATCH_I3 (see the details below).
- parameter – Method-specific parameter (not supported now).
The function compares two shapes. All three implemented methods use the Hu invariants (see
HuMoments() ) as follows (
denotes object1,:math:B denotes object2 ):
are the Hu moments of
Performs a point-in-contour test.
C++: double pointPolygonTest(InputArray contour, Point2f pt, bool measureDist)
Python: cv2.pointPolygonTest(contour, pt, measureDist) → retval
C: double cvPointPolygonTest(const CvArr* contour, CvPoint2D32f pt, int measure_dist)
- contour – Input contour.
- pt – Point tested against the contour.
- measureDist – If true, the function estimates the signed distance from the point to the nearest contour edge. Otherwise, the function only checks if the point is inside a contour or not.
The function determines whether the
point is inside a contour, outside, or lies on an edge (or coincides
with a vertex). It returns positive (inside), negative (outside), or zero (on an edge) value,
correspondingly. When measureDist=false , the return value
is +1, -1, and 0, respectively. Otherwise, the return value
is a signed distance between the point and the nearest contour
See below a sample output of the function where each image pixel is tested against the contour.
|[Fitzgibbon95]||Andrew W. Fitzgibbon, R.B.Fisher. A Buyer’s Guide to Conic Fitting. Proc.5th British Machine Vision Conference, Birmingham, pp. 513-522, 1995.|
- Hu. Visual Pattern Recognition by Moment Invariants, IRE Transactions on Information Theory, 8:2, pp. 179-187, 1962.
|[KleeLaskowski85]||Klee, V. and Laskowski, M.C., Finding the smallest triangles containing a given convex polygon, Journal of Algorithms, vol. 6, no. 3, pp. 359-375 (1985)|
|[ORourke86]||O’Rourke, J., Aggarwal, A., Maddila, S., and Baldwin, M., An optimal algorithm for finding minimal enclosing triangles, Journal of Algorithms, vol. 7, no. 2, pp. 258-269 (1986)|
|[Sklansky82]||Sklansky, J., Finding the Convex Hull of a Simple Polygon. PRL 1 $number, pp 79-83 (1982)|
|[Suzuki85]||Suzuki, S. and Abe, K., Topological Structural Analysis of Digitized Binary Images by Border Following. CVGIP 30 1, pp 32-46 (1985)|
|[TehChin89]||Teh, C.H. and Chin, R.T., On the Detection of Dominant Points on Digital Curve. PAMI 11 8, pp 859-872 (1989)|
Finds out if there is any intersection between two rotated rectangles. If there is then the vertices of the interesecting region are returned as well.
C++: int rotatedRectangleIntersection(const RotatedRect& rect1, const RotatedRect& rect2, OutputArray intersectingRegion)
Python: cv2.rotatedRectangleIntersection(rect1, rect2) → retval, intersectingRegion
- rect1 – First rectangle
- rect2 – Second rectangle
- intersectingRegion – The output array of the verticies of the intersecting region. It returns at most 8 vertices. Stored as std::vector<cv::Point2f> or cv::Mat as Mx1 of type CV_32FC2.
- pointCount – The number of vertices.
The following values are returned by the function:
- INTERSECT_NONE=0 - No intersection
- INTERSECT_PARTIAL=1 - There is a partial intersection
- INTERSECT_FULL=2 - One of the rectangle is fully enclosed in the other
Below are some examples of intersection configurations. The hatched pattern indicates the intersecting region and the red vertices are returned by the function.