OpenCV 之ios 霍夫线变换

作者: 充满活力的早晨 | 来源:发表于2019-11-14 16:19 被阅读0次

OpenCV 之ios 霍夫线变换
【OpenCV入门教程之十四】OpenCV霍夫变换：霍夫线变换，
OpenCV-Python学习(十六)：霍夫变换
OpenCV 之ios 霍夫圆变换
Python+OpenCV教程17：霍夫变换
椭圆检测
021-Opencv笔记-霍夫圆变换
python skimage图像处理(三)
opencv+python -- 霍夫圆检测
OpenCV 之ios 仿射变换

OpenCV 之ios 霍夫线变换

目标

在这个部分您将学习到:

使用OpenCV的以下函数 HoughLines 和 HoughLinesP 来检测图像中的直线.

原理

霍夫线变换

霍夫线变换是一种用来寻找直线的方法.
是用霍夫线变换之前, 首先要对图像进行边缘检测的处理，也即霍夫线变换的直接输入只能是边缘二值图像.

它是如何实现的?

众所周知, 一条直线在图像二维空间可由两个变量表示. 例如:
a. 在 笛卡尔坐标系: 可由参数: (m,b)斜率和截距表示.
b. 在 极坐标系: 可由参数: (r,θ) 极径和极角表示

对于霍夫变换, 我们将用极坐标系来表示直线. 因此, 直线的表达式可为:

化简得:

一般来说对于点 (x₀,y₀), 我们可以将通过这个点的一族直线统一定义为:

这就意味着每一对(r_θ) 代表一条通过点(x₀,y₀), 的直线.

如果对于一个给定点 (x₀,y₀) 我们在极坐标对极径极角平面绘出所有通过它的直线, 将得到一条正弦曲线. 例如, 对于给定点x₀=8andy₀=6
我们可以绘出下图 (在平面 θ-r):

只绘出满足下列条件的点r > 0 and 0< θ < 2π

4.我们可以对图像中所有的点进行上述操作. 如果两个不同点进行上述操作后得到的曲线在平面 θ-r相交, 这就意味着它们通过同一条直线. 例如, 接上面的例子我们继续对点: x₁=9,y₁=4 和点x₂=12,y₂=3 绘图, 得到下图:

.这三条曲线在 θ-r 平面相交于点 (0.925, 9.6), 坐标表示的是参数对(θ,r)
) 或者是说点(x₀,y₀),点(x₁,y₁)和点点(x₂,y₂) 组成的平面内的的直线.

那么以上的材料要说明什么呢? 这意味着一般来说, 一条直线能够通过在平面 θ-r 寻找交于一点的曲线数量来检测. 越多曲线交于一点也就意味着这个交点表示的直线由更多的点组成. 一般来说我们可以通过设置直线上点的阈值来定义多少条曲线交于一点我们才认为检测到了一条直线.
这就是霍夫线变换要做的. 它追踪图像中每个点对应曲线间的交点. 如果交于一点的曲线的数量超过了阈值, 那么可以认为这个交点所代表的参数对(θ,r_θ) 在原图像中为一条直线.

标准霍夫线变换和统计概率霍夫线变换

OpenCV实现了以下两种霍夫线变换:

标准霍夫线变换
原理在上面的部分已经说明了. 它能给我们提供一组参数对 (θ,r_θ) 的集合来表示检测到的直线
在OpenCV 中通过函数 HoughLines 来实现

统计概率霍夫线变换
这是执行起来效率更高的霍夫线变换. 它输出检测到的直线的端点 (x₀,y₀,x₁,y₁)
在OpenCV 中它通过函数 HoughLinesP 来实现

源码

该程序的主要目的是对图片进行标准霍夫线变换或是统计概率霍夫线变换.

#ifdef __cplusplus
#import <opencv2/opencv.hpp>
#import <opencv2/imgcodecs/ios.h>
#import <opencv2/imgproc.hpp>
#import <opencv2/highgui.hpp>
#import <opencv2/core/operations.hpp>

#import <opencv2/core/core_c.h>
using namespace cv;
using namespace std;

#endif
#import "HoughLinesViewController.h"

@interface HoughLinesViewController ()

@end

@implementation HoughLinesViewController

Mat src, edges;
Mat src_gray;
Mat standard_hough, probabilistic_hough;
int min_threshold = 50;
int max_trackbar = 150;
int s_trackbar = max_trackbar;
int p_trackbar = max_trackbar;
- (void)viewDidLoad {
    [super viewDidLoad];

    UIImage * src1Image = [UIImage imageNamed:@"building.jpg"];
     src  = [self cvMatFromUIImage:src1Image];
    UIImageView *imageView;
    imageView = [self createImageViewInRect:CGRectMake(0, 100, 150, 150)];
    [self.view addSubview:imageView];
    imageView.image  = [self UIImageFromCVMat:src];
    cvtColor( src, src_gray, COLOR_RGB2GRAY );
    imageView = [self createImageViewInRect:CGRectMake(0, 250, 150, 150)];
    [self.view addSubview:imageView];
    imageView.image  = [self UIImageFromCVMat:src_gray];
    Canny( src_gray, edges, 50, 200, 3 );

    imageView = [self createImageViewInRect:CGRectMake(0, 400, 150, 150)];
      [self.view addSubview:imageView];
      imageView.image  = [self UIImageFromCVMat:edges];
    
    [self createSliderFrame:CGRectMake(150, 100, 100, 50) maxValue:max_trackbar minValue:0 block:^(float value) {
        s_trackbar = value;
       [self Standard_Hough];
    }];
    [self Standard_Hough];
    
    [self createSliderFrame:CGRectMake(150, 150, 100, 50) maxValue:max_trackbar minValue:0 block:^(float value) {
           p_trackbar = value;
          [self Probabilistic_Hough];
       }];
    [self Probabilistic_Hough];

}

-(void)Standard_Hough{
     vector<Vec2f> s_lines;
    cvtColor( edges, standard_hough, COLOR_GRAY2BGR );
          /// 1. Use Standard Hough Transform
        HoughLines( edges, s_lines, 1, CV_PI/180, min_threshold + s_trackbar, 0, 0 );
    for( size_t i = 0; i < s_lines.size(); i++ )
    {
     float r = s_lines[i][0], t = s_lines[i][1];
     double cos_t = cos(t), sin_t = sin(t);
     double x0 = r*cos_t, y0 = r*sin_t;
     double alpha = 1000;

     cv::Point pt1( cvRound(x0 + alpha*(-sin_t)), cvRound(y0 + alpha*cos_t) );
      cv::Point pt2( cvRound(x0 - alpha*(-sin_t)), cvRound(y0 - alpha*cos_t) );
      line( standard_hough, pt1, pt2, Scalar(255,0,0), 3, LINE_AA);
    }
    
     UIImageView *imageView;
    imageView = [self createImageViewInRect:CGRectMake(150, 250, 150, 150)];
        [self.view addSubview:imageView];
        imageView.image  = [self UIImageFromCVMat:standard_hough];
}

-(void)Probabilistic_Hough{
    vector<Vec4i> p_lines;
     cvtColor( edges, probabilistic_hough, COLOR_GRAY2BGR );

     /// 2. Use Probabilistic Hough Transform
     HoughLinesP( edges, p_lines, 1, CV_PI/180, min_threshold + p_trackbar, 30, 10 );

     /// Show the result
     for( size_t i = 0; i < p_lines.size(); i++ )
        {
          Vec4i l = p_lines[I];
          line( probabilistic_hough, cv::Point(l[0], l[1]), cv::Point(l[2], l[3]), Scalar(255,0,0), 3, LINE_AA);
        }
    UIImageView *imageView;
    imageView = [self createImageViewInRect:CGRectMake(150, 400, 150, 150)];
    [self.view addSubview:imageView];
    imageView.image  = [self UIImageFromCVMat:probabilistic_hough];
}

#pragma mark  - private
//brg
- (cv::Mat)cvMatFromUIImage:(UIImage *)image
{
  CGColorSpaceRef colorSpace =CGColorSpaceCreateDeviceRGB();
    
  CGFloat cols = image.size.width;
  CGFloat rows = image.size.height;
    Mat cvMat(rows, cols, CV_8UC4); // 8 bits per component, 4 channels (color channels + alpha)
  CGContextRef contextRef = CGBitmapContextCreate(cvMat.data,                 // Pointer to  data
                                                 cols,                       // Width of bitmap
                                                 rows,                       // Height of bitmap
                                                 8,                          // Bits per component
                                                 cvMat.step[0],              // Bytes per row
                                                 colorSpace,                 // Colorspace
                                                 kCGImageAlphaNoneSkipLast |
                                                 kCGBitmapByteOrderDefault); // Bitmap info flags
  CGContextDrawImage(contextRef, CGRectMake(0, 0, cols, rows), image.CGImage);
  CGContextRelease(contextRef);
    
    Mat dst;
    Mat src;
    cvtColor(cvMat, dst, COLOR_RGBA2BGRA);
    cvtColor(dst, src, COLOR_BGRA2BGR);

  return src;
}

-(UIImage *)UIImageFromCVMat:(cv::Mat)cvMat
{
//    mat 是brg 而 rgb
    Mat src;
    NSData *data=nil;
    CGBitmapInfo info =kCGImageAlphaNone|kCGBitmapByteOrderDefault;
    CGColorSpaceRef colorSpace;
    if (cvMat.depth()!=CV_8U) {
        Mat result;
        cvMat.convertTo(result, CV_8U,255.0);
        cvMat = result;
    }
  if (cvMat.elemSize() == 1) {
      colorSpace = CGColorSpaceCreateDeviceGray();
      data= [NSData dataWithBytes:cvMat.data length:cvMat.elemSize()*cvMat.total()];
  } else if(cvMat.elemSize() == 3){
      cvtColor(cvMat, src, COLOR_BGR2RGB);
       data= [NSData dataWithBytes:src.data length:src.elemSize()*src.total()];
      colorSpace = CGColorSpaceCreateDeviceRGB();
  }else if(cvMat.elemSize() == 4){
      colorSpace = CGColorSpaceCreateDeviceRGB();
      cvtColor(cvMat, src, COLOR_BGRA2RGBA);
      data= [NSData dataWithBytes:src.data length:src.elemSize()*src.total()];
      info =kCGImageAlphaNoneSkipLast | kCGBitmapByteOrderDefault;
  }else{
      NSLog(@"[error:] 错误的颜色通道");
      return nil;
  }
  CGDataProviderRef provider = CGDataProviderCreateWithCFData((__bridge CFDataRef)data);
  // Creating CGImage from cv::Mat
  CGImageRef imageRef = CGImageCreate(cvMat.cols,                                 //width
                                     cvMat.rows,                                 //height
                                     8,                                          //bits per component
                                     8 * cvMat.elemSize(),                       //bits per pixel
                                     cvMat.step[0],                            //bytesPerRow
                                     colorSpace,                                 //colorspace
                                     kCGImageAlphaNone|kCGBitmapByteOrderDefault,// bitmap info
                                     provider,                                   //CGDataProviderRef
                                     NULL,                                       //decode
                                     false,                                      //should interpolate
                                     kCGRenderingIntentAbsoluteColorimetric                   //intent
                                     );
  // Getting UIImage from CGImage
  UIImage *finalImage = [UIImage imageWithCGImage:imageRef];
  CGImageRelease(imageRef);
  CGDataProviderRelease(provider);
  CGColorSpaceRelease(colorSpace);
  return finalImage;
 }
@end

代码说明

标准霍夫线变换
首先, 你要执行变换:

     vector<Vec2f> s_lines;
    cvtColor( edges, standard_hough, COLOR_GRAY2BGR );
          /// 1. Use Standard Hough Transform
        HoughLines( edges, s_lines, 1, CV_PI/180, min_threshold + s_trackbar, 0, 0 );

带有以下自变量:

dst: 边缘检测的输出图像. 它应该是个灰度图
lines: 储存着检测到的直线的参数对 (r,θ) 的容器
rho : 参数极径r 以像素值为单位的分辨率. 我们使用 1 像素.
theta: θ以弧度为单位的分辨率. 我们使用 1度 (即CV_PI/180)
threshold: 要”检测” 一条直线所需最少的的曲线交点
srn and stn: 参数默认为0. 查缺OpenCV参考文献来获取更多信息.

通过画出检测到的直线来显示结果

 for( size_t i = 0; i < s_lines.size(); i++ )
    {
     float r = s_lines[i][0], t = s_lines[i][1];
     double cos_t = cos(t), sin_t = sin(t);
     double x0 = r*cos_t, y0 = r*sin_t;
     double alpha = 1000;

     cv::Point pt1( cvRound(x0 + alpha*(-sin_t)), cvRound(y0 + alpha*cos_t) );
      cv::Point pt2( cvRound(x0 - alpha*(-sin_t)), cvRound(y0 - alpha*cos_t) );
      line( standard_hough, pt1, pt2, Scalar(255,0,0), 3, LINE_AA);
    }

统计概率霍夫线变换
首先, 你要执行变换:

 vector<Vec4i> p_lines;
     cvtColor( edges, probabilistic_hough, COLOR_GRAY2BGR );

     /// 2. Use Probabilistic Hough Transform
     HoughLinesP( edges, p_lines, 1, CV_PI/180, min_threshold + p_trackbar, 30, 10 );

带有以下自变量:

dst: 边缘检测的输出图像. 它应该是个灰度图 (但事实上是个二值化图) * lines: 储存着检测到的直线的参数对(x_start,y_start,x_end,x_end)的容器
rho : 参数极径 r 以像素值为单位的分辨率. 我们使用 1 像素.
theta: 参数极角 θ以弧度为单位的分辨率. 我们使用 1度 (即CV_PI/180)
threshold: 要”检测” 一条直线所需最少的的曲线交点
minLinLength: 能组成一条直线的最少点的数量. 点数量不足的直线将被抛弃.
maxLineGap: 能被认为在一条直线上的亮点的最大距离.
通过画出检测到的直线来显示结果.

 for( size_t i = 0; i < p_lines.size(); i++ )
        {
          Vec4i l = p_lines[I];
          line( probabilistic_hough, cv::Point(l[0], l[1]), cv::Point(l[2], l[3]), Scalar(255,0,0), 3, LINE_AA);
        }

结果

cpp源码地址

cpp

github 地址

摘录博客

OpenCV 之ios 霍夫线变换
OpenCV 之ios 霍夫线变换目标在这个部分您将学习到: 使用OpenCV的以下函数 HoughLines...
【OpenCV入门教程之十四】OpenCV霍夫变换：霍夫线变换，
【OpenCV入门教程之十四】OpenCV霍夫变换：霍夫线变换，霍夫圆变换合辑文辑: https://blog.c...
OpenCV-Python学习(十六)：霍夫变换
目录： 1.什么是霍夫变换？ 2.OpenCV中的霍夫线变换-->直线检测 3.OpenCV中的霍夫圆变换-->圆...
OpenCV 之ios 霍夫圆变换
OpenCV 之ios 霍夫圆变换目标在这个教程中你将学习如何: 使用OpenCV函数 HoughCircle...
Python+OpenCV教程17：霍夫变换
主站：http://ex2tron.wang原文：Python+OpenCV教程17：霍夫变换学习使用霍夫变换识...
椭圆检测
Hough变换检测椭圆附带matlab与opencv代码 QT+opencv学习笔记（5）——霍夫直线检测、圆检...
021-Opencv笔记-霍夫圆变换
霍夫圆变换原理因为霍夫圆检测对噪声比较敏感，所以首先要对图像做中值滤波。基于效率考虑，Opencv中实现的霍夫变...
python skimage图像处理(三)
本文转自 python数字图像处理霍夫线变换在图片处理中，霍夫变换主要是用来检测图片中的几何形状，包括直线、圆...
opencv+python -- 霍夫圆检测
.霍夫圆变换的基本原理和霍夫线变换原理类似，只是点对应的二维极径、极角空间被三维的圆心和半径空间取代。在标准霍夫圆...
OpenCV 之ios 仿射变换
OpenCV 之ios 仿射变换目标在这个教程中你将学习到如何: 使用OpenCV函数 warpAffine ...