特徵檢測

詳細描述

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

列舉
列舉	cv::HoughModes {   cv::HOUGH_STANDARD = 0 ,   cv::HOUGH_PROBABILISTIC = 1 ,   cv::HOUGH_MULTI_SCALE = 2 ,   cv::HOUGH_GRADIENT = 3 ,   cv::HOUGH_GRADIENT_ALT = 4 }
	霍夫變換的變體。 更多...
列舉	cv::LineSegmentDetectorModes {   cv::LSD_REFINE_NONE = 0 ,   cv::LSD_REFINE_STD = 1 ,   cv::LSD_REFINE_ADV = 2 }
	線段檢測器的變體。 更多...

函式
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 演算法 [49] 在影像中查詢邊緣。
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 corner detector.
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)
	計算用於角點檢測的特徵圖。

列舉型別文件

HoughModes

enum cv::HoughModes

#include <opencv2/imgproc.hpp>

霍夫變換的變體。

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

LineSegmentDetectorModes

enum cv::LineSegmentDetectorModes

#include <opencv2/imgproc.hpp>

線段檢測器的變體。

列舉器
LSD_REFINE_NONE  Python: cv.LSD_REFINE_NONE	不應用細化。
LSD_REFINE_STD  Python: cv.LSD_REFINE_STD	應用標準細化。例如，將弧線分解為更小的直線近似。
LSD_REFINE_ADV  Python: cv.LSD_REFINE_ADV	高階細化。計算誤報數量，透過提高精度、減小尺寸等方式細化線條。

函式文件

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	image,
		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 演算法 [49] 在影像中查詢邊緣。

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

引數

image	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 corner detector.

該函式在影像上執行 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	image,
		InputOutputArray	corners,
		Size	winSize,
		Size	zeroZone,
		TermCriteria	criteria )

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

#include <opencv2/imgproc.hpp>

精煉角點位置。

該函式迭代以查詢角點或徑向鞍點的亞畫素精確位置，如 [96] 中所述，並如下圖所示。

image

亞畫素精確角點定位器基於以下觀察：從中心 \(q\) 到位於 \(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\) ，然後迭代直到中心保持在設定的閾值內。

引數

image	輸入單通道，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	image,
		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	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 )

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>

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

引數

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

goodFeaturesToTrack() [3/3]

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 )

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>

檢測影像中的強角點。

該函式在影像或指定的影像區域中找到最突出的角點，如 [248] 中所述。

• 函式使用 cornerMinEigenVal 或 cornerHarris 計算每個源影像畫素的角點質量度量。
• 函式執行非最大抑制（保留 3 x 3 鄰域中的區域性最大值）。
• 最小特徵值小於 \(\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\) 的角點將被拒絕。
• 剩餘的角點按質量度量降序排序。
• 函式丟棄每個距離小於 maxDistance 的較強角點。

該函式可用於初始化基於點的物件跟蹤器。

注意

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

引數

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

另請參見

cornerMinEigenVal, cornerHarris, calcOpticalFlowPyrLK, estimateRigidTransform,

HoughCircles()

void cv::HoughCircles	(	InputArray	image,
		OutputArray	circles,
		int	方法,
		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>

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

該函式使用霍夫變換的修改版本在灰度影像中查詢圓形。

示例：

#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() 可能會有所幫助。

引數

image	8 位、單通道灰度輸入影像。
circles	找到的圓形的輸出向量。每個向量編碼為 3 或 4 元素浮點向量 \((x, y, radius)\) 或 \((x, y, radius, votes)\) 。
方法	檢測方法，參見 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	image,
		OutputArray	輸出向量，包含與另一影像中點對應的對極線。每條線\(ax + by + c=0\)由3個數字\((a, b, c)\)編碼。,
		double	rho,
		double	theta,
		int	RANSAC引數。它是點到畫素中對極線的最大距離，超過此距離的點將被視為異常值，不用於計算最終的基本矩陣。它可以設定為1-3左右，具體取決於點定位的精度、影像解析度和影像噪聲。,
		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]]]]]]	) ->	輸出向量，包含與另一影像中點對應的對極線。每條線\(ax + by + c=0\)由3個數字\((a, b, c)\)編碼。

#include <opencv2/imgproc.hpp>

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

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

引數

image	8 位，單通道二值源影像。影像可能被函式修改。
輸出向量，包含與另一影像中點對應的對極線。每條線\(ax + by + c=0\)由3個數字\((a, b, c)\)編碼。	線條的輸出向量。每條線由 2 或 3 元素向量 \((\rho, \theta)\) 或 \((\rho, \theta, \textrm{votes})\) 表示，其中 \(\rho\) 是到座標原點 \((0,0)\) （影像左上角）的距離，\(\theta\) 是線旋轉角度（弧度）（ \(0 \sim \textrm{垂直線}, \pi/2 \sim \textrm{水平線}\) ），\(\textrm{votes}\) 是累加器的值。
rho	累加器的距離解析度（以畫素為單位）。
theta	累加器的角度解析度（以弧度為單位）。
RANSAC引數。它是點到畫素中對極線的最大距離，超過此距離的點將被視為異常值，不用於計算最終的基本矩陣。它可以設定為1-3左右，具體取決於點定位的精度、影像解析度和影像噪聲。	累加器閾值引數。只返回獲得足夠票數（ \(>\texttt{threshold}\) ）的線條。
srn	對於多尺度霍夫變換，它是距離解析度 rho 的除數。粗累加器距離解析度為 rho，精確累加器解析度為 rho/srn。如果 srn=0 和 stn=0 都為 0，則使用經典霍夫變換。否則，這兩個引數都應為正。
stn	對於多尺度霍夫變換，它是距離解析度 theta 的除數。
min_theta	對於標準和多尺度霍夫變換，要檢查線條的最小角度。必須介於 0 和 max_theta 之間。
max_theta	對於標準和多尺度霍夫變換，角度的上限。必須介於 min_theta 和 CV_PI 之間。累加器中的實際最大角度可能略小於 max_theta，具體取決於引數 min_theta 和 theta。
use_edgeval	如果要使用加權霍夫變換，則為 True。

HoughLinesP()

void cv::HoughLinesP	(	InputArray	image,
		OutputArray	輸出向量，包含與另一影像中點對應的對極線。每條線\(ax + by + c=0\)由3個數字\((a, b, c)\)編碼。,
		double	rho,
		double	theta,
		int	RANSAC引數。它是點到畫素中對極線的最大距離，超過此距離的點將被視為異常值，不用於計算最終的基本矩陣。它可以設定為1-3左右，具體取決於點定位的精度、影像解析度和影像噪聲。,
		double	minLineLength = 0,
		double	maxLineGap = 0 )

Python
	cv.HoughLinesP(	image, rho, theta, threshold[, lines[, minLineLength[, maxLineGap]]]	) ->	輸出向量，包含與另一影像中點對應的對極線。每條線\(ax + by + c=0\)由3個數字\((a, b, c)\)編碼。

#include <opencv2/imgproc.hpp>

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

該函式實現了用於直線檢測的機率霍夫變換演算法，如 [188] 中所述。

請參閱下面的直線檢測示例

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

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

image

這是機率霍夫變換情況下上述程式的輸出

image

引數

image	8 位，單通道二值源影像。影像可能被函式修改。
輸出向量，包含與另一影像中點對應的對極線。每條線\(ax + by + c=0\)由3個數字\((a, b, c)\)編碼。	線條的輸出向量。每條線由 4 元素向量 \((x_1, y_1, x_2, y_2)\) 表示，其中 \((x_1,y_1)\) 和 \((x_2, y_2)\) 是每個檢測到的線段的端點。
rho	累加器的距離解析度（以畫素為單位）。
theta	累加器的角度解析度（以弧度為單位）。
RANSAC引數。它是點到畫素中對極線的最大距離，超過此距離的點將被視為異常值，不用於計算最終的基本矩陣。它可以設定為1-3左右，具體取決於點定位的精度、影像解析度和影像噪聲。	累加器閾值引數。只返回獲得足夠票數（ \(>\texttt{threshold}\) ）的線條。
minLineLength	最小線長。比此短的線段將被拒絕。
maxLineGap	同一條線上點之間允許的最大間隙，用於連線它們。

另請參見

LineSegmentDetector

HoughLinesPointSet()

void cv::HoughLinesPointSet	(	InputArray	point,
		OutputArray	輸出向量，包含與另一影像中點對應的對極線。每條線\(ax + by + c=0\)由3個數字\((a, b, c)\)編碼。,
		int	lines_max,
		int	RANSAC引數。它是點到畫素中對極線的最大距離，超過此距離的點將被視為異常值，不用於計算最終的基本矩陣。它可以設定為1-3左右，具體取決於點定位的精度、影像解析度和影像噪聲。,
		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]	) ->	輸出向量，包含與另一影像中點對應的對極線。每條線\(ax + by + c=0\)由3個數字\((a, b, c)\)編碼。

#include <opencv2/imgproc.hpp>

使用標準霍夫變換在一組點中查詢線條。

該函式使用霍夫變換的修改版本在一組點中查詢線條。

#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。
輸出向量，包含與另一影像中點對應的對極線。每條線\(ax + by + c=0\)由3個數字\((a, b, c)\)編碼。	找到的線條的輸出向量。每個向量編碼為 vector<Vec3d> \((votes, rho, theta)\)。'votes' 的值越大，霍夫線的可靠性越高。
lines_max	霍夫線的最大計數。
RANSAC引數。它是點到畫素中對極線的最大距離，超過此距離的點將被視為異常值，不用於計算最終的基本矩陣。它可以設定為1-3左右，具體取決於點定位的精度、影像解析度和影像噪聲。	累加器閾值引數。只返回獲得足夠票數（ \(>\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。