结构分析和形状描述符

详细描述

命名空间
命名空间	cv::traits

类
类	cv::GeneralizedHough
	使用广义霍夫变换在灰度图像中查找任意模板 更多…
类	cv::GeneralizedHoughBallard
	使用广义霍夫变换在灰度图像中查找任意模板 更多…
类	cv::GeneralizedHoughGuil
	使用广义霍夫变换在灰度图像中查找任意模板 更多…
类	cv::Moments
	由 cv::moments 返回的结构体 更多…

枚举
枚举	cv::ConnectedComponentsAlgorithmsTypes {   cv::CCL_DEFAULT = -1 ,   cv::CCL_WU = 0 ,   cv::CCL_GRANA = 1 ,   cv::CCL_BOLELLI = 2 ,   cv::CCL_SAUF = 3 ,   cv::CCL_BBDT = 4 ,   cv::CCL_SPAGHETTI = 5 }
	连通分量算法 更多…
枚举	cv::ConnectedComponentsTypes {   cv::CC_STAT_LEFT = 0 ,   cv::CC_STAT_TOP = 1 ,   cv::CC_STAT_WIDTH = 2 ,   cv::CC_STAT_HEIGHT = 3 ,   cv::CC_STAT_AREA = 4 }
	连通分量统计信息 更多…
枚举	cv::ContourApproximationModes {   cv::CHAIN_APPROX_NONE = 1 ,   cv::CHAIN_APPROX_SIMPLE = 2 ,   cv::CHAIN_APPROX_TC89_L1 = 3 ,   cv::CHAIN_APPROX_TC89_KCOS = 4 }
	轮廓逼近算法 更多…
枚举	cv::RectanglesIntersectTypes {   cv::INTERSECT_NONE = 0 ,   cv::INTERSECT_PARTIAL = 1 ,   cv::INTERSECT_FULL = 2 }
	矩形相交类型 更多…
枚举	cv::RetrievalModes {   cv::RETR_EXTERNAL = 0 ,   cv::RETR_LIST = 1 ,   cv::RETR_CCOMP = 2 ,   cv::RETR_TREE = 3 ,   cv::RETR_FLOODFILL = 4 }
	轮廓检索算法模式 更多…
枚举	cv::ShapeMatchModes {   cv::CONTOURS_MATCH_I1 =1 ,   cv::CONTOURS_MATCH_I2 =2 ,   cv::CONTOURS_MATCH_I3 =3 }
	形状匹配方法。 更多…

函数
void	cv::approxPolyDP (InputArray curve, OutputArray approxCurve, double epsilon, bool closed)
	以指定的精度逼近多边形曲线。
void	cv::approxPolyN (InputArray curve, OutputArray approxCurve, int nsides, float epsilon_percentage=-1.0, bool ensure_convex=true)
	用指定精度和边数的凸包逼近多边形。
double	cv::arcLength (InputArray curve, bool closed)
	计算轮廓周长或曲线长度。
Rect	cv::boundingRect (InputArray array)
	计算点集或灰度图像非零像素的右上方边界矩形。
void	cv::boxPoints (RotatedRect box, OutputArray points)
	查找旋转矩形的四个顶点。可用于绘制旋转矩形。
int	cv::connectedComponents (InputArray image, OutputArray labels, int connectivity, int ltype, int ccltype)
	计算布尔图像的连通分量标记图像
int	cv::connectedComponents (InputArray image, OutputArray labels, int connectivity=8, int ltype=CV_32S)
int	cv::connectedComponentsWithStats (InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, int connectivity, int ltype, int ccltype)
	计算布尔图像的连通分量标记图像，并为每个标记生成统计输出。
int	cv::connectedComponentsWithStats (InputArray image, OutputArray labels, OutputArray stats, OutputArray centroids, int connectivity=8, int ltype=CV_32S)
double	cv::contourArea (InputArray contour, bool oriented=false)
	计算轮廓面积。
void	cv::convexHull (InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true)
	查找点集的凸包。
void	cv::convexityDefects (InputArray contour, InputArray convexhull, OutputArray convexityDefects)
	查找轮廓的凸缺陷。
Ptr< GeneralizedHoughBallard >	cv::createGeneralizedHoughBallard ()
	创建一个指向 cv::GeneralizedHoughBallard 类的智能指针并对其进行初始化。
Ptr<GeneralizedHoughGuil>	cv::createGeneralizedHoughGuil ()
	创建一个指向cv::GeneralizedHoughGuil类的智能指针并进行初始化。
void	cv::findContours (InputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point())
void	cv::findContours (InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point())
	在二值图像中查找轮廓。
void	cv::findContoursLinkRuns (InputArray image, OutputArrayOfArrays contours)
	这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。
void	cv::findContoursLinkRuns (InputArray image, OutputArrayOfArrays contours, OutputArray hierarchy)
	使用链接运行算法查找轮廓。
RotatedRect	cv::fitEllipse (InputArray points)
	拟合一个椭圆到一组2D点。
RotatedRect	cv::fitEllipseAMS (InputArray points)
	拟合一个椭圆到一组2D点。
RotatedRect	cv::fitEllipseDirect (InputArray points)
	拟合一个椭圆到一组2D点。
void	cv::fitLine (InputArray points, OutputArray line, int distType, double param, double reps, double aeps)
	将一条线拟合到2D或3D点集。
void	cv::HuMoments (const Moments &m, OutputArray hu)
void	cv::HuMoments (const Moments &moments, double hu[7])
	计算七个Hu不变矩。
float	cv::intersectConvexConvex (InputArray p1, InputArray p2, OutputArray p12, bool handleNested=true)
	查找两个凸多边形的交集。
bool	cv::isContourConvex (InputArray contour)
	测试轮廓的凸性。
double	cv::matchShapes (InputArray contour1, InputArray contour2, int method, double parameter)
	比较两个形状。
RotatedRect	cv::minAreaRect (InputArray points)
	找到最小面积的旋转矩形，该矩形包含输入的2D点集。
void	cv::minEnclosingCircle (InputArray points, Point2f &center, float &radius)
	找到最小面积的圆形，该圆形包含2D点集。
double	cv::minEnclosingTriangle (InputArray points, OutputArray triangle)
	找到最小面积的三角形，该三角形包含2D点集并返回其面积。
Moments	cv::moments (InputArray array, bool binaryImage=false)
	计算多边形或光栅化形状的三阶矩。
double	cv::pointPolygonTest (InputArray contour, Point2f pt, bool measureDist)
	执行点在轮廓内的测试。
int	cv::rotatedRectangleIntersection (const RotatedRect &rect1, const RotatedRect &rect2, OutputArray intersectingRegion)
	找出两个旋转矩形之间是否存在任何交集。

枚举类型文档

ConnectedComponentsAlgorithmsTypes

enum cv::ConnectedComponentsAlgorithmsTypes

#include <opencv2/imgproc.hpp>

连通分量算法

枚举器
CCL_DEFAULT Python: cv.CCL_DEFAULT	用于8向连通性的Spaghetti算法[31]，用于4向连通性的Spaghetti4C算法[32]。
CCL_WU Python: cv.CCL_WU	用于8向连通性的SAUF算法[301]，用于4向连通性的SAUF算法。[30]中描述的SAUF并行实现可用。
CCL_GRANA Python: cv.CCL_GRANA	用于8向连通性的BBDT算法[109]，用于4向连通性的SAUF算法。[30]中描述的BBDT和SAUF并行实现可用。
CCL_BOLELLI Python: cv.CCL_BOLELLI	用于8向连通性的Spaghetti算法 [31]，用于4向连通性的Spaghetti4C算法 [32]。在 [30] 中描述的并行实现可用于Spaghetti和Spaghetti4C。
CCL_SAUF  Python: cv.CCL_SAUF	与CCL_WU相同。最好使用算法名称的标志(CCL_SAUF)，而不是使用第一作者的名称(CCL_WU)。
CCL_BBDT  Python: cv.CCL_BBDT	与CCL_GRANA相同。最好使用算法名称的标志(CCL_BBDT)，而不是使用第一作者的名称(CCL_GRANA)。
CCL_SPAGHETTI  Python: cv.CCL_SPAGHETTI	与CCL_BOLELLI相同。最好使用算法名称的标志(CCL_SPAGHETTI)，而不是使用第一作者的名称(CCL_BOLELLI)。

连通分量类型

枚举 cv::ConnectedComponentsTypes

#include <opencv2/imgproc.hpp>

连通分量统计

枚举器
CC_STAT_LEFT  Python: cv.CC_STAT_LEFT	最左边的（x）坐标，即水平方向上边界框的起始坐标（包含）。
CC_STAT_TOP  Python: cv.CC_STAT_TOP	最顶端的（y）坐标，即垂直方向上边界框的起始坐标（包含）。
CC_STAT_WIDTH  Python: cv.CC_STAT_WIDTH	边界框的水平大小。
CC_STAT_HEIGHT  Python: cv.CC_STAT_HEIGHT	边界框的垂直大小。
CC_STAT_AREA  Python: cv.CC_STAT_AREA	连通分量的总面积（以像素为单位）。

轮廓逼近模式

枚举 cv::ContourApproximationModes

#include <opencv2/imgproc.hpp>

轮廓逼近算法

枚举器
CHAIN_APPROX_NONE  Python: cv.CHAIN_APPROX_NONE	存储所有轮廓点。也就是说，轮廓的任意两个后续点(x1,y1)和(x2,y2)将是水平、垂直或对角线邻居，即max(abs(x1-x2),abs(y2-y1))==1。
CHAIN_APPROX_SIMPLE  Python: cv.CHAIN_APPROX_SIMPLE	压缩水平、垂直和对角线线段，只留下它们的端点。例如，一个向上的矩形轮廓用4个点编码。
CHAIN_APPROX_TC89_L1  Python: cv.CHAIN_APPROX_TC89_L1	应用Teh-Chin链逼近算法的一种变体 [266]
CHAIN_APPROX_TC89_KCOS  Python: cv.CHAIN_APPROX_TC89_KCOS	应用Teh-Chin链逼近算法的一种变体 [266]

矩形相交类型

枚举 cv::RectanglesIntersectTypes

#include <opencv2/imgproc.hpp>

矩形之间相交的类型

枚举器
INTERSECT_NONE  Python: cv.INTERSECT_NONE	不相交。
INTERSECT_PARTIAL  Python: cv.INTERSECT_PARTIAL	部分相交。
INTERSECT_FULL  Python: cv.INTERSECT_FULL	一个矩形完全包含在另一个矩形中。

检索模式

枚举 cv::RetrievalModes

#include <opencv2/imgproc.hpp>

轮廓检索算法的模式

枚举器
RETR_EXTERNAL  Python: cv.RETR_EXTERNAL	只检索最外层的轮廓。它将所有轮廓的hierarchy[i][2]=hierarchy[i][3]=-1。
RETR_LIST  Python: cv.RETR_LIST	检索所有轮廓，而不建立任何层次关系。
RETR_CCOMP  Python: cv.RETR_CCOMP	检索所有轮廓并将它们组织成两级层次结构。在顶层，是组件的外部边界。在第二层，是孔的边界。如果连通分量的孔内还有另一个轮廓，它仍然放在顶层。
RETR_TREE  Python: cv.RETR_TREE	检索所有轮廓并重建嵌套轮廓的完整层次结构。
RETR_FLOODFILL  Python: cv.RETR_FLOODFILL

形状匹配模式

枚举 cv::ShapeMatchModes

#include <opencv2/imgproc.hpp>

形状匹配方法。

\(A\) 表示对象1，\(B\) 表示对象2

\(\begin{array}{l} m^A_i = \mathrm{sign} (h^A_i) \cdot \log{h^A_i} \\ m^B_i = \mathrm{sign} (h^B_i) \cdot \log{h^B_i} \end{array}\)

并且\(h^A_i, h^B_i\)分别是\(A\)和\(B\)的Hu矩。

枚举器
CONTOURS_MATCH_I1  Python: cv.CONTOURS_MATCH_I1	\[I_1(A,B) = \sum _{i=1...7} \left | \frac{1}{m^A_i} - \frac{1}{m^B_i} \right |\]
CONTOURS_MATCH_I2  Python: cv.CONTOURS_MATCH_I2	\[I_2(A,B) = \sum _{i=1...7} \left | m^A_i - m^B_i \right |\]
CONTOURS_MATCH_I3  Python: cv.CONTOURS_MATCH_I3	\[I_3(A,B) = \max _{i=1...7} \frac{ \left| m^A_i - m^B_i \right| }{ \left| m^A_i \right| }\]

函数文档

approxPolyDP()

void cv::approxPolyDP	(	输入数组	曲线,
		输出数组	近似曲线,
		双精度浮点数	精度,
		布尔值	闭合 )

Python
	cv.approxPolyDP(	曲线, 精度, 闭合[, 近似曲线]	) ->	近似曲线

#include <opencv2/imgproc.hpp>

以指定的精度逼近多边形曲线。

函数cv::approxPolyDP 用更少的顶点逼近曲线或多边形，使得它们之间的距离小于或等于指定的精度。它使用道格拉斯-普克算法 http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm

参数

曲线	存储在std::vector或Mat中的二维点的输入向量
近似曲线	逼近的结果。类型应与输入曲线的类型匹配。
精度	指定逼近精度的参数。这是原始曲线与其逼近之间最大距离。
闭合	如果为真，则逼近的曲线是闭合的（其第一个和最后一个顶点连接）。否则，它不是闭合的。

approxPolyN()

void cv::approxPolyN	(	输入数组	曲线,
		输出数组	近似曲线,
		整数	边数,
		单精度浮点数	精度百分比 = -1.0,
		布尔值	确保凸性 = true )

Python
	cv.approxPolyN(	曲线, 边数[, 近似曲线[, 精度百分比[, 确保凸性]]]	) ->	近似曲线

#include <opencv2/imgproc.hpp>

用指定精度和边数的凸包逼近多边形。

cv::approxPolyN 函数用凸包逼近多边形，使得原始轮廓的轮廓面积与新多边形之间的差异最小。它使用贪婪算法将两个顶点收缩成一个顶点，使得附加面积最小。绘制凸轮廓的每条边的直线，并考虑所得三角形的面积。每个顶点将位于原始轮廓上或其外部。

该算法基于论文[148]。

参数

曲线	存储在std::vector或Mat中的二维点的输入向量，点必须是浮点数或整数。
近似曲线	逼近的结果。类型是std::vector或Mat中的二维点（Point2f或Point）向量。
边数	该参数定义结果多边形的边数。
精度百分比	定义附加面积最大值的百分比。如果等于-1，则不使用。否则，如果附加面积大于contourArea(_curve) *百分比，则算法停止。如果附加面积超过限制，则算法返回在超过限制时存在的顶点数。
确保凸性	如果为真，则算法创建输入轮廓的凸包。否则，输入向量应为凸的。

arcLength()

double cv::arcLength	(	输入数组	曲线,
		布尔值	闭合 )

Python
	cv.arcLength(	曲线, 闭合	) ->	返回值

#include <opencv2/imgproc.hpp>

计算轮廓周长或曲线长度。

该函数计算曲线长度或闭合轮廓周长。

参数

曲线	存储在std::vector或Mat中的二维点的输入向量。
闭合	指示曲线是否闭合的标志。

boundingRect()

Rect cv::boundingRect

(

输入数组

数组

)

Python
	cv.boundingRect(	数组	) ->	返回值

#include <opencv2/imgproc.hpp>

计算点集或灰度图像非零像素的右上方边界矩形。

该函数计算并返回指定点集或灰度图像的非零像素的最小正向包围矩形。

参数

数组	输入灰度图像或二维点集，存储在std::vector或Mat中。

boxPoints()

void cv::boxPoints	(	RotatedRect	矩形框,
		输出数组	点 )

Python
	cv.boxPoints(	矩形框[, 点]	) ->	点

#include <opencv2/imgproc.hpp>

查找旋转矩形的四个顶点。可用于绘制旋转矩形。

该函数查找旋转矩形的四个顶点。此函数可用于绘制矩形。在C++中，无需使用此函数，可以直接使用RotatedRect::points方法。请访问轮廓创建边界旋转框和椭圆的教程以了解更多信息。

参数

矩形框	输入旋转矩形。它可能是minAreaRect的输出。
点	矩形的四个顶点的输出数组。

connectedComponents() [1/2]

int cv::connectedComponents	(	输入数组	图像,
		输出数组	标签,
		整数	连通性,
		整数	标签类型,
		整数	连通分量算法类型 )

Python
	cv.connectedComponents(	图像[, 标签[, 连通性[, 标签类型]]]	) ->	返回值, 标签
	cv.connectedComponentsWithAlgorithm(	图像, 连通性, 标签类型, 连通分量算法类型[, 标签]	) ->	返回值, 标签

#include <opencv2/imgproc.hpp>

计算布尔图像的连通分量标记图像

具有4路或8路连通性的图像 - 返回N，标签总数[0, N-1]，其中0代表背景标签。ltype指定输出标签图像类型，根据标签总数或源图像中的像素总数进行重要考虑。ccltype指定要使用的连通分量标记算法，当前支持Bolelli（Spaghetti）[31]、Grana（BBDT）[109]和Wu（SAUF）[301]算法，详情请参见ConnectedComponentsAlgorithmsTypes。请注意，SAUF算法强制执行标签的行主序，而Spaghetti和BBDT则不强制执行。如果启用了至少一个允许的并行框架，并且图像的行数至少是getNumberOfCPUs返回的两倍，则此函数使用算法的并行版本。

参数

图像	要标记的8位单通道图像
标签	目标标记图像
连通性	8或4分别表示8路或4路连通性
标签类型	输出图像标签类型。目前支持CV_32S和CV_16U。
ccltype	连通分量算法类型（参见ConnectedComponentsAlgorithmsTypes）。

connectedComponents() [2/2]

int cv::connectedComponents	(	输入数组	图像,
		输出数组	标签,
		整数	连通性 = 8,
		整数	标签类型 = CV_32S )

Python
	cv.connectedComponents(	图像[, 标签[, 连通性[, 标签类型]]]	) ->	返回值, 标签
	cv.connectedComponentsWithAlgorithm(	图像, 连通性, 标签类型, 连通分量算法类型[, 标签]	) ->	返回值, 标签

#include <opencv2/imgproc.hpp>

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数

图像	要标记的8位单通道图像
标签	目标标记图像
连通性	8或4分别表示8路或4路连通性
标签类型	输出图像标签类型。目前支持CV_32S和CV_16U。

connectedComponentsWithStats() [1/2]

int cv::connectedComponentsWithStats	(	输入数组	图像,
		输出数组	标签,
		输出数组	统计数据,
		输出数组	质心,
		整数	连通性,
		整数	标签类型,
		整数	连通分量算法类型 )

Python
	cv.connectedComponentsWithStats(	图像[, 标签[, 统计数据[, 质心[, 连通性[, 标签类型]]]]]	) ->	返回值, 标签, 统计数据, 质心
	cv.connectedComponentsWithStatsWithAlgorithm(	图像, 连通性, 标签类型, 连通分量算法类型[, 标签[, 统计数据[, 质心]]]	) ->	返回值, 标签, 统计数据, 质心

#include <opencv2/imgproc.hpp>

计算布尔图像的连通分量标记图像，并为每个标记生成统计输出。

图像具有4或8连通性 - 返回N，总标签数[0, N-1]，其中0代表背景标签。ltype指定输出标签图像类型，这是一个重要考虑因素，基于总标签数或源图像中的总像素数。ccltype指定要使用的连通分量标记算法，目前支持Bolelli (Spaghetti) [31]、Grana (BBDT) [109]和Wu (SAUF) [301] 算法，详情请参见ConnectedComponentsAlgorithmsTypes。请注意，SAUF算法强制执行标签的行主序，而Spaghetti和BBDT则没有。如果至少启用了一个允许的并行框架，并且图像的行数至少是getNumberOfCPUs返回数值的两倍，则此函数使用算法的并行版本（包含统计信息）。

参数

图像	要标记的8位单通道图像
标签	目标标记图像
统计数据	每个标签（包括背景标签）的统计输出。统计信息通过stats(label, COLUMN)访问，其中COLUMN是ConnectedComponentsTypes之一，用于选择统计信息。数据类型为CV_32S。
质心	每个标签（包括背景标签）的质心输出。可以通过centroids(label, 0)访问x坐标质心，通过centroids(label, 1)访问y坐标质心。数据类型为CV_64F。
连通性	8或4分别表示8路或4路连通性
标签类型	输出图像标签类型。目前支持CV_32S和CV_16U。
ccltype	连通分量算法类型（参见ConnectedComponentsAlgorithmsTypes）。

connectedComponentsWithStats() [2/2]

int cv::connectedComponentsWithStats	(	输入数组	图像,
		输出数组	标签,
		输出数组	统计数据,
		输出数组	质心,
		整数	连通性 = 8,
		整数	标签类型 = CV_32S )

Python
	cv.connectedComponentsWithStats(	图像[, 标签[, 统计数据[, 质心[, 连通性[, 标签类型]]]]]	) ->	返回值, 标签, 统计数据, 质心
	cv.connectedComponentsWithStatsWithAlgorithm(	图像, 连通性, 标签类型, 连通分量算法类型[, 标签[, 统计数据[, 质心]]]	) ->	返回值, 标签, 统计数据, 质心

#include <opencv2/imgproc.hpp>

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

参数

图像	要标记的8位单通道图像
标签	目标标记图像
统计数据	每个标签（包括背景标签）的统计输出。统计信息通过stats(label, COLUMN)访问，其中COLUMN是ConnectedComponentsTypes之一，用于选择统计信息。数据类型为CV_32S。
质心	每个标签（包括背景标签）的质心输出。可以通过centroids(label, 0)访问x坐标质心，通过centroids(label, 1)访问y坐标质心。数据类型为CV_64F。
连通性	8或4分别表示8路或4路连通性
标签类型	输出图像标签类型。目前支持CV_32S和CV_16U。

contourArea()

double cv::contourArea	(	输入数组	轮廓,
		布尔值	oriented = false )

Python
	cv.contourArea(	轮廓[, oriented]	) ->	返回值

#include <opencv2/imgproc.hpp>

计算轮廓面积。

该函数计算轮廓面积。与矩类似，面积使用格林公式计算。因此，如果您使用drawContours或fillPoly绘制轮廓，则返回的面积和非零像素数量可能不同。此外，对于具有自相交的轮廓，该函数很可能会给出错误的结果。

示例

vector<Point> contour;
contour.push_back(Point2f(0, 0));
contour.push_back(Point2f(10, 0));
contour.push_back(Point2f(10, 10));
contour.push_back(Point2f(5, 4));
 
double area0 = contourArea(contour);
vector<Point> approx;
approxPolyDP(contour, approx, 5, true);
double area1 = contourArea(approx);
 
cout << "area0 =" << area0 << endl <<
        "area1 =" << area1 << endl <<
        "近似多边形顶点" << approx.size() << endl;

参数

轮廓	输入二维点向量（轮廓顶点），存储在std::vector或Mat中。
oriented	方向面积标志。如果为真，则函数返回带符号的面积值，具体取决于轮廓方向（顺时针或逆时针）。使用此功能，您可以通过取面积的符号来确定轮廓的方向。默认情况下，参数为false，这意味着返回绝对值。

convexHull()

void cv::convexHull	(	输入数组	点,
		输出数组	凸包,
		布尔值	clockwise = false,
		布尔值	returnPoints = true )

Python
	cv.convexHull(	点集[, 凸包[, clockwise[, returnPoints]]]	) ->	凸包

#include <opencv2/imgproc.hpp>

查找点集的凸包。

函数cv::convexHull使用Sklansky算法[247]查找二维点集的凸包，在当前实现中其复杂度为O(N logN)。

参数

点	输入二维点集，存储在std::vector或Mat中。
凸包	输出凸包。它可以是索引的整数向量，也可以是点的向量。在第一种情况下，凸包元素是原始数组中凸包点的基于0的索引（因为凸包点集是原始点集的子集）。在第二种情况下，凸包元素是凸包点本身。
clockwise	方向标志。如果为真，则输出凸包按顺时针方向定向。否则，它按逆时针方向定向。假定的坐标系其X轴指向右侧，Y轴指向向上。
returnPoints	操作标志。对于矩阵，当标志为真时，函数返回凸包点。否则，它返回凸包点的索引。当输出数组为std::vector时，将忽略该标志，输出取决于向量的类型：std::vector<int>表示returnPoints=false，std::vector<Point>表示returnPoints=true。

注意

points和hull应该是不同的数组，不支持就地处理。

查看相应的教程以了解更多详细信息。

有用链接

https://www.learnopencv.com/convex-hull-using-opencv-in-python-and-c/

convexityDefects()

void cv::convexityDefects	(	输入数组	轮廓,
		输入数组	凸包,
		输出数组	convexityDefects )

Python
	cv.convexityDefects(	轮廓, 凸包[, convexityDefects]	) ->	凸性缺陷

#include <opencv2/imgproc.hpp>

查找轮廓的凸缺陷。

下图显示了手部轮廓的凸性缺陷。

图像

参数

轮廓	输入轮廓。
凸包	使用convexHull获得的凸包，应包含构成凸包的轮廓点的索引。
凸性缺陷	凸缺陷的输出向量。在C++和新的Python/Java接口中，每个凸缺陷都表示为一个4元素整数向量（也称为Vec4i）：(start_index, end_index, farthest_pt_index, fixpt_depth)，其中索引是凸缺陷开始、结束和最远点在原始轮廓中的基于0的索引，fixpt_depth是距离最远轮廓点和凸包的距离的定点近似值（具有8个分数位）。也就是说，要获得深度的浮点值，将为fixpt_depth/256.0。

createGeneralizedHoughBallard()

Ptr< GeneralizedHoughBallard > cv::createGeneralizedHoughBallard

(

)

Python
	cv.createGeneralizedHoughBallard(		) ->	返回值

#include <opencv2/imgproc.hpp>

创建一个指向 cv::GeneralizedHoughBallard 类的智能指针并对其进行初始化。

createGeneralizedHoughGuil()

Ptr< GeneralizedHoughGuil > cv::createGeneralizedHoughGuil

(

)

Python
	cv.createGeneralizedHoughGuil(		) ->	返回值

#include <opencv2/imgproc.hpp>

创建一个指向cv::GeneralizedHoughGuil类的智能指针并进行初始化。

findContours() [1/2]

void cv::findContours	(	输入数组	图像,
		OutputArrayOfArrays	contours,
		整数	mode,
		整数	method,
		Point	offset = Point() )

Python
	cv.findContours(	image, mode, method[, contours[, hierarchy[, offset]]]	) ->	contours, hierarchy

#include <opencv2/imgproc.hpp>

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

findContours() [2/2]

void cv::findContours	(	输入数组	图像,
		OutputArrayOfArrays	contours,
		输出数组	hierarchy,
		整数	mode,
		整数	method,
		Point	offset = Point() )

Python
	cv.findContours(	image, mode, method[, contours[, hierarchy[, offset]]]	) ->	contours, hierarchy

#include <opencv2/imgproc.hpp>

在二值图像中查找轮廓。

该函数使用算法[258]从二值图像中检索轮廓。轮廓是用于形状分析和目标检测与识别的有用工具。参见OpenCV示例目录中的squares.cpp。

注意

从opencv 3.2开始，此函数不会修改源图像。

参数

图像	源图像，一个8位单通道图像。非零像素被视为1。零像素保持为0，因此图像被视为二值图像。可以使用compare、inRange、threshold、adaptiveThreshold、Canny等函数从灰度或彩色图像创建二值图像。如果mode等于RETR_CCOMP或RETR_FLOODFILL，输入也可以是标签的32位整数图像(CV_32SC1)。
contours	检测到的轮廓。每个轮廓都存储为点的向量（例如std::vector<std::vector<cv::Point> >）。
hierarchy	可选输出向量（例如std::vector<cv::Vec4i>），包含有关图像拓扑的信息。它与轮廓的数量具有相同数量的元素。对于每个第i个轮廓contours[i]，元素hierarchy[i][0]、hierarchy[i][1]、hierarchy[i][2]和hierarchy[i][3]分别设置为相同层次结构级别上的下一个和上一个轮廓、第一个子轮廓和父轮廓在轮廓中的基于0的索引。如果对于轮廓i没有下一个、上一个、父级或嵌套轮廓，则hierarchy[i]的相应元素将为负值。

注意

在Python中，hierarchy嵌套在顶级数组中。使用hierarchy[0][i]访问第i个轮廓的层次结构元素。

参数

mode	轮廓检索模式，参见RetrievalModes
method	轮廓逼近方法，参见ContourApproximationModes
offset	每个轮廓点移动的可选偏移量。如果轮廓是从图像ROI中提取的，然后应该在整个图像上下文中分析它们，这将非常有用。

findContoursLinkRuns() [1/2]

void cv::findContoursLinkRuns	(	输入数组	图像,
		OutputArrayOfArrays	contours )

Python
	cv.findContoursLinkRuns(	image[, contours[, hierarchy]]	) ->	contours, hierarchy
	cv.findContoursLinkRuns(	image[, contours]	) ->	contours

#include <opencv2/imgproc.hpp>

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

findContoursLinkRuns() [2/2]

void cv::findContoursLinkRuns	(	输入数组	图像,
		OutputArrayOfArrays	contours,
		输出数组	hierarchy )

Python
	cv.findContoursLinkRuns(	image[, contours[, hierarchy]]	) ->	contours, hierarchy
	cv.findContoursLinkRuns(	image[, contours]	) ->	contours

#include <opencv2/imgproc.hpp>

使用链接运行算法查找轮廓。

此函数实现的算法与cv::findContours不同。

• 不会在内部分配临时图像，因此减少了内存消耗。
• 仅支持CV_8UC1图像。
• 仅输出两级层次结构（RETR_CCOMP模式）。
• 不支持除CHAIN_APPROX_SIMPLE之外的其他近似更改。在所有其他方面，此函数与cv::findContours兼容。

fitEllipse()

RotatedRect cv::fitEllipse

(

输入数组

点

)

Python
	cv.fitEllipse(	点	) ->	返回值

#include <opencv2/imgproc.hpp>

拟合一个椭圆到一组2D点。

该函数计算最适合（最小二乘意义上）一组二维点的椭圆。它返回椭圆内接的旋转矩形。[92]中描述的第一个算法被使用。开发者需要注意，由于数据点靠近包含Mat元素的边界，返回的椭圆/旋转矩形数据可能包含负索引。

参数

点	输入二维点集，存储在std::vector<>或Mat中。

fitEllipseAMS()

RotatedRect cv::fitEllipseAMS

(

输入数组

点

)

Python
	cv.fitEllipseAMS(	点	) ->	返回值

#include <opencv2/imgproc.hpp>

拟合一个椭圆到一组2D点。

该函数计算拟合一组二维点的椭圆。它返回椭圆内接的旋转矩形。[265]提出的近似均方误差 (AMS) 被使用。

对于椭圆，该基集为\( \chi= \left(x^2, x y, y^2, x, y, 1\right) \)，它是一组六个自由系数\( A^T=\left\{A_{\text{xx}},A_{\text{xy}},A_{\text{yy}},A_x,A_y,A_0\right\} \)。然而，要指定一个椭圆，只需要五个数字：长轴和短轴长度\( (a,b) \)、位置\( (x_0,y_0) \)和方向\( \theta \)。这是因为该基集包含直线、二次曲线、抛物线和双曲线函数以及椭圆函数作为可能的拟合结果。如果发现拟合结果为抛物线或双曲线函数，则使用标准fitEllipse方法。AMS方法通过施加条件\( A^T ( D_x^T D_x + D_y^T D_y) A = 1 \)将拟合限制在抛物线、双曲线和椭圆曲线上，其中矩阵\( Dx \)和\( Dy \)分别是设计矩阵\( D \)关于x和y的偏导数。这些矩阵是逐行形成的，对集合中的每个点应用以下操作：

\begin{align*} D(i,:)&=\left\{x_i^2, x_i y_i, y_i^2, x_i, y_i, 1\right\} & D_x(i,:)&=\left\{2 x_i,y_i,0,1,0,0\right\} & D_y(i,:)&=\left\{0,x_i,2 y_i,0,1,0\right\} \end{align*}

AMS方法最小化代价函数

\begin{equation*} \epsilon ^2=\frac{ A^T D^T D A }{ A^T (D_x^T D_x + D_y^T D_y) A^T } \end{equation*}

通过求解广义特征值问题找到最小代价。

\begin{equation*} D^T D A = \lambda \left( D_x^T D_x + D_y^T D_y\right) A \end{equation*}

参数

点	输入二维点集，存储在std::vector<>或Mat中。

fitEllipseDirect()

RotatedRect cv::fitEllipseDirect

(

输入数组

点

)

Python
	cv.fitEllipseDirect(	点	) ->	返回值

#include <opencv2/imgproc.hpp>

拟合一个椭圆到一组2D点。

该函数计算拟合一组二维点的椭圆。它返回椭圆内接的旋转矩形。[211] 中的直接最小二乘法 (Direct) 被使用。

对于椭圆，该基集为\( \chi= \left(x^2, x y, y^2, x, y, 1\right) \)，它是一组六个自由系数\( A^T=\left\{A_{\text{xx}},A_{\text{xy}},A_{\text{yy}},A_x,A_y,A_0\right\} \)。然而，要指定一个椭圆，只需要五个数字：长轴和短轴长度\( (a,b) \)、位置\( (x_0,y_0) \)和方向\( \theta \)。这是因为该基集包含直线、二次曲线、抛物线和双曲线函数以及椭圆函数作为可能的拟合结果。Direct方法通过确保\( 4 A_{xx} A_{yy}- A_{xy}^2 > 0 \)来将拟合限制在椭圆内。施加的条件是\( 4 A_{xx} A_{yy}- A_{xy}^2=1 \)，这满足不等式，并且由于系数可以任意缩放，因此限制不严格。

\begin{equation*} \epsilon ^2= A^T D^T D A \quad \text{with} \quad A^T C A =1 \quad \text{and} \quad C=\left(\begin{matrix} 0 & 0 & 2 & 0 & 0 & 0 \\ 0 & -1 & 0 & 0 & 0 & 0 \\ 2 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{matrix} \right) \end{equation*}

通过求解广义特征值问题找到最小代价。

\begin{equation*} D^T D A = \lambda \left( C\right) A \end{equation*}

该系统只产生一个正特征值\( \lambda\)，它被选为解，其特征向量为\(\mathbf{u}\)。这些用于查找系数

\begin{equation*} A = \sqrt{\frac{1}{\mathbf{u}^T C \mathbf{u}}} \mathbf{u} \end{equation*}

缩放因子保证\(A^T C A =1\)。

参数

点	输入二维点集，存储在std::vector<>或Mat中。

fitLine()

void cv::fitLine	(	输入数组	点,
		输出数组	line,
		整数	distType,
		双精度浮点数	param,
		双精度浮点数	reps,
		双精度浮点数	aeps )

Python
	cv.fitLine(	points, distType, param, reps, aeps[, line]	) ->	line

#include <opencv2/imgproc.hpp>

将一条线拟合到2D或3D点集。

fitLine 函数通过最小化 \(\sum_i \rho(r_i)\) 来拟合二维或三维点集的直线，其中 \(r_i\) 是第 \(i\) 个点与直线的距离，而 \(\rho(r)\) 是距离函数，以下是其中几种：

• DIST_L2

  \[\rho (r) = r^2/2 \quad \text{(最简单也是最快的最小二乘法)}\]

• DIST_L1

  \[\rho (r) = r\]

• DIST_L12

  \[\rho (r) = 2 \cdot ( \sqrt{1 + \frac{r^2}{2}} - 1)\]

• DIST_FAIR

  \[\rho \left (r \right ) = C^2 \cdot \left ( \frac{r}{C} - \log{\left(1 + \frac{r}{C}\right)} \right ) \quad \text{其中} \quad C=1.3998\]

• DIST_WELSCH

  \[\rho \left (r \right ) = \frac{C^2}{2} \cdot \left ( 1 - \exp{\left(-\left(\frac{r}{C}\right)^2\right)} \right ) \quad \text{其中} \quad C=2.9846\]

• DIST_HUBER

  \[\rho (r) = \fork{r^2/2}{如果 \(r < C\)}{C \cdot (r-C/2)}{否则} \quad \text{其中} \quad C=1.345\]

该算法基于 M 估计器（http://en.wikipedia.org/wiki/M-estimator）技术，该技术使用加权最小二乘算法迭代地拟合直线。在每次迭代之后，权重 \(w_i\) 会被调整为与 \(\rho(r_i)\) 成反比。

参数

点	输入的二维或三维点向量，存储在 std::vector<> 或 Mat 中。
line	输出直线参数。对于二维拟合，它应该是一个包含 4 个元素的向量 (如 Vec4f) - (vx, vy, x0, y0)，其中 (vx, vy) 是与直线共线的归一化向量，(x0, y0) 是直线上的一个点。对于三维拟合，它应该是一个包含 6 个元素的向量 (如 Vec6f) - (vx, vy, vz, x0, y0, z0)，其中 (vx, vy, vz) 是与直线共线的归一化向量，(x0, y0, z0) 是直线上的一个点。
distType	M 估计器使用的距离，参见 DistanceTypes
param	某些类型距离的数值参数 (C)。如果为 0，则选择最佳值。
reps	半径（坐标原点与直线之间的距离）的足够精度。
aeps	角度的足够精度。对于 reps 和 aeps，0.01 将是一个很好的默认值。

HuMoments() [1/2]

void cv::HuMoments	(	const Moments &	m,
		输出数组	hu )

Python
	cv.HuMoments(	m[, hu]	) ->	hu

#include <opencv2/imgproc.hpp>

这是一个重载的成员函数，为了方便提供。它与上面的函数的区别仅在于它接受的参数。

HuMoments() [2/2]

void cv::HuMoments	(	const Moments &	moments,
		双精度浮点数	hu[7] )

Python
	cv.HuMoments(	m[, hu]	) ->	hu

#include <opencv2/imgproc.hpp>

计算七个Hu不变矩。

该函数计算七个 Hu 不变量（在 [130] 中介绍；另见 http://en.wikipedia.org/wiki/Image_moment），定义如下：

\[\begin{array}{l} hu[0]= \eta _{20}+ \eta _{02} \\ hu[1]=( \eta _{20}- \eta _{02})^{2}+4 \eta _{11}^{2} \\ hu[2]=( \eta _{30}-3 \eta _{12})^{2}+ (3 \eta _{21}- \eta _{03})^{2} \\ hu[3]=( \eta _{30}+ \eta _{12})^{2}+ ( \eta _{21}+ \eta _{03})^{2} \\ hu[4]=( \eta _{30}-3 \eta _{12})( \eta _{30}+ \eta _{12})[( \eta _{30}+ \eta _{12})^{2}-3( \eta _{21}+ \eta _{03})^{2}]+(3 \eta _{21}- \eta _{03})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}] \\ hu[5]=( \eta _{20}- \eta _{02})[( \eta _{30}+ \eta _{12})^{2}- ( \eta _{21}+ \eta _{03})^{2}]+4 \eta _{11}( \eta _{30}+ \eta _{12})( \eta _{21}+ \eta _{03}) \\ hu[6]=(3 \eta _{21}- \eta _{03})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}]-( \eta _{30}-3 \eta _{12})( \eta _{21}+ \eta _{03})[3( \eta _{30}+ \eta _{12})^{2}-( \eta _{21}+ \eta _{03})^{2}] \\ \end{array}\]

其中 \(\eta_{ji}\) 代表 \(\texttt{Moments::nu}_{ji}\) 。

除了第七个值（其符号会因反射而改变）外，这些值已被证明对图像缩放、旋转和反射是不变的。此不变性是在假设无限图像分辨率的情况下证明的。对于栅格图像，原始图像和变换图像计算出的 Hu 不变量略有不同。

参数

moments	使用矩计算的输入矩。
hu	输出 Hu 不变量。

另请参见

matchShapes

intersectConvexConvex()

float cv::intersectConvexConvex	(	输入数组	p1,
		输入数组	p2,
		输出数组	p12,
		布尔值	handleNested = true )

Python
	cv.intersectConvexConvex(	p1, p2[, p12[, handleNested]]	) ->	retval, p12

#include <opencv2/imgproc.hpp>

查找两个凸多边形的交集。

参数

p1	第一个多边形
p2	第二个多边形
p12	描述相交区域的输出多边形
handleNested	如果为真，则如果其中一个多边形完全包含在另一个多边形中，则会找到一个交集。如果为假，则找不到交集。如果多边形共享一条边，或者一个多边形的顶点位于另一个多边形的边上，则它们不被认为是嵌套的，无论 handleNested 的值如何，都会找到一个交集。

返回值

相交多边形的面积。如果算法没有收敛（例如非凸输入），则可能为负值。

注意

intersectConvexConvex 不会确认两个多边形都是凸的，如果不是凸的，则会返回无效的结果。

isContourConvex()

bool cv::isContourConvex

(

输入数组

轮廓

)

Python
	cv.isContourConvex(	轮廓	) ->	返回值

#include <opencv2/imgproc.hpp>

测试轮廓的凸性。

该函数测试输入轮廓是否为凸的。轮廓必须是简单的，即没有自相交。否则，函数输出未定义。

参数

轮廓	输入的二维点向量，存储在 std::vector<> 或 Mat 中

matchShapes()

double cv::matchShapes	(	输入数组	contour1,
		输入数组	contour2,
		整数	method,
		双精度浮点数	parameter )

Python
	cv.matchShapes(	contour1, contour2, method, parameter	) ->	返回值

#include <opencv2/imgproc.hpp>

比较两个形状。

该函数比较两个形状。所有三种实现的方法都使用 Hu 不变量（参见 HuMoments）

参数

contour1	第一个轮廓或灰度图像。
contour2	第二个轮廓或灰度图像。
method	比较方法，参见 ShapeMatchModes
parameter	特定于方法的参数（目前不支持）。

minAreaRect()

RotatedRect cv::minAreaRect

(

输入数组

点

)

Python
	cv.minAreaRect(	点	) ->	返回值

#include <opencv2/imgproc.hpp>

找到最小面积的旋转矩形，该矩形包含输入的2D点集。

该函数计算并返回指定点集的最小面积包围矩形（可能旋转）。开发者应该记住，当数据接近包含 Mat 元素边界时，返回的 RotatedRect 可能包含负索引。

参数

点	输入的二维点向量，存储在 std::vector<> 或 Mat 中

minEnclosingCircle()

void cv::minEnclosingCircle	(	输入数组	点,
		Point2f &	center,
		float &	radius )

Python
	cv.minEnclosingCircle(	点	) ->	center, radius

#include <opencv2/imgproc.hpp>

找到最小面积的圆形，该圆形包含2D点集。

该函数使用迭代算法查找二维点集的最小外接圆。

参数

点	输入的二维点向量，存储在 std::vector<> 或 Mat 中
center	圆的输出中心。
radius	圆的输出半径。

minEnclosingTriangle()

double cv::minEnclosingTriangle	(	输入数组	点,
		输出数组	triangle )

Python
	cv.minEnclosingTriangle(	points[, triangle]	) ->	retval, triangle

#include <opencv2/imgproc.hpp>

找到最小面积的三角形，该三角形包含2D点集并返回其面积。

该函数查找包含给定二维点集的最小面积三角形并返回其面积。下图显示了给定二维点集的输出。二维点以红色*表示，外接三角形以*黄色*表示。

最小外接三角形函数的示例输出

该算法的实现基于 O'Rourke 的 [210] 和 Klee 和 Laskowski 的 [147] 论文。O'Rourke 提供了一个 \(\theta(n)\) 算法，用于查找具有 n 个顶点的二维凸多边形的最小外接三角形。由于 minEnclosingTriangle 函数以二维点集作为输入，因此需要一个额外的预处理步骤来计算二维点集的凸包。 convexHull 函数的复杂度为 \(O(n log(n))\)，高于 \(\theta(n)\)。因此，该函数的总体复杂度为 \(O(n log(n))\)。

参数

点	深度为 CV_32S 或 CV_32F 的二维点输入向量，存储在 std::vector<> 或 Mat 中
triangle	定义三角形顶点的三个二维点的输出向量。OutputArray 的深度必须为 CV_32F。

moments()

Moments cv::moments	(	输入数组	数组,
		布尔值	binaryImage = false )

Python
	cv.moments(	array[, binaryImage]	) ->	返回值

#include <opencv2/imgproc.hpp>

计算多边形或光栅化形状的三阶矩。

该函数计算向量形状或栅格化形状的最高三阶矩。结果以结构 cv::Moments 返回。

参数

数组	单通道栅格图像（CV_8U、CV_16U、CV_16S、CV_32F、CV_64F）或二维点数组（\(1 \times N\) 或 \(N \times 1\)）（Point 或 Point2f）。
binaryImage	如果为真，则所有非零图像像素都视为 1。此参数仅用于图像。

返回值

矩。

注意

仅适用于 Python 绑定中的轮廓矩计算：请注意，输入数组的 numpy 类型应为 np.int32 或 np.float32。

另请参见

contourArea，arcLength

pointPolygonTest()

double cv::pointPolygonTest	(	输入数组	轮廓,
		Point2f	pt,
		布尔值	measureDist )

Python
	cv.pointPolygonTest(	contour, pt, measureDist	) ->	返回值

#include <opencv2/imgproc.hpp>

执行点在轮廓内的测试。

该函数确定点是在轮廓内、轮廓外还是位于边上（或与顶点重合）。它分别返回正值（内部）、负值（外部）或零值（边上）。当 measureDist=false 时，返回值分别为 +1、-1 和 0。否则，返回值是点与最近轮廓边缘之间的带符号距离。

下图显示了该函数的示例输出，其中每个图像像素都针对轮廓进行了测试

示例输出

参数

轮廓	输入轮廓。
pt	针对轮廓测试的点。
measureDist	如果为真，则该函数估计点到最近轮廓边缘的带符号距离。否则，该函数仅检查点是否在轮廓内。

rotatedRectangleIntersection()

int cv::rotatedRectangleIntersection	(	const RotatedRect &	rect1,
		const RotatedRect &	rect2,
		输出数组	intersectingRegion )

Python
	cv.rotatedRectangleIntersection(	rect1, rect2[, intersectingRegion]	) ->	retval, intersectingRegion

#include <opencv2/imgproc.hpp>

找出两个旋转矩形之间是否存在任何交集。

如果存在交集，则返回交集区域的顶点。

以下是交集配置的一些示例。阴影图案表示交集区域，红色顶点由函数返回。

交集示例

参数

rect1	第一个矩形
rect2	第二个矩形
intersectingRegion	交集区域顶点的输出数组。它最多返回8个顶点。存储为std::vector<cv::Point2f> 或 cv::Mat，类型为Mx1的CV_32FC2。

返回值

RectanglesIntersectTypes 之一