精华内容
下载资源
问答
  • houghlines

    2020-10-27 09:08:30
    lines = houghlines(BW,theta,rho,peaks) lines = houghlines(___,Name,Value) Description lines = houghlines(BW,theta,rho,peaks) 提取图像 BW 中与 Hough 变换中的特定 bin 相关联的线段。theta 和 rho 是函数 ...


    基于 Hough 变换提取线段

    Syntax

    lines = houghlines(BW,theta,rho,peaks)
    lines = houghlines(___,Name,Value)
    

    Description

    lines = houghlines(BW,theta,rho,peaks) 提取图像 BW 中与 Hough 变换中的特定 bin 相关联的线段。theta 和 rho 是函数 hough 返回的向量。peaks 是由 houghpeaks 函数返回的矩阵,其中包含 Hough 变换 bin 的行和列坐标,用于搜索线段。返回值 lines 包含有关提取的线段的信息。
    
    lines = houghlines(___,Name,Value) 使用名称-值对组参数来控制线条提取的各个方面。
    

    Examples

    查找线段并突出显示最长的线段

    clear all
    close all
    clc
    I  = imread('circuit.tif');
    %旋转图像。
    rotI = imrotate(I,33,'crop');
    %创建二值图像。
    BW = edge(rotI,'canny');
    %使用二值图像创建 Hough 变换。
    [H,T,R] = hough(BW);
    imshow(H,[],'XData',T,'YData',R,...
                'InitialMagnification','fit');
    xlabel('\theta'), ylabel('\rho');
    axis on, axis normal, hold on;
    %查找图像的 Hough 变换中的峰值。
    P  = houghpeaks(H,5,'threshold',ceil(0.3*max(H(:))));
    x = T(P(:,2)); y = R(P(:,1));
    plot(x,y,'s','color','white');
    %查找线条并对其绘图。
    lines = houghlines(BW,T,R,P,'FillGap',5,'MinLength',7);
    figure, imshow(rotI), hold on
    max_len = 0;
    for k = 1:length(lines)
       xy = [lines(k).point1; lines(k).point2];
       plot(xy(:,1),xy(:,2),'LineWidth',2,'Color','green');
    
       % Plot beginnings and ends of lines
       plot(xy(1,1),xy(1,2),'x','LineWidth',2,'Color','yellow');
       plot(xy(2,1),xy(2,2),'x','LineWidth',2,'Color','red');
    
       % Determine the endpoints of the longest line segment
       len = norm(lines(k).point1 - lines(k).point2);
       if ( len > max_len)
          max_len = len;
          xy_long = xy;
       end
    end
    %将最长的线段设为青色以突出显示。
    plot(xy_long(:,1),xy_long(:,2),'LineWidth',2,'Color','cyan');
    

    输入参数

    BW - 二值图像
    二维逻辑矩阵 | 二维数值矩阵
    二值图像,指定为二维逻辑矩阵或二维数值矩阵。对于数值输入,任何非零像素都被视为 1 (true)。

    theta - 线条旋转角度
    数值矩阵
    线条旋转角度,以度为单位,指定为数值矩阵。角度是在 x 轴和 rho 向量之间测量的角度。

    rho - 从原点到线条的距离
    数值矩阵
    距坐标原点的距离,指定为数值矩阵。坐标原点是图像的左上角 (0,0)。

    peaks - Hough 变换 bin 的行和列坐标
    数值矩阵
    Hough 变换 bin 的行和列坐标,指定为数值矩阵。

    名称-值对组参数
    ‘FillGap’ - 与同一 Hough 变换 bin 相关联的两个线段之间的距离
    20 (默认) | 正数
    与同一个 Hough 变换 bin 相关联的两个线段之间的距离,指定为正数。当线段之间的距离小于指定值时,houghlines 函数会将这些线段合并为一条线段。

    ‘MinLength’ - 最小线条长度
    40 (默认) | 正数
    最小线条长度,指定为正数。houghlines 丢弃短于指定值的线条。

    输出参数

    lines - 检测到的线条
    结构体数组
    检测到的线条,以结构体数组形式返回,其长度等于找到的合并线段数。结构体数组的每个元素都有以下字段:

    字段说明
    point1指定线段端点坐标的二元素向量 [X Y]
    point2指定线段端点坐标的二元素向量 [X Y]
    thetaHough 变换 bin 的角度(以度为单位)
    rhoHough 变换 bin 的 rho 轴位置
    展开全文
  • 标准霍夫变换HoughLines

    2018-09-23 22:28:18
    本示例是《OpenCV3编程入门》中7.2.4的示例程序标准霍夫变换HoughLines的C# EMGU 3.4.1版。
  • 霍尔霍夫检测直线、圆
  • OpenCV霍夫直线houghlines点集的实例OpenCV霍夫直线houghlines点集的实例 OpenCV霍夫直线houghlines点集的实例 #include <opencv2/core.hpp> #include <opencv2/imgproc.hpp> using namespace cv; using...

    OpenCV霍夫直线houghlines点集的实例

    OpenCV霍夫直线houghlines点集的实例

    #include <opencv2/core.hpp>
    #include <opencv2/imgproc.hpp>
    using namespace cv;
    using namespace std;
    int main(
    展开全文
  • 标准HoughLines()变换

    千次阅读 2019-05-17 16:33:14
    void cv::HoughLines (InputArray image, //8位,单通道二值源图像。该函数可以修改图像。 OutputArray lines,//输出直线vector(ρ,θ) or (ρ,θ,votes) //ρ是距坐标原点的距离, //θ是以弧...

     C++ API说明

    void cv::HoughLines	(InputArray image, //8位,单通道二值源图像。该函数可以修改图像。
        OutputArray lines,//输出直线vector(ρ,θ) or (ρ,θ,votes) 
                          //ρ是距坐标原点的距离, 
                          //θ是以弧度表示的线旋转角度(0∼垂直直线,π/2∼水平直线) 
                          //votes 曲线交点累加计数
        double 	rho, //以像素为单位的累加器的距离分辨率。 推荐用1.0;
        double 	theta, //以弧度表示的累加器角度分辨率。 CV_PI/180
        int 	threshold, //累加计数大于此阈值才返回 累加平面的阈值参数,int类型,超过设定阈值才被检测出线段,值越大,基本上意味着检出的线段越长,检出的线段个数越少。根据情况推荐先用100试试;
        double 	srn = 0,
        double 	stn = 0,
        double 	min_theta = 0, //检查线条的最小角度。必须介于0和maxθ之间。
        double 	max_theta = CV_PI  //要检查线条的最大角度。必须介于minθ和CV_PI之间。
        )		
    
    Parameters
    image	8-bit, single-channel binary source image. The image may be modified by the function.
    lines	Output vector of lines. Each line is represented by a 2 or 3 element vector (ρ,θ) or (ρ,θ,votes) . ρ is the distance from the coordinate origin (0,0) (top-left corner of the image). θ is the line rotation angle in radians ( 0∼vertical line,π/2∼horizontal line ). votes is the value of accumulator.
    rho	Distance resolution of the accumulator in pixels.
    theta	Angle resolution of the accumulator in radians.
    threshold	Accumulator threshold parameter. Only those lines are returned that get enough votes ( >threshold ).
    srn	For the multi-scale Hough transform, it is a divisor for the distance resolution rho . The coarse accumulator distance resolution is rho and the accurate accumulator resolution is rho/srn . If both srn=0 and stn=0 , the classical Hough transform is used. Otherwise, both these parameters should be positive.
    stn	For the multi-scale Hough transform, it is a divisor for the distance resolution theta.
    min_theta	For standard and multi-scale Hough transform, minimum angle to check for lines. Must fall between 0 and max_theta.
    max_theta	For standard and multi-scale Hough transform, maximum angle to check for lines. Must fall between min_theta and CV_PI.

          函数输入为一幅二值图像(有很多待检测点),其中一些点排列后形成直线,通常这是一幅边缘图像,比如来自Sobel算子或Canny算子。函数的输出是cv::Vec2f的向量,每个元素都是一对代表检测到的直线的浮点数(ρ, θ)。函数的作法是先求出原图像中每点的极坐标方程,若相交于一点的极坐标曲线的个数大于最小投票数,则将该点(ρ, θ)(参数坐标系点)放入输出向量。 

    	Mat src = imread("1.png", IMREAD_COLOR);
    
    	Mat canny;
    	Canny(src, canny, 100, 250); 
    	imshow("canny", canny);
    
    	vector<Vec2f> lines;
    	HoughLines(canny, lines, 1.0, CV_PI / 180, 102, 0, 0, 0,0.1); //垂直直线
        //依次在图中绘制出每条线段
    	for (size_t i = 0; i < lines.size(); i++)
    	{
    		float rho = lines[i][0], theta = lines[i][1];
    		Point pt1, pt2;
    		double a = cos(theta), b = sin(theta);
    		double x0 = a*rho, y0 = b*rho;
    		pt1.x = cvRound(x0 + 2000 * (-b));  //把浮点数转化成整数
    		pt1.y = cvRound(y0 + 2000 * (a));
    		pt2.x = cvRound(x0 - 2000 * (-b));
    		pt2.y = cvRound(y0 - 2000 * (a));
    		line(src, pt1, pt2, Scalar(255), 1, CV_AA);
    	}
    
    	imshow("src", src);
    HoughLines(canny, lines, 1.0, CV_PI / 180, 102, 0, 0, 0,0.1); //垂直直线
    102 最大为矩形高度,超过该值后直线检测不到

     HoughLines(canny, lines, 1.0, CV_PI / 180, 30, 0, 0, 0,0.1); //垂直直线
     30 将检测到许多直线

    HoughLines(canny, lines, 1.0, CV_PI / 180, 30, 0, 0, CV_PI / 2, CV_PI);
    30 检测到许多直线
    CV_PI / 2, CV_PI 直线90到180

    HoughLines(canny, lines, 1.0, CV_PI / 180, 120, 0, 0, CV_PI / 2, CV_PI);
    120 返回累加器数目大于该值的值
    CV_PI / 2, CV_PI 直线90到180

    HoughLines(canny, lines, 1.0, CV_PI / 18, 120, 0, 0, CV_PI / 2, CV_PI);
    CV_PI / 18 该参数调整没发现影响检测结果

     HoughLines(canny, lines, 1.0, CV_PI / 180, 120, 0, 0, CV_PI / 2, CV_PI);
    1.0 5.0 10.0 改变后对检测结果影响很大
    

                

    代码中两个点为什么要乘以2000 

     

    原理:直线的斜率不变

    在图片上画直线需要两个点(x1, y1)和(x2, y2)(平面中两个点可以确定一条直线)
     

    (你也可以乘以(10、1500等) 

    假设x1 - x0 = 1000(-sinθ),那么x1 = x0 + 1000(-sinθ)

    假设y1 - y0 = 1000(cosθ),那么y1 = y0 + 1000(cosθ)

    同理可得x2 = x0 - 1000(-sinθ),y2 = y0 - 1000(cosθ)

     参考:

    https://www.cnblogs.com/long5683/p/9678386.html 

    https://blog.csdn.net/m0_37350758/article/details/82077990

    https://blog.csdn.net/yl_best/article/details/88744997 

    https://blog.csdn.net/qq_39384184/article/details/82944280

    展开全文
  • while (true) { if (hough_mode == true) { //霍夫变换检测直线 cv::HoughLines(img_c, lines, 1, 0.3*CV_PI / 180, 230, 0, 0); //画出直线 for (size_t i = 0; i (); ++i) { float rho = lines[i][0], theta = ...

    环境

    vs2019,Opencv4.0

    效果

    在这里插入图片描述

    函数原型

    在这里插入图片描述
    image:输入图像,必须是单通道二进制图像,比如Canny边缘检测后的输出图像。
    lines:检测到的直线,一般类型为std::vector<cv::Vec2f>
    rho: 累加器的距离分辨率(以像素为单位)。
    theta:以弧度为单位的累加器的角度分辨率。
    threshold:累加器阈值
    srn:0
    stn:0
    min_theta:线条的最小角度
    max_theta:线条最大角度,默认为PI

    示例代码

    
    #include <iostream>
    #include <opencv2/opencv.hpp>
    #include <opencv2/highgui.hpp>
    #include <opencv2/imgproc.hpp>
    #include <opencv2/videoio.hpp>
    #include <opencv2/core/cuda.hpp>
    #include<sstream>
    
    
    int main(int argc, char* argv[])
    {
    
        cv::Mat img, img_clone, img_g, img_c;
        img = cv::imread("E:\\Comm\\demo\\22.jpeg", 1);
        img_clone = img.clone();
        cv::cvtColor(img, img_g, cv::COLOR_BGR2GRAY); //灰度图像
        cv::Canny(img_g, img_c, 100, 300, 3, false);
    
      
        cv::namedWindow("example", 1); //创建一个窗口用于显示图像,1代表窗口适应图像的分辨率进行拉伸。
        cv::namedWindow("hough", 1); //创建一个窗口用于显示图像,1代表窗口适应图像的分辨率进行拉伸。
        cv::namedWindow("houghP", 1); //创建一个窗口用于显示图像,1代表窗口适应图像的分辨率进行拉伸。
    
        std::vector<cv::Vec2f> lines; //储存霍夫变换的线
        std::vector<cv::Vec4i> linesP; //渐进概率霍夫变换
    
        bool hough_mode = true;
        bool houghp_mode = true;
        while (true)
        {
            if (hough_mode == true)
            {
                //霍夫变换检测直线
                cv::HoughLines(img_c, lines, 1, 0.3*CV_PI / 180, 230, 0, 0);
    
                //画出直线
                for (size_t i = 0; i < lines.size(); ++i)
                {
                    float rho = lines[i][0], theta = lines[i][1];
                    cv::Point pt1, pt2;
                    double a = cos(theta), b = sin(theta);
                    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));
                    cv::line(img, pt1, pt2, cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
                }
    
                if (img.empty() == false) //图像不为空则显示图像
                {
                    cv::imshow("example", img_c);
                    cv::imshow("hough", img);
                }
            }
    
            if (houghp_mode == true)
            {
                //渐进概率霍夫变换
                cv::HoughLinesP(img_c, linesP, 3, 0.3*CV_PI / 180, 230, 20, 10);
                
                for (size_t i = 0; i < linesP.size(); i++)
                {
                    //取出检测到的线段,从起点到终点(x0, y0, x1, y1)
                    cv::Vec4i l = linesP[i]; 
                    //画出线段
                    cv::line(img_clone, cv::Point(l[0], l[1]), cv::Point(l[2], l[3]), cv::Scalar(0, 0, 255), 1, cv::LINE_AA);
                }
    
                if (img_clone.empty() == false) //图像不为空则显示图像
                {
                    if(hough_mode == false) cv::imshow("example", img_c);
                    cv::imshow("houghP", img_clone);
                }
            }
    
           
    
            
            int  key = cv::waitKey(30); //等待30ms
            if (key ==  int('q')) //按下q退出
            {
                break;
            }
    
        }
        cv::destroyAllWindows(); //关闭所有窗口
            
        return 0;
    
    }
    
    

    两种检测方法,第二种检测方法的速度更快,但是会有一定的精度损失。

    展开全文
  • python opencv houghlines()过程出错 ![图片说明](https://img-ask.csdn.net/upload/202002/19/1582052121_341223.jpg) 我写的跟书本一样 后面也一样 但是出错了 ![图片说明]...
  • 此函数在HoughLines的基础上末尾加了一个代表Probabilistic(概率)的P,表明它可以采用累计概率霍夫变换(PPHT)来找出二值图像中的直线。 void HoughLinesP(InputArray image, OutputArray lines, double rho, ...
  • 霍夫变换(Hough Transform )HoughLines 和HoughLinesP 有什么不同? 一、背景 1. HoughLines定义 OpenCV 提供了函数 cv2.HoughLines()用来实现霍夫直线变换,该函数要求所操作的源图像是一个二值图像,所以在...
  • houghlines.cpp

    2021-08-16 15:52:56
    霍夫直线/圆检测OpenCV中源码
  • void cv::HoughLines (InputArray image, // 必须为单通道8位二进制图像 OutputArray lines, // 类型:vector<Vec2f> 表示形式为(ro,theta) double rho, // 生成极坐标时像素的扫描步长,...
  • OpenCV学习笔记(十三):霍夫变换:HoughLines(),HoughLinesP(),HoughCircles( ) 1、霍夫线变换 OpenCV支持三种不同的霍夫线变换,它们分别是: 1)标准霍夫变换(Standard Hough Transform,SHT) 2)多尺度霍夫...
  • HoughLines(midImage, lines, 1, CV_PI / 180, 150, 0, 0); for (size_t i = 0; i (); i++) { float rho = lines[i][0], theta = lines[i][1]; Point pt1,pt2; double a = cos(theta), b = sin(theta); double x0 =...
  • void HoughLines(InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0 ) 参数: image:边缘检测的输出图像. 它应该是个灰度图 (但事实上是个二值化图) lines...
  • HoughLines 函数

    千次阅读 2015-08-26 17:16:59
    使用OpenCV的以下函数 HoughLines 和 HoughLinesP 来检测图像中的直线. 原理 Note   以下原理的说明来自书籍 学习OpenCV 作者Bradski和Kaehler. 霍夫线变换 霍夫线变换是一种用来...
  • HoughLines霍夫变换实现

    2021-06-14 20:20:11
    原理: 实现: void hough(Mat& edge, vector<Vec2f>& lines, int threshold) { Mat H = Mat::zeros(2 * edge.rows + 2 * edge.cols, 180, CV_16S); float theta, rho; ... j++)
  • HoughLines( )函数 和 HoughLinesP()函数

    万次阅读 2018-12-17 14:49:12
    HoughLines( )函数详解   此函数可以找出采用标准霍夫变换的二值图像线条。在OpenCV中,我们可以用其来调用标准霍夫变换SHT和多尺度霍夫变换MSHT的OpenCV内建算法。 C++: void HoughLines(InputArray image, ...
  • cv2.HoughLines() dst: 输出图像. 它应该是个灰度图 (但事实上是个二值化图) lines: 储存着检测到的直线的参数对 (r,\theta) 的容器 rho : 参数极径 r 以像素值为单位的分辨率. 我们使用 1 像素. theta: 参
  • HoughLines函数用法示例

    千次阅读 2016-11-29 19:11:22
    //--------------------------------------【程序说明】-...// 程序描述:HoughLines函数用法示例 // 开发测试所用操作系统: Windows 7 64bit // 开发测试所用IDE版本:Visual Studio 2010 // 开发测试所用OpenCV版
  • void HoughLines( InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn = 0, double stn = 0, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,650
精华内容 1,060
关键字:

houghlines