图像处理寻找直线

2009-07-23 22:30:00 byxdaz 阅读数 23744
  • SIFT特征提取2

    了解Hough变换基本思想及直线检测步骤; 掌握Harris角点检测的基本思想及实现步骤; 了解尺度空间概念及SIFT特征提取的基本思想 了解ORB中快速特征检测及BRIEF特征建立方法 掌握前述算子的OpenCV实现

    2606人学习 CSDN就业班
    免费试看

图像处理与识别学习小结

 

数字图像处理是对图像进行分析、加工、和处理,使其满足视觉、心理以及其他要求的技术。图像处理是信号处理在图像域上的一个应用。目前大多数的图像是以数字形式存储,因而图像处理很多情况下指数字图像处理。此外,基于光学理论的处理方法依然占有重要的地位。 数字图像处理是信号处理的子类, 另外与计算机科学、人工智能等领域也有密切的关系。 传统的一维信号处理的方法和概念很多仍然可以直接应用在图像处理上,比如降噪、量化等。然而,图像属于二维信号,和一维信号相比,它有自己特殊的一面,处理的方式和角度也有所不同。大多数用于一维信号处理的概念都有其在二维图像信号领域的延伸,它们中的一部分在二维情形下变得十分复杂。同时图像处理也具有自身一些新的概念,例如,连通性、旋转不变性,等等。这些概念仅对二维或更高维的情况下才有非平凡的意义。图像处理中常用到快速傅立叶变换,因为它可以减小数据处理量和处理时间。
数字图像处理应用在以下方面

摄影及印刷 (Photography and printing)

卫星图像处理 (Satellite image processing)

医学图像处理 (Medical image processing)

面孔识别, 特征识别 (Face detection, feature detection, face identification)

显微图像处理 (Microscope image processing)

汽车障碍识别 (Car barrier detection)

 

数字图像基础

图像的基本概念、图像取样和量化、数字图像表示、 空间和灰度级分辨率、图像纹理、像素间的一些基本关系(相邻像素、邻接性、连通性、区域和边界、距离度量)、线性和非线性变换

线性变换:如果变换函数是线性的或是分段线性,这种变换就是线性变换。以线性函数加大图像的对比度的效果是使整幅图像的质量改善。以分段线性函数加大图像中某个(或某几个)亮度区间的对比度的效果是使局部亮度区间的质量得到改善。

非线性变换:当变换函数是非线性时,即为非线性变换。常用的有指数变换和对数变换。

RGB (red green blue): 红绿蓝三基色

CMYK (Cyan-Magenta-Yellow-black inK): 青色-品红-黄色-黑色

HSI (Hue-Saturation-Intensity): 色调-饱和度-强度

DDB (device-dependent bitmap): 设备相关位图

DIB (device-independent bitmap): 设备无关位图

CVBS (Composite Video Broadcast Signal): 复合电视广播信号

YUV(亦称Y Cr Cb)是被欧洲电视系统所采用的一种颜色编码方法(属于PAL制)。

 



 

数字图像存储与显示

图像格式

在计算机中,有两种类型的图:矢量图(vector graphics)和位映象图(bitmapped graphics)。矢量图是用数学方法描述的一系列点、线、弧和其他几何形状,如图(a)所示。因此存放这种图使用的格式称为矢量图格式,存储的数据主要是绘制图形的数学描述;位映象图(bitmapped graphics)也称光栅图(raster graphics),这种图就像电视图像一样,由象点组成的,如图(b),因此存放这种图使用的格式称为位映象图格式,经常简称为位图格式,存储的数据是描述像素的数值。

 

矢量图与位映象图

目前包括bmp格式、gif格式、jpeg格式、jpeg2000格式、tiff格式、psd格式、

Png格式、swf格式、svg格式、pcx格式、dxf格式、wmf格式、emf格式、LIC格式、eps格式、TGA格式。

目前比较出名的图像处理库有很多,比如LEADTOOLSOPENCVLEADTOOLS这个是功能非常强大的图像多媒体库,但是这个是收费注册的。OpenCV 是一个跨平台的中、高层 API 构成,目前包括 300 多个 C 函数。它不依赖与其它的外部库,尽管也可以使用某些外部库。OpenCV 对非商业用途和商业用途都是免费(FREE)的。开源的图像库也有不少,比如:

ImageStoneGIMPCxImage等,虽然它们的功能没有LEADTOOLS强大,但是一般的图像处理是可以应付的。

具体的功能介绍参考:http://blog.csdn.net/byxdaz/archive/2009/03/09/3972293.aspx

OpenCV源代码及文档下载:SOURCEFORGE.NET
http://sourceforge.net/projects/opencvlibrary/

 

 

数字图像增强

图像增强的目的在于改善图像的显示质量,以利于信息的提取和识别。从方法上说,则是设法摒弃一些认为不必要或干扰的信息,而将所需要的信息得以突出出来,以利于分析判读或作进一步的处理。以下介绍几种较为简单的遥感数字图像增强处理方法。

A空间域增强处理

空间域是指图像平面所在的二维空间,空间域图像增强是指在图像平面上应用某种数学模型,通过改变图像像元灰度值达到增强效果,这种增强并不改变像元的位置。空域增强包括空域变换增强与空域滤波增强两种。空域变换增强是基于点处理的增强方法、空域滤波增强是基于邻域处理的增强方法。

1)、空域变换增强

常用的空域变换增强方法包括:对比度增强、直方图增强和图像算术运算等。

对比度增强是一种通过改变图像像元的亮度分布态势,扩展灰度分布区间来改变图像像元对比度,从而改善图像质量的图像处理方法。因为亮度值是辐射强度的反映,所以也称为辐射增强。常用的方法有对比度线性变换和非线性变换。其关键是寻找到一个函数,以此函数对图像中每一个像元进行变换,使像元得到统一的重新分配,构成得到反差增强的图像。

直方图增强

直方图均衡化

     直方图均衡化基本做法是将每个灰度区间等概率分布代替了原来的随机分布,即增强后的图象中每一灰度级的像元数目大致相同。直方图均衡化可使得面积最大的地物细节得以增强,而面积小的地物与其灰度接近的地物进行合并,形成综合地物。减少灰度等级换取对比度的增大。

直方图归一化 

     直方图归一化是把原图像的直方图变换为某种指定形态的直方图或某一参考图像的直方图,然后按着已知的指定形态的直方图调整原图像各像元的灰级,最后得到一个直方图匹配的图像。这种方法主要应用在有一幅很好的图像作为标准的情况下,对另一幅不满意的图像用标准图像的直方图进行匹配处理,以改善被处理图像的质量。如在数字镶嵌时,重叠区影像色调由于时相等原因差异往往很大,利用直方图匹配这一方法后可以改善重叠区影像色调过度,如果镶嵌图像时相相差不大,完全可以作到无缝镶嵌。

数字图像的算术运算

两幅或多幅单波段影像,完成空间配准后,通过一系列运算,可以实现图像增强,达到提取某些信息或去掉某些不必要信息的目的。

  

2)、空域滤波增强

空域变换增强是按像元逐点运算的,从整体上改善图像的质量,并不考虑周围像元影响。空间滤波增强则是以重点突出图像上的某些特征为目的的(如突出边缘或纹理等),通过像元与周围相邻像元的关系,采取空间域中的邻域处理方法进行图像增强。邻域法处理用于去噪声、图像平滑、锐化和相关运算。

图像卷积运算是在空间域上对图像作局部检测的运算,以实现平滑和锐化的目的。具体作法是选定一卷积函数,又称为“M×N窗口模板,如3×35×5等。然后从图像左上角开始开一与模板同样大小的活动窗口,图像窗口与模板像元的亮度值对应相乘再相加。将计算结果赋予中心像元作为其灰度值,然后待移动后重新计算,将计算结果赋予另一个中心像元,以此类推直到全幅图像扫描一遍结束生成新的图像。

平滑是指图像中出现某些亮度变化过大的区域,或出现不该有的亮点(噪声)时,采用平滑方法可以减小变化,使亮度平缓或去掉不必要噪声点。它实际上是使图像中高频成分消退,即平滑图像的细节,降低其反差,保存低频成分,在频域中称为低通滤波。具体方法有:均值平滑、中值滤波、锐化。

锐化的作用在于提高边缘灰度值的变化率,使界线更加清晰。它是增强图像中的高频成分,在频域处理中称为高通滤波,也就是使图像细节的反差提高,也称边缘增强。要突出图像的边缘、线状目标或亮度变化率大的部分常采用锐化方法。一般有三种实现方法:

1)梯度法

    梯度反映了相邻像元的亮度变化率,即图像中如果存在边缘,如湖泊、河流的边界,山脉和道路等,则边缘处有较大的梯度值。对于亮度值较平滑的部分,亮度梯度值较小。因此,找到梯度较大的位置,也就找到边缘,然后再用不同的梯度计算值代替边缘处像元的值,也就突出了边缘,实现了图像的锐化。通常有罗伯特梯度和索伯尔梯度方法。

2)拉普拉斯算法

    拉普拉斯算法的意义与梯度法不同,它不检测均匀的亮度变化,而是检测变化率的变化率,相当于二阶微分。计算出的图像更加突出亮度值突变的位置。

3)定向检测

    当有目的地检测某一方向的边、线或纹理特征时,可选择特定的模板卷积运算作定向检测。可以检测垂直边界、水平边界和对角线边界等,各使用的模板不同

 

B频率域图像增强处理
频域增强指在图像的频率域内,对图像的变换系数(频率成分)直接进行运算,然后通过Fourier逆变换以获得图像的增强效果。

一般来说,图像的边缘和噪声对应Fourier变换中的高频部分,所以低通滤波能够平滑图像、去除噪声。

图像灰度发生聚变的部分与频谱的高频分量对应,所以采用高频滤波器衰减或抑制低频分量,能够对图像进行锐化处理。

频域,就是由图像f(x,y)的二维傅立叶变换和相应的频率变量(u,v)的值所组成的空间。在空间域图像强度的变化模式(或规律)可以直接在该空间得到反应。F(0,0)是频域中的原点,反应图像的平均灰度级,即图像中的直流成分;低频反映图像灰度发生缓慢变化的部分;而高频对应图像中灰度发生更快速变化的部分,如边缘、噪声等。但频域不能反应图像的空间信息。

 

 

二维DFT及其反变换、Fast FT

关于这方面的内容需要参考数学知识。

空域和频域滤波间的对应关系:

卷积定理是空域和频域滤波的最基本联系纽带。二维卷积定理:

 

 

 


基本计算过程:

  1. 取函数h(m,n)关于原点的镜像,得到h(-m,-n)
  2. 对某个(x,y),使h(-m,-n)移动相应的距离,得到h(x-m,y-n)
  3. 对积函数f(m,n)h(x-m,y-n)(m,n)的取值范围内求和
  4. 位移是整数增量,对所有的(x,y)重复上面的过程,直到两个函数:f(m,n)h(x-m,y-n)不再有重叠的部分。

 

傅立叶变换是空域和频域的桥梁,关于两个域滤波的傅立叶变换对:

 

 

 

 

 

 

 

 


频域与空域滤波的比较:

1. 对具有同样大小的空域和频率滤波器:h(x,y), H(u,v),频域计算(由于FFT)往往更有效(尤其是图像尺寸比较大时)。但对在空域中用尺寸较小的模板就能解决的问题,则往往在空域中直接操作。

2. 频域滤波虽然更直接,但如果可以使用较小的滤波器,还是在空域计算为好。    因为省去了计算傅立叶变换及反变换等步骤。

3. 由于更多的直观性,频率滤波器设计往往作为空域滤波器设计的向导。

 

平滑的频率域滤波器类型
、理想低通滤波器
、巴特沃思低通滤波器
、高斯低通滤波器
频率域锐化滤波器类型
理想高通滤波器
巴特沃思高通滤波器

高斯型高通滤波器

频率域的拉普拉斯算子
钝化模板、高频提升滤波和高频加强滤波
频率域图像增强处理的过程:

 

 

图像复原
图像复原:试图利用退化过程的先验知识,去恢复已被退化图像的本来面目。

 

图像复原的基本思路:先建立退化的数学模型,然后根据该模型对退化图像进行拟合。

图像复原模型可以用连续数学和离散数学处理,处理项的实现可在空间域卷积,或在频域相乘。 
参考资料:
http://download.csdn.net/source/1513324

 


边缘检测

数字图像的边缘检测是图像分割、目标区域的识别、区域形状提取等图像分析领域十分重要的基础,图像理解和分析的第一步往往就是边缘检测,目前它以成为机器视觉研究领域最活跃的课题之一,在工程应用中占有十分重要的地位。所谓边缘就是指图像局部亮度变化最显著的部分,它是检测图像局部变化显著变化的最基本的运算。边缘的记录有链码表和线段表2种,链码表适合计算周长,线段表容易计算面积以及相关的,他们之间可以相互的转换

常见的边缘检测算法:

Roberts边缘检测算子

Sobel边缘算子

Prewitt边缘算子

Kirsch边缘算子

CANNY边缘检测

 


图像压缩
图像压缩是数据压缩技术在数字图像上的应用,它的目的是减少图像数据中的冗余信息从而用更加高效的格式存储和传输数据。图像压缩可以是有损数据压缩也可以是无损数据压缩。对于如绘制的技术图、图表或者漫画优先使用无损压缩,这是因为有损压缩方法,尤其是在低的位速条件下将会带来压缩失真。如医疗图像或者用于存档的扫描图像等这些有价值的内容的压缩也尽量选择无损压缩方法。有损方法非常适合于自然的图像,例如一些应用中图像的微小损失是可以接受的(有时是无法感知的),这样就可以大幅度地减小位速。

无损图像压缩方法有:

行程长度编码

熵编码法

LZW算法

有损压缩方法有:

将色彩空间化减到图像中常用的颜色。所选择的颜色定义在压缩图像头的调色板中,图像中的每个像素都用调色板中颜色索引表示。这种方法可以与 抖动(en:dithering)一起使用以模糊颜色边界。

色度抽样,这利用了人眼对于亮度变化的敏感性远大于颜色变化,这样就可以将图像中的颜色信息减少一半甚至更多。

变换编码,这是最常用的方法。首先使用如离散余弦变换(DCT)或者小波变换这样的傅立叶相关变换,然后进行量化和用熵编码法压缩。

分形压缩(en:Fractal compression)。



形态学图像处理
 
膨胀与腐蚀

 膨胀
腐蚀
开操作与闭操作
击中或击不中变换
一些基本的形态学算法

边界提取
区域填充
连通分量的提取
凸壳
细化
粗化
骨架

裁剪


图像分割
图像分割是指通过某种方法,使得画面场景中的目标物被分为不同的类别。通常图像分割的实现方法是,将图像分为“黑”、“白”两类,这两类分别代表了两个不同的对象。

图像分割方法:阈值分割区域分割、数学形态学、模式识别方法

A、阈值分割包括以下几种:

1)由直方图灰度分布选择阈值

2)双峰法选择阈值

3)迭代法选取阈值

     原理如下,很好理解。

     迭代法是基于逼近的思想,其步骤如下:
      1. 求出图象的最大灰度值和最小灰度值,分别记为ZMAX和ZMIN,令初始阈值T0=(ZMAX+ZMIN)/2;
     2. 根据阈值TK将图象分割为前景和背景,分别求出两者的平均灰度值ZO和ZB;
     3. 求出新阈值TK+1=(ZO+ZB)/2;
     4. 若TK=TK+1,则所得即为阈值;否则转2,迭代计算。

4 )大津法选择阈值

大津法是属于最大类间方差法,它是自适应计算单阈值的简单高效方法,或者叫(Otsu

大津法由大津于1979年提出,对图像Image,记t为前景与背景的分割阈值,前景点数占图像比例为w0,平均灰度为u0;背景点数占图像比例为w1,平均灰度为u1。图像的总平均灰度为:u=w0*u0+w1*u1。从最小灰度值到最大灰度值遍历t,当t使得值g=w0*(u0-u)2+w1*(u1-u)2 最大时t即为分割的最佳阈值。对大津法可作如下理解:该式实际上就是类间方差值,阈值t分割出的前景和背景两部分构成了整幅图像,而前景取值u0,概率为 w0,背景取值u1,概率为w1,总均值为u,根据方差的定义即得该式。因方差是灰度分布均匀性的一种度量,方差值越大,说明构成图像的两部分差别越大, 当部分目标错分为背景或部分背景错分为目标都会导致两部分差别变小,因此使类间方差最大的分割意味着错分概率最小。直接应用大津法计算量较大,因此一般采用了等价的公式g=w0*w1*(u0-u1)2

5)由灰度拉伸选择阈值

大津法是较通用的方法,但是它对两群物体在灰度不明显的情况下会丢失一些整体信息。因此为了解决这种现象采用灰度拉伸的增强大津法。在大津法的思想上增加灰度的级数来增强前两群物体的灰度差。对于原来的灰度级乘上同一个系数,从而扩大了图像灰度的级数。试验结果表明不同的拉伸系数,分割效果差别比较大。

 

B、区域的分割

区域生长、区域分离与合并

 区域生长算法


C基于形态学分水岭的分割

分水岭分割算法


图像特征提取与匹配

常用的图像特征有颜色特征、纹理特征、形状特征、空间关系特征。

A 颜色特征

特点:颜色特征是一种全局特征,描述了图像或图像区域所对应的景物的表面性质。一般颜色特征是基于像素点的特征,此时所有属于图像或图像区域的像素都有各自的贡献。由于颜色对图像或图像区域的方向、大小等变化不敏感,所以颜色特征不能很好地捕捉图像中对象的局部特征。

常用的特征提取与匹配方法:

颜色直方图

其优点在于:它能简单描述一幅图像中颜色的全局分布,即不同色彩在整幅图像中所占的比例,特别适用于描述那些难以自动分割的图像和不需要考虑物体空间位置的图像。其缺点在于:它无法描述图像中颜色的局部分布及每种色彩所处的空间位置,即无法描述图像中的某一具体的对象或物体。

颜色直方图特征匹配方法:直方图相交法、距离法、中心距法、参考颜色表法、累加颜色直方图法。

 

B 纹理特征

纹理特征的提取方法比较简单,它是用一个活动的窗口在图像上连续滑动,分别计算出窗口中的方差、均值、最大值、最小值及二者之差和信息熵等,

形成相应的纹理图像,当目标的光谱特性比较接近时,纹理特征对于区分目标可以起到积极的作用。选取适当的数据动态变化范围,进行纹理特征提取后,使影像的纹理特征得到突出,有利于提取构造信息。

特点:纹理特征也是一种全局特征,它也描述了图像或图像区域所对应景物的表面性质。但由于纹理只是一种物体表面的特性,并不能完全反映出物体的本质属性,所以仅仅利用纹理特征是无法获得高层次图像内容的。与颜色特征不同,纹理特征不是基于像素点的特征,它需要在包含多个像素点的区域中进行统计计算。在模式匹配中,这种区域性的特征具有较大的优越性,不会由于局部的偏差而无法匹配成功。作为一种统计特征,纹理特征常具有旋转不变性,并且对于噪声有较强的抵抗能力。但是,纹理特征也有其缺点,一个很明显的缺点是当图像的分辨率变化的时候,所计算出来的纹理可能会有较大偏差。另外,由于有可能受到光照、反射情况的影响,从2-D图像中反映出来的纹理不一定是3-D物体表面真实的纹理。

常用的特征提取与匹配方法:

纹理特征描述方法分类

1)统计方法统计方法的典型代表是一种称为灰度共生矩阵的纹理特征分析方法Gotlieb Kreyszig 等人在研究共生矩阵中各种统计特征基础上,通过实验,得出灰度共生矩阵的四个关键特征:能量、惯量、熵和相关性。统计方法中另一种典型方法,则是从图像的自相关函数(即图像的能量谱函数)提取纹理特征,即通过对图像的能量谱函数的计算,提取纹理的粗细度及方向性等特征参数

2)几何法

所谓几何法,是建立在纹理基元(基本的纹理元素)理论基础上的一种纹理特征分析方法。纹理基元理论认为,复杂的纹理可以由若干简单的纹理基元以一定的有规律的形式重复排列构成。在几何法中,比较有影响的算法有两种:Voronio 棋盘格特征法和结构法。

3)模型法

模型法以图像的构造模型为基础,采用模型的参数作为纹理特征。典型的方法是随机场模型法,如马尔可夫(Markov)随机场(MRF)模型法和 Gibbs 随机场模型法

4)信号处理法

纹理特征的提取与匹配主要有:灰度共生矩阵、Tamura 纹理特征、自回归纹理模型、小波变换等。

灰度共生矩阵特征提取与匹配主要依赖于能量、惯量、熵和相关性四个参数。Tamura 纹理特征基于人类对纹理的视觉感知心理学研究,提出6种属性,即

:粗糙度、对比度、方向度、线像度、规整度和粗略度。自回归纹理模型(simultaneous auto-regressive, SAR)是马尔可夫随机场(MRF)模型的一种应用实例。

 

C形状特征

特点:各种基于形状特征的检索方法都可以比较有效地利用图像中感兴趣的目标来进行检索,但它们也有一些共同的问题,

常用的特征提取与匹配方法:

通常情况下,形状特征有两类表示方法,一类是轮廓特征,另一类是区域特征。图像的轮廓特征主要针对物体的外边界,而图像的区域特征则关系到整个形状区域。

几种典型的形状特征描述方法:

1)边界特征法该方法通过对边界特征的描述来获取图像的形状参数。其中Hough 变换检测平行直线方法和边界方向直方图方法是经典方法。Hough 变换是利用图像全局特性而将边缘像素连接起来组成区域封闭边界的一种方法,其基本思想是点—线的对偶性;边界方向直方图法首先微分图像求得图像边缘,然后,做出关于边缘大小和方向的直方图,通常的方法是构造图像灰度梯度方向矩阵。

2)傅里叶形状描述符法

傅里叶形状描述符(Fourier shape descriptors)基本思想是用物体边界的傅里叶变换作为形状描述,利用区域边界的封闭性和周期性,将二维问题转化为一维问题。

由边界点导出三种形状表达,分别是曲率函数、质心距离、复坐标函数。

3)几何参数法

形状的表达和匹配采用更为简单的区域特征描述方法,例如采用有关形状定量测度(如矩、面积、周长等)的形状参数法(shape factor)。在 QBIC 系统中,便是利用圆度、偏心率、主轴方向和代数不变矩等几何参数,进行基于形状特征的图像检索。

 

D空间关系特征

特点:所谓空间关系,是指图像中分割出来的多个目标之间的相互的空间位置或相对方向关系,这些关系也可分为连接/邻接关系、交叠/重叠关系和包含/包容关系等。通常空间位置信息可以分为两类:相对空间位置信息和绝对空间位置信息。前一种关系强调的是目标之间的相对情况,如上下左右关系等,后一种关系强调的是目标之间的距离大小以及方位。显而易见,由绝对空间位置可推出相对空间位置,但表达相对空间位置信息常比较简单。
空间关系特征的使用可加强对图像内容的描述区分能力,但空间关系特征常对图像或目标的旋转、反转、尺度变化等比较敏感。另外,实际应用中,仅仅利用空间信息往往是不够的,不能有效准确地表达场景信息。为了检索,除使用空间关系特征外,还需要其它特征来配合。

常用的特征提取与匹配方法:

提取图像空间关系特征可以有两种方法:一种方法是首先对图像进行自动分割,划分出图像中所包含的对象或颜色区域,然后根据这些区域提取图像特征,并建立索引;另一种方法则简单地将图像均匀地划分为若干规则子块,然后对每个图像子块提取特征,并建立索引。

 

 

模式识别

模式识别是一种从大量信息和数据出发,在专家经验和已有认识的基础上,利用计算机和数学推理的方法对形状、模式、曲线、数字、字符格式和图形自动完成识别的过程。模式识别包括相互关联的两个阶段,即学习阶段和实现阶段,前者是对样本进行特征选择,寻找分类的规律,后者是根据分类规律对未知样本集进行分类和识别。广义的模式识别属计算机科学中智能模拟的研究范畴,内容非常广泛,包括声音和语言识别、文字识别、指纹识别、声纳信号和地震信号分析、照片图片分析、化学模式识别等等。计算机模式识别实现了部分脑力劳动自动化。

模式识别--对表征事物或现象的各种形式的(数值的,文字的和逻辑关系的)信息进行处理和分析,以对事物或现象进行描述、辨认、分类和解释的过程,是信息科学和人工智能的重要组成部分。

模式还可分成抽象的和具体的两种形式。前者如意识、思想、议论等,属于概念识别研究的范畴,是人工智能的另一研究分支。我们所指的模式识别主要是对语音波形、地震波、心电图、脑电图、图片、文字、符号、三位物体和景物以及各种可以用物理的、化学的、生物的传感器对对象进行测量的具体模式进行分类和辨识。

模式识别问题指的是对一系列过程或事件的分类与描述,具有某些相类似的性质的过程或事件就分为一类。模式识别问题一般可以应用以下4种方法进行分析处理。

模版比对:

统计模式识别方法:统计模式识别方法是受数学中的决策理论的启发而产生的一种识别方法,它一般假定被识别的对象或经过特征提取向量是符合一定分布规律的随机变量。其基本思想是将特征提取阶段得到的特征向量定义在一个特征空间中,这个空间包含了所有的特征向量,不同的特征向量,或者说不同类别的对象都对应于空间中的一点。在分类阶段,则利用统计决策的原理对特征空间进行划分,从而达到识别不同特征的对象的目的。统计模式识别中个应用的统计决策分类理论相对比较成熟,研究的重点是特征提取。统计模式识别的基本原理是:有相似性的样本在模式空间中互相接近,并形成集团,即物以类聚。其分析方法是根据模式所测得的特征向量Xi=(xi1,xi2,…,xid)T(i=1,2,…,N),将一个给定的模式归入C个类ω1,ω2,…,ωc中,然后根据模式之间的距离函数来判别分类。其中,T表示转置;N为样本点数;d为样本特征数。

统计模式识别的主要方法有:判别函数法,k近邻分类法,非线性映射法,特征分析法,主因子分析法等。

在统计模式识别中,贝叶斯决策规则从理论上解决了最优分类器的设计问题,但其实施却必须首先解决更困难的概率密度估计问题。BP神经网络直接从观测数据(训练样本)学习,是更简便有效的方法,因而获得了广泛的应用,但它是一种启发式技术,缺乏指定工程实践的坚实理论基础。统计推断理论研究所取得的突破性成果导致现代统计学习理论——VC理论的建立,该理论不仅在严格的数学基础上圆满地回答了人工神经网络中出现的理论问题,而且导出了一种新的学习方法——支撑向量机。

 

人工神经网络模式识别:人工神经网络的研究起源于对生物神经系统的研究。人工神经网络区别于其他识别方法的最大特点是它对待识别的对象不要求有太多的分析与了解,具有一定的智能化处理的特点。

句法结构模式识别:又称结构方法或语言学方法。其基本思想是把一个模式描述为较简单的子模式的组合,子模式又可描述为更简单的子模式的组合,最终得到一个树形的结构描述,在底层的最简单的子模式称为模式基元。在句法方法中选取基元的问题相当于在决策理论方法中选取特征的问题。通常要求所选的基元能对模式提供一个紧凑的反映其结构关系的描述,又要易于用非句法方法加以抽取。显然,基元本身不应该含有重要的结构信息。模式以一组基元和它们的组合关系来描述,称为模式描述语句,这相当于在语言中,句子和短语用词组合,词用字符组合一样。基元组合成模式的规则,由所谓语法来指定。一旦基元被鉴别,识别过程可通过句法分析进行,即分析给定的模式语句是否符合指定的语法,满足某类语法的即被分入该类。

在几种算法中,统计模式识别是最经典的分类识别方法,在图像模式识别中有着非常广泛的应用。

 

 

参考书籍:美国 冈萨雷斯 数字图像处理第二版

2016-10-21 23:08:12 Yogi_zhang 阅读数 1884
  • SIFT特征提取2

    了解Hough变换基本思想及直线检测步骤; 掌握Harris角点检测的基本思想及实现步骤; 了解尺度空间概念及SIFT特征提取的基本思想 了解ORB中快速特征检测及BRIEF特征建立方法 掌握前述算子的OpenCV实现

    2606人学习 CSDN就业班
    免费试看

一、原理

 参考霍夫变换,如果有课本的话参考冈萨雷斯的图像处理课本及matlab版本的课本最好,如果没有就看下这节的原理描述。
直角坐标系中对于直线方程有如下等式:

ρ=xcosθ+ysinθ(ρ0)

其中ρ为坐标原点到直线的距离,θρ 与x轴正方向的夹角,x、y为直线上的点:
如图
对于直线上任意一个已知的点(x0,y0)有:ρ=x0cosθ+y0sinθ,则该函数是关于ρθ的方程。

所以,对于图像上的任意一个像素点都有上述方程成立,亦即对于图像上的任意一个点,在霍夫变换后的参数空间内(θ,ρ)都可以找到一条三角函数曲线与其对应。图像上的任意两个点,即对应两条曲线,那么这两条曲线必然会产生一个交点(θ0,ρ0),这个交点再放到直线方程中,即可确定一条直线(也正是图像上这两个点所确立的直线)。

由此推断,图像上在同一条直线(图像上应该是一个线段)上的点所产生的曲线都会在参数空间相交于一个点(θ0,ρ0),直线的长度越长(点越多),那么交于该点的曲线也越多。

所以,在图像上找直线可以演变成在霍夫变化后参数空间(霍夫图像)中找曲线相交次数最多的点。

代码

平台:Ti的DSP系列
语言:C
2012-05-14 20:47:26 syxynao 阅读数 3226
  • SIFT特征提取2

    了解Hough变换基本思想及直线检测步骤; 掌握Harris角点检测的基本思想及实现步骤; 了解尺度空间概念及SIFT特征提取的基本思想 了解ORB中快速特征检测及BRIEF特征建立方法 掌握前述算子的OpenCV实现

    2606人学习 CSDN就业班
    免费试看
  public Bitmap hough_line(Bitmap bmpobj, int cross_num)
        {
            Bitmap I_out = bmpobj;
            int x = bmpobj.Width;
            int y = bmpobj.Height;
            for (int ii = 0; ii < 10; ii++)
            {

                int rho_max = (int)Math.Floor(Math.Sqrt(x * x + y * y)) + 1; //由原图数组坐标算出ρ最大值,并取整数部分加1
                //此值作为ρ,θ坐标系ρ最大值
                int[,] accarray = new int[rho_max, 180]; //定义ρ,θ坐标系的数组,初值为0。
                //θ的最大值,180度

                double[] Theta = new double[180];
                //定义θ数组,确定θ取值范围
                double i = 0;
                for (int index = 0; index < 180; index++)
                {
                    Theta[index] = i;
                    i += Math.PI / 180;
                }

                double rho;
                int rho_int;
                for (int n = 0; n < x; n++)
                {
                    for (int m = 0; m < y; m++)
                    {
                        Color pixel = bmpobj.GetPixel(n, m);
                        if (pixel.R == 255)
                        {
                            for (int k = 0; k < 180; k++)
                            {
                                //将θ值代入hough变换方程,求ρ值
                                rho = (m * Math.Cos(Theta[k])) + (n * Math.Sin(Theta[k]));
                                //将ρ值与ρ最大值的和的一半作为ρ的坐标值(数组坐标),这样做是为了防止ρ值出现负数
                                rho_int = (int)Math.Round(rho / 2 + rho_max / 2);
                                //在ρθ坐标(数组)中标识点,即计数累加
                                accarray[rho_int, k] = accarray[rho_int, k] + 1;
                            }
                        }
                    }
                }

                //=======利用hough变换提取直线======
                //寻找100个像素以上的直线在hough变换后形成的点
                const int max_line = 100;
                int[] case_accarray_n = new int[max_line];
                int[] case_accarray_m = new int[max_line];
                int K = 0; //存储数组计数器
                for (int rho_n = 0; rho_n < rho_max; rho_n++) //在hough变换后的数组中搜索
                {
                    for (int theta_m = 0; theta_m < 180; theta_m++)
                    {
                        if (accarray[rho_n, theta_m] >= cross_num && K < max_line) //设定直线的最小值
                        {
                            case_accarray_n[K] = rho_n; //存储搜索出的数组下标
                            case_accarray_m[K] = theta_m;
                            K = K + 1;
                        }
                    }
                }

                //把这些点构成的直线提取出来,输出图像数组为I_out
                //I_out=ones(x,y).*255;
                
                for (int n = 0; n < x; n++)
                {
                    for (int m = 0; m < y; m++)
                    {
                        //首先设置为白色

                        Color pixel = bmpobj.GetPixel(n, m);
                        if (pixel.R == 255)
                        {
                            for (int k = 0; k < 180; k++)
                            {
                                rho = (m * Math.Cos(Theta[k])) + (n * Math.Sin(Theta[k]));
                                rho_int = (int)Math.Round(rho / 2 + rho_max / 2);
                                //如果正在计算的点属于100像素以上点,则把它提取出来
                                for (int a = 0; a < K - 1; a++)
                                {
                                    //if rho_int==case_accarray_n(a) && k==case_accarray_m(a)%%%==gai==%%% k==case_accarray_m(a)&rho_int==case_accarray_n(a)
                                    if (rho_int == case_accarray_n[a] && k == case_accarray_m[a])
                                        I_out.SetPixel(n, m, Color.Black);
                                }
                            }
                        }

                    }
                }
            }
           
            return I_out;
        }

处理前:

处理后:

2017-11-14 09:28:14 u010312937 阅读数 1806
  • SIFT特征提取2

    了解Hough变换基本思想及直线检测步骤; 掌握Harris角点检测的基本思想及实现步骤; 了解尺度空间概念及SIFT特征提取的基本思想 了解ORB中快速特征检测及BRIEF特征建立方法 掌握前述算子的OpenCV实现

    2606人学习 CSDN就业班
    免费试看

图像处理之霍夫变换(直线检测算法)

霍夫变换是图像变换中的经典手段之一,主要用来从图像中分离出具有某种相同特征的几何

形状(如,直线,圆等)。霍夫变换寻找直线与圆的方法相比与其它方法可以更好的减少噪

声干扰。经典的霍夫变换常用来检测直线,圆,椭圆等。

 

霍夫变换算法思想:

以直线检测为例,每个像素坐标点经过变换都变成都直线特质有贡献的统一度量,一个简单

的例子如下:一条直线在图像中是一系列离散点的集合,通过一个直线的离散极坐标公式,

可以表达出直线的离散点几何等式如下:

X *cos(theta) + y * sin(theta)  = r 其中角度theta指r与X轴之间的夹角,r为到直线几何垂

直距离。任何在直线上点,x, y都可以表达,其中 r, theta是常量。该公式图形表示如下:

然而在实现的图像处理领域,图像的像素坐标P(x, y)是已知的,而r, theta则是我们要寻找

的变量。如果我们能绘制每个(r, theta)值根据像素点坐标P(x, y)值的话,那么就从图像笛卡

尔坐标系统转换到极坐标霍夫空间系统,这种从点到曲线的变换称为直线的霍夫变换。变换

通过量化霍夫参数空间为有限个值间隔等分或者累加格子。当霍夫变换算法开始,每个像素

坐标点P(x, y)被转换到(r, theta)的曲线点上面,累加到对应的格子数据点,当一个波峰出现

时候,说明有直线存在。同样的原理,我们可以用来检测圆,只是对于圆的参数方程变为如

下等式:

(x –a ) ^2 + (y-b) ^ 2 = r^2其中(a, b)为圆的中心点坐标,r圆的半径。这样霍夫的参数空间就

变成一个三维参数空间。给定圆半径转为二维霍夫参数空间,变换相对简单,也比较常用。

 

编程思路解析:

1.      读取一幅带处理二值图像,最好背景为黑色。

2.      取得源像素数据

3.      根据直线的霍夫变换公式完成霍夫变换,预览霍夫空间结果

4.       寻找最大霍夫值,设置阈值,反变换到图像RGB值空间(程序难点之一)

5.      越界处理,显示霍夫变换处理以后的图像

 

关键代码解析:

直线的变换角度为[0 ~ PI]之间,设置等份为500为PI/500,同时根据参数直线参数方程的取值

范围为[-r, r]有如下霍夫参数定义:

[java] view plain copy
  1. // prepare for hough transform  
  2. int centerX = width / 2;  
  3. int centerY = height / 2;  
  4. double hough_interval = PI_VALUE/(double)hough_space;  
  5.       
  6. int max = Math.max(width, height);  
  7. int max_length = (int)(Math.sqrt(2.0D) * max);  
  8. hough_1d = new int[2 * hough_space * max_length];  

实现从像素RGB空间到霍夫空间变换的代码为:

[java] view plain copy
  1. // start hough transform now....  
  2. int[][] image_2d = convert1Dto2D(inPixels);  
  3. for (int row = 0; row < height; row++) {  
  4.     for (int col = 0; col < width; col++) {  
  5.         int p = image_2d[row][col] & 0xff;  
  6.         if(p == 0continue// which means background color  
  7.           
  8.         // since we does not know the theta angle and r value,   
  9.         // we have to calculate all hough space for each pixel point  
  10.         // then we got the max possible theta and r pair.  
  11.         // r = x * cos(theta) + y * sin(theta)  
  12.         for(int cell=0; cell < hough_space; cell++ ) {  
  13.             max = (int)((col - centerX) * Math.cos(cell * hough_interval) + (row - centerY) * Math.sin(cell * hough_interval));  
  14.             max += max_length; // start from zero, not (-max_length)  
  15.             if (max < 0 || (max >= 2 * max_length)) {// make sure r did not out of scope[0, 2*max_lenght]  
  16.                 continue;  
  17.             }  
  18.             hough_2d[cell][max] +=1;  
  19.         }  
  20.     }  
  21. }  

寻找最大霍夫值计算霍夫阈值的代码如下:

[java] view plain copy
  1. // find the max hough value  
  2. int max_hough = 0;  
  3. for(int i=0; i<hough_space; i++) {  
  4.     for(int j=0; j<2*max_length; j++) {  
  5.         hough_1d[(i + j * hough_space)] = hough_2d[i][j];  
  6.         if(hough_2d[i][j] > max_hough) {  
  7.             max_hough = hough_2d[i][j];  
  8.         }  
  9.     }  
  10. }  
  11. System.out.println("MAX HOUGH VALUE = " + max_hough);  
  12.   
  13. // transfer back to image pixels space from hough parameter space  
  14. int hough_threshold = (int)(threshold * max_hough);  

从霍夫空间反变换回像素数据空间代码如下:

[java] view plain copy
  1. // transfer back to image pixels space from hough parameter space  
  2. int hough_threshold = (int)(threshold * max_hough);  
  3. for(int row = 0; row < hough_space; row++) {  
  4.     for(int col = 0; col < 2*max_length; col++) {  
  5.         if(hough_2d[row][col] < hough_threshold) // discard it  
  6.             continue;  
  7.         int hough_value = hough_2d[row][col];  
  8.         boolean isLine = true;  
  9.         for(int i=-1; i<2; i++) {  
  10.             for(int j=-1; j<2; j++) {  
  11.                 if(i != 0 || j != 0) {  
  12.                   int yf = row + i;  
  13.                   int xf = col + j;  
  14.                   if(xf < 0continue;  
  15.                   if(xf < 2*max_length) {  
  16.                       if (yf < 0) {  
  17.                           yf += hough_space;  
  18.                       }  
  19.                       if (yf >= hough_space) {  
  20.                           yf -= hough_space;  
  21.                       }  
  22.                       if(hough_2d[yf][xf] <= hough_value) {  
  23.                           continue;  
  24.                       }  
  25.                       isLine = false;  
  26.                       break;  
  27.                   }  
  28.                 }  
  29.             }  
  30.         }  
  31.         if(!isLine) continue;  
  32.           
  33.         // transform back to pixel data now...  
  34.         double dy = Math.sin(row * hough_interval);  
  35.         double dx = Math.cos(row * hough_interval);  
  36.         if ((row <= hough_space / 4) || (row >= 3 * hough_space / 4)) {  
  37.             for (int subrow = 0; subrow < height; ++subrow) {  
  38.               int subcol = (int)((col - max_length - ((subrow - centerY) * dy)) / dx) + centerX;  
  39.               if ((subcol < width) && (subcol >= 0)) {  
  40.                   image_2d[subrow][subcol] = -16776961;  
  41.               }  
  42.             }  
  43.           } else {  
  44.             for (int subcol = 0; subcol < width; ++subcol) {  
  45.               int subrow = (int)((col - max_length - ((subcol - centerX) * dx)) / dy) + centerY;  
  46.               if ((subrow < height) && (subrow >= 0)) {  
  47.                   image_2d[subrow][subcol] = -16776961;  
  48.               }  
  49.             }  
  50.           }  
  51.     }  
  52. }  
霍夫变换源图如下:

霍夫变换以后,在霍夫空间显示如下:(白色表示已经找到直线信号)


最终反变换回到像素空间效果如下:


一个更好的运行监测直线的结果(输入为二值图像):


完整的霍夫变换源代码如下:

[java] view plain copy
  1. package com.gloomyfish.image.transform;  
  2.   
  3. import java.awt.image.BufferedImage;  
  4.   
  5. import com.process.blur.study.AbstractBufferedImageOp;  
  6.   
  7. public class HoughLineFilter extends AbstractBufferedImageOp {  
  8.     public final static double PI_VALUE = Math.PI;  
  9.     private int hough_space = 500;  
  10.     private int[] hough_1d;  
  11.     private int[][] hough_2d;  
  12.     private int width;  
  13.     private int height;  
  14.       
  15.     private float threshold;  
  16.     private float scale;  
  17.     private float offset;  
  18.       
  19.     public HoughLineFilter() {  
  20.         // default hough transform parameters  
  21.         //  scale = 1.0f;  
  22.         //  offset = 0.0f;  
  23.         threshold = 0.5f;  
  24.         scale = 1.0f;  
  25.         offset = 0.0f;  
  26.     }  
  27.       
  28.     public void setHoughSpace(int space) {  
  29.         this.hough_space = space;  
  30.     }  
  31.       
  32.     public float getThreshold() {  
  33.         return threshold;  
  34.     }  
  35.   
  36.     public void setThreshold(float threshold) {  
  37.         this.threshold = threshold;  
  38.     }  
  39.   
  40.     public float getScale() {  
  41.         return scale;  
  42.     }  
  43.   
  44.     public void setScale(float scale) {  
  45.         this.scale = scale;  
  46.     }  
  47.   
  48.     public float getOffset() {  
  49.         return offset;  
  50.     }  
  51.   
  52.     public void setOffset(float offset) {  
  53.         this.offset = offset;  
  54.     }  
  55.   
  56.     @Override  
  57.     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
  58.         width = src.getWidth();  
  59.         height = src.getHeight();  
  60.   
  61.         if ( dest == null )  
  62.             dest = createCompatibleDestImage( src, null );  
  63.   
  64.         int[] inPixels = new int[width*height];  
  65.         int[] outPixels = new int[width*height];  
  66.         getRGB( src, 00, width, height, inPixels );  
  67.         houghTransform(inPixels, outPixels);  
  68.         setRGB( dest, 00, width, height, outPixels );  
  69.         return dest;  
  70.     }  
  71.   
  72.     private void houghTransform(int[] inPixels, int[] outPixels) {  
  73.         // prepare for hough transform  
  74.         int centerX = width / 2;  
  75.         int centerY = height / 2;  
  76.         double hough_interval = PI_VALUE/(double)hough_space;  
  77.           
  78.         int max = Math.max(width, height);  
  79.         int max_length = (int)(Math.sqrt(2.0D) * max);  
  80.         hough_1d = new int[2 * hough_space * max_length];  
  81.           
  82.         // define temp hough 2D array and initialize the hough 2D  
  83.         hough_2d = new int[hough_space][2*max_length];  
  84.         for(int i=0; i<hough_space; i++) {  
  85.             for(int j=0; j<2*max_length; j++) {  
  86.                 hough_2d[i][j] = 0;  
  87.             }  
  88.         }  
  89.           
  90.         // start hough transform now....  
  91.         int[][] image_2d = convert1Dto2D(inPixels);  
  92.         for (int row = 0; row < height; row++) {  
  93.             for (int col = 0; col < width; col++) {  
  94.                 int p = image_2d[row][col] & 0xff;  
  95.                 if(p == 0continue// which means background color  
  96.                   
  97.                 // since we does not know the theta angle and r value,   
  98.                 // we have to calculate all hough space for each pixel point  
  99.                 // then we got the max possible theta and r pair.  
  100.                 // r = x * cos(theta) + y * sin(theta)  
  101.                 for(int cell=0; cell < hough_space; cell++ ) {  
  102.                     max = (int)((col - centerX) * Math.cos(cell * hough_interval) + (row - centerY) * Math.sin(cell * hough_interval));  
  103.                     max += max_length; // start from zero, not (-max_length)  
  104.                     if (max < 0 || (max >= 2 * max_length)) {// make sure r did not out of scope[0, 2*max_lenght]  
  105.                         continue;  
  106.                     }  
  107.                     hough_2d[cell][max] +=1;  
  108.                 }  
  109.             }  
  110.         }  
  111.           
  112.         // find the max hough value  
  113.         int max_hough = 0;  
  114.         for(int i=0; i<hough_space; i++) {  
  115.             for(int j=0; j<2*max_length; j++) {  
  116.                 hough_1d[(i + j * hough_space)] = hough_2d[i][j];  
  117.                 if(hough_2d[i][j] > max_hough) {  
  118.                     max_hough = hough_2d[i][j];  
  119.                 }  
  120.             }  
  121.         }  
  122.         System.out.println("MAX HOUGH VALUE = " + max_hough);  
  123.           
  124.         // transfer back to image pixels space from hough parameter space  
  125.         int hough_threshold = (int)(threshold * max_hough);  
  126.         for(int row = 0; row < hough_space; row++) {  
  127.             for(int col = 0; col < 2*max_length; col++) {  
  128.                 if(hough_2d[row][col] < hough_threshold) // discard it  
  129.                     continue;  
  130.                 int hough_value = hough_2d[row][col];  
  131.                 boolean isLine = true;  
  132.                 for(int i=-1; i<2; i++) {  
  133.                     for(int j=-1; j<2; j++) {  
  134.                         if(i != 0 || j != 0) {  
  135.                           int yf = row + i;  
  136.                           int xf = col + j;  
  137.                           if(xf < 0continue;  
  138.                           if(xf < 2*max_length) {  
  139.                               if (yf < 0) {  
  140.                                   yf += hough_space;  
  141.                               }  
  142.                               if (yf >= hough_space) {  
  143.                                   yf -= hough_space;  
  144.                               }  
  145.                               if(hough_2d[yf][xf] <= hough_value) {  
  146.                                   continue;  
  147.                               }  
  148.                               isLine = false;  
  149.                               break;  
  150.                           }  
  151.                         }  
  152.                     }  
  153.                 }  
  154.                 if(!isLine) continue;  
  155.                   
  156.                 // transform back to pixel data now...  
  157.                 double dy = Math.sin(row * hough_interval);  
  158.                 double dx = Math.cos(row * hough_interval);  
  159.                 if ((row <= hough_space / 4) || (row >= 3 * hough_space / 4)) {  
  160.                     for (int subrow = 0; subrow < height; ++subrow) {  
  161.                       int subcol = (int)((col - max_length - ((subrow - centerY) * dy)) / dx) + centerX;  
  162.                       if ((subcol < width) && (subcol >= 0)) {  
  163.                           image_2d[subrow][subcol] = -16776961;  
  164.                       }  
  165.                     }  
  166.                   } else {  
  167.                     for (int subcol = 0; subcol < width; ++subcol) {  
  168.                       int subrow = (int)((col - max_length - ((subcol - centerX) * dx)) / dy) + centerY;  
  169.                       if ((subrow < height) && (subrow >= 0)) {  
  170.                           image_2d[subrow][subcol] = -16776961;  
  171.                       }  
  172.                     }  
  173.                   }  
  174.             }  
  175.         }  
  176.           
  177.         // convert to hough 1D and return result  
  178.         for (int i = 0; i < this.hough_1d.length; i++)  
  179.         {  
  180.           int value = clamp((int)(scale * this.hough_1d[i] + offset)); // scale always equals 1  
  181.           this.hough_1d[i] = (0xFF000000 | value + (value << 16) + (value << 8));  
  182.         }  
  183.           
  184.         // convert to image 1D and return  
  185.         for (int row = 0; row < height; row++) {  
  186.             for (int col = 0; col < width; col++) {  
  187.                 outPixels[(col + row * width)] = image_2d[row][col];  
  188.             }  
  189.         }  
  190.     }  
  191.       
  192.     public BufferedImage getHoughImage() {  
  193.         BufferedImage houghImage = new BufferedImage(hough_2d[0].length, hough_space, BufferedImage.TYPE_4BYTE_ABGR);  
  194.         setRGB(houghImage, 00, hough_2d[0].length, hough_space, hough_1d);  
  195.         return houghImage;  
  196.     }  
  197.       
  198.     public static int clamp(int value) {  
  199.           if (value < 0)  
  200.               value = 0;  
  201.           else if (value > 255) {  
  202.               value = 255;  
  203.           }  
  204.           return value;  
  205.     }  
  206.       
  207.     private int[][] convert1Dto2D(int[] pixels) {  
  208.         int[][] image_2d = new int[height][width];  
  209.         int index = 0;  
  210.         for(int row = 0; row < height; row++) {  
  211.             for(int col = 0; col < width; col++) {  
  212.                 index = row * width + col;  
  213.                 image_2d[row][col] = pixels[index];  
  214.             }  
  215.         }  
  216.         return image_2d;  
  217.     }  
  218.   
  219. }  
转载文章请务必注明出自本博客!!
2017-07-26 13:35:29 walilk 阅读数 12545
  • SIFT特征提取2

    了解Hough变换基本思想及直线检测步骤; 掌握Harris角点检测的基本思想及实现步骤; 了解尺度空间概念及SIFT特征提取的基本思想 了解ORB中快速特征检测及BRIEF特征建立方法 掌握前述算子的OpenCV实现

    2606人学习 CSDN就业班
    免费试看

前言

  [图像处理] 实验笔记系列是以图像处理算法为主的文章专栏,以我在算法研究中的实验笔记资料为基础加以整理推出的。该系列内容涉及常见的图像处理算法理论以及常见的算法应用,每篇博客都会介绍相关的算法原理,代码实现和算法在实际应用中的技巧。
  本文主要整理自笔者在一项图像处理任务中的直线检测(line detection)部分的笔记资料,采用了基于霍夫变换(Hough Transform)的直线检测算法。文中给出了直线检测常用的算法介绍,论文资料等,以及笔者的实验笔记和实验结果。
  
  文章小节安排如下:
  1)直线检测相关算法
  2)霍夫直线检测的基本原理
  3)霍夫直线检测的OpenCV实现
  4)直线检测的应用
  
  

一、直线检测相关算法  

1.1 霍夫变换(Hough Transform) 

  霍夫变换(Hough Transform)换于1962年由Paul Hough 首次提出,后于1972年由Richard Duda和Peter Hart推广使用,是图像处理中从图像中检测几何形状的基本方法之一。经典霍夫变换用来检测图像中的直线,后来霍夫变换经过扩展可以进行任意形状物体的识别,例如圆和椭圆。
  
  霍夫变换运用两个坐标空间之间的变换将在一个空间中具有相同形状的曲线或直线映射到另一个坐标空间的一个点上形成峰值,从而把检测任意形状的问题转化为统计峰值问题。
  
  参考论文:
  [1] P.V.C. Hough,Machine Analysis of Bubble Chamber Pictures, Proc. Int. Conf. High Energy Accelerators and Instrumentation, 1959.
  [2] Duda, R. O. and P. E. Hart, “Use of the Hough Transformation to Detect Lines and Curves in Pictures,”Comm. ACM, Vol. 15, pp. 11–15 (January, 1972).
  
  

1.2 霍夫直线检测(Hough Line Detection) 

  Hough直线检测的基本原理在于利用点与线的对偶性,在我们的直线检测任务中,即图像空间中的直线与参数空间中的点是一一对应的,参数空间中的直线与图像空间中的点也是一一对应的。这意味着我们可以得出两个非常有用的结论:
  1)图像空间中的每条直线在参数空间中都对应着单独一个点来表示;
  2)图像空间中的直线上任何一部分线段在参数空间对应的是同一个点。
  
  因此Hough直线检测算法就是把在图像空间中的直线检测问题转换到参数空间中对点的检测问题,通过在参数空间里寻找峰值来完成直线检测任务。
  

1.3 LSD 

  -待续-
  

二、霍夫直线检测的基本原理

2.1 关于对偶性

  首先,我们通过实例来解释一下对偶性的意义。
  1)图像空间中的点与参数空间中的直线一一对应
  在图像空间x-y中一条直线在直角坐标系下可以表示为:
  

直线方程

  其中k和b是参数,对应表示斜率和截距。
  
图像空间的直线

  过某一点A(x0, y0)的所有直线的参数均满足方程y0=k*x0+b,即点A(x0, y0)确定了一族直线。
  如果我们将方程改写为:
  
直接方程形式改写

  那么该方程在参数空间k-b中就对应了一条直线:
  
参数空间的直线

  也就是说,图像空间x-y中的点(x0,y0)对应了参数空间k-b中的直线b=-k*x0+y0。因此可以得到结论,图像空间中的点与参数空间中的直线一一对应。
  
  2)图像空间中的直线与参数空间中的点一一对应
  我们在直线y=k*x+b上再增加一个点B(x1, y1),如下图所示:
  
图像空间的直线

  那么点B(x1, y1)在参数空间同样对应了一条直线:
  
参数空间的直线
  
  可以看到,图像空间x-y中的点A和点B在参数空间k-b中对应的直线相交于一点,这也就是说AB所确定的直线,在参数空间中对应着唯一一个点,这个点的坐标值(k0, b0)也就是直线AB的参数。
  
  以上就是在直线检测任务中关于对偶性的直观解释。这个性质也为我们解决直线检测任务提供了方法,也就是把图像空间中的直线对应到参数空间中的点,最后通过统计特性来解决问题。假如图像空间中有两条直线,那么最终在参数空间中就会对应到两个峰值点,依此类推。
  

2.2 参数空间的选择

  上述为了方便讲解对偶性和霍夫变换的基本原理,我们的参数空间也选择了笛卡尔直角坐标系。但在实际应用中,参数空间是不能选择直角坐标系的,因为原始图像直角坐标空间中的特殊直线x=c(垂直x轴,直线的斜率为无穷大)是没办法在基于直角坐标系的参数空间中表示的。
  
  所以在实际应用中,参数空间采用极坐标系ρ-θ,图示如下:
  

参数空间选择极坐标系时的直线示意

  直线的表达式为:
  
直线表达式

  化简便可得到:
  

化简的直线表达式

  对于直线上的点(x0, y0),可以将通过该点的直线族定义为:
  
经过指定点的直线族表达式

  
  
  这就回到我们刚才的结论,参数空间的每个点(ρ,θ)都对应了图像空间的一条直线,或者说图像空间的一个点在参数空间中就对应为一条曲线。参数空间采用极坐标系,这样就可以在参数空间表示原始空间中的所有直线了。
  注意,此时图像空间(直角坐标系x-y)上的一个点对应到参数空间(极坐标系ρ-θ)上是一条曲线,确切的说是一条正弦曲线。
  
参数空间的曲线

  

2.3 利用霍夫变换检测直线

  如前所述,霍夫直线检测就是把图像空间中的直线变换到参数空间中的点,通过统计特性来解决检测问题。具体来说,如果一幅图像中的像素构成一条直线,那么这些像素坐标值(x, y)在参数空间对应的曲线一定相交于一个点,所以我们只需要将图像中的所有像素点(坐标值)变换成参数空间的曲线,并在参数空间检测曲线交点就可以确定直线了。
  
  在理论上,一个点对应无数条直线或者说任意方向的直线,但在实际应用中,我们必须限定直线的数量(即有限数量的方向)才能够进行计算。
  
  因此,我们将直线的方向θ离散化为有限个等间距的离散值,参数ρ也就对应离散化为有限个值,于是参数空间不再是连续的,而是被离散量化为一个个等大小网格单元。将图像空间(直角坐标系)中每个像素点坐标值变换到参数空间(极坐标系)后,所得值会落在某个网格内,使该网格单元的累加计数器加1。当图像空间中所有的像素都经过霍夫变换后,对网格单元进行检查,累加计数值最大的网格,其坐标值(ρ0, θ0)就对应图像空间中所求的直线。
  

参数空间的量化

  
  以上就是霍夫直线检测算法要做的,它检测图像中每个像素点在参数空间对应曲线之间的交点,如果交于一点的曲线的数量超过了阈值,那就可以认为这个交点(ρ,θ)在图像空间中对应一条直线。
    
    

2.4 霍夫直线检测的优缺点

  优点:
  Hough直线检测的优点是抗干扰能力强,对图像中直线的殘缺部分、噪声以及其它共存的非直线结构不敏感。
  缺点:
  Hough变换算法的特点导致其时间复杂度和空间复杂度都很高,并且在检测过程中只能确定直线方向,丢失了线段的长度信息。
  
  

三、霍夫直线检测的OpenCV实现  

  OpenCV支持三种霍夫直线检测算法:
  1)Standard Hough Transform(SHT,标准霍夫变换)
  2)Multiscale Hough Transform(MSHT,多尺度霍夫变换)
  3)Progressive Probability Houth Transform(PPHT,渐进概率式霍夫变换)
  

3.1 霍夫直线检测函数定义

  在OpenCV2.1之前的版本,霍夫直线检测函数如下:
  
  函数原型:

CVAPI(CvSeq*) cvHoughLines2( CvArr* image, void* line_storage, int method,
  double rho, double theta, int threshold,
  double param1 CV_DEFAULT(0), double param2 CV_DEFAULT(0),
  double min_theta CV_DEFAULT(0), double max_theta CV_DEFAULT(CV_PI));

  函数说明:
  cvHoughLines2老版OpenCV的霍夫直线检测函数,通过method参数可以支持三种霍夫直线检测算法,分别是CV_HOUGH_STANDARD、CV_HOUGH_PROBABILISTIC =1、CV_HOUGH_MULTI_SCALE。
  
  
  在OpenCV新版本下,霍夫直线检测算法定义了两个函数:HoughLines、HoughLinesP
  1)HoughLines:标准霍夫变换、多尺度霍夫变换
  函数原型:

CV_EXPORTS_W void 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 );
  

  参数说明:
  InputArray image:输入图像,必须是8位单通道图像。
  OutputArray lines:检测到的线条参数集合。
  double rho:以像素为单位的距离步长。
  double theta:以弧度为单位的角度步长。
  int threshold:累加计数值的阈值参数,当参数空间某个交点的累加计数的值超过该阈值,则认为该交点对应了图像空间的一条直线。
  double srn:默认值为0,用于在多尺度霍夫变换中作为参数rho的除数,rho=rho/srn。
  double stn:默认值为0,用于在多尺度霍夫变换中作为参数theta的除数,theta=theta/stn。
  
  函数说明:
  HoughLines函数输出检测到直线的矢量表示集合,每一条直线由具有两个元素的矢量(ρ, θ)表示,其中ρ表示直线距离原点(0, 0)的长度,θ表示直线的角度(以弧度为单位)。
HoughLines函数无法输出图像空间中线段的长度,这也是霍夫变换本身的弱点。

  
  备注说明:
  如果srn和stn同时为0,就表示HoughLines函数执行标准霍夫变换,否则就是执行多尺度霍夫变换。
  
  
  2)HoughLinesP:渐进概率式霍夫变换
  函数原型:

CV_EXPORTS_W void HoughLinesP( InputArray image, OutputArray lines,
  double rho, double theta, int threshold,
  double minLineLength = 0, double maxLineGap = 0 );
  

  参数说明:
  InputArray image:输入图像,必须是8位单通道图像。
  OutputArray lines:检测到的线条参数集合。
  double rho:直线搜索时的距离步长,以像素为单位。
  double theta:直线搜索时的角度步长,以弧度为单位。
  int threshold:累加计数值的阈值参数,当参数空间某个交点的累加计数的值超过该阈值,则认为该交点对应了图像空间的一条直线。
  double minLineLength:默认值为0,表示最小线段长度阈值(像素)。
  double maxLineGap:默认值为0,表示直线断裂的最大间隔距离阈值。即如果有两条线段是在一条直线上,但它们之间有间隙,那么如果这个间隔距离大于该值,则被认为是一条线段,否则认为是两条线段。
  
  函数说明:
  HoughLinesP函数输出检测到直线的矢量表示集合,每一条直线由具有四个元素的矢量(x1, y1, x2, y2)表示,其中(x1, y1)表示线段的起点,(x2, y2)表示线段的终点。
  HoughLinesP函数可以检测出图像空间中线段的长度。

  
  

3.2 霍夫直线检测函数使用

  霍夫直线变换是一种用来在图像空间寻找直线的方法,输入图像要求是二值图像,同时为了提高检测直线的效率和准确率,在使用霍夫线变换之前,最好对图像进行边缘检测生成边缘二值图像,这样的检测效果是最好的。
  
  1)HoughLines函数
  代码:

std::string img_path;
cv::Mat mat_color;
cv::Mat mat_gray;
cv::Mat mat_binary;
cv::Mat mat_canny;
cv::Mat mat_board;

img_path = "line.png";
mat_color = cv::imread(img_path, 1);
mat_gray = cv::imread(img_path, 0);
mat_board = cv::Mat(mat_color.size(), mat_color.type(), Scalar::all(255));

// binary
cv::threshold(mat_gray, mat_binary, 0.0, 255.0, cv::THRESH_OTSU);
// invert color
cv::bitwise_not(mat_binary, mat_binary);

// detect edge
Canny(mat_binary, mat_canny, 50, 200, 3);

// detect line
vector<Vec2f> lines;
HoughLines(mat_canny, lines, 1, CV_PI / 180, 150, 0, 0);

// draw line
cout << "line number: " << lines.size() << endl;
for (size_t i = 0; i < lines.size(); i++)
{
    Vec2f linex = lines[i];
    cout << "radius: " << linex[0] << ", radian: "<< linex[1] << ", angle: " << 180 / CV_PI * linex[1] << endl;
    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 + 1000 * (-b));
    pt1.y = cvRound(y0 + 1000 * (a));
    pt2.x = cvRound(x0 - 1000 * (-b));
    pt2.y = cvRound(y0 - 1000 * (a));
    line(mat_board, pt1, pt2, Scalar(255, 0, 0), 1);
}
cv::imshow("gray", mat_gray);
cv::imshow("binary", mat_binary);
cv::imshow("canny", mat_canny);
cv::imshow("color", mat_board);
cv::waitKey();

  原图:
  

原图

  二值图:
  
二值图

  边缘图:
  
边缘图

  检测效果:
  
HoughLines的检测效果

  
  2)HoughLinesP函数
  代码:

std::string img_path;
cv::Mat mat_color;
cv::Mat mat_gray;
cv::Mat mat_binary;
cv::Mat mat_canny;
cv::Mat mat_board;

img_path = "line.png";
mat_color = cv::imread(img_path, 1);
mat_gray  = cv::imread(img_path, 0);
mat_board = cv::Mat(mat_color.size(), mat_color.type(), Scalar::all(255));

// binary
cv::threshold(mat_gray, mat_binary, 0.0, 255.0, cv::THRESH_OTSU);
// invert color
cv::bitwise_not(mat_binary, mat_binary);

// detect edge
Canny(mat_binary, mat_canny, 50, 200, 3);

// detect line
vector<Vec4i> lines;
HoughLinesP(mat_canny, lines, 1, CV_PI / 180, 150, 50, 50);

// draw line
cout << "line number: " << lines.size() << endl;
for (size_t i = 0; i < lines.size(); i++)
{
    Vec4i linex = lines[i];
    line(mat_board, Point(linex[0], linex[1]), Point(linex[2], linex[3]), Scalar(255, 0, 0), 1);
}

cv::imshow("gray",   mat_gray);
cv::imshow("binary", mat_binary);
cv::imshow("canny", mat_canny);
cv::imshow("color", mat_board);
cv::waitKey();

  检测效果:
  

HoughLinesP的检测效果

  
  

四、直线检测的应用

4.1 直线检测的实际应用

  直线检测是机器视觉和模式识别中最重要的任务之一,对图像理解/分析等有重要的意义。在实际应用中,直线检测可用于机器人定位中的网格识别,板材的裂纹检测,表单票据的格式识别,零件纹路的检测,自动驾驶中的车道检测等等,可以看出,在工业领域中,直线检测以及各种图像处理技术应用是非常丰富的。
  

4.2 直线检测在图像矫正方面的应用

  笔者最近在一个OCR项目也使用了Hough Line Detection算法。在该项目中,待识别文本图像的内容是倾斜的(即文字是倾斜的),我们采用的测略就是通过直线检测确定图像内容的倾斜程度并进行旋转纠正,这样得到的无倾斜图像更有利于OCR任务。
  原图:
  

原图

  矫正效果:
  
矫正效果

  

五、参考资料

参考论文与书目:
[1] Duda, R. O. and P. E. Hart, “Use of the Hough Transformation to Detect Lines and Curves in Pictures,”Comm. ACM, Vol. 15, pp. 11–15 (January, 1972).
[2] 顾思妍. 机器视觉的直线检测技术及应用研究[D].广东工业大学,2011.
[3] 数字图像处理[M]. 电子工业出版社 , (美)RafaelC.Gonzalez,(美)RichardE.Woods,(美)StevenL.Eddins著, 2005

参考博客:
Hough变换-理解篇
http://blog.csdn.net/abcjennifer/article/details/7448513
Hough transform(霍夫变换)
http://www.cnblogs.com/AndyJee/p/3805594.html
霍夫变换概述和标准霍夫变换
http://www.jianshu.com/p/55eabb42c6c2

图像处理与识别

阅读数 9098