特征检测

详细描述

类
类	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 图像, OutputArray 角点, int 最大角点数, double 质量级别, double 最小距离, InputArray 遮罩, int 块大小, int 梯度大小, bool 使用Harris检测器=false, double k=0.04)
void	cv::goodFeaturesToTrack (InputArray 图像, OutputArray 角点, int 最大角点数, double 质量级别, double 最小距离, InputArray 遮罩, OutputArray 角点质量, int 块大小=3, int 梯度大小=3, bool 使用Harris检测器=false, double k=0.04)
	与上面相同，但还返回检测到的角点的质量度量。
void	cv::goodFeaturesToTrack (InputArray 图像, OutputArray 角点, int 最大角点数, double 质量级别, double 最小距离, InputArray 遮罩=noArray(), int 块大小=3, bool 使用Harris检测器=false, double k=0.04)
	在图像上确定强角点。
void	cv::HoughCircles (InputArray 图像, OutputArray 圆圈, int 方法, double dp, double 最小距离, double param1=100, double param2=100, int 最小半径=0, int 最大半径=0)
	使用Hough变换在灰度图像中找到圆。
void	cv::HoughLines (InputArray 图像, OutputArray 线条, double rho, double theta, int 阈值, double srn=0, double stn=0, double min_theta=0, double max_theta=CV_PI)
	使用标准Hough变换在二值图像中查找线条。
void	cv::HoughLinesP (InputArray 图像, OutputArray 线条, double rho, double theta, int 阈值, double 最小线长=0, double 最大线间隙=0)
	使用概率Hough变换在二值图像中查找线段。
void	cv::HoughLinesPointSet (InputArray 点, OutputArray 线条, int 线条最大数, int 阈值, double 最小rho, double 最大rho, double rho_step, double 最小theta, double 最大theta, double theta_step)
	使用标准Hough变换在点集集合中查找线条。
void	cv::preCornerDetect (InputArray 源, OutputArray 目标, int ksize, int 边界类型=BORDER_DEFAULT)
	计算用于角点检测的特征图。

枚举类型文档

HoughModes

enum cv::HoughModes

#include <opencv2/imgproc.hpp>

Hough变换的变体。

枚举器
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，见 [312]
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>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

使用 Canny 算法在有自定义图像梯度的图像中查找边缘。

参数

dx	输入图像的16位x偏导数（CV_16SC1 或 CV_16SC3）。
dy	输入图像的16位y偏导数（与dx相同类型）。
edges	输出边缘图；具有与图像相同大小的单通道8位图像。
threshold1	梅森过程的第一阈值。
threshold2	梅森过程的第二阈值。
L2梯度	一个标志，指示是否应该使用更精确的 \(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算法在图像中找到边缘 [48] .

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

参数

图像	8 位输入图像。
edges	输出边缘图；具有与图像相同大小的单通道8位图像。
threshold1	梅森过程的第一阈值。
threshold2	梅森过程的第二阈值。
apertureSize	用于 Sobel 操作器的孔径大小。
L2梯度	一个标志，指示是否应该使用更精确的 \(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 检测器响应的图像。它的大小与 src 相同，类型为 CV_32FC1 。
blockSize	Neighborhood size (see the details on 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	Neighborhood size (see the details on 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>

细化角点位置。

该函数通过迭代找到如[95]所述角点或径向鞍点的亚像素准确位置，如下面的图所示。

图像

亚像素级角点定位是基于以下观察：来自中心\(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\)设置为0

\[\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)\]

其中梯度在一个名为“搜索窗口”的邻域内求和。将第一个梯度项称为\(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.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>

在图像上确定强角点。

函数在图像或指定的图像区域内找到最突出的角落，如[244]中所述。

• 函数在每个源图像像素上使用 cornerMinEigenVal 或 cornerHarris 计算拐角质量度量。
• 函数执行非最大抑制（保留3 x 3邻域中的局部最大值）。
• 拐角的最小特征值小于 \(\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\) 被拒绝。
• 剩余拐角按质量度量降序排序。
• 函数丢弃距离小于maxDistance的每个比邻拐角更强的拐角。

该函数可用于初始化对象的基于点的跟踪器。

注意

如果以参数质量的A和B的不同值调用函数，并且A > B，那么具有质量水平=A的返回拐角矢量将是具有质量水平=B的输出矢量的前缀。

参数

图像	输入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	图像,
		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变换在灰度图像中找到圆。

该函数使用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);
    // smooth it, otherwise a lot of false circles may be detected
    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标准差的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
	)

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

#include <opencv2/imgproc.hpp>

使用标准Hough变换在二值图像中查找线条。

该函数实现了标准或标准多尺度的霍夫变换算法进行线检测。有关霍夫变换的详细解释，请参阅http://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{vertical line}, \pi/2 \sim \textrm{horizontal line}\)），而\votes\)是累加器的值。
rho	累加器的像素距离分辨率。
theta	累加器角度分辨率（以弧度为单位）。
threshold	累加器阈值参数。只有获得足够投票（ \(>\texttt{threshold}\)）的线条才会被返回。
srn	对于多尺度霍夫变换，它是距离分辨率\rho\)的除数。粗糙累加器距离分辨率为\rho\)，准确累加器分辨率为\rho/srn\)。如果\rn=0且\rn=0，则使用经典霍夫变换。否则，这两个参数都应为正数。
stn	对于多尺度霍夫变换，它是角度分辨率\theta\)的除数。
min_theta	对于标准和多尺度霍夫变换，检查线的最小角度。必须在0和max_theta之间。
max_theta	对于标准和多尺度霍夫变换，角度的上限。必须在min_theta和CV_PI之间。实际累加器中的最大角度可能略小于max_theta，具体取决于min_theta和\theta\)的参数。

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变换在二值图像中查找线段。

该函数实现了用于线检测的概率霍夫变换算法，如< retrieves> [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)
        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;
}

这个示例图片的函数参数已经调整过

图像

这是上述程序在概率霍夫变换情况下的输出

图像

参数

图像	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	输入点向量。每个向量必须编码为点向量 \((x,y)\)。类型必须是 CV_32FC2 或 CV_32SC2。
lines	找到的线向量。每个向量编码为向量 < 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 不受支持。