特徵檢測

詳細說明

類
類	cv::LineSegmentDetector
	直線段檢測器類。更多...

列舉
enum	cv::HoughModes {   cv::HOUGH_STANDARD = 0 ,   cv::HOUGH_PROBABILISTIC = 1 ,   cv::HOUGH_MULTI_SCALE = 2 ,   cv::HOUGH_GRADIENT = 3 ,   cv::HOUGH_GRADIENT_ALT = 4 }
	Hough 變換的變體。更多...
enum	cv::LineSegmentDetectorModes {   cv::LSD_REFINE_NONE = 0 ,   cv::LSD_REFINE_STD = 1 ,   cv::LSD_REFINE_ADV = 2 }
	直線段檢測器 (Line Segment Detector) 的變體。更多...

函式
void	cv::Canny (InputArray dx, InputArray dy, OutputArray edges, double threshold1, double threshold2, bool L2gradient=false)
void	cv::Canny (InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)
	使用 Canny 演算法查詢影像中的邊緣 [50]。
void	cv::cornerEigenValsAndVecs (InputArray src, OutputArray dst, int blockSize, int ksize, int borderType=BORDER_DEFAULT)
	計算用於角點檢測的影像塊的特徵值和特徵向量。
void	cv::cornerHarris (InputArray src, OutputArray dst, int blockSize, int ksize, double k, int borderType=BORDER_DEFAULT)
	Harris 角點檢測器。
void	cv::cornerMinEigenVal (InputArray src, OutputArray dst, int blockSize, int ksize=3, int borderType=BORDER_DEFAULT)
	計算用於角點檢測的梯度矩陣的最小特徵值。
void	cv::cornerSubPix (InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria)
	最佳化角點位置（亞畫素精度）。
Ptr< LineSegmentDetector >	cv::createLineSegmentDetector (int refine=LSD_REFINE_STD, double scale=0.8, double sigma_scale=0.6, double quant=2.0, double ang_th=22.5, double log_eps=0, double density_th=0.7, int n_bins=1024)
	建立一個指向 LineSegmentDetector 物件的智慧指標並初始化。
void	cv::goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask, int blockSize, int gradientSize, bool useHarrisDetector=false, double k=0.04)
void	cv::goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask, OutputArray cornersQuality, int blockSize=3, int gradientSize=3, bool useHarrisDetector=false, double k=0.04)
	與上述相同，但同時返回檢測到的角點的質量度量。
void	cv::goodFeaturesToTrack (InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04)
	在影像上確定強角點。
void	cv::HoughCircles (InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0)
	使用霍夫變換在灰度影像中查詢圓。
void	cv::HoughLines (InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0, double min_theta=0, double max_theta=CV_PI, bool use_edgeval=false)
	使用標準霍夫變換在二值影像中查詢直線。
void	cv::HoughLinesP (InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0)
	使用機率霍夫變換在二值影像中查詢線段。
void	cv::HoughLinesPointSet (InputArray point, OutputArray lines, int lines_max, int threshold, double min_rho, double max_rho, double rho_step, double min_theta, double max_theta, double theta_step)
	使用標準霍夫變換在點集中查詢直線。
void	cv::preCornerDetect (InputArray src, OutputArray dst, int ksize, int borderType=BORDER_DEFAULT)
	計算用於角點檢測的特徵圖。

列舉型別文件 (Enumeration Type Documentation)

HoughModes

列舉 cv::HoughModes

#include <opencv2/imgproc.hpp>

Hough 變換的變體。

列舉值 (Enumerator)
HOUGH_STANDARD  Python: cv.HOUGH_STANDARD	經典或標準 Hough 變換。每條線由兩個浮點數 \((\rho, \theta)\) 表示，其中 \(\rho\) 是點 (0,0) 與直線之間的距離，而 \(\theta\) 是 x 軸與直線法線之間的角度。因此，矩陣必須是（建立的序列將是）CV_32FC2 型別
HOUGH_PROBABILISTIC  Python: cv.HOUGH_PROBABILISTIC	機率 Hough 變換（在圖片包含少量長線性段的情況下效率更高）。它返回的是線段而不是整條直線。每個線段由起點和終點表示，矩陣必須是（建立的序列將是）CV_32SC4 型別。
HOUGH_MULTI_SCALE  Python: cv.HOUGH_MULTI_SCALE	經典 Hough 變換的多尺度變體。直線的編碼方式與 HOUGH_STANDARD 相同。
HOUGH_GRADIENT  Python: cv.HOUGH_GRADIENT	基本上是 21HT，描述於 [318]
HOUGH_GRADIENT_ALT  Python: cv.HOUGH_GRADIENT_ALT	HOUGH_GRADIENT 的變體，以獲得更好的精度

LineSegmentDetectorModes

列舉 cv::LineSegmentDetectorModes

#include <opencv2/imgproc.hpp>

直線段檢測器的變體。

列舉值 (Enumerator)
LSD_REFINE_NONE  Python: cv.LSD_REFINE_NONE	不應用精煉。
LSD_REFINE_STD  Python: cv.LSD_REFINE_STD	應用標準精煉。例如，將圓弧分解為更小的直線近似段。
LSD_REFINE_ADV  Python: cv.LSD_REFINE_ADV	高階精煉。計算虛警數量，透過提高精度、減小尺寸等方式對直線進行精煉。

函式文件 (Function Documentation)

Canny() [1/2]

void cv::Canny	(	InputArray	dx,
		InputArray	dy,
		OutputArray	edges,
		double	threshold1,
		double	threshold2,
		bool	L2gradient = false )

Python
	cv.Canny(	image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]]	) ->	edges
	cv.Canny(	dx, dy, threshold1, threshold2[, edges[, L2gradient]]	) ->	edges

#include <opencv2/imgproc.hpp>

這是一個過載的成員函式，為方便起見而提供。它與上述函式的區別僅在於所接受的引數不同。

使用 Canny 演算法和自定義影像梯度查詢影像中的邊緣。

引數

dx	輸入影像的 16 位 x 導數 (CV_16SC1 或 CV_16SC3)。
dy	輸入影像的 16 位 y 導數（與 dx 型別相同）。
edges	輸出邊緣圖；單通道 8 點陣圖像，大小與輸入影像相同。
threshold1	滯後過程的第一個閾值。
threshold2	滯後過程的第二個閾值。
L2gradient	一個標誌，指示是否應使用更精確的 \(L_2\) 範數 \(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) 來計算影像梯度幅值 ( L2gradient=true )，或者預設的 \(L_1\) 範數 \(=|dI/dx|+|dI/dy|\) 是否足夠 ( L2gradient=false )。

Canny() [2/2]

void cv::Canny	(	InputArray	影像,
		OutputArray	edges,
		double	threshold1,
		double	threshold2,
		int	apertureSize = 3,
		bool	L2gradient = false )

Python
	cv.Canny(	image, threshold1, threshold2[, edges[, apertureSize[, L2gradient]]]	) ->	edges
	cv.Canny(	dx, dy, threshold1, threshold2[, edges[, L2gradient]]	) ->	edges

#include <opencv2/imgproc.hpp>

使用 Canny 演算法查詢影像中的邊緣 [50]。

該函式使用 Canny 演算法查詢輸入影像中的邊緣，並在輸出對映圖 edges 中標記。threshold1 和 threshold2 之間的較小值用於邊緣連線。較大值用於查詢強邊緣的初始段。參見 https://en.wikipedia.org/wiki/Canny_edge_detector

引數

影像	8 位輸入影像。
edges	輸出邊緣圖；單通道 8 點陣圖像，大小與輸入影像相同。
threshold1	滯後過程的第一個閾值。
threshold2	滯後過程的第二個閾值。
apertureSize	Sobel 運算元的孔徑大小。
L2gradient	一個標誌，指示是否應使用更精確的 \(L_2\) 範數 \(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) 來計算影像梯度幅值 ( L2gradient=true )，或者預設的 \(L_1\) 範數 \(=|dI/dx|+|dI/dy|\) 是否足夠 ( L2gradient=false )。

cornerEigenValsAndVecs()

void cv::cornerEigenValsAndVecs	(	InputArray	src,
		OutputArray	dst,
		int	blockSize,
		int	ksize,
		int	borderType = BORDER_DEFAULT )

Python
	cv.cornerEigenValsAndVecs(	src, blockSize, ksize[, dst[, borderType]]	) ->	dst

#include <opencv2/imgproc.hpp>

計算用於角點檢測的影像塊的特徵值和特徵向量。

對於每個畫素 \(p\) ，函式 cornerEigenValsAndVecs 考慮一個 blockSize \(\times\) blockSize 的鄰域 \(S(p)\) 。它計算該鄰域內導數的協方差矩陣：

\[M = \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 & \sum _{S(p)}dI/dx dI/dy \\ \sum _{S(p)}dI/dx dI/dy & \sum _{S(p)}(dI/dy)^2 \end{bmatrix}\]

其中導數是使用 Sobel 運算元計算的。

之後，它求出 \(M\) 的特徵向量和特徵值，並將它們儲存在目標影像中，格式為 \((\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)\) ，其中：

• \(\lambda_1, \lambda_2\) 是 \(M\) 的未排序特徵值
• \(x_1, y_1\) 是對應於 \(\lambda_1\) 的特徵向量
• \(x_2, y_2\) 是對應於 \(\lambda_2\) 的特徵向量

該函式的輸出可用於魯棒的邊緣或角點檢測。

引數

src	輸入單通道 8 位或浮點影像。
dst	儲存結果的影像。它與 src 具有相同的大小，型別為 CV_32FC(6) 。
blockSize	鄰域大小（詳見下文）。
ksize	Sobel 運算元的孔徑引數。
borderType	畫素外插方法。參見 BorderTypes。不支援 BORDER_WRAP。

另請參閱

cornerMinEigenVal, cornerHarris, preCornerDetect

cornerHarris()

void cv::cornerHarris	(	InputArray	src,
		OutputArray	dst,
		int	blockSize,
		int	ksize,
		double	k,
		int	borderType = BORDER_DEFAULT )

Python
	cv.cornerHarris(	src, blockSize, ksize, k[, dst[, borderType]]	) ->	dst

#include <opencv2/imgproc.hpp>

Harris 角點檢測器。

該函式在影像上執行 Harris 角點檢測器。類似於 cornerMinEigenVal 和 cornerEigenValsAndVecs ，對於每個畫素 \((x, y)\) ，它在 \(\texttt{blockSize} \times \texttt{blockSize}\) 的鄰域上計算一個 \(2\times2\) 梯度協方差矩陣 \(M^{(x,y)}\) 。然後，它計算以下特徵值：

\[\texttt{dst} (x,y) = \mathrm{det} M^{(x,y)} - k \cdot \left ( \mathrm{tr} M^{(x,y)} \right )^2\]

影像中的角點可以透過該響應圖的區域性極大值找到。

引數

src	輸入單通道 8 位或浮點影像。
dst	儲存 Harris 檢測器響應的影像。它的型別為 CV_32FC1，大小與 src 相同。
blockSize	鄰域大小（參見 cornerEigenValsAndVecs 的詳細資訊）。
ksize	Sobel 運算元的孔徑引數。
k	Harris 檢測器自由引數。參見上述公式。
borderType	畫素外插方法。參見 BorderTypes。不支援 BORDER_WRAP。

cornerMinEigenVal()

void cv::cornerMinEigenVal	(	InputArray	src,
		OutputArray	dst,
		int	blockSize,
		int	ksize = 3,
		int	borderType = BORDER_DEFAULT )

Python
	cv.cornerMinEigenVal(	src, blockSize[, dst[, ksize[, borderType]]]	) ->	dst

#include <opencv2/imgproc.hpp>

計算用於角點檢測的梯度矩陣的最小特徵值。

該函式與 cornerEigenValsAndVecs 類似，但它僅計算並存儲導數協方差矩陣的最小特徵值，即 cornerEigenValsAndVecs 描述公式中的 \(\min(\lambda_1, \lambda_2)\) 。

引數

src	輸入單通道 8 位或浮點影像。
dst	儲存最小特徵值的影像。它的型別為 CV_32FC1，大小與 src 相同。
blockSize	鄰域大小（參見 cornerEigenValsAndVecs 的詳細資訊）。
ksize	Sobel 運算元的孔徑引數。
borderType	畫素外插方法。參見 BorderTypes。不支援 BORDER_WRAP。

cornerSubPix()

void cv::cornerSubPix	(	InputArray	影像,
		InputOutputArray	corners,
		Size	winSize,
		Size	zeroZone,
		TermCriteria	criteria )

Python
	cv.cornerSubPix(	image, corners, winSize, zeroZone, criteria	) ->	corners

#include <opencv2/imgproc.hpp>

最佳化角點位置（亞畫素精度）。

該函式透過迭代尋找角點或徑向鞍點的亞畫素準確位置，如 [98] 所述，並如下圖所示。

影像

亞畫素準確角點定位器基於這樣一個觀察：在 \(q\) 的鄰域內的點 \(p\) ，從中心 \(q\) 到 \(p\) 的每個向量都與 \(p\) 處的影像梯度正交（受影像和測量噪聲影響）。考慮表示式：

\[\epsilon _i = {DI_{p_i}}^T \cdot (q - p_i)\]

其中 \({DI_{p_i}}\) 是 \(q\) 鄰域內點 \(p_i\) 處的影像梯度。尋找 \(q\) 的值以使 \(\epsilon_i\) 最小。可以建立一個令 \(\epsilon_i\) 為零的方程組：

\[\sum _i(DI_{p_i} \cdot {DI_{p_i}}^T) \cdot q - \sum _i(DI_{p_i} \cdot {DI_{p_i}}^T \cdot p_i)\]

其中梯度在 \(q\) 的鄰域（“搜尋視窗”）內求和。令第一個梯度項為 \(G\) ，第二個梯度項為 \(b\) ，得到：

\[q = G^{-1} \cdot b\]

演算法將鄰域視窗的中心設定為這個新的中心 \(q\) ，然後迭代直到中心保持在設定的閾值內。

引數

影像	輸入單通道、8 位或浮點影像。
corners	輸入角點的初始座標，並提供精煉後的輸出座標。
winSize	搜尋視窗邊長的一半。例如，如果 winSize=Size(5,5) ，則使用 \((5*2+1) \times (5*2+1) = 11 \times 11\) 的搜尋視窗。
zeroZone	搜尋區域中間“死區”尺寸的一半，在該區域內不進行下式中的求和。有時用於避免自相關矩陣可能的奇異性。值 (-1,-1) 表示沒有這種尺寸。
criteria	角點精煉迭代過程的終止標準。即，角點位置精煉過程在達到 criteria.maxCount 次迭代後，或當角點位置在某次迭代中的移動距離小於 criteria.epsilon 時停止。

createLineSegmentDetector()

Ptr< LineSegmentDetector > cv::createLineSegmentDetector	(	int	refine = LSD_REFINE_STD,
		double	scale = 0.8,
		double	sigma_scale = 0.6,
		double	quant = 2.0,
		double	ang_th = 22.5,
		double	log_eps = 0,
		double	density_th = 0.7,
		int	n_bins = 1024 )

Python
	cv.createLineSegmentDetector(	[, refine[, scale[, sigma_scale[, quant[, ang_th[, log_eps[, density_th[, n_bins]]]]]]]]	) ->	retval

#include <opencv2/imgproc.hpp>

建立一個指向 LineSegmentDetector 物件的智慧指標並初始化。

LineSegmentDetector 演算法使用標準值定義。只有高階使用者可能需要修改這些值，以使其適應特定的應用程式。

引數

refine	找到的直線的精煉方式，參見 LineSegmentDetectorModes
scale	用於查詢直線的影像縮放比例。範圍 (0..1]。
sigma_scale	高斯濾波器的 Sigma 值。計算公式為 sigma = sigma_scale/scale。
quant	梯度範數上量化誤差的界限。
ang_th	梯度角度公差（單位：度）。
log_eps	檢測閾值：-log10(NFA) > log_eps。僅在選擇高階精煉時使用。
density_th	包圍矩形中對齊區域點的最小密度。
n_bins	梯度模偽排序中的箱 (bin) 數量。

goodFeaturesToTrack() [1/3]

void cv::goodFeaturesToTrack	(	InputArray	影像,
		OutputArray	corners,
		int	maxCorners,
		double	qualityLevel,
		double	minDistance,
		InputArray	mask,
		int	blockSize,
		int	gradientSize,
		bool	useHarrisDetector = false,
		double	k = 0.04 )

Python
	cv.goodFeaturesToTrack(	image, maxCorners, qualityLevel, minDistance[, corners[, mask[, blockSize[, useHarrisDetector[, k]]]]]	) ->	corners
	cv.goodFeaturesToTrack(	image, maxCorners, qualityLevel, minDistance, mask, blockSize, gradientSize[, corners[, useHarrisDetector[, k]]]	) ->	corners
	cv.goodFeaturesToTrackWithQuality(	image, maxCorners, qualityLevel, minDistance, mask[, corners[, cornersQuality[, blockSize[, gradientSize[, useHarrisDetector[, k]]]]]]	) ->	corners, cornersQuality

#include <opencv2/imgproc.hpp>

goodFeaturesToTrack() [2/3]

void cv::goodFeaturesToTrack	(	InputArray	影像,
		OutputArray	corners,
		int	maxCorners,
		double	qualityLevel,
		double	minDistance,
		InputArray	mask,
		OutputArray	cornersQuality,
		int	blockSize = 3,
		int	gradientSize = 3,
		bool	useHarrisDetector = false,
		double	k = 0.04 )

Python
	cv.goodFeaturesToTrack(	image, maxCorners, qualityLevel, minDistance[, corners[, mask[, blockSize[, useHarrisDetector[, k]]]]]	) ->	corners
	cv.goodFeaturesToTrack(	image, maxCorners, qualityLevel, minDistance, mask, blockSize, gradientSize[, corners[, useHarrisDetector[, k]]]	) ->	corners
	cv.goodFeaturesToTrackWithQuality(	image, maxCorners, qualityLevel, minDistance, mask[, corners[, cornersQuality[, blockSize[, gradientSize[, useHarrisDetector[, k]]]]]]	) ->	corners, cornersQuality

#include <opencv2/imgproc.hpp>

與上述相同，但同時返回檢測到的角點的質量度量。

引數

影像	輸入 8 位或浮點 32 位單通道影像。
corners	檢測到的角點的輸出向量。
maxCorners	要返回的最大角點數。如果發現的角點多於此數量，則返回最強的那些。maxCorners <= 0 表示不設定最大值限制，返回所有檢測到的角點。
qualityLevel	表徵影像角點最小可接受質量的引數。該引數值乘以最佳角點質量測量值，即最小特徵值（參見 cornerMinEigenVal ）或 Harris 函式響應（參見 cornerHarris ）。質量測量值小於該乘積的角點將被剔除。例如，如果最佳角點的質量測量值為 1500，且 qualityLevel=0.01，則所有質量測量值小於 15 的角點都將被剔除。
minDistance	返回的角點之間可能的最小歐幾里得距離。
mask	感興趣區域。如果影像不為空（需要為 CV_8UC1 型別且與 image 大小相同），它指定檢測角點的區域。
cornersQuality	檢測到的角點質量測量值的輸出向量。
blockSize	用於計算每個畫素鄰域上導數協方差矩陣的平均塊大小。參見 cornerEigenValsAndVecs 。
gradientSize	用於導數計算的 Sobel 運算元的孔徑引數。參見 cornerEigenValsAndVecs 。
useHarrisDetector	指示是否使用 Harris 檢測器（參見 cornerHarris）或 cornerMinEigenVal 的引數。
k	Harris 檢測器的自由引數。

goodFeaturesToTrack() [3/3]

void cv::goodFeaturesToTrack	(	InputArray	影像,
		OutputArray	corners,
		int	maxCorners,
		double	qualityLevel,
		double	minDistance,
		InputArray	mask = noArray(),
		int	blockSize = 3,
		bool	useHarrisDetector = false,
		double	k = 0.04 )

Python
	cv.goodFeaturesToTrack(	image, maxCorners, qualityLevel, minDistance[, corners[, mask[, blockSize[, useHarrisDetector[, k]]]]]	) ->	corners
	cv.goodFeaturesToTrack(	image, maxCorners, qualityLevel, minDistance, mask, blockSize, gradientSize[, corners[, useHarrisDetector[, k]]]	) ->	corners
	cv.goodFeaturesToTrackWithQuality(	image, maxCorners, qualityLevel, minDistance, mask[, corners[, cornersQuality[, blockSize[, gradientSize[, useHarrisDetector[, k]]]]]]	) ->	corners, cornersQuality

#include <opencv2/imgproc.hpp>

在影像上確定強角點。

該函式按照 [251] 中的描述，在影像或指定的影像區域中查詢最顯著的角點。

• 函式使用 cornerMinEigenVal 或 cornerHarris 計算源影像每個畫素處的角點質量測量值。
• 函式執行非極大值抑制（保留 3 x 3 鄰域內的區域性極大值）。
• 最小特徵值小於 \(\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\) 的角點將被剔除。
• 剩餘的角點按質量測量值降序排列。
• 函式剔除在小於 maxDistance 距離記憶體在更強角點的每個角點。

該函式可用於初始化物件的點軌跡追蹤器。

注意

如果使用引數 qualityLevel 的不同值 A 和 B 呼叫該函式，且 A > B，則使用 qualityLevel=A 返回的角點向量將是使用 qualityLevel=B 返回的輸出向量的字首。

引數

影像	輸入 8 位或浮點 32 位單通道影像。
corners	檢測到的角點的輸出向量。
maxCorners	要返回的最大角點數。如果發現的角點多於此數量，則返回最強的那些。maxCorners <= 0 表示不設定最大值限制，返回所有檢測到的角點。
qualityLevel	表徵影像角點最小可接受質量的引數。該引數值乘以最佳角點質量測量值，即最小特徵值（參見 cornerMinEigenVal ）或 Harris 函式響應（參見 cornerHarris ）。質量測量值小於該乘積的角點將被剔除。例如，如果最佳角點的質量測量值為 1500，且 qualityLevel=0.01，則所有質量測量值小於 15 的角點都將被剔除。
minDistance	返回的角點之間可能的最小歐幾里得距離。
mask	可選的感興趣區域。如果影像不為空（需要為 CV_8UC1 型別且與 image 大小相同），它指定檢測角點的區域。
blockSize	用於計算每個畫素鄰域上導數協方差矩陣的平均塊大小。參見 cornerEigenValsAndVecs 。
useHarrisDetector	指示是否使用 Harris 檢測器（參見 cornerHarris）或 cornerMinEigenVal 的引數。
k	Harris 檢測器的自由引數。

另請參閱

cornerMinEigenVal, cornerHarris, calcOpticalFlowPyrLK, estimateRigidTransform,

HoughCircles()

void cv::HoughCircles	(	InputArray	影像,
		OutputArray	circles,
		int	method,
		double	dp,
		double	minDist,
		double	param1 = 100,
		double	param2 = 100,
		int	minRadius = 0,
		int	maxRadius = 0 )

Python
	cv.HoughCircles(	image, method, dp, minDist[, circles[, param1[, param2[, minRadius[, maxRadius]]]]]	) ->	circles

#include <opencv2/imgproc.hpp>

使用霍夫變換在灰度影像中查詢圓。

該函式使用 Hough 變換的改進版在灰度影像中查詢圓。

示例：

#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <math.h>
 
using namespace cv;
using namespace std;
 
int main(int argc, char** argv)
{
    Mat img, gray;
    if( argc != 2 || !(img=imread(argv[1], IMREAD_COLOR)).data)
        return -1;
    cvtColor(img, gray, COLOR_BGR2GRAY);
    // 進行平滑處理，否則可能會檢測到大量虛假圓
    GaussianBlur( gray, gray, Size(9, 9), 2, 2 );
vector<Vec3f> circles;
    HoughCircles(gray, circles, HOUGH_GRADIENT,
2, gray.rows/4, 200, 100 );
    for( size_t i = 0; i < circles.size(); i++ )
    {
         Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
         int radius = cvRound(circles[i][2]);
         // 繪製圓心
circle( img, center, 3, Scalar(0,255,0), -1, 8, 0 );
         // 繪製圓輪廓
circle( img, center, radius, Scalar(0,0,255), 3, 8, 0 );
    }
namedWindow( "circles", 1 );
imshow( "circles", img );
 
waitKey(0);
    return 0;
}

注意

通常該函式能很好地檢測圓心。但是，它可能無法找到正確的半徑。如果您知道半徑範圍，可以透過指定半徑範圍（ minRadius 和 maxRadius ）來輔助函式。或者，在 HOUGH_GRADIENT 方法的情況下，您可以將 maxRadius 設定為負數，以僅返回圓心而不進行半徑搜尋，然後使用額外的程式查詢正確的半徑。

除非影像已經很柔和，否則稍微平滑影像也有幫助。例如，使用 7x7 核心和 1.5x1.5 sigma 的 GaussianBlur() 或類似的模糊處理可能會有幫助。

引數

影像	8 位單通道灰度輸入影像。
circles	找到的圓的輸出向量。每個向量編碼為 3 或 4 元素浮點向量 \((x, y, radius)\) 或 \((x, y, radius, votes)\) 。
method	檢測方法，參見 HoughModes。可用方法為 HOUGH_GRADIENT 和 HOUGH_GRADIENT_ALT。
dp	累加器解析度與影像解析度的反比。例如，如果 dp=1 ，則累加器與輸入影像具有相同的解析度。如果 dp=2 ，則累加器的寬度和高度是輸入影像的一半。對於 HOUGH_GRADIENT_ALT，推薦值為 dp=1.5，除非需要檢測非常小的圓。
minDist	檢測到的圓心之間的最小距離。如果該引數太小，除了真實的圓外，還可能會錯誤地檢測到多個相鄰的圓。如果太大，可能會漏掉一些圓。
param1	第一個方法特定引數。在 HOUGH_GRADIENT 和 HOUGH_GRADIENT_ALT 的情況下，它是傳遞給 Canny 邊緣檢測器的兩個閾值中的較高者（較低者是其一半）。注意 HOUGH_GRADIENT_ALT 使用 Scharr 演算法計算影像導數，因此對於曝光正常且對比度高的影像，閾值通常應更高，例如 300。
param2	第二個方法特定引數。在 HOUGH_GRADIENT 的情況下，它是檢測階段圓心的累加器閾值。越小，檢測到的虛假圓就越多。對應於較大累加器值的圓將首先返回。在 HOUGH_GRADIENT_ALT 演算法的情況下，這是圓的“完美度”衡量標準。越接近 1，演算法選擇的圓形狀越好。在大多數情況下，0.9 應該可以。如果您想更好地檢測小圓，可以將其減小到 0.85、0.8 甚至更小。但同時也請嘗試限制搜尋範圍 [minRadius, maxRadius] 以避免出現許多虛假圓。
minRadius	最小圓半徑。
maxRadius	最大圓半徑。如果 <= 0，則使用最大影像尺寸。如果 < 0，HOUGH_GRADIENT 僅返回中心而不查詢半徑。HOUGH_GRADIENT_ALT 始終計算圓半徑。

另請參閱

fitEllipse, minEnclosingCircle

HoughLines()

void cv::HoughLines	(	InputArray	影像,
		OutputArray	lines,
		double	rho,
		double	theta,
		int	閾值 (threshold),
		double	srn = 0,
		double	stn = 0,
		double	min_theta = 0,
		double	max_theta = CV_PI,
		bool	use_edgeval = false )

Python
	cv.HoughLines(	image, rho, theta, threshold[, lines[, srn[, stn[, min_theta[, max_theta[, use_edgeval]]]]]]	) ->	lines

#include <opencv2/imgproc.hpp>

使用標準霍夫變換在二值影像中查詢直線。

該函式實現了用於直線檢測的標準或標準多尺度 Hough 變換演算法。有關 Hough 變換的詳細說明，請參閱 https://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm 。

引數

影像	8 位單通道二進位制源影像。影像可能會被該函式修改。
lines	直線的輸出向量。每條線由 2 或 3 元素向量 \((\rho, \theta)\) 或 \((\rho, \theta, \textrm{votes})\) 表示，其中 \(\rho\) 是距離座標原點 \((0,0)\) （影像左上角）的距離，\(\theta\) 是以弧度表示的直線旋轉角度（ \(0 \sim \textrm{垂直線}, \pi/2 \sim \textrm{水平線}\) ），而 \(\textrm{votes}\) 是累加器的值。
rho	累加器的距離解析度（單位：畫素）。
theta	累加器的角度解析度（單位：弧度）。
閾值 (threshold)	累加器閾值引數。只有那些獲得足夠票數 ( \(>\texttt{threshold}\) ) 的直線才會被返回。
srn	對於多尺度 Hough 變換，它是距離解析度 rho 的除數。粗略累加器距離解析度為 rho，精確累加器解析度為 rho/srn。如果 srn=0 且 stn=0，則使用經典 Hough 變換。否則，這兩個引數都應為正數。
stn	對於多尺度 Hough 變換，它是角度解析度 theta 的除數。
min_theta	對於標準和多尺度 Hough 變換，檢查直線的最小角度。必須介於 0 和 max_theta 之間。
max_theta	對於標準和多尺度 Hough 變換，角度的上限。必須介於 min_theta 和 CV_PI 之間。累加器中的實際最大角度可能略小於 max_theta，具體取決於引數 min_theta 和 theta。
use_edgeval	如果您想使用加權 Hough 變換，則為 True。

HoughLinesP()

void cv::HoughLinesP	(	InputArray	影像,
		OutputArray	lines,
		double	rho,
		double	theta,
		int	閾值 (threshold),
		double	minLineLength = 0,
		double	maxLineGap = 0 )

Python
	cv.HoughLinesP(	image, rho, theta, threshold[, lines[, minLineLength[, maxLineGap]]]	) ->	lines

#include <opencv2/imgproc.hpp>

使用機率霍夫變換在二值影像中查詢線段。

該函式實現了機率 Hough 變換演算法用於直線檢測，描述於 [191]

參見下方的直線檢測示例

#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
 
using namespace cv;
using namespace std;
 
int main(int argc, char** argv)
{
    Mat src, dst, color_dst;
    if( argc != 2 || !(src=imread(argv[1], IMREAD_GRAYSCALE)).data)
        return -1;
 
    Canny( src, dst, 50, 200, 3 );
    cvtColor( dst, color_dst, COLOR_GRAY2BGR );
 
vector<Vec4i> lines;
    HoughLinesP( dst, lines, 1, CV_PI/180, 80, 30, 10 );
    for( size_t i = 0; i < lines.size(); i++ )
    {
        line( color_dst, Point(lines[i][0], lines[i][1]),
        Point( lines[i][2], lines[i][3]), Scalar(0,0,255), 3, 8 );
    }
namedWindow( "Source", 1 );
imshow( "Source", src );
 
namedWindow( "Detected Lines", 1 );
imshow( "Detected Lines", color_dst );
 
waitKey(0);
    return 0;
}

這是已針對其調整函式引數的示例圖片

影像

這是上述程式在使用機率 Hough 變換情況下的輸出

影像

引數

影像	8 位單通道二進位制源影像。影像可能會被該函式修改。
lines	直線的輸出向量。每個直線由 4 元素向量 \((x_1, y_1, x_2, y_2)\) 表示，其中 \((x_1,y_1)\) 和 \((x_2, y_2)\) 是每個檢測到的線段的終點。
rho	累加器的距離解析度（單位：畫素）。
theta	累加器的角度解析度（單位：弧度）。
閾值 (threshold)	累加器閾值引數。只有那些獲得足夠票數 ( \(>\texttt{threshold}\) ) 的直線才會被返回。
minLineLength	最小線段長度。短於此長度的線段將被剔除。
maxLineGap	同一條直線上點之間允許連線的最大間隙。

另請參閱

LineSegmentDetector

HoughLinesPointSet()

void cv::HoughLinesPointSet	(	InputArray	point,
		OutputArray	lines,
		int	lines_max,
		int	閾值 (threshold),
		double	min_rho,
		double	max_rho,
		double	rho_step,
		double	min_theta,
		double	max_theta,
		double	theta_step )

Python
	cv.HoughLinesPointSet(	point, lines_max, threshold, min_rho, max_rho, rho_step, min_theta, max_theta, theta_step[, lines]	) ->	lines

#include <opencv2/imgproc.hpp>

使用標準霍夫變換在點集中查詢直線。

該函式使用 Hough 變換的改進版在點集中查詢直線。

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
 
using namespace cv;
using namespace std;
 
int main()
{
    Mat lines;
vector<Vec3d> line3d;
vector<Point2f> point;
    const static float Points[20][2] = {
{ 0.0f, 369.0f }, { 10.0f, 364.0f }, { 20.0f, 358.0f }, { 30.0f, 352.0f },
{ 40.0f, 346.0f }, { 50.0f, 341.0f }, { 60.0f, 335.0f }, { 70.0f, 329.0f },
{ 80.0f, 323.0f }, { 90.0f, 318.0f }, { 100.0f, 312.0f }, { 110.0f, 306.0f },
{ 120.0f, 300.0f }, { 130.0f, 295.0f }, { 140.0f, 289.0f }, { 150.0f, 284.0f },
{ 160.0f, 277.0f }, { 170.0f, 271.0f }, { 180.0f, 266.0f }, { 190.0f, 260.0f }
    };
 
    for (int i = 0; i < 20; i++)
    {
point.push_back(Point2f(Points[i][0],Points[i][1]));
    }
 
    double rhoMin = 0.0f, rhoMax = 360.0f, rhoStep = 1;
    double thetaMin = 0.0f, thetaMax = CV_PI / 2.0f, thetaStep = CV_PI / 180.0f;
 
    HoughLinesPointSet(point, lines, 20, 1,
rhoMin, rhoMax, rhoStep,
thetaMin, thetaMax, thetaStep);
 
lines.copyTo(line3d);
printf("votes:%d, rho:%.7f, theta:%.7f\n",(int)line3d.at(0).val[0], line3d.at(0).val[1], line3d.at(0).val[2]);
}

引數

point	輸入點向量。每個向量必須編碼為 Point 向量 \((x,y)\)。型別必須為 CV_32FC2 或 CV_32SC2。
lines	找到的直線的輸出向量。每個向量編碼為 vector<Vec3d> \((votes, rho, theta)\)。'votes' 的值越大，Hough 直線的可靠性越高。
lines_max	Hough 直線的最大數量。
閾值 (threshold)	累加器閾值引數。只有那些獲得足夠票數 ( \(>\texttt{threshold}\) ) 的直線才會被返回。
min_rho	累加器 \(\rho\) 的最小值（注意：\(\rho\) 可以為負數。絕對值 \(|\rho|\) 是直線到原點的距離。）。
max_rho	累加器 \(\rho\) 的最大值。
rho_step	累加器的距離解析度。
min_theta	累加器的最小角度值（單位：弧度）。
max_theta	累加器角度值的上限（單位：弧度）。實際最大角度可能略小於 max_theta，具體取決於引數 min_theta 和 theta_step。
theta_step	累加器的角度解析度（單位：弧度）。

preCornerDetect()

void cv::preCornerDetect	(	InputArray	src,
		OutputArray	dst,
		int	ksize,
		int	borderType = BORDER_DEFAULT )

Python
	cv.preCornerDetect(	src, ksize[, dst[, borderType]]	) ->	dst

#include <opencv2/imgproc.hpp>

計算用於角點檢測的特徵圖。

該函式計算源影像基於復空間導數的函式：

\[\texttt{dst} = (D_x \texttt{src} )^2 \cdot D_{yy} \texttt{src} + (D_y \texttt{src} )^2 \cdot D_{xx} \texttt{src} - 2 D_x \texttt{src} \cdot D_y \texttt{src} \cdot D_{xy} \texttt{src}\]

其中 \(D_x\), \(D_y\) 是影像的一階導數，\(D_{xx}\), \(D_{yy}\) 是影像的二階導數，而 \(D_{xy}\) 是混合導數。

角點可以透過該函式的區域性極大值找到，如下所示：

Mat corners, dilated_corners;
preCornerDetect(image, corners, 3);
// 使用 3x3 矩形結構元素進行膨脹
dilate(corners, dilated_corners, Mat(), 1);
Mat corner_mask = corners == dilated_corners;

引數

src	源單通道 8 位或浮點影像。
dst	輸出影像，型別為 CV_32F，大小與 src 相同。
ksize	Sobel 運算元的孔徑大小。
borderType	畫素外插方法。參見 BorderTypes。不支援 BORDER_WRAP。