详细描述

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

类
类	cv::广义霍夫
	使用广义霍夫变换在灰度图像中查找任意模板更多...

类	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)
	computes the connected components labeled image of boolean image

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)
	Calculates a contour area.

void	cv::convexHull (InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true)
	Finds the convex hull of a point set.

void	cv::convexityDefects (InputArray contour, InputArray convexhull, OutputArray convexityDefects)
	Finds the convexity defects of a contour.

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::getClosestEllipsePoints (const RotatedRect &ellipse_params, InputArray points, OutputArray closest_pts)
	计算每个2D点在给定椭圆上最近的2D点。

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)
	查找包含二维点集的最小面积圆。

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

枚举 cv::ConnectedComponentsAlgorithmsTypes

#include <opencv2/imgproc.hpp>

连通分量算法

枚举器
CCL_DEFAULT Python: cv.CCL_DEFAULT	用于8向连通性的Spaghetti [32] 算法，用于4向连通性的Spaghetti4C [33] 算法。
CCL_WU Python: cv.CCL_WU	用于8向连通性的SAUF [303] 算法，用于4向连通性的SAUF算法。SAUF算法可使用 [31] 中描述的并行实现。
CCL_GRANA Python: cv.CCL_GRANA	用于8向连通性的BBDT [111] 算法，用于4向连通性的SAUF算法。BBDT和SAUF算法均可使用 [31] 中描述的并行实现。
CCL_BOLELLI Python: cv.CCL_BOLELLI	用于8向连通性的Spaghetti [32] 算法，用于4向连通性的Spaghetti4C [33] 算法。Spaghetti和Spaghetti4C算法均可使用 [31] 中描述的并行实现。
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

枚举 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	连通分量的总面积（像素）。

◆ ContourApproximationModes

枚举 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 链逼近算法 [269] 的一种变体
CHAIN_APPROX_TC89_KCOS Python: cv.CHAIN_APPROX_TC89_KCOS	应用 Teh-Chin 链逼近算法 [269] 的一种变体

◆ RectanglesIntersectTypes

枚举 cv::RectanglesIntersectTypes

#include <opencv2/imgproc.hpp>

矩形之间的交集类型

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

◆ RetrievalModes

枚举 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

◆ ShapeMatchModes

枚举 cv::ShapeMatchModes

#include <opencv2/imgproc.hpp>

形状匹配方法。

\(A\) 表示 object1，\(B\) 表示 object2

\(\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	(	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 用凸包近似多边形，使得原始轮廓与新多边形的轮廓面积差异最小。它使用一种贪婪算法，将两个顶点收缩为一个，使得额外面积最小。绘制由凸轮廓每条边形成的直线，并考虑结果三角形的面积。每个顶点将位于原始轮廓上或其外部。

该算法基于论文 [151] 。

参数

curve	存储在 std::vector 或 Mat 中的 2D 点输入向量，点必须是浮点或整数。
approxCurve	近似结果。类型是存储在 std::vector 或 Mat 中的 2D 点向量（Point2f 或 Point）。
nsides	该参数定义结果多边形的边数。
epsilon_percentage	定义额外面积最大值的百分比。如果为 -1，则不使用。否则，如果额外面积大于 contourArea(_curve) * percentage，算法将停止。如果额外面积超过限制，算法将返回在超过限制时存在的顶点数量。
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	image,
		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>

computes the connected components labeled image of boolean image

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

参数

image	要标记的8位单通道图像
labels	目标标记图像
connectivity	8 表示 8 向连通性，4 表示 4 向连通性
ltype	输出图像标签类型。目前支持 CV_32S 和 CV_16U。
ccltype	连通分量算法类型（请参阅 ConnectedComponentsAlgorithmsTypes）。

◆ connectedComponents() [2/2]

int cv::connectedComponents	(	InputArray	image,
		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>

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

参数

image	要标记的8位单通道图像
labels	目标标记图像
connectivity	8 表示 8 向连通性，4 表示 4 向连通性
ltype	输出图像标签类型。目前支持 CV_32S 和 CV_16U。

◆ connectedComponentsWithStats() [1/2]

int cv::connectedComponentsWithStats	(	InputArray	image,
		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) [32]、Grana (BBDT) [111] 和 Wu (SAUF) [303] 算法，详情请参阅 ConnectedComponentsAlgorithmsTypes。请注意，SAUF 算法强制按行主序排列标签，而 Spaghetti 和 BBDT 则不强制。如果至少启用了一个允许的并行框架，并且图像的行数至少是 getNumberOfCPUs 返回值的两倍，则此函数使用算法的并行版本（包括统计信息）。

参数

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

◆ connectedComponentsWithStats() [2/2]

int cv::connectedComponentsWithStats	(	InputArray	image,
		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>

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

参数

image	要标记的8位单通道图像
labels	目标标记图像
stats	每个标签的统计输出，包括背景标签。通过 stats(label, COLUMN) 访问统计数据，其中 COLUMN 是 ConnectedComponentsTypes 之一，用于选择统计数据。数据类型为 CV_32S。
centroids	每个标签的质心输出，包括背景标签。通过 centroids(label, 0) 访问 x 坐标，通过 centroids(label, 1) 访问 y 坐标。数据类型为 CV_64F。
connectivity	8 表示 8 向连通性，4 表示 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>

Calculates a contour area.

该函数计算轮廓面积。与矩类似，面积使用格林公式计算。因此，如果您使用 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 poly vertices" << 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>

Finds the convex hull of a point set.

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

参数

points	存储在 std::vector 或 Mat 中的 2D 点输入集。
hull	输出凸包。它可以是整数索引向量，也可以是点向量。在第一种情况下，凸包元素是原始数组中凸包点的 0-based 索引（因为凸包点集是原始点集的一个子集）。在第二种情况下，凸包元素是凸包点本身。
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	凸包,
		OutputArray	convexityDefects )

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

#include <opencv2/imgproc.hpp>

Finds the convexity defects of a contour.

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

image

参数

contour	输入轮廓。
凸包	使用 convexHull 获得的凸包，应包含构成凸包的轮廓点的索引。
convexityDefects	凸缺陷的输出向量。在 C++ 和新的 Python/Java 接口中，每个凸缺陷表示为一个 4 元素整数向量（即 Vec4i）：(start_index, end_index, farthest_pt_index, fixpt_depth)，其中索引是原始轮廓中凸缺陷起始点、结束点和最远点的 0-based 索引，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	image,
		OutputArrayOfArrays	contours,
		int	mode,
		int	方法,
		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	image,
		OutputArrayOfArrays	contours,
		OutputArray	hierarchy,
		int	mode,
		int	方法,
		Point	offset = Point() )

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

#include <opencv2/imgproc.hpp>

在二值图像中查找轮廓。

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

注意: 由于 OpenCV 3.2，源图像不会被此函数修改。

参数

image	源图像，一个 8 位单通道图像。非零像素被视为 1。零像素保持为 0，因此图像被视为二值图像。您可以使用 compare、inRange、threshold、adaptiveThreshold、Canny 等函数从灰度或彩色图像创建二值图像。如果模式等于 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-based 索引。如果轮廓 i 没有下一个、上一个、父级或嵌套轮廓，则 hierarchy[i] 的相应元素将为负值。

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

参数

mode	轮廓检索模式，请参阅 RetrievalModes
方法	轮廓逼近方法，请参阅 ContourApproximationModes
offset	可选的偏移量，用于平移每个轮廓点。如果轮廓是从图像 ROI 中提取的，然后需要在整个图像上下文中进行分析，则此功能很有用。

◆ findContoursLinkRuns() [1/2]

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

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

#include <opencv2/imgproc.hpp>

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

此函数实现了与 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 点拟合椭圆。

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

参数

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 点拟合椭圆。

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

该函数计算拟合一组 2D 点的椭圆。它返回椭圆内接的旋转矩形。使用了 [214] 的直接最小二乘 (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{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\)。

参数

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>

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

函数 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{where} \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{where} \quad C=2.9846\]
DIST_HUBER
\[\rho (r) = \fork{r^2/2}{if \(r < C\)}{C \cdot (r-C/2)}{otherwise} \quad \text{where} \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	角度的足够精度。0.01 对于 reps 和 aeps 来说是一个不错的默认值。

◆ 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点。

该函数计算给定椭圆上与 2D 点向量最近的 2D 位置，并基于 [52] 中的代码。此函数可用于计算例如椭圆拟合误差。

参数

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 不变矩。

该函数计算七个胡不变矩（在 [133] 中引入；另请参见 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}\) 。

这些值被证明对图像的尺度、旋转和反射具有不变性，除了第七个胡不变矩，其符号会因反射而改变。这种不变性是在无限图像分辨率的假设下证明的。对于光栅图像，原始图像和变换图像计算出的胡不变矩会略有不同。

参数

moments	使用 moments 计算的输入矩。
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	方法,
		double	parameter )

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

#include <opencv2/imgproc.hpp>

比较两个形状。

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

参数

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

◆ minAreaRect()

RotatedRect cv::minAreaRect ( InputArray points )

Python
	cv.minAreaRect(	points	) ->	retval

#include <opencv2/imgproc.hpp>

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

该函数计算并返回指定点集的最小面积边界矩形（可能旋转）。旋转角度表示连接起始点和结束点（基于 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	圆的输出半径。

◆ minEnclosingTriangle()

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

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

#include <opencv2/imgproc.hpp>

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

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

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

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

参数

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

◆ moments()

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

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

#include <opencv2/imgproc.hpp>

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

该函数计算向量形状或光栅化形状的矩，最高可达三阶。结果以结构 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。

另请参见: 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> 或 cv::Mat，类型为 Mx1 的 CV_32FC2。

返回: RectanglesIntersectTypes 之一

详细描述

命名空间

类

枚举

函数

枚举类型文档

◆ ConnectedComponentsAlgorithmsTypes

◆ ConnectedComponentsTypes

◆ ContourApproximationModes

◆ RectanglesIntersectTypes

◆ RetrievalModes

◆ ShapeMatchModes

函数文档

◆ approxPolyDP()

◆ approxPolyN()

◆ arcLength()

◆ boundingRect()

◆ boxPoints()

◆ connectedComponents() [1/2]

◆ connectedComponents() [2/2]

◆ connectedComponentsWithStats() [1/2]

◆ connectedComponentsWithStats() [2/2]

◆ contourArea()

◆ convexHull()

◆ convexityDefects()

◆ createGeneralizedHoughBallard()

◆ createGeneralizedHoughGuil()

◆ findContours() [1/2]

◆ findContours() [2/2]

◆ findContoursLinkRuns() [1/2]

◆ findContoursLinkRuns() [2/2]

◆ fitEllipse()

◆ fitEllipseAMS()

◆ fitEllipseDirect()

◆ fitLine()

◆ getClosestEllipsePoints()

◆ HuMoments() [1/2]

◆ HuMoments() [2/2]

◆ intersectConvexConvex()

◆ isContourConvex()

◆ matchShapes()

◆ minAreaRect()

◆ minEnclosingCircle()

◆ minEnclosingTriangle()

◆ moments()

◆ pointPolygonTest()

◆ rotatedRectangleIntersection()