特征检测

详细描述

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