结构分析与形状描述符

详细说明

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

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

枚举
enum	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 }
	连通分量算法 更多...
enum	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 }
	连通分量统计信息 更多...
enum	cv::ContourApproximationModes {   cv::CHAIN_APPROX_NONE = 1 ,   cv::CHAIN_APPROX_SIMPLE = 2 ,   cv::CHAIN_APPROX_TC89_L1 = 3 ,   cv::CHAIN_APPROX_TC89_KCOS = 4 }
	轮廓近似算法 更多...
enum	cv::RectanglesIntersectTypes {   cv::INTERSECT_NONE = 0 ,   cv::INTERSECT_PARTIAL = 1 ,   cv::INTERSECT_FULL = 2 }
	矩形间的相交类型 更多...
enum	cv::RetrievalModes {   cv::RETR_EXTERNAL = 0 ,   cv::RETR_LIST = 1 ,   cv::RETR_CCOMP = 2 ,   cv::RETR_TREE = 3 ,   cv::RETR_FLOODFILL = 4 }
	轮廓检索算法的模式 更多...
enum	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)
	使用 link runs 算法查找轮廓。
RotatedRect	cv::fitEllipse (InputArray points)
	围绕一组二维点拟合椭圆。
RotatedRect	cv::fitEllipseAMS (InputArray points)
	围绕一组二维点拟合椭圆。
RotatedRect	cv::fitEllipseDirect (InputArray points)
	围绕一组二维点拟合椭圆。
void	cv::fitLine (InputArray points, OutputArray line, int distType, double param, double reps, double aeps)
	对二维或三维点集进行直线拟合。
void	cv::getClosestEllipsePoints (const RotatedRect &ellipse_params, InputArray points, OutputArray closest_pts)
	为每个二维点计算其在给定椭圆上最近的二维点。
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)
	查找包围输入二维点集的最小面积旋转矩形。
void	cv::minEnclosingCircle (InputArray points, Point2f &center, float &radius)
	查找包围二维点集的最小面积圆。
double	cv::minEnclosingConvexPolygon (InputArray points, OutputArray polygon, int k)
	查找包围二维点集的最小面积凸多边形并返回其面积。
double	cv::minEnclosingTriangle (InputArray points, OutputArray triangle)
	查找包围二维点集的最小面积三角形并返回其面积。
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)
	查找两个旋转矩形之间是否存在交集。

枚举类型文档 (Enumeration Type Documentation)

ConnectedComponentsAlgorithmsTypes

enum cv::ConnectedComponentsAlgorithmsTypes

#include <opencv2/imgproc.hpp>

连通分量算法

枚举值 (Enumerator)
CCL_DEFAULT  Python: cv.CCL_DEFAULT	针对 8 连通的 Spaghetti [33] 算法，针对 4 连通的 Spaghetti4C [34] 算法。
CCL_WU  Python: cv.CCL_WU	针对 8 连通的 SAUF [306] 算法，以及针对 4 连通的 SAUF 算法。[32] 中描述的并行实现可用于 SAUF。
CCL_GRANA  Python: cv.CCL_GRANA	针对 8 连通的 BBDT [112] 算法，以及针对 4 连通的 SAUF 算法。[32] 中描述的并行实现可用于 BBDT 和 SAUF。
CCL_BOLELLI  Python: cv.CCL_BOLELLI	针对 8 连通的 Spaghetti [33] 算法，针对 4 连通的 Spaghetti4C [34] 算法。[32] 中描述的并行实现可用于 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)。

ConnectedComponentsTypes

enum cv::ConnectedComponentsTypes

#include <opencv2/imgproc.hpp>

连通分量统计信息

枚举值 (Enumerator)
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	连通分量的总面积（以像素为单位）。

ContourApproximationModes

enum cv::ContourApproximationModes

#include <opencv2/imgproc.hpp>

轮廓近似算法

枚举值 (Enumerator)
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 链近似算法的一种变体 [272]
CHAIN_APPROX_TC89_KCOS  Python: cv.CHAIN_APPROX_TC89_KCOS	应用 Teh-Chin 链近似算法的一种变体 [272]

RectanglesIntersectTypes

enum cv::RectanglesIntersectTypes

#include <opencv2/imgproc.hpp>

矩形间的相交类型

枚举值 (Enumerator)
INTERSECT_NONE  Python: cv.INTERSECT_NONE	无相交。
INTERSECT_PARTIAL  Python: cv.INTERSECT_PARTIAL	有部分相交。
INTERSECT_FULL  Python: cv.INTERSECT_FULL	其中一个矩形完全被包含在另一个矩形中。

RetrievalModes

enum cv::RetrievalModes

#include <opencv2/imgproc.hpp>

轮廓检索算法的模式

枚举值 (Enumerator)
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

ShapeMatchModes

enum 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 矩。

枚举值 (Enumerator)
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| }\]

函数文档 (Function Documentation)

approxPolyDP()

void cv::approxPolyDP	(	InputArray	curve,
		OutputArray	approxCurve,
		double	epsilon,
		bool	closed )

Python
	cv.approxPolyDP(	curve, epsilon, closed[, approxCurve]	) ->	approxCurve

#include <opencv2/imgproc.hpp>

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

函数 cv::approxPolyDP 使用另一个具有较少顶点的曲线/多边形来近似一条曲线或多边形，使得它们之间的距离小于或等于指定的精度。它使用的是 Douglas-Peucker 算法 https://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm

参数

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

approxPolyN()

void cv::approxPolyN	(	InputArray	curve,
		OutputArray	approxCurve,
		int	nsides,
		float	epsilon_percentage = -1.0,
		bool	ensure_convex = true )

Python
	cv.approxPolyN(	curve, nsides[, approxCurve[, epsilon_percentage[, ensure_convex]]]	) ->	approxCurve

#include <opencv2/imgproc.hpp>

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

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

该算法基于论文 [154]。

参数

curve	存储在 std::vector 或 Mat 中的 2D 点的输入向量，点必须是浮点数或整数。
approxCurve	近似结果。类型是存储在 std::vector 或 Mat 中的 2D 点（Point2f 或 Point）向量。
nsides	该参数定义结果多边形的边数。
epsilon_percentage	定义最大额外面积的百分比。如果等于 -1，则不使用。否则，如果额外面积大于 contourArea(_curve) * 百分比，算法停止。如果额外面积超过限制，算法将返回超过限制那一刻所拥有的顶点数。
ensure_convex	如果为 true，算法会创建输入轮廓的凸包。否则输入向量应该是凸的。

arcLength()

double cv::arcLength	(	InputArray	curve,
		bool	closed )

Python
	cv.arcLength(	curve, closed	) ->	retval

#include <opencv2/imgproc.hpp>

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

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

参数

curve	存储在 std::vector 或 Mat 中的 2D 点输入向量。
closed	指示曲线是否封闭的标志。

boundingRect()

Rect cv::boundingRect

(

InputArray

array

)

Python
	cv.boundingRect(	array	) ->	retval

#include <opencv2/imgproc.hpp>

计算点集或灰度图像中非零像素的正外接矩形。

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

参数

array

存储在 std::vector 或 Mat 中的输入灰度图像或 2D 点集。

boxPoints()

void cv::boxPoints	(	RotatedRect	box,
		OutputArray	points )

Python
	cv.boxPoints(	box[, points]	) ->	points

#include <opencv2/imgproc.hpp>

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

该函数寻找旋转矩形的四个顶点。四个顶点按顺时针顺序返回，从 \(y\) 坐标最大的点开始。如果两点具有相同的 \(y\) 坐标，则最右侧的点为起始点。此函数对于绘制矩形非常有用。在 C++ 中，您可以直接使用 RotatedRect::points 方法，而无需使用此函数。欲了解更多信息，请访问有关为轮廓创建旋转边界框和椭圆的教程。

参数

box	输入的旋转矩形。它可以是 minAreaRect 的输出。
points	矩形四个顶点的输出数组。

connectedComponents() [1/2]

int cv::connectedComponents	(	InputArray	图像,
		OutputArray	labels,
		int	connectivity,
		int	ltype,
		int	ccltype )

Python
	cv.connectedComponents(	image[, labels[, connectivity[, ltype]]]	) ->	retval, labels
	cv.connectedComponentsWithAlgorithm(	image, connectivity, ltype, ccltype[, labels]	) ->	retval, labels

#include <opencv2/imgproc.hpp>

计算二值图像的连通域标记图像

具有 4 连通或 8 连通的图像 - 返回标签总数 N，范围为 [0, N-1]，其中 0 代表背景标签。ltype 指定输出标签图像类型，这是基于标签总数或源图像中像素总数的重要考虑因素。ccltype 指定要使用的连通分量标记算法，目前支持 Bolelli (Spaghetti) [33]、Grana (BBDT) [112] 和 Wu's (SAUF) [306] 算法，详情请参阅 ConnectedComponentsAlgorithmsTypes。请注意，SAUF 算法强制执行标签的行优先顺序，而 Spaghetti 和 BBDT 则不强制执行。如果启用了至少一个允许的并行框架，并且图像的行数至少是 getNumberOfCPUs 返回数量的两倍，则此函数使用算法的并行版本。

参数

图像	待标记的 8 位单通道图像
labels	目标标记图像
connectivity	8 或 4，分别代表 8 连通或 4 连通
ltype	输出图像标签类型。目前支持 CV_32S 和 CV_16U。
ccltype	连通分量算法类型（见 ConnectedComponentsAlgorithmsTypes）。

connectedComponents() [2/2]

int cv::connectedComponents	(	InputArray	图像,
		OutputArray	labels,
		int	connectivity = 8,
		int	ltype = CV_32S )

Python
	cv.connectedComponents(	image[, labels[, connectivity[, ltype]]]	) ->	retval, labels
	cv.connectedComponentsWithAlgorithm(	image, connectivity, ltype, ccltype[, labels]	) ->	retval, labels

#include <opencv2/imgproc.hpp>

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

图像	待标记的 8 位单通道图像
labels	目标标记图像
connectivity	8 或 4，分别代表 8 连通或 4 连通
ltype	输出图像标签类型。目前支持 CV_32S 和 CV_16U。

connectedComponentsWithStats() [1/2]

int cv::connectedComponentsWithStats	(	InputArray	图像,
		OutputArray	labels,
		OutputArray	stats,
		OutputArray	centroids,
		int	connectivity,
		int	ltype,
		int	ccltype )

Python
	cv.connectedComponentsWithStats(	image[, labels[, stats[, centroids[, connectivity[, ltype]]]]]	) ->	retval, labels, stats, centroids
	cv.connectedComponentsWithStatsWithAlgorithm(	image, connectivity, ltype, ccltype[, labels[, stats[, centroids]]]	) ->	retval, labels, stats, centroids

#include <opencv2/imgproc.hpp>

计算二值图像的连通域标记图像，并输出每个标记的统计信息

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

参数

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

connectedComponentsWithStats() [2/2]

int cv::connectedComponentsWithStats	(	InputArray	图像,
		OutputArray	labels,
		OutputArray	stats,
		OutputArray	centroids,
		int	connectivity = 8,
		int	ltype = CV_32S )

Python
	cv.connectedComponentsWithStats(	image[, labels[, stats[, centroids[, connectivity[, ltype]]]]]	) ->	retval, labels, stats, centroids
	cv.connectedComponentsWithStatsWithAlgorithm(	image, connectivity, ltype, ccltype[, labels[, stats[, centroids]]]	) ->	retval, labels, stats, centroids

#include <opencv2/imgproc.hpp>

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

参数

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

contourArea()

double cv::contourArea	(	InputArray	contour,
		bool	oriented = false )

Python
	cv.contourArea(	contour[, oriented]	) ->	retval

#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;

参数

contour	存储在 std::vector 或 Mat 中的 2D 点（轮廓顶点）输入向量。
oriented	定向面积标志。如果为 true，该函数根据轮廓方向（顺时针或逆时针）返回带符号的面积值。利用此特性，您可以通过面积的符号来确定轮廓的方向。默认情况下，该参数为 false，表示返回绝对值。

convexHull()

void cv::convexHull	(	InputArray	points,
		OutputArray	hull,
		bool	clockwise = false,
		bool	returnPoints = true )

Python
	cv.convexHull(	points[, hull[, clockwise[, returnPoints]]]	) ->	hull

#include <opencv2/imgproc.hpp>

查找点集的凸包。

函数 cv::convexHull 使用 Sklansky 算法 [253] 寻找 2D 点集的凸包，在当前实现中，该算法的时间复杂度为 O(N logN)。

参数

points	存储在 std::vector 或 Mat 中的输入 2D 点集。
hull	输出凸包。它或者是索引的整数向量，或者是点的向量。在第一种情况下，凸包元素是原始数组中凸包点的从 0 开始的索引（因为凸包点集是原始点集的子集）。在第二种情况下，凸包元素是凸包点本身。
clockwise	方向标志。如果为 true，则输出凸包按顺时针方向排序。否则，按逆时针方向排序。假设的坐标系其 X 轴向右，Y 轴向上。
returnPoints	操作标志。对于矩阵，当标志为 true 时，函数返回凸包点。否则，它返回凸包点的索引。当输出数组为 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	(	InputArray	contour,
		InputArray	convexhull,
		OutputArray	convexityDefects )

Python
	cv.convexityDefects(	contour, convexhull[, convexityDefects]	) ->	convexityDefects

#include <opencv2/imgproc.hpp>

查找轮廓的凸性缺陷。

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

图像

参数

contour	输入轮廓。
convexhull	使用 convexHull 获得的凸包，应包含构成凸包的轮廓点的索引。
convexityDefects	凸性缺陷的输出向量。在 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(		) ->	retval

#include <opencv2/imgproc.hpp>

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

createGeneralizedHoughGuil()

Ptr< GeneralizedHoughGuil > cv::createGeneralizedHoughGuil

(

)

Python
	cv.createGeneralizedHoughGuil(		) ->	retval

#include <opencv2/imgproc.hpp>

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

findContours() [1/2]

void cv::findContours	(	InputArray	图像,
		OutputArrayOfArrays	contours,
		int	mode,
		int	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	(	InputArray	图像,
		OutputArrayOfArrays	contours,
		OutputArray	hierarchy,
		int	mode,
		int	method,
		点 (Point)	offset = Point() )

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

#include <opencv2/imgproc.hpp>

在二值图像中查找轮廓。

该函数使用算法 [264] 从二值图像中检索轮廓。轮廓是形状分析以及对象检测和识别的有用工具。请参阅 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] 分别被设置为 contours 中同一层级的下一个和前一个轮廓、第一个子轮廓和父轮廓的从 0 开始的索引。如果对于轮廓 i 没有下一个、前一个、父级或嵌套轮廓，则 hierarchy[i] 的相应元素将为负数。

注意

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

参数

mode	轮廓检索模式，见 RetrievalModes
method	轮廓近似方法，见 ContourApproximationModes
offset	每个轮廓点移动的可选偏移量。如果轮廓是从图像 ROI 中提取的，然后需要在整个图像上下文中对其进行分析，这非常有用。

findContoursLinkRuns() [1/2]

void cv::findContoursLinkRuns	(	InputArray	图像,
		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	(	InputArray	图像,
		OutputArrayOfArrays	contours,
		OutputArray	hierarchy )

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

#include <opencv2/imgproc.hpp>

使用 link runs 算法查找轮廓。

此函数实现了一种与 cv::findContours 不同的算法

• 内部不分配临时图像，因此内存消耗更低
• 仅支持 CV_8UC1 图像
• 仅输出 2 级层级结构 (RETR_CCOMP 模式)
• 除了 CHAIN_APPROX_SIMPLE 之外，不支持其他近似变更。在所有其他方面，此函数与 cv::findContours 兼容。

fitEllipse()

RotatedRect cv::fitEllipse

(

InputArray

points

)

Python
	cv.fitEllipse(	points	) ->	retval

#include <opencv2/imgproc.hpp>

围绕一组二维点拟合椭圆。

该函数计算最能拟合（在最小二乘意义上）一组 2D 点的椭圆。它返回椭圆内接的旋转矩形。使用了 [96] 描述的第一种算法。开发人员应记住，由于数据点靠近包含它的 Mat 元素的边界，返回的 ellipse/rotatedRect 数据可能包含负索引。

参数

points

存储在 std::vector<> 或 Mat 中的输入 2D 点集

注意

输入点类型为 Point2i 或 Point2f，且至少需要 5 个点。

getClosestEllipsePoints 函数可用于计算椭圆拟合误差。

fitEllipseAMS()

RotatedRect cv::fitEllipseAMS

(

InputArray

points

)

Python
	cv.fitEllipseAMS(	points	) ->	retval

#include <opencv2/imgproc.hpp>

围绕一组二维点拟合椭圆。

该函数计算拟合一组 2D 点的椭圆。它返回椭圆内接的旋转矩形。使用了 [271] 提出的近似均方 (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*}

参数

points

存储在 std::vector<> 或 Mat 中的输入 2D 点集

注意

输入点类型为 Point2i 或 Point2f，且至少需要 5 个点。

getClosestEllipsePoints 函数可用于计算椭圆拟合误差。

fitEllipseDirect()

RotatedRect cv::fitEllipseDirect

(

InputArray

points

)

Python
	cv.fitEllipseDirect(	points	) ->	retval

#include <opencv2/imgproc.hpp>

围绕一组二维点拟合椭圆。

该函数计算拟合一组 2D 点的椭圆。它返回椭圆内接的旋转矩形。使用了 [217] 的直接最小二乘 (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 \)。这是因为基集包括直线、二次函数、抛物线和双曲函数以及椭圆函数作为可能的拟合结果。直接法通过确保 \( 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{其中} \quad A^T C A =1 \quad \text{且} \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\)。

参数

points

存储在 std::vector<> 或 Mat 中的输入 2D 点集

注意

输入点类型为 Point2i 或 Point2f，且至少需要 5 个点。

getClosestEllipsePoints 函数可用于计算椭圆拟合误差。

fitLine()

void cv::fitLine	(	InputArray	points,
		OutputArray	line,
		int	distType,
		double	param,
		double	reps,
		double	aeps )

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

#include <opencv2/imgproc.hpp>

对二维或三维点集进行直线拟合。

函数 fitLine 通过最小化 \(\sum_i \rho(r_i)\) 来对 2D 或 3D 点集拟合直线，其中 \(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 估计器 ( https://en.wikipedia.org/wiki/M-estimator ) 技术，该技术使用加权最小二乘算法迭代拟合直线。每次迭代后，调整权重 \(w_i\) 使其与 \(\rho(r_i)\) 成反比。

参数

points	存储在 std::vector<> 或 Mat 中的 2D 或 3D 点输入向量。
line	输出直线参数。在 2D 拟合的情况下，它应该是一个包含 4 个元素的向量（如 Vec4f）- (vx, vy, x0, y0)，其中 (vx, vy) 是与直线共线的归一化向量，而 (x0, y0) 是直线上的一个点。在 3D 拟合的情况下，它应该是一个包含 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 是一个很好的默认值。

getClosestEllipsePoints()

void cv::getClosestEllipsePoints	(	const RotatedRect &	ellipse_params,
		InputArray	points,
		OutputArray	closest_pts )

Python
	cv.getClosestEllipsePoints(	ellipse_params, points[, closest_pts]	) ->	closest_pts

#include <opencv2/imgproc.hpp>

为每个二维点计算其在给定椭圆上最近的二维点。

该函数计算一组 2d 点在给定椭圆上最近的 2d 位置，基于 [53] 的代码。此函数可用于计算例如椭圆拟合误差。

参数

ellipse_params	椭圆参数
points	输入 2d 点
closest_pts	对于每个 2d 点，其对应的位于给定椭圆上的最近 2d 点

注意

输入点类型为 Point2i 或 Point2f

另请参阅

fitEllipse, fitEllipseAMS, fitEllipseDirect

HuMoments() [1/2]

void cv::HuMoments	(	const Moments &	m,
		OutputArray	hu )

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

#include <opencv2/imgproc.hpp>

这是一个重载的成员函数，为方便起见而提供。它与上述函数的区别仅在于所接受的参数不同。

HuMoments() [2/2]

void cv::HuMoments	(	const Moments &	矩 (moments),
		double	hu[7] )

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

#include <opencv2/imgproc.hpp>

计算七个 Hu 不变量。

该函数计算七个 Hu 不变量（在 [135] 中引入；另请参阅 https://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)	使用 moments 计算的输入矩。
hu	输出 Hu 不变量。

另请参阅

matchShapes

intersectConvexConvex()

float cv::intersectConvexConvex	(	InputArray	p1,
		InputArray	p2,
		OutputArray	p12,
		bool	handleNested = true )

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

#include <opencv2/imgproc.hpp>

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

参数

p1	第一个多边形
p2	第二个多边形
p12	描述相交区域的输出多边形
handleNested	当为 true 时，如果一个多边形完全被包含在另一个中，则会发现相交。当为 false 时，则不视为相交。如果多边形共用一条边，或者一个多边形的顶点位于另一个多边形的边上，则它们不被视为嵌套，无论 handleNested 的值如何，都将找到相交区域。

返回

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

注意

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

isContourConvex()

bool cv::isContourConvex

(

InputArray

contour

)

Python
	cv.isContourConvex(	contour	) ->	retval

#include <opencv2/imgproc.hpp>

测试轮廓的凸性。

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

参数

contour

存储在 std::vector<> 或 Mat 中的 2D 点输入向量

matchShapes()

double cv::matchShapes	(	InputArray	contour1,
		InputArray	contour2,
		int	method,
		double	parameter )

Python
	cv.matchShapes(	contour1, contour2, method, parameter	) ->	retval

#include <opencv2/imgproc.hpp>

比较两个形状。

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

参数

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

minAreaRect()

RotatedRect cv::minAreaRect

(

InputArray

points

)

Python
	cv.minAreaRect(	points	) ->	retval

#include <opencv2/imgproc.hpp>

查找包围输入二维点集的最小面积旋转矩形。

该函数计算并返回指定点集的最小面积边界矩形（可能是旋转的）。旋转角度表示连接起点和终点（基于顺时针顺序，\(y\) 坐标最大的角具有最大索引）的直线与水平轴之间的角度。此角度始终落在 \([-90, 0)\) 范围内，因为如果物体旋转超过直角，则使用下一条边来测量角度。起点和终点随物体旋转而变化。开发人员应记住，当数据靠近包含它的 Mat 元素边界时，返回的 RotatedRect 可能包含负索引。

参数

points

存储在 std::vector<> 或 Mat 中的 2D 点输入向量

minEnclosingCircle()

void cv::minEnclosingCircle	(	InputArray	points,
		Point2f &	center,
		float &	radius )

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

#include <opencv2/imgproc.hpp>

查找包围二维点集的最小面积圆。

该函数使用迭代算法寻找 2D 点集的最小外接圆。

参数

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

minEnclosingConvexPolygon()

double cv::minEnclosingConvexPolygon	(	InputArray	points,
		OutputArray	polygon,
		int	k )

Python
	cv.minEnclosingConvexPolygon(	points, k[, polygon]	) ->	retval, polygon

#include <opencv2/imgproc.hpp>

查找包围二维点集的最小面积凸多边形并返回其面积。

此函数接收一组给定的 2D 点，并寻找具有 k 个顶点且面积最小的外接多边形。它将点集和参数 k 作为输入，并返回最小外接多边形的面积。

实现基于 Aggarwal、Chang 和 Yap 的论文 [2]。他们提供了一个 \(\theta(n²log(n)log(k))\) 算法，用于寻找包围具有 n 个顶点的 2D 凸多边形的具有 k 个顶点的最小凸多边形 (k < n)。由于 minEnclosingConvexPolygon 函数接收 2D 点集作为输入，因此需要计算 2D 点集凸包的额外预处理步骤。convexHull 函数的复杂度为 \(O(n log(n))\)，低于 \(\theta(n²log(n)log(k))\)。因此，该函数的整体复杂度为 \(O(n²log(n)log(k))\)。

参数

points	存储在 std::vector<> 或 Mat 中的 2D 点输入向量
polygon	定义外接多边形顶点的 2D 点输出向量
k	输出多边形的顶点数

minEnclosingTriangle()

double cv::minEnclosingTriangle	(	InputArray	points,
		OutputArray	triangle )

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

#include <opencv2/imgproc.hpp>

查找包围二维点集的最小面积三角形并返回其面积。

该函数寻找包围给定 2D 点集的最小面积三角形并返回其面积。给定 2D 点集的输出如下图所示。2D 点以红色描绘，外接三角形以黄色描绘。

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

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

参数

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

moments()

Moments cv::moments	(	InputArray	array,
		bool	binaryImage = false )

Python
	cv.moments(	array[, binaryImage]	) ->	retval

#include <opencv2/imgproc.hpp>

计算多边形或光栅化形状的所有三阶以内矩。

该函数计算矢量形状或栅格化形状的最高 3 阶的矩。结果在结构体 cv::Moments 中返回。

参数

array	单通道光栅图像（CV_8U、CV_16U、CV_16S、CV_32F、CV_64F）或 2D 点（Point 或 Point2f）数组（ \(1 \times N\) 或 \(N \times 1\) ）。
binaryImage	如果为 true，则所有非零图像像素均被视为 1。该参数仅用于图像。

返回

矩。

注意

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

对于基于轮廓的矩，零阶矩 m00 代表轮廓面积。

如果输入轮廓退化（例如，单个点或所有点共线），则面积为零，因此 m00 == 0。

在这种情况下，质心坐标 (m10/m00, m01/m00) 未定义，必须由调用者显式处理。

常见的解决方法是使用 cv::boundingRect() 或通过对输入点求平均值来计算中心。

另请参阅

contourArea, arcLength

pointPolygonTest()

double cv::pointPolygonTest	(	InputArray	contour,
		Point2f	pt (点),
		bool	measureDist )

Python
	cv.pointPolygonTest(	contour, pt, measureDist	) ->	retval

#include <opencv2/imgproc.hpp>

执行点与轮廓的位置关系测试。

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

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

示例输出

参数

contour	输入轮廓。
pt (点)	针对轮廓进行测试的点。
measureDist	如果为 true，函数会估计从点到最近轮廓边的带符号距离。否则，函数仅检查点是否在轮廓内。

rotatedRectangleIntersection()

int cv::rotatedRectangleIntersection	(	const RotatedRect &	rect1,
		const RotatedRect &	rect2,
		OutputArray	intersectingRegion )

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

#include <opencv2/imgproc.hpp>

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

如果存在，则同时返回相交区域的顶点。

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

相交示例

参数

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

返回

RectanglesIntersectTypes 之一