2015-10-24 13:28:34 Dopamy_BusyMonkey 阅读数 2109

转自:http://www.cnblogs.com/slysky/archive/2011/10/16/2214015.html

原理:在特殊领域运算形式——结构元素(Sturcture Element),在每个像素位置上与二值图像对应的区域进行特定的逻辑运算。运算结构是输出图像的相应像素。运算效果取决于结构元素大小内容以及逻辑运算性质。

结构元素:膨胀和腐蚀操作的最基本组成部分,用于测试输出图像,通常要比待处理的图像小还很多。二维平面结构元素由一个数值为0或1的矩阵组成。结构元素的原点指定了图像中需要处理的像素范围,结构元素中数值为1的点决定结构元素的邻域像素在进行膨胀或腐蚀操作时是否需要参与计算。

先来定义一些基本符号和关系。

1.         元素

设有一幅图象X,若点aX的区域以内,则称aX的元素,记作aX,如图6.1所示。

2.         B包含于X

设有两幅图象BX。对于B中所有的元素ai,都有aiX,则称B包含于(included in)X,记作B  X,如图6.2所示。

3.         B击中X

设有两幅图象BX。若存在这样一个点,它即是B的元素,又是X的元素,则称B击中(hit)X,记作BX,如图6.3所示。

4.         B不击中X

设有两幅图象BX。若不存在任何一个点,它即是B的元素,又是X的元素,即BX的交集是空,则称B不击中(miss)X,记作BX=Ф;其中∩是集合运算相交的符号,Ф表示空集。如图6.4所示。

6.1     元素

6.2     包含

6.3     击中

6.4     不击中

5.         补集

设有一幅图象X,所有X区域以外的点构成的集合称为X的补集,记作Xc,如图6.5所示。显然,如果BX=Ф,则BX的补集内,即B  Xc

6.5     补集的示意图

6.         结构元素

设有两幅图象BX。若X是被处理的对象,而B是用来处理X的,则称B为结构元素(structure element),又被形象地称做刷子。结构元素通常都是一些比较小的图象。

7.         对称集

设有一幅图象B,将B中所有元素的坐标取反,即令(xy)变成(-x-y),所有这些点构成的新的集合称为B的对称集,记作Bv,如图6.6所示。

8.         平移

设有一幅图象B,有一个点a(x0,y0),将B平移a后的结果是,把B中所有元素的横坐标加x0,纵坐标加y0,即令(xy)变成(x+x0y+y0),所有这些点构成的新的集合称为B的平移,记作Ba,如图6.7所示。

6.6     对称集的示意图

6.7     平移的示意图

好了,介绍了这么多基本符号和关系,现在让我们应用这些符号和关系,看一下形态学的基本运算。


把结构元素B平移a后得到Ba,若Ba包含于X,我们记下这个a点,所有满足上述条件的a点组成的集合称做XB腐蚀(Erosion)的结果。用公式表示为:E(X)={a| Ba  X}=X B,如图6.8所示。

6.8     腐蚀的示意图

6.8X是被处理的对象,B是结构元素。不难知道,对于任意一个在阴影部分的点aBa 包含于X,所以XB腐蚀的结果就是那个阴影部分。阴影部分在X的范围之内,且比X小,就象X被剥掉了一层似的,这就是为什么叫腐蚀的原因。

值得注意的是,上面的B是对称的,即B的对称集Bv=B,所以XB腐蚀的结果和X Bv腐蚀的结果是一样的。如果B不是对称的,让我们看看图6.9,就会发现XB腐蚀的结果和X Bv腐蚀的结果不同。

6.9     结构元素非对称时,腐蚀的结果不同

6.8和图6.9都是示意图,让我们来看看实际上是怎样进行腐蚀运算的。

在图6.10中,左边是被处理的图象X(二值图象,我们针对的是黑点),中间是结构元素B,那个标有origin的点是中心点,即当前处理元素的位置,我们在介绍模板操作时也有过类似的概念。腐蚀的方法是,拿B的中心点和X上的点一个一个地对比,如果B上的所有点都在X的范围内,则该点保留,否则将该点去掉;右边是腐蚀后的结果。可以看出,它仍在原来X的范围内,且比X包含的点要少,就象X被腐蚀掉了一层。

6.10   腐蚀运算

6.11为原图,图6.12为腐蚀后的结果图,能够很明显地看出腐蚀的效果。

6.11    原图

6.12   腐蚀后的结果图

下面的这段程序,实现了上述的腐蚀运算,针对的都是黑色点。参数中有一个BOOL变量,为真时,表示在水平方向进行腐蚀运算,即结构元素B  ;否则在垂直方向上进行腐蚀运算,即结构元素B  


膨胀

膨胀(dilation)可以看做是腐蚀的对偶运算,其定义是:把结构元素B平移a后得到Ba,若Ba击中X,我们记下这个a点。所有满足上述条件的a点组成的集合称做XB膨胀的结果。用公式表示为:D(X)={a | BaX}=X  B,如图6.13所示。图6.13X是被处理的对象,B是结构元素,不难知道,对于任意一个在阴影部分的点aBa击中X,所以XB膨胀的结果就是那个阴影部分。阴影部分包括X的所有范围,就象X膨胀了一圈似的,这就是为什么叫膨胀的原因。

同样,如果B不是对称的,XB膨胀的结果和X Bv膨胀的结果不同。

让我们来看看实际上是怎样进行膨胀运算的。在图6.14中,左边是被处理的图象X(二值图象,我们针对的是黑点),中间是结构元素B。膨胀的方法是,拿B的中心点和X上的点及X周围的点一个一个地对,如果B上有一个点落在X的范围内,则该点就为黑;右边是膨胀后的结果。可以看出,它包括X的所有范围,就象X膨胀了一圈似的。

6.13   膨胀的示意图

6.14   膨胀运算

6.15为图6.11膨胀后的结果图,能够很明显的看出膨胀的效果。

6.15   6.11膨胀后的结果图

下面的这段程序,实现了上述的膨胀运算,针对的都是黑色点。参数中有一个BOOL变量,为真时,表示在水平方向进行膨胀运算,即结构元素B  ;否则在垂直方向上进行膨胀运算,即结构元素B  


腐蚀运算和膨胀运算互为对偶的,用公式表示为(X  B)c=(Xc  B),即B腐蚀后的补集等于X的补集被B膨胀。这句话可以形象的理解为:河岸的补集为河面,河岸的腐蚀等价于河面的膨胀。你可以自己举个例子来验证一下这个关系。在有些情况下,这个对偶关系是非常有用的。例如:某个图象处理系统用硬件实现了腐蚀运算,那么不必再另搞一套膨胀的硬件,直接利用该对偶就可以实现了。


先腐蚀后膨胀称为开(open),即OPEN(X)=D(E(X))

让我们来看一个开运算的例子(见图6.16)

6.16开运算

在图16上面的两幅图中,左边是被处理的图象X(二值图象,我们针对的是黑点),右边是结构元素B,下面的两幅图中左边是腐蚀后的结果;右边是在此基础上膨胀的结果。可以看到,原图经过开运算后,一些孤立的小点被去掉了。一般来说,开运算能够去除孤立的小点,毛刺和小桥(即连通两块区域的小点),而总的位置和形状不变。这就是开运算的作用。要注意的是,如果B是非对称的,进行开运算时要用B的对称集Bv膨胀,否则,开运算的结果和原图相比要发生平移。图6.17和图6.18能够说明这个问题。

6.17 B膨胀后,结果向左平移了

6.18   Bv膨胀后位置不变

6.17是用B膨胀的,可以看到,OPEN(X)向左平移了。图18是用Bv膨胀的,可以看到,总的位置和形状不变。

6.19为图6.11经过开运算后的结果。

6.19   6.11经过开运算后的结果

开运算的源程序可以很容易的根据上面的腐蚀,膨胀程序得到,这里就不给出了。

先膨胀后腐蚀称为闭(close),即CLOSE(X)=E(D(X))

让我们来看一个闭运算的例子(见图6.20)

6.20   闭运算

在图6.20上面的两幅图中,左边是被处理的图象X(二值图象,我们针对的是黑点),右边是结构元素B,下面的两幅图中左边是膨胀后的结果,右边是在此基础上腐蚀的结果可以看到,原图经过闭运算后,断裂的地方被弥合了。一般来说,闭运算能够填平小湖(即小孔),弥合小裂缝,而总的位置和形状不变。这就是闭运算的作用。同样要注意的是,如果B是非对称的,进行闭运算时要用B的对称集Bv膨胀,否则,闭运算的结果和原图相比要发生平移。

6.21为图6.11经过闭运算后的结果。

6.21   .611经过闭运算后的结果

闭运算的源程序可以很容易的根据上面的膨胀,腐蚀程序得到,这里就不给出了。

你大概已经猜到了,开和闭也是对偶运算,的确如此。用公式表示为(OPEN(X))c=CLOSE((Xc)),或者(CLOSE(X))c =OPEN((Xc))。即开运算的补集等于X的补集的闭运算,或者闭运算的补集等于X的补集的开运算。这句话可以这样来理解:在两个小岛之间有一座小桥,我们把岛和桥看做是处理对象X,则X的补集为大海。如果涨潮时将小桥和岛的外围淹没(相当于用尺寸比桥宽大的结构元素对X进行开运算),那么两个岛的分隔,相当于小桥两边海域的连通(Xc做闭运算)


细化(thinning)算法有很多,我们在这里介绍的是一种简单而且效果很好的算法,用它就能够实现从文本抽取骨架的功能。我们的对象是白纸黑字的文本,但在程序中为了处理的方便,还是采用256级灰度图,不过只用到了调色板中0255两项。

所谓细化,就是从原来的图中去掉一些点,但仍要保持原来的形状。实际上,是保持原图的骨架。所谓骨架,可以理解为图象的中轴,例如一个长方形的骨架是它的长方向上的中轴线;正方形的骨架是它的中心点;圆的骨架是它的圆心,直线的骨架是它自身,孤立点的骨架也是自身。文本的骨架嘛,前言中的例子显示的很明白。那么怎样判断一个点是否能去掉呢?显然,要根据它的八个相邻点的情况来判断,我们给几个例子(如图6.22所示)

6.22   根据某点的八个相邻点的情况来判断该点是否能删除

6.22中,(1)不能删,因为它是个内部点,我们要求的是骨架,如果连内部点也删了,骨架也会被掏空的;(2)不能删,和(1)是同样的道理;(3)可以删,这样的点不是骨架;(4)不能删,因为删掉后,原来相连的部分断开了;(5)可以删,这样的点不是骨架;(6)不能删,因为它是直线的端点,如果这样的点删了,那么最后整个直线也被删了,剩不下什么;(7)不能删,因为孤立点的骨架就是它自身。

总结一下,有如下的判据:(1)内部点不能删除;(2)孤立点不能删除;(3)直线端点不能删除;(4)如果P是边界点,去掉P后,如果连通分量不增加,则P可以删除。

我们可以根据上述的判据,事先做出一张表,从0255共有256个元素,每个元素要么是0,要么是1。我们根据某点(当然是要处理的黑色点了)的八个相邻点的情况查表,若表中的元素是1,则表示该点可删,否则保留。

查表的方法是,设白点为1,黑点为0;左上方点对应一个8位数的第一位(最低位),正上方点对应第二位,右上方点对应的第三位,左邻点对应第四位,右邻点对应第五位,左下方点对应第六位,正下方点对应第七位,右下方点对应的第八位,按这样组成的8位数去查表即可。例如上面的例子中(1)对应表中的第0项,该项应该为0(2)对应37,该项应该为0(3)对应173,该项应该为1(4)对应231,该项应该为0(5)对应237,该项应该为1(6)对应254,该项应该为0(7)对应255,该项应该为0

这张表我已经替大家做好了,可花了我不少时间呢!

static int erasetable[256]={

                                         0,0,1,1,0,0,1,1,          1,1,0,1,1,1,0,1,

                                   1,1,0,0,1,1,1,1,             0,0,0,0,0,0,0,1,

                                          0,0,1,1,0,0,1,1,             1,1,0,1,1,1,0,1,

                                          1,1,0,0,1,1,1,1,             0,0,0,0,0,0,0,1,

                                          1,1,0,0,1,1,0,0,             0,0,0,0,0,0,0,0,

                                          0,0,0,0,0,0,0,0,             0,0,0,0,0,0,0,0,

                                          1,1,0,0,1,1,0,0,             1,1,0,1,1,1,0,1,

                                   0,0,0,0,0,0,0,0,             0,0,0,0,0,0,0,0,

                           0,0,1,1,0,0,1,1,             1,1,0,1,1,1,0,1,

                                          1,1,0,0,1,1,1,1,             0,0,0,0,0,0,0,1,

                                          0,0,1,1,0,0,1,1,             1,1,0,1,1,1,0,1,

                                          1,1,0,0,1,1,1,1,             0,0,0,0,0,0,0,0,

                                          1,1,0,0,1,1,0,0,             0,0,0,0,0,0,0,0,

                                1,1,0,0,1,1,1,1,             0,0,0,0,0,0,0,0,

                                          1,1,0,0,1,1,0,0,             1,1,0,1,1,1,0,0,

                                   1,1,0,0,1,1,1,0,             1,1,0,0,1,0,0,0

                                     };

有了这张表,算法就很简单了,每次对一行一行的将整个图象扫描一遍,对于每个点(不包括边界点),计算它在表中对应的索引,若为0,则保留,否则删除该点。如果这次扫描没有一个点被删除,则循环结束,剩下的点就是骨架点,如果有点被删除,则进行新的一轮扫描,如此反复,直到没有点被删除为止。

实际上,该算法有一些缺陷。举个简单的例子,有一个黑色矩形,如图6.23所示。

6.23经过细化后,我们预期的结果是一条水平直线,且位于该黑色矩形的中心。实际的结果确实是一条水平直线,但不是位于黑色矩形的中心,而是最下面的一条边。

为什么会这样,我们来分析一下:在从上到下,从左到右的扫描过程中,我们遇到的第一个黑点就是黑色矩形的左上角点,经查表,该点可以删。下一个点是它右边的点,经查表,该点也可以删,如此下去,整个一行被删了。每一行都是同样的情况,所以都被删除了。到了最后一行时,黑色矩形已经变成了一条直线,最左边的黑点不能删,因为它是直线的端点,它右边的点也不能删,因为如果删除,直线就断了,如此下去,直到最右边的点,也不能删,因为它是直线的右端点。所以最下面的一条边保住了,但这并不是我们希望的结果。

解决的办法是,在每一行水平扫描的过程中,先判断每一点的左右邻居,如果都是黑点,则该点不做处理。另外,如果某个黑点被删除了,那么跳过它的右邻居,处理下一个点。这样就避免了上述的问题。

6.23  黑色矩形

6.24  6.23细化后的结果

解决了上面的问题,我们来看看处理后的结果,如图6.24所示。这次变成一小段竖线了,还是不对,是不是很沮丧?别着急,让我们再来分析一下:在上面的算法中,我们遇到的第一个能删除的点就是黑色矩形的左上角点;第二个是第一行的最右边的点,即黑色矩形的右上角点;第三个是第二行的最左边的点;第四个是第二行的最右边的点;……;整个图象处理这样一次后,宽度减少2。每次都是如此,直到剩最中间一列,就不能再删了。为什么会这样呢?原因是这样的处理过程只实现了水平细化,如果在每一次水平细化后,再进行一次垂直方向的细化(只要把上述过程的行列换一下),就可以了。

这样一来,每处理一次,删除点的顺序变成:(先是水平方向扫描)第一行最左边的点;第一行最右边的点;第二行最左边的点;第二行最右边的点;……最后一行最左边的点;最后一行最右边的点;(然后是垂直方向扫描)第二列最上边的点(因为第一列最上边的点已被删除);第二列最下边的点;第三列最上边的点;第三列最下边的点;……倒数第二列最上边的点(因为倒数第一列最上边的点已被删除);倒数第二列最下边的点。我们发现,刚好剥掉了一圈,这也正是细化要做的事。实际的结果也验证了我们的想法。


题外话:

腐蚀:删除对象边界的某些像素

膨胀:给图像中的对象边界添加像素

算法:

膨胀算法:用3X3的结构元素,扫描二值图像的每一个像素,用结构元素与其覆盖的二值图像做“与”运算,如果都为0,结构图像的该像素为0,否则为1.结果:使二值图像扩大一圈。

腐蚀算法:用3X3的结构元素,扫描二值图像的每一个像素,用结构元素与其覆盖的二值图像做“与”运算,如果都为1,结构图像的该像素为1,否则为0.结果:使二值图像减小一圈。


2016-10-18 15:54:45 lcb1992 阅读数 618

开操作是先腐蚀再膨胀,闭操作是先膨胀再腐蚀。灰度图像是求最大最小值,二值图像是进行与运算。

二值图像:

1.二值腐蚀的具体操作是:用一个结构元素(一般是3×3的大小)扫描图像中的每一个像素,用结构元素中的每一个像素与其覆盖的像素做“与”操作,如果都为1,则该像素为1,否则为0。中心及领域有一个点不是黑点,该点就被腐蚀成白点

2.二值膨胀的具体操作是:用一个结构元素(一般是3×3的大小)扫描图像中的每一个像素,用结构元素中的每一个像素与其覆盖的像素做“与”操作,如果都为0,则该像素为0,否则为1。

目的:开操作可以平滑物体轮廓,断开较窄的狭颈和消除细小的突出物。
   闭操作同样可以平滑轮廓的一部分,但与开操作相反,它通常会弥合较窄的间断和细长的沟壑,消除小的孔洞,填补轮廓线中的断裂。

灰度图像:
1. 灰度形态学膨胀:膨胀就是求局部最大值的操作,结构元素B扫描图像的每一个像素,即计算核B覆盖的图像区域的像素点的最大值,并把这个最大值赋值给参考点(核B的中心点)指定的像素,使图像变明亮。
2. 灰度形态学腐蚀:求局部最小值的操作,结构元素B扫描图像的每一个像素,即计算核B覆盖的图像区域的像素点的最小值,并把这个最小值赋值给参考点(核B的中心点)指定的像素,使图像变灰暗。



2019-01-09 20:22:10 qq_42887760 阅读数 752

形态学操作(morphology operators)-膨胀与腐蚀(Dilation与Erosion)。

  • 图像形态学操作
    • 图像形态学操作 – 基于形状的一系列图像处理操作的合集,主要是基于集合论基础上的形态学数学
    • 形态学有四个基本操作:腐蚀、膨胀、开、闭
    • 膨胀与腐蚀是图像处理中最常用的形态学操作手段
    • 腐蚀和膨胀是对白色部分(高亮部分)而言的,不是黑色部分。膨胀就是图像中的高亮部分进行膨胀,“领域扩张”,效果图拥有比原图更大的高亮区域。腐蚀就是原图中的高亮部分被腐蚀,“领域被蚕食”,效果图拥有比原图更小的高亮区域。
  • 膨胀与腐蚀能实现多种多样的功能,主要如下:
    • 消除噪声
    • 分割(isolate)出独立的图像元素,在图像中连接(join)相邻的元素。
    • 寻找图像中的明显的极大值区域或极小值区域
    • 求出图像的梯度
相关的 API

getStructuringElement(int shape, Size ksize, Point anchor)

  • 形状 (MORPH_RECT \MORPH_CROSS \MORPH_ELLIPSE)
  • 大小
  • 锚点 默认是Point(-1, -1)意思就是中心像素

1. 形态学操作-膨胀

  • 相关的API:dilate(src, dst, kernel);
    在这里插入图片描述
  • 跟卷积操作类似,假设有图像A和结构元素B,结构元素B在A上面移动,其中B定义其中心为锚点,计算B覆盖下A的最大像素值用来替换锚点的像素,其中B作为结构体可以是任意形状
  • 形态学操作-膨胀(感官上图像变细,变白了)
    在这里插入图片描述

2. 形态学操作-腐蚀

  • 相关的API:erode(src, dst, kernel)
    在这里插入图片描述
  • 腐蚀跟膨胀操作的过程类似,唯一不同的是以最小值替换锚点重叠下图像的像素值
  • 形态学操作-腐蚀(感官上图像变粗,变黑了)

在这里插入图片描述

动态调整结构元素大小

  • TrackBar –
    createTrackbar(const String & trackbarname, const String winName, int* value, int count, Trackbarcallback func, void* userdata=0)
    其中最中要的是 callback 函数功能。如果设置为NULL就是说只有值update,但是不会调用callback的函数。

代码示例

#include<opencv2/opencv.hpp>
#include<iostream>
#include<math.h>
using namespace cv;
using namespace std;

Mat src,erode_dst,dilate_dst;
char input_Win[]="input windows",dilate_Win[]="Dilation windows",Erode_Win[]="Erosion windows";
int dilate_elem=0,erode_elem=0;
int dilate_size=0,erode_size=0;
int const max_elem=2;
int const max_kernel_size=21;

void Dilation(int,void*);//膨胀
void Erosion(int,void*);//腐蚀

int main(int argc,char** argv){
	//1、加载图像,可以是BGR或灰度
	src = imread("E:/Experiment/OpenCV/Pictures/lenanoise.jpg");
	if(src.empty()){
		printf("Could not load Image ...");
		return -1;
	}

	namedWindow(input_Win,CV_WINDOW_AUTOSIZE);
	imshow(input_Win,src);
	
	//2、创建两个窗口(一个用于膨胀Dilation,另一个用于侵蚀Erosion)
	//每次移动任何滑块时,都会调用用户的Erosion或Dilation函数,它将根据当前的trackbar值更新输出图像。
	namedWindow(dilate_Win,CV_WINDOW_AUTOSIZE);
	namedWindow(Erode_Win,CV_WINDOW_AUTOSIZE);
	
	//3、为每个操作创建两组轨道栏:
	
	//3.1、第一个轨道栏“Element”返回erosion_elem或dilation_elem
	createTrackbar("卷积核类型",dilate_Win,&dilate_elem,max_elem,Dilation);
	//3.2、第二个轨道栏“内核大小”返回相应操作的erosion_size或dilation_size。
	createTrackbar("卷积核大小",dilate_Win,&dilate_size,max_kernel_size,Dilation);
	
	
	createTrackbar("卷积核类型",Erode_Win,&erode_elem,max_elem,Erosion);
	createTrackbar("卷积核大小",Erode_Win,&erode_size,max_kernel_size,Erosion);

	Dilation( 0, 0 );
	Erosion( 0, 0 );

	waitKey(0);
}

//膨胀
void Dilation(int,void*){
	int dilate_type;//内核选择三种形状中的任何一种
	if(dilate_elem == 0){ dilate_type = MORPH_RECT; }//矩形内核:MORPH_RECT
	else if(dilate_elem == 1){ dilate_type = MORPH_CROSS; }//十字架内核:MORPH_CROSS
	else if(dilate_elem == 2){ dilate_type = MORPH_ELLIPSE; }//椭圆内核:MORPH_ELLIPSE

	Mat kernel = getStructuringElement(dilate_type,Size(2*dilate_size+1,2*dilate_size+1),Point(dilate_size,dilate_size));
	dilate(src,dilate_dst,kernel);
	imshow( dilate_Win, dilate_dst );
}

//腐蚀
void Erosion(int,void*){
	int erosion_type;//内核选择三种形状中的任何一种
	if(erode_elem == 0){ erosion_type = MORPH_RECT; }//矩形内核:MORPH_RECT
	else if(erode_elem == 1){ erosion_type = MORPH_CROSS; }//十字架内核:MORPH_CROSS
	else if(erode_elem == 2){ erosion_type = MORPH_ELLIPSE; }//椭圆内核:MORPH_ELLIPSE

	Mat kernel = getStructuringElement(erosion_type,Size(2*erode_size+1,2*erode_size+1),Point(erode_size,erode_size));
	erode(src,erode_dst,kernel);
	imshow( Erode_Win, erode_dst );
}

在这里插入图片描述

推荐参考:

  1. https://blog.csdn.net/LYKymy/article/details/83153122
  2. https://blog.csdn.net/huanghuangjin/article/details/80945770
2014-01-23 14:32:54 cxf7394373 阅读数 5492

腐蚀的算法:

用3x3的结构元素,扫描图像的每一个像素,用结构元素与其覆盖的二值图像做“与”操作:如果都为1,结果图像的该像素为1。否则为0。

结果:使二值图像减小一圈

B}Í S = { x,y | SxyÄ定义:E = B

 

膨胀的算法:

用3x3的结构元素,扫描图像的每一个像素,用结构元素与其覆盖的二值图像做“与”操作:如果都为0,结果图像的该像素为0。否则为1

结果:使二值图像扩大一圈

 S = { x,y | Sxy∩B ≠Ф}Å定义:E = B 

void erode_image(IplImage * src,IplImage * dst)
{	
	if(src == NULL || dst == NULL)
		return;
	
	int width = src->width;
	int height = src->height;

	//水平方向的腐蚀
	for (int i=0;i < src->height;i++)
	{
		for (int j=1;j < src->width - 1;j++)
		{
		//	data = ((uchar *)(src->imageData + src->widthStep * i))[j];
			if(((uchar *)(src->imageData + src->widthStep * i))[j] == 0)
			{
				((uchar *)(dst->imageData + dst->widthStep * i))[j] = 0;
				for (int k=0;k < 3;k++)
				{
				//	data = ((uchar *)(src->imageData + src->widthStep * i))[j + k -1];
					if(((uchar *)(src->imageData + src->widthStep * i))[j + k -1] == 255)
					{
						((uchar *)(dst->imageData + dst->widthStep * i))[j] = 255;
						break;
					}
				}
			}
			else
				((uchar *)(dst->imageData + dst->widthStep * i))[j] = 255;
		}
	}
	//垂直方向的腐蚀
	for (int i=0;i < dst->width;i++)
	{
		for (int j=1;j < dst->height - 1;j++)
		{
			//	data = ((uchar *)(src->imageData + src->widthStep * i))[j];
			if(((uchar *)(dst->imageData + dst->widthStep * j))[i] == 0)
			{
				((uchar *)(src->imageData + src->widthStep * j))[i] = 0;
				for (int k=0;k < 3;k++)
				{
					//	data = ((uchar *)(src->imageData + src->widthStep * i))[j + k -1];
					if(((uchar *)(dst->imageData + dst->widthStep * (j + k -1)))[i] == 255)
					{
						((uchar *)(src->imageData + src->widthStep * j))[i] = 255;
						break;
					}
				}
			}
			else
				((uchar *)(src->imageData + src->widthStep * j))[i] = 255;
		}
	}
}	
void dilate_image(IplImage * src,IplImage * dst)
{	
	if(src == NULL || dst == NULL)
		return;

	int width = src->width;
	int height = src->height;

	//水平方向的膨胀
	for (int i=0;i < src->height;i++)
	{
		for (int j=1;j < src->width - 1;j++)
		{
			if(((uchar *)(src->imageData + src->widthStep * i))[j] == 255)
			{
				((uchar *)(dst->imageData + dst->widthStep * i))[j] = 255;
				for (int k=0;k < 3;k++)
				{
					if(((uchar *)(src->imageData + src->widthStep * i))[j + k -1] == 0)
					{
						((uchar *)(dst->imageData + dst->widthStep * i))[j] = 0;
						break;
					}
				}
			}
			else
				((uchar *)(dst->imageData + dst->widthStep * i))[j] = 0;
		}
	}
	//垂直方向的膨胀
	for (int i=0;i < dst->width;i++)
	{
		for (int j=1;j < dst->height - 1;j++)
		{
			//	data = ((uchar *)(src->imageData + src->widthStep * i))[j];
			if(((uchar *)(dst->imageData + dst->widthStep * j))[i] == 255)
			{
				((uchar *)(src->imageData + src->widthStep * j))[i] = 255;
				for (int k=0;k < 3;k++)
				{
					//	data = ((uchar *)(src->imageData + src->widthStep * i))[j + k -1];
					if(((uchar *)(dst->imageData + dst->widthStep * (j + k -1)))[i] == 0)
					{
						((uchar *)(src->imageData + src->widthStep * j))[i] = 0;
						break;
					}
				}
			}
			else
				((uchar *)(src->imageData + src->widthStep * j))[i] = 0;
		}
	}
}
image = cvLoadImage(filename,CV_LOAD_IMAGE_GRAYSCALE);
		dst1 = cvCreateImage(cvSize(image->width,image->height),image->depth,image->nChannels);
		
		dilate_image(image,dst1);
		erode_image(image,dst1);

		cvSaveImage(str,image);

原图


结果



2017-10-07 19:08:20 weixin_40202230 阅读数 2517


一、准备知识1——概念介绍

1.形态学是什么

形态学在数字图像处理中表示的是图像的数学形态里的内容,将数学形态学作为工具从图像中提取区域图像形状的有用的图像分量,如边缘、骨架,区域分割等。

如例:


如例:

如例:


2、数学形态学的语言是集合论。这个集合表示的是图像中的对象。
3、有哪些对象呢?
在二值图像中,每一个像素点都是一个对象,像素点的值只有0,1之分,所以,所有值为1的像素的集合就是一个完整的形态学描述。在这个集合里,每个元素都是一个二维向量(像素值都是1,只有x,y坐标信息不一致)。在灰度图像中,一个图片包含了一个像素点的坐标值、像素的亮度值。所以可以将其看作是三位空间上的一个集合。还有些图像有更高维的信息,如RGB图像,有R、G、B三个图像通道,每个通道都有坐标和像素值,RGB-D传感器有四个通道。

二、关于图像知识

1、反射


2、平移


3、结构元(SE):

即:研究图像感兴趣部分时用的小集合或小图片
SE里包含了成员和原点(原点的设立依赖于问题)


4.结构元的使用


三、原理

1、腐蚀


2、膨胀


四、代码

clear all;
clc;

%图像进行中值滤波,并显示图像
%读进图像
 [filename, pathname] = uigetfile({'*.jpg'; '*.bmp'; '*.gif'}, '选择原图片');

%没有图像
if filename == 0
    return;
end

picture = imread([pathname, filename]);
[m, n, z] = size(picture);

%彩色图片转化为二进制图片
if z>1
    graypicture = rgb2gray(picture);%转换为灰度图
    level = graythresh(graypicture);%使用最大类间方差法找到图片的一个合适的阈值
    imgbw = im2bw(graypicture,level);%将灰度图像 picture 转换为二进制图像 
end

%图像膨胀
b=[0 1 0;1 1 1;0 1 0];
c=imdilate(imgbw,b);

%图像腐蚀
d=imerode(imgbw,b);

figure(1)
 subplot(1,4,1);
    imshow(picture);
    title('原图片');
 subplot(1,4,2);
    imshow(imgbw);
    title('二值图片');
 subplot(1,4,3);
    imshow(c);
    title('膨胀图片');
 subplot(1,4,4);
    imshow(d);
    title('腐蚀图片');

五、实验结果


没有更多推荐了,返回首页