OpenCV（十八）霍夫变换（直线、线段与圆检测）

一、基础理论霍夫变换(Hough Transform)是图像处理中的一种特征提取技术，它通过一种投票算法检测具有特定形状的物体。Hough变换是图像处理中从图像中识别几何形状的基本方法之一。Hough变换的基本原理在于利用点与线的对偶性，将原始图像空间的给定的曲线通过曲线表达形式变为参数空间的一个点。这样就把原始图像中给定曲线的检测问题转化为寻找参数空间中的峰值问题。也即把检测整体特性转化为检测局

文章共7,500字 · 阅读需要大约26分钟

一键AI生成摘要，助你高效阅读

问答

_睿智_

12894人浏览 · 2021-08-16 11:47:24

_睿智_ · 2021-08-16 11:47:24 发布

3、HoughLinesP函数（线段检测）

一、基础理论

1、作用：

提取直线和圆等几何形状。

2、定义

霍夫变换(Hough Transform)是图像处理中的一种特征提取技术，它通过一种投票算法检测具有特定形状的物体。Hough变换是图像处理中从图像中识别几何形状的基本方法之一。Hough变换的基本原理在于利用点与线的对偶性，将原始图像空间的给定的曲线通过曲线表达形式变为参数空间的一个点。这样就把原始图像中给定曲线的检测问题转化为寻找参数空间中的峰值问题。也即把检测整体特性转化为检测局部特性。比如直线、椭圆、圆、弧线等。

原则上霍夫变换可以检测任何形状，但复杂的形状需要的参数就多，霍夫空间的维数就多，因此在程序实现上所需的内存空间以及运行效率上都不利于把标准霍夫变换应用于实际复杂图形的检测中。霍夫梯度法是霍夫变换的改进（圆检测），它的目的是减小霍夫空间的维度，提高效率。

3、原理

直线检测原理：将要检测的对象转到霍夫空间中，利用累加器找到最优解，即为所求直线。

（注：检测前要对图像二值化处理）

圆检检测原理：霍夫梯度法，找到达到阈值的原点和半径。

两个点决定直线的斜率和截距情况：

三个点决定直线斜率和截距情况：

极坐标系：

求出了“极坐标”空间下相交的点，自然也就可以用哪个 $\rho$ 和 $\theta$ 求出直线的三个点坐标。

得到曲线：采用不同的 $\theta$ 遍历 $\rho$ 值

使用累加器检测直线：

累加器是一个二维数组。

二、直线检测

1、基础理论

霍夫变换 (Hough Line Transform) 是图像处理中的一种特征提取技术. 通过平面空间到极值坐标空间的转换, 可以帮助我们实现直线检测

1、原理

1、首先边缘检测，得到许多点

2、遍历第一个点的各个 $\theta$ 方向的 $\rho$ ，得到第一个点的曲线

3、遍历每一个点，得到多条曲线

4、多曲线相交，就是最终的 $\rho$ 和 $\theta$ ，通过它可以确定最终直线

（左：笛卡尔坐标系右：霍夫空间）

2、过程

1、首先边缘检测，得到许多点

2、遍历第一个点的各个 $\theta$ 方向的 $\rho$ ，得到第一个点的曲线

3、遍历每一个点，得到多条曲线

4、多曲线相交，就是最终的 $\rho$ 和 $\theta$ ，通过它可以确定最终直线

2、HoughLines函数（直线检测）

HoughLines函数：
void HoughLines(InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0 )  
第一个参数，InputArray类型的image，输入图像，即源图像，需为8位的单通道二进制图像，可以将任意的源图载入进来后由函数修改成此格式后，再填在这里。
第二个参数，InputArray类型的lines，经过调用HoughLines函数后储存了霍夫线变换检测到线条的输出矢量。每一条线由具有两个元素的矢量表示，其中，是离坐标原点((0,0)（也就是图像的左上角）的距离。是弧度线条旋转角度（0~垂直线，π/2~水平线）。
第三个参数，double类型的rho，以像素为单位的距离精度。另一种形容方式是直线搜索时的进步尺寸的单位半径。PS:Latex中/rho就表示。
第四个参数，double类型的theta，以弧度为单位的角度精度。另一种形容方式是直线搜索时的进步尺寸的单位角度。
第五个参数，int类型的threshold，累加平面的阈值参数，即识别某部分为图中的一条直线时它在累加平面中必须达到的值。大于阈值threshold的线段才可以被检测通过并返回到结果中。
第六个参数，double类型的srn，有默认值0。对于多尺度的霍夫变换，这是第三个参数进步尺寸rho的除数距离。粗略的累加器进步尺寸直接是第三个参数rho，而精确的累加器进步尺寸为rho/srn。
第七个参数，double类型的stn，有默认值0，对于多尺度霍夫变换，srn表示第四个参数进步尺寸的单位角度theta的除数距离。且如果srn和stn同时为0，就表示使用经典的霍夫变换。否则，这两个参数应该都为正数。
HoughLines(dst, lines, 1,                       CV_PI / 180,        150);
    //                距离精度(像素)           角度精度(弧度)     累加平面阈值  

//霍夫直线检测
void Hough_Line()
{
    //1、边缘检测
    Canny(src, dst, 50, 200, 3);
    imshow("canny edge", dst);

    //2、霍夫变换
    vector<Vec2f> lines;        //定义一个矢量结构lines用于存放得到的线段矢量集合  
    HoughLines(dst, lines, 1, CV_PI / 180, 150);
    //                                  距离精度(像素)   角度精度(弧度)     累加平面阈值  

    //3、依次绘制每条线段
    for (size_t i = 0; i < lines.size(); i++)
    {
        float rho = lines[i][0], theta = lines[i][1];    //距离精度、角度精度
        Point pt1, pt2;                                  //定义两点p1和p2
        double a = cos(theta), b = sin(theta);           //a:cos  b:sin
        //以x0和y0作为参照点，求出(x1, y1)和(x2, y2)
        double x0 = a * rho, y0 = b * rho;
        pt1.x = cvRound(x0 - 1000 * (-b));
        pt1.y = cvRound(y0 - 1000 * (a));
        pt2.x = cvRound(x0 + 1000 * (-b));
        pt2.y = cvRound(y0 + 1000 * (a));
        line(dst, pt1, pt2, Scalar(200, 0, 0), 3);       //绘制直线
    }
    imshow("Hough", dst);
}

3、HoughLinesP函数（线段检测）

HoughLinesP函数：

此函数在HoughLines的基础上末尾加了一个代表Probabilistic（概率）的P，表明它可以采用累计概率霍夫变换（PPHT）来找出二值图像中的线段。
void HoughLinesP(InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0 )  
第一个参数，InputArray类型的image，输入图像，即源图像，需为8位的单通道二进制图像，可以将任意的源图载入进来后由函数修改成此格式后，再填在这里。
第二个参数，InputArray类型的lines，经过调用HoughLinesP函数后后存储了检测到的线条的输出矢量，每一条线由具有四个元素的矢量(x_1,y_1, x_2, y_2）表示，其中，(x_1, y_1)和(x_2, y_2) 是是每个检测到的线段的结束点。
第三个参数，double类型的rho，以像素为单位的距离精度。另一种形容方式是直线搜索时的进步尺寸的单位半径。
第四个参数，double类型的theta，以弧度为单位的角度精度。另一种形容方式是直线搜索时的进步尺寸的单位角度。
第五个参数，int类型的threshold，累加平面的阈值参数，即识别某部分为图中的一条直线时它在累加平面中必须达到的值。大于阈值threshold的线段才可以被检测通过并返回到结果中。
第六个参数，double类型的minLineLength，有默认值0，表示最低线段的长度，比这个设定参数短的线段就不能被显现出来。
第七个参数，double类型的maxLineGap，有默认值0，允许将同一行点与点之间连接起来的最大的距离。
HoughLinesP(dst, lines, 1,                      CV_PI / 180,        80,                 50,                 10);
    //                  距离精度(像素)          角度精度(弧度)     累加平面阈值         最低线段长度  同一行点与点连接的最大距离

//霍夫线段检测
void Hough_LineP()
{
    //1、边缘检测
    Canny(src, dst, 50, 200, 3);
    imshow("canny edge", dst);

    //2、霍夫变换
    vector<Vec4i> lines;        //定义一个矢量结构lines用于存放得到的线段矢量集合  
    HoughLinesP(dst, lines, 1,                      CV_PI / 180,        80,                 50,                 10);
    //                      距离精度(像素)         角度精度(弧度)     累加平面阈值  最低线段长度  同一行点与点连接的最大距离

    //3、依次绘制每条线段
    for (size_t i = 0; i < lines.size(); i++)
    {
        Vec4i l = lines[i];
        line(dst, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(255, 0, 0), 3);
    }
    imshow("Hough", dst);
}

三、圆检测

1、基础理论

1、概念

霍夫圆变换 (Hough Circle Transform) 的原理和霍夫直线变换类似. 对于一条直线, 我们可以用参数表示, 对于圆我们需要三个参数，分别代表三个参数 圆心(x, y), r半径。（也叫霍夫梯度法）

因为霍夫圆检测对噪声比较敏感, 所以首先要对图像做中值滤波。

2、原理

霍夫变换圆检测是基于图像梯度实现：

圆心检测的原理︰圆心是圆周法线的交汇处，设置一个阈值，在某点的相交的直线的条数大于这个阈值就认为该交汇点为圆心。
圆半径确定原理：圆心到圆周上的距离〔半径）是相同的，设置一个阈值，只要相同距离的数量大于该阈值，就认为该距离是该圆心的半径。

（霍夫圆检测里面包含有canny边缘检测）

2、HoughCircles函数

C++ API：

void HoughCircles(InputArray image,OutputArray circles, int method, double dp, double minDist, double param1=100,double param2=100, int minRadius=0, int maxRadius=0 )  
第一个参数，InputArray类型的image，输入图像，即源图像，需为8位的灰度单通道图像。
第二个参数，InputArray类型的circles，经过调用HoughCircles函数后此参数存储了检测到的圆的输出矢量，每个矢量由包含了3个元素的浮点矢量(x, y, radius)表示。
第三个参数，int类型的method，即使用的检测方法，目前OpenCV中就霍夫梯度法一种可以使用，它的标识符为CV_HOUGH_GRADIENT，在此参数处填这个标识符即可。
第四个参数，double类型的dp，用来检测圆心的累加器图像的分辨率于输入图像之比的倒数，且此参数允许创建一个比输入图像分辨率低的累加器。上述文字不好理解的话，来看例子吧。例如，如果dp= 1时，累加器和输入图像具有相同的分辨率。如果dp=2，累加器便有输入图像一半那么大的宽度和高度。
第五个参数，double类型的minDist，为霍夫变换检测到的圆的圆心之间的最小距离，即让我们的算法能明显区分的两个不同圆之间的最小距离。这个参数如果太小的话，多个相邻的圆可能被错误地检测成了一个重合的圆。反之，这个参数设置太大的话，某些圆就不能被检测出来了。
第六个参数，double类型的param1，有默认值100。它是第三个参数method设置的检测方法的对应的参数。对当前唯一的方法霍夫梯度法CV_HOUGH_GRADIENT，它表示传递给canny边缘检测算子的高阈值，而低阈值为高阈值的一半。
第七个参数，double类型的param2，也有默认值100。它是第三个参数method设置的检测方法的对应的参数。对当前唯一的方法霍夫梯度法CV_HOUGH_GRADIENT，它表示在检测阶段圆心的累加器阈值。它越小的话，就可以检测到更多根本不存在的圆，而它越大的话，能通过检测的圆就更加接近完美的圆形了。
第八个参数，int类型的minRadius,有默认值0，表示圆半径的最小值。
第九个参数，int类型的maxRadius,也有默认值0，表示圆半径的最大值。
HoughCircles(dst, circles, HOUGH_GRADIENT, 1.5, 10,                     200, 100,               0,  0);
    //                     霍夫梯度法       dp  圆心间最小距离          高阈值  累加阈值    圆半径最小、最大值      

python API：

def HoughCircles(image: Any,
                 method: Any,
                 dp: Any,
                 minDist: Any,
                 circles: Any = None,
                 param1: Any = None,
                 param2: Any = None,
                 minRadius: Any = None,
                 maxRadius: Any = None) -> None
参数：

第二个参数，int类型的method，即使用的检测方法，目前OpenCV中就霍夫梯度法一种可以使用，它的标识符为CV_HOUGH_GRADIENT，在此参数处填这个标识符即可。
第三个参数，double类型的dp，用来检测圆心的累加器图像的分辨率于输入图像之比的倒数，且此参数允许创建一个比输入图像分辨率低的累加器。上述文字不好理解的话，来看例子吧。例如，如果dp= 1时，累加器和输入图像具有相同的分辨率。如果dp=2，累加器便有输入图像一半那么大的宽度和高度。
第四个参数，double类型的minDist，为霍夫变换检测到的圆的圆心之间的最小距离，即让我们的算法能明显区分的两个不同圆之间的最小距离。这个参数如果太小的话，多个相邻的圆可能被错误地检测成了一个重合的圆。反之，这个参数设置太大的话，某些圆就不能被检测出来了。
第五个参数，InputArray类型的circles，经过调用HoughCircles函数后此参数存储了检测到的圆的输出矢量，每个矢量由包含了3个元素的浮点矢量(x, y, radius)表示。
第六个参数，double类型的param1，有默认值100。它是第三个参数method设置的检测方法的对应的参数。对当前唯一的方法霍夫梯度法CV_HOUGH_GRADIENT，它表示传递给canny边缘检测算子的高阈值，而低阈值为高阈值的一半。
第七个参数，double类型的param2，也有默认值100。它是第三个参数method设置的检测方法的对应的参数。对当前唯一的方法霍夫梯度法CV_HOUGH_GRADIENT，它表示在检测阶段圆心的累加器阈值。它越小的话，就可以检测到更多根本不存在的圆，而它越大的话，能通过检测的圆就更加接近完美的圆形了。
第八个参数，int类型的minRadius,有默认值0，表示圆半径的最小值。
第九个参数，int类型的maxRadius,也有默认值0，表示圆半径的最大值。

//霍夫圆检测
void Hough_Circle()
{
    //1、转化为灰度图并图像平滑
    cvtColor(src, gray, COLOR_BGR2GRAY);
    GaussianBlur(gray, dst, Size(9, 9), 2, 2);
    imshow("滤波", dst);
    
    //2、霍夫圆变换（用灰度图）
    vector<Vec3f> circles;
    HoughCircles(dst, circles, HOUGH_GRADIENT, 1.5, 10,                     200, 100,               0,  0);
    //                         霍夫梯度法      dp  圆心间最小距离           高阈值  累加阈值    圆半径最小、最大值      

    //3、依次在图中绘制出圆 
    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(src, center, 3, Scalar(0, 255, 255), -1);
        //绘制圆轮廓  
        circle(src, center, radius, Scalar(0, 255, 255), 3);
    }
    imshow("Hough", src);
}

最佳地匹配每个图像，参数不一样

HoughCircles(dst, circles, HOUGH_GRADIENT, 1.5, 10, 50,    100, 0, 0);

HoughCircles(dst, circles, HOUGH_GRADIENT, 1.5, 10, 200, 100, 0, 0);

总代码

//霍夫变换（直线和圆检测）
#include <opencv2/opencv.hpp>  
#include <opencv2/imgproc/imgproc.hpp>  
#include<vector>

using namespace cv;
using namespace std;

Mat src, dst, gray;

//霍夫直线检测（不推荐）
void Hough_Line()
{
    //1、边缘检测
    Canny(src, dst, 50, 200, 3);
    imshow("canny edge", dst);

    //2、霍夫变换
    vector<Vec2f> lines;        //定义一个矢量结构lines用于存放得到的线段矢量集合  
    HoughLines(dst, lines, 1, CV_PI / 180, 150);
    //                                  距离精度(像素)   角度精度(弧度)     累加平面阈值  

    //3、依次绘制每条线段
    for (size_t i = 0; i < lines.size(); i++)
    {
        float rho = lines[i][0], theta = lines[i][1];       //距离精度、角度精度
        Point pt1, pt2;                                               //定义两点p1和p2
        double a = cos(theta), b = sin(theta);           //a:cos  b:sin
        //以x0和y0作为参照点，求出(x1, y1)和(x2, y2)
        double x0 = a * rho, y0 = b * rho;
        pt1.x = cvRound(x0 - 1000 * (-b));
        pt1.y = cvRound(y0 - 1000 * (a));
        pt2.x = cvRound(x0 + 1000 * (-b));
        pt2.y = cvRound(y0 + 1000 * (a));
        line(dst, pt1, pt2, Scalar(200, 0, 0), 3);          //绘制直线
    }
    imshow("Hough", dst);
}


//霍夫线段检测（推荐）
void Hough_LineP()
{
    //1、边缘检测
    Canny(src, dst, 50, 200, 3);
    imshow("canny edge", dst);
    //2、霍夫变换
    vector<Vec4i> lines;        //定义一个矢量结构lines用于存放得到的线段矢量集合  
    HoughLinesP(dst, lines, 1, CV_PI / 180, 80, 100, 10);
    //                                  距离精度(像素)   角度精度(弧度)     累加平面阈值  最低线段长度  同一行点与点连接的最大距离

    //3、依次绘制每条线段
    for (size_t i = 0; i < lines.size(); i++)
    {
        Vec4i l = lines[i];
        line(dst, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(255, 0, 0), 3);
    }
    imshow("Hough", dst);
}


//霍夫圆检测
void Hough_Circle()
{
    //1、转化为灰度图并图像平滑
    cvtColor(src, gray, COLOR_BGR2GRAY);
    GaussianBlur(gray, dst, Size(9, 9), 2, 2);
    imshow("滤波", dst);

    //2、霍夫圆变换（用灰度图）
    vector<Vec3f> circles;
    HoughCircles(dst, circles, HOUGH_GRADIENT, 1.5, 10, 50, 100, 0, 0);
    //                                      霍夫梯度法                 dp  圆心间最小距离   高阈值  累加阈值    圆半径最小、最大值      
    //HoughCircles(dst, circles, HOUGH_GRADIENT, 1.5, 10, 200, 100, 0, 0);

    //3、依次在图中绘制出圆 
    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(src, center, 3, Scalar(0, 0, 255), -1);
        //绘制圆轮廓  
        circle(src, center, radius, Scalar(0, 0, 255), 3);
    }
    imshow("Hough", src);
}

int main()
{
    src = imread("Resource/4.jpg");
    imshow("原图", src);

    Hough_Line();                   //霍夫直线检测

    Hough_LineP();                   //霍夫线段检测

    Hough_Circle();                 //霍夫圆检测

    waitKey(0);

    return 0;
}