[转]灰度图像的腐蚀算法和细化算法（C#代码）

本文转自：http://www.cnblogs.com/yuanbao/archive/2008/04/12/1149923.html

最近做一些图像处理，需要将图像中的一些像素过滤一下，有网友给提了个名词：腐蚀算法。我不是学图像学的，乍一听，觉得很神奇。后来从网上收集了一些VC代码，研究了一下，发现其它也就是那么回事。尤其是腐蚀算法，我在以前的验证码图片去噪声的文章中提到过，只是那是我不知叫什么名词，就从用途出发，叫做“根据周边点数去噪”。腐蚀的原理也一样，就是根据当前点的周边点数（如3X3的，周边就有8个点）来修改当前点的状态的。
代码是我从VC代码中转译过来的，注释都沿用了原作者的文字（别说是剽窃，^_^)。唯一改进的地方是，原代码功能只能处理0和255的二值灰度（搞不懂为什么这样，对于250、128这样的都不行，还不如弄成二值灰度，别弄256灰度了），我将之改成了能根据0~255中任意灰度划界的256灰度图像！
以下是C#代码：

/// <summary>
2

/// 该函数用于对图像进行腐蚀运算。结构元素为水平方向或垂直方向的三个点，
3

/// 中间点位于原点；或者由用户自己定义3×3的结构元素。
4

/// </summary>
5

/// <param name="dgGrayValue">前后景临界值</param>
6

/// <param name="nMode">腐蚀方式：0表示水平方向，1垂直方向，2自定义结构元素。</param>
7

/// <param name="structure"> 自定义的3×3结构元素</param>
8

public void ErosionPic(int dgGrayValue, int nMode, bool[,] structure)
9

{
10

int lWidth = bmpobj.Width;
11

int lHeight = bmpobj.Height;
12

Bitmap newBmp = new Bitmap(lWidth, lHeight);
13

int i, j, n, m; //循环变量
15

Color pixel; //像素颜色值
16

if (nMode == 0)
18

{
19

//使用水平方向的结构元素进行腐蚀
20

// 由于使用1×3的结构元素，为防止越界，所以不处理最左边和最右边
21

// 的两列像素
22

for (j = 0; j < lHeight; j++)
23

{
24

for (i = 1; i < lWidth - 1; i++)
25

{
26

//目标图像中的当前点先赋成黑色
27

newBmp.SetPixel(i, j, Color.Black);
28

//如果源图像中当前点自身或者左右有一个点不是黑色，
30

//则将目标图像中的当前点赋成白色
31

if (bmpobj.GetPixel(i - 1, j).R > dgGrayValue ||
32

bmpobj.GetPixel(i, j).R > dgGrayValue ||
33

bmpobj.GetPixel(i + 1, j).R > dgGrayValue)
34

newBmp.SetPixel(i, j, Color.White);
35

}
36

}
37

}
38

else if (nMode == 1)
39

{
40

//使用垂真方向的结构元素进行腐蚀
41

// 由于使用3×1的结构元素，为防止越界，所以不处理最上边和最下边
42

// 的两行像素
43

for (j = 1; j < lHeight - 1; j++)
44

{
45

for (i = 0; i < lWidth; i++)
46

{
47

//目标图像中的当前点先赋成黑色
48

newBmp.SetPixel(i, j, Color.Black);
49

//如果源图像中当前点自身或者左右有一个点不是黑色，
51

//则将目标图像中的当前点赋成白色
52

if (bmpobj.GetPixel(i, j - 1).R > dgGrayValue ||
53

bmpobj.GetPixel(i, j).R > dgGrayValue ||
54

bmpobj.GetPixel(i, j + 1).R > dgGrayValue)
55

newBmp.SetPixel(i, j, Color.White);
56

}
57

}
58

}
59

else
60

{
61

if (structure.Length != 9) //检查自定义结构
62

return;
63

//使用自定义的结构元素进行腐蚀
64

// 由于使用3×3的结构元素，为防止越界，所以不处理最左边和最右边
65

// 的两列像素和最上边和最下边的两列像素
66

for (j = 1; j < lHeight - 1; j++)
67

{
68

for (i = 1; i < lWidth - 1; i++)
69

{
70

//目标图像中的当前点先赋成黑色
71

newBmp.SetPixel(i, j, Color.Black);
72

//如果原图像中对应结构元素中为黑色的那些点中有一个不是黑色，
73

//则将目标图像中的当前点赋成白色
74

for (m = 0; m < 3; m++)
75

{
76

for (n = 0; n < 3; n++)
77

{
78

if (!structure[m, n])
79

continue;
80

if (bmpobj.GetPixel(i + m - 1, j + n - 1).R > dgGrayValue)
81

{
82

newBmp.SetPixel(i, j, Color.White);
83

break;
84

}
85

}
86

}
87

}
88

}
89

}
90

bmpobj = newBmp;
92

}
93

/// <summary>
96

/// 该函数用于对图像进行细化运算。要求目标图像为灰度图像
97

/// </summary>
98

/// <param name="dgGrayValue"></param>
99

public void ThiningPic(int dgGrayValue)
100

{
101

int lWidth = bmpobj.Width;
102

int lHeight = bmpobj.Height;
103

// Bitmap newBmp = new Bitmap(lWidth, lHeight);
104

105

bool bModified; //脏标记
106

int i, j, n, m; //循环变量
107

Color pixel; //像素颜色值
108

109

//四个条件
110

bool bCondition1;
111

bool bCondition2;
112

bool bCondition3;
113

bool bCondition4;
114

115

int nCount; //计数器
116

int[,] neighbour = new int[5, 5]; //5×5相邻区域像素值
117

118

119

120

bModified = true;
121

while (bModified)
122

{
123

bModified = false;
124

125

//由于使用5×5的结构元素，为防止越界，所以不处理外围的几行和几列像素
126

for (j = 2; j < lHeight - 2; j++)
127

{
128

for (i = 2; i < lWidth - 2; i++)
129

{
130

bCondition1 = false;
131

bCondition2 = false;
132

bCondition3 = false;
133

bCondition4 = false;
134

135

if (bmpobj.GetPixel(i, j).R > dgGrayValue)
136

{
137

if(bmpobj.GetPixel(i, j).R<255)
138

bmpobj.SetPixel(i, j, Color.White);
139

continue;
140

}
141

142

//获得当前点相邻的5×5区域内像素值，白色用0代表，黑色用1代表
143

for (m = 0; m < 5; m++)
144

{
145

for (n = 0; n < 5; n++)
146

{
147

neighbour[m, n] = bmpobj.GetPixel(i + m - 2, j + n - 2).R < dgGrayValue ? 1 : 0;
148

}
149

}
150

151

//逐个判断条件。
152

//判断2<=NZ(P1)<=6
153

nCount = neighbour[1, 1] + neighbour[1, 2] + neighbour[1, 3]
154

+ neighbour[2, 1] + neighbour[2, 3] +
155

+neighbour[3, 1] + neighbour[3, 2] + neighbour[3, 3];
156

if (nCount >= 2 && nCount <= 6)
157

{
158

bCondition1 = true;
159

}
160

161

//判断Z0(P1)=1
162

nCount = 0;
163

if (neighbour[1, 2] == 0 && neighbour[1, 1] == 1)
164

nCount++;
165

if (neighbour[1, 1] == 0 && neighbour[2, 1] == 1)
166

nCount++;
167

if (neighbour[2, 1] == 0 && neighbour[3, 1] == 1)
168

nCount++;
169

if (neighbour[3, 1] == 0 && neighbour[3, 2] == 1)
170

nCount++;
171

if (neighbour[3, 2] == 0 && neighbour[3, 3] == 1)
172

nCount++;
173

if (neighbour[3, 3] == 0 && neighbour[2, 3] == 1)
174

nCount++;
175

if (neighbour[2, 3] == 0 && neighbour[1, 3] == 1)
176

nCount++;
177

if (neighbour[1, 3] == 0 && neighbour[1, 2] == 1)
178

nCount++;
179

if (nCount == 1)
180

bCondition2 = true;
181

182

//判断P2*P4*P8=0 or Z0(p2)!=1
183

if (neighbour[1, 2] * neighbour[2, 1] * neighbour[2, 3] == 0)
184

{
185

bCondition3 = true;
186

}
187

else
188

{
189

nCount = 0;
190

if (neighbour[0, 2] == 0 && neighbour[0, 1] == 1)
191

nCount++;
192

if (neighbour[0, 1] == 0 && neighbour[1, 1] == 1)
193

nCount++;
194

if (neighbour[1, 1] == 0 && neighbour[2, 1] == 1)
195

nCount++;
196

if (neighbour[2, 1] == 0 && neighbour[2, 2] == 1)
197

nCount++;
198

if (neighbour[2, 2] == 0 && neighbour[2, 3] == 1)
199

nCount++;
200

if (neighbour[2, 3] == 0 && neighbour[1, 3] == 1)
201

nCount++;
202

if (neighbour[1, 3] == 0 && neighbour[0, 3] == 1)
203

nCount++;
204

if (neighbour[0, 3] == 0 && neighbour[0, 2] == 1)
205

nCount++;
206

if (nCount != 1)
207

bCondition3 = true;
208

}
209

210

//判断P2*P4*P6=0 or Z0(p4)!=1
211

if (neighbour[1, 2] * neighbour[2, 1] * neighbour[3, 2] == 0)
212

{
213

bCondition4 = true;
214

}
215

else
216

{
217

nCount = 0;
218

if (neighbour[1, 1] == 0 && neighbour[1, 0] == 1)
219

nCount++;
220

if (neighbour[1, 0] == 0 && neighbour[2, 0] == 1)
221

nCount++;
222

if (neighbour[2, 0] == 0 && neighbour[3, 0] == 1)
223

nCount++;
224

if (neighbour[3, 0] == 0 && neighbour[3, 1] == 1)
225

nCount++;
226

if (neighbour[3, 1] == 0 && neighbour[3, 2] == 1)
227

nCount++;
228

if (neighbour[3, 2] == 0 && neighbour[2, 2] == 1)
229

nCount++;
230

if (neighbour[2, 2] == 0 && neighbour[1, 2] == 1)
231

nCount++;
232

if (neighbour[1, 2] == 0 && neighbour[1, 1] == 1)
233

nCount++;
234

if (nCount != 1)
235

bCondition4 = true;
236

}
237

238

if (bCondition1 && bCondition2 && bCondition3 && bCondition4)
239

{
240

bmpobj.SetPixel(i, j, Color.White);
241

bModified = true;
242

}
243

else
244

{
245

bmpobj.SetPixel(i, j, Color.Black);
246

}
247

}
248

}
249

}
250

// 复制细化后的图像
251

// bmpobj = newBmp;
252

}
253