結構分析與形狀描述

詳細描述

名稱空間
名稱空間	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 之一