結構分析與形狀描述符

詳細說明

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