特征检测

详细说明

类
类	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。