灰度化、二值化、膨胀算法、腐蚀算法以及开运算和闭运算

一、RGB

RGB色彩模式使用RGB模型为图像中每一个像素的RGB分量分配一个0~255范围内的强度值。RGB图像只使用三种颜色，R(red)、G(green)、B(blue)，就可以使它们按照不同的比例混合，在屏幕上呈现16777216(256 * 256 * 256)种颜色。

在电脑中，RGB的所谓“多少”就是指亮度，并使用整数来表示。通常情况下，RGB各有256级亮度，用数字表示为从0、1、2...直到255。

二、ARGB

一种色彩模式，也就是RGB色彩模式附加上Alpha（透明度）通道，常见于32位位图的存储结构。

ARGB---Alpha,Red,Green,Blue.

三、灰度化

 在RGB模型中，如果R=G=B时，则彩色表示一种灰度颜色，其中R=G=B的值叫灰度值，因此，灰度图像每个像素只需一个字节存放灰度值（又称强度值、亮度值），灰度范围为0-255。一般有以下四种方法对彩色图像进行灰度化。

1.分量法 　　

将彩色图像中的三分量的亮度作为三个灰度图像的灰度值，可根据应用需要选取一种灰度图像。f1(i,j)=R(i,j) f2(i,j)=G(i,j) f3(i,j)=B(i,j) 其中fk(i,j)(k=1,2,3)为转换后的灰度图像在（i,j）处的灰度值。

如图4-1的彩色图像转为4-2三种灰度图。

　图4-1 彩色图像 　　（a）R分量灰度图 （b）G分量灰度图 （c）B分量灰度图 　　

图4-2 彩色图的三分量灰度图 　　

2.最大值法 　　

将彩色图像中的三分量亮度的最大值作为灰度图的灰度值。 　　f(i,j)=max(R(i,j),G(i,j),B(i,j)) 　　

3.平均值法 　　

将彩色图像中的三分量亮度求平均得到一个灰度图。 　　f(i,j)=(R(i,j)+G(i,j)+B(i,j)) /3 　　

4.加权平均法 　　

根据重要性及其它指标，将三个分量以不同的权值进行加权平均。由于人眼对绿色的敏感最高，对蓝色敏感最低，因此，按下式对RGB三分量进行加权平均能得到较合理的灰度图像。 　　f(i,j)=0.30R(i,j)+0.59G(i,j)+0.11B(i,j))

四、二值化

一幅图像包括目标物体、背景还有噪声，要想从多值的数字图像中直接提取出目标物体，最常用的方法就是设定一个全局的阈值T，用T将图像的数据分成两部分：大于T的像素群和小于T的像素群。将大于T的像素群的像素值设定为白色（或者黑色），小于T的像素群的像素值设定为黑色（或者白色）。

比如：计算每一个像素的（R+G+B）/3，如果>127，则设置该像素为白色，即R=G=B=255；否则设置为黑色，即R=G=B=0。

C#实现代码如下：

[csharp] view plain copy

 print?

1. public Bitmap binarization()  
2.         {  
3.             Bitmap bitImage = new Bitmap(pictureBox1.Image);//二值化pictureBox1中的图片  
4.             Color c;  
5.             int height = pictureBox1.Image.Height;  
6.             int width = pictureBox1.Image.Width;  
7.             for (int i = 0; i < height; i++)  
8.             {  
9.                 for (int j = 0; j < width; j++)  
10.                 {  
11.                     c = bitImage.GetPixel(j,i);  
12.                     int r = c.R;  
13.                     int g = c.G;  
14.                     int b = c.B;  
15.                     if ((r + g + b) / 3 >= 127)  
16.                     {                         
17.                         bitImage.SetPixel(j, i, Color.FromArgb(255, 255, 255));                    
18.                     }  
19.                     else  
20.                     {       
21.                         bitImage.SetPixel(j, i, Color.FromArgb(0,0,0));  
22.                     }  
23.                 }  
24.             }  
25.             return bitImage;  
26.         }  

运行结果如图：

左边为处理前，右边为二值化后效果。

全局二值化，在表现图像细节方面存在很大缺陷。为了弥补这个缺陷，出现了局部二值化方法。

　　局部二值化的方法就是按照一定的规则将整幅图像划分为N个窗口，对这N个窗口中的每一个窗口再按照一个统一的阈值T将该窗口内的像素划分为两部分，进行二值化处理。

局部自适应二值化
　　局部二值化也有一个缺陷。这个缺陷存在于那个统一阈值的选定。这个阈值是没有经过合理的运算得来，一般是取该窗口的平局值。这就导致在每一个窗口内仍然出现的是全局二值化的缺陷。为了解决这个问题，就出现了局部自适应二值化方法。

　　局部自适应二值化，该方法就是在局部二值化的基础之上，将阈值的设定更加合理化。该方法的阈值是通过对该窗口像素的平均值E，像素之间的差平方P，像素之间的均方根值Q等各种局部特征，设定一个参数方程进行阈值的计算，例如：T=a*E+b*P+c*Q，其中a,b,c是自由参数。这样得出来的二值化图像就更能表现出二值化图像中的细节。

五、膨胀算法

膨胀是将与物体接触的所有背景点合并到该物体中，使边界向外部扩张的过程。

可以用来填补物体中的空洞。

 

用3x3的结构元素，扫描图像的每一个像素

用结构元素与其覆盖的二值图像做“或”操作

如果都为0，结果图像的该像素为0。否则为1

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

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

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

我设计了一个简单的膨胀算法，依次遍历整个图片的像素，分析每一个像素的周围八个像素，只要该像素周围存在黑色的像素，就设置该像素颜色为黑色。下面是使用膨胀算法处理经过二值化后的图像的C#实现代码：

[csharp] view plain copy

 print?

1. public bool[] getRoundPixel(Bitmap bitmap, int x, int y)//返回(x,y)周围像素的情况，为黑色，则设置为true  
2.         {  
3.             bool[] pixels=new bool[8];  
4.             Color c;  
5.             int num = 0;  
6.             for (int i = -1; i < 2; i++)  
7.             {  
8.                 for (int j = -1; j < 2; j++)  
9.                 {  
10.                     c = bitmap.GetPixel(x+i,y+j);  
11.                     if (i != 0 || j != 0)  
12.                     {  
13.                         if (255 == c.G)//因为经过了二值化，所以只要检查RGB中一个属性的值  
14.                         {  
15.                             pixels[num] = false;//为白色，设置为false  
16.                             num++;  
17.                         }  
18.                         else if(0==c.G)  
19.                         {  
20.                             pixels[num] = true;//为黑色，设置为true  
21.                             num++;  
22.                         }  
23.                     }  
24.                 }  
25.             }  
26.             return pixels;  
27.         }  

[csharp] view plain copy

 print?

1. public Bitmap expend()  
2.         {  
3.             Bitmap bitImage = new Bitmap(pictureBox2.Image);//处理pictureBox2中的图片  
4.             Bitmap bitImage1 = new Bitmap(pictureBox2.Image);  
5.             int height = pictureBox1.Image.Height;  
6.             int width = pictureBox1.Image.Width;  
7.             bool[] pixels;  
8.             for (int i = 1; i < width-1; i++)  
9.             {  
10.                 for (int j = 1; j < height-1; j++)  
11.                 {  
12.                       
13.                     if (bitImage.GetPixel(i, j).R != 0)  
14.                     {  
15.                         pixels = getRoundPixel(bitImage, i, j);  
16.                         for (int k = 0; k < pixels.Length; k++)  
17.                         {  
18.                             if (pixels[k] == true)  
19.                             {  
20.                                 //set this piexl's color to black  
21.                                 bitImage1.SetPixel(i, j, Color.FromArgb(0,0,0));  
22.                                 break;  
23.                             }  
24.                         }  
25.                     }  
26.                 }  
27.             }  
28.                 return bitImage1;  
29.   
30.         }  

运行结果如图：

六、腐蚀算法

腐蚀是一种消除边界点，使边界向内部收缩的过程。可以用来消除小且无意义的物体。

用3x3的结构元素，扫描图像的每一个像素

用结构元素与其覆盖的二值图像做“与”操作

如果都为1，结果图像的该像素为1。否则为0。

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

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

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

我设计了一个简单的腐蚀算法，一次遍历图像中每一个像素，检查它四周的八个像素，如果有白色的像素，则设置改点为白色。用二值化处理后的图片进行腐蚀算法C#代码如下：

[csharp] view plain copy

 print?

1. public Bitmap corrode()  
2.         {  
3.             Bitmap bitImage = new Bitmap(pictureBox2.Image);  
4.             Bitmap bitImage1 = new Bitmap(pictureBox2.Image);  
5.             Color c;  
6.             int height = pictureBox1.Image.Height;  
7.             int width = pictureBox1.Image.Width;  
8.             bool[] pixels;  
9.             for (int i = 1; i < width - 1; i++)  
10.             {  
11.                 for (int j = 1; j < height - 1; j++)  
12.                 {  
13.                     c = bitImage.GetPixel(i, j);  
14.                     if (bitImage.GetPixel(i, j).R == 0)  
15.                     {  
16.                         pixels = getRoundPixel(bitImage, i, j);  
17.                         for (int k = 0; k < pixels.Length; k++)  
18.                         {  
19.                             if (pixels[k] == false)  
20.                             {  
21.                                 //set this piexl's color to black  
22.                                 bitImage1.SetPixel(i, j, Color.FromArgb(255, 255, 255));  
23.                                 break;  
24.                             }  
25.                         }  
26.                     }  
27.                 }  
28.             }  
29.             return bitImage1;  
30.         }  

处理后图片变成：

七、开运算

先腐蚀后膨胀的过程称为开运算。用来消除小物体、在纤细点处分离物体、平滑较大物体的边界的同时并不明显改变其面积。

八、闭运算

先膨胀后腐蚀的过程称为闭运算。用来填充物体内细小空洞、连接邻近物体、平滑其边界的同时并不明显改变其面积。

文章转自：http://blog.csdn.net/hellousb2010/article/details/37939809