特征检测

详细描述

类
类	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算法检测图像边缘 [48]。
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)
	计算角点检测的特征图。

枚举类型文档

HoughModes

枚举 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	基本上是[313]中描述的21HT。
HOUGH_GRADIENT_ALT  Python: cv.HOUGH_GRADIENT_ALT	HOUGH_GRADIENT的变体，以获得更高的精度。

LineSegmentDetectorModes

枚举 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位图像，与image大小相同。
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算法检测图像边缘 [48]。

该函数使用Canny算法查找输入图像中的边缘，并使用输出映射edges在输出映射中标记它们。threshold1和threshold2之间的最小值用于边缘连接。最大值用于查找强边缘的初始段。参见 http://en.wikipedia.org/wiki/Canny_edge_detector

参数

image	8位输入图像。
edges	输出边缘图；单通道8位图像，与image大小相同。
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)，它在一个 blockSize × blockSize 的邻域内计算一个 2×2 的梯度协方差矩阵 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(λ₁, λ₂)。

参数

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>

细化角点位置。

该函数迭代查找角点或径向鞍点的亚像素精确位置，如 [94] 中所述，以及下图所示。

image

亚像素精确角点定位器基于以下观察结果：从中心 q 到位于 q 邻域内的点 p 的每个向量都与 p 处的图像梯度正交，受图像和测量噪声的影响。考虑表达式

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

其中 {DI_pi} 是 q 邻域内其中一个点 p_i 处的图像梯度。要找到 q 的值，以便使 ε_i 最小化。可以建立一个方程组，其中 ε_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) × (5*2+1) = 11 × 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	将用于查找线的图像比例。 Range (0..1]。
sigma_scale	高斯滤波器的 sigma 值。它计算为 sigma = sigma_scale/scale。
quant	梯度范数的量化误差界限。
ang_th	以度为单位的梯度角度容差。
log_eps	检测阈值：-log10(NFA) > log_eps。仅在选择高级细化时使用。
density_th	包围矩形中对齐区域点的最小密度。
n_bins	梯度模量的伪排序中的仓数。

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 类型并且大小与 image 相同），则它指定检测角点的区域。
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>

确定图像上的强角点。

该函数根据 [245] 中的描述，查找图像或指定图像区域中最突出的角点。

• 该函数使用 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	圆圈,
		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]]]]]	) ->	圆圈

#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)
        返回 -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);
    返回 0;
}

注意

该函数通常能够很好地检测圆的中心。但是，它可能无法找到正确的半径。如果您知道半径范围（minRadius 和 maxRadius），可以通过指定半径范围来辅助该函数。或者，对于HOUGH_GRADIENT方法，您可以将maxRadius设置为负数以仅返回中心而不进行半径搜索，并使用附加过程查找正确的半径。

除非图像已经很柔和，否则对其进行一些平滑处理也很有帮助。例如，使用7x7内核和1.5x1.5 sigma的GaussianBlur()或类似的模糊处理可能会有所帮助。

参数

image	8位单通道灰度输入图像。
圆圈	找到的圆的输出向量。每个向量都被编码为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	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>

使用标准霍夫变换在二值图像中查找直线。

该函数实现了用于直线检测的标准或标准多尺度霍夫变换算法。有关霍夫变换的良好解释，请参见http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm。

参数

image	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	对于多尺度霍夫变换，它是距离分辨率rho的除数。粗略的累加器距离分辨率为rho，精确的累加器分辨率为rho/srn。如果srn=0且stn=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	lines,
		double	rho,
		double	theta,
		int	threshold,
		double	minLineLength = 0,
		double	maxLineGap = 0 )

Python
	cv.HoughLinesP(	图像, rho, theta, 阈值[, 线段[, minLineLength[, maxLineGap]]]	) ->	lines

#include <opencv2/imgproc.hpp>

使用概率霍夫变换在二值图像中查找线段。

该函数实现了用于线检测的概率霍夫变换算法，详见 [185]

参见下面的线检测示例

#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)
        返回 -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);
    返回 0;
}

这是一个示例图片，函数参数已针对该图片进行调整。

image

这是概率霍夫变换程序的输出结果。

image

参数

image	8位单通道二值源图像。图像可能会被函数修改。
lines	输出线段向量。每条线段由一个四元素向量\((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	点集,
		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(	点集, lines_max, 阈值, min_rho, max_rho, rho_step, min_theta, max_theta, theta_step[, 线段]	) ->	lines

#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("投票数:%d, rho:%.7f, theta:%.7f\n",(int)line3d.at(0).val[0], line3d.at(0).val[1], line3d.at(0).val[2]);
}

参数

点集	输入点向量。每个向量必须编码为Point向量\((x,y)\)。类型必须为CV_32FC2或CV_32SC2。
lines	输出找到的线段向量。每个向量编码为vector<Vec3d> \((投票数, rho, theta)\)。'投票数'的值越大，霍夫直线的可靠性越高。
lines_max	霍夫直线的最大计数。
threshold	累加器阈值参数。仅返回获得足够投票数（\(>\texttt{threshold}\)）的直线。
min_rho	累加器中\(\rho\)的最小值（注意：\(\rho\)可以为负。绝对值\(|\rho|\)是直线到原点的距离）。
max_rho	累加器中\(\rho\)的最大值。
rho_step	累加器的距离分辨率。
min_theta	累加器中最小角度值（以弧度为单位）。
max_theta	累加器中最大角度值的上限（以弧度为单位）。根据参数min_theta和theta_step，实际最大角度可能略小于max_theta。
theta_step	累加器中角度分辨率（以弧度为单位）。

preCornerDetect()

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

Python
	cv.preCornerDetect(	源图像, ksize[, 目标图像[, 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。