图像基本处理算法的简单实现（二）

 

1. /** 
2.  * 对二值化Bitmap进行膨胀运算后返回 
3.  * 
4.  * 膨胀结构元素：3x3 全 
5.  * 
6.  * JNIEnv*  jni环境（jni必要参数） 
7.  * jobject  java对象（jni必要参数） 
8.  * jintArray    Bitmap所有像素值 
9.  * int  Bitmap宽度 
10.  * int  Bitmap高度 
11.  */ 
12. JNIEXPORT jintArray JNICALL Java_org_join_p_w_picpath_util_JoinImage_dilation( 
13.         JNIEnv* env, jobject obj, jintArray buf, int w, int h) { 
14.     LOGE("==dilation=="); 
15.  
16.     jint * cbuf; // 源图像 
17.     cbuf = (*env)->GetIntArrayElements(env, buf, 0); // 获取int数组元素 
18.  
19.     int white = 0xFFFFFFFF; // 不透明白色 
20.     int black = 0xFF000000; // 不透明黑色 
21.  
22.     int size = w * h; 
23.     jint rbuf[size]; // 目标图像 
24.     memset(rbuf, black, size * sizeof(jint)); // 将目标图像置成全黑 
25.  
26.     int i, j, m, n, gray; 
27.     jint *p, *q; 
28.     // 由于使用3×3的结构元素，为防止越界，所以不处理上下左右四边像素 
29.     for (i = 1; i < h - 1; i++) { 
30.         for (j = 1; j < w - 1; j++) { 
31.             p = cbuf + w * i + j; // 指向源图像i行j列 
32.  
33.             // 遍历源图像对应结构元素的各点 
34.             for (m = -1; m <= 1; m++) { 
35.                 for (n = -1; n <= 1; n++) { 
36.                     gray = (*(p + w * m + n)) & 0xFF; // 获取源图像对应结构元素点的灰度值 
37.                     // 如果对应3x3范围内有白点（其他色都算为黑） 
38.                     if (gray == 255) { 
39.                         q = rbuf + w * i + j; // 指向目标图像i行j列 
40.                         *q = white; // 将目标图像中的当前点赋成白色 
41.                         break; 
42.                     } 
43.                 } 
44.             } 
45.         } 
46.     } 
47.  
48.     jintArray result = (*env)->NewIntArray(env, size); // 新建一个jintArray 
49.     (*env)->SetIntArrayRegion(env, result, 0, size, rbuf); // 将rbuf转存入result 
50.     (*env)->ReleaseIntArrayElements(env, buf, cbuf, 0); // 释放int数组元素 
51.     return result; 
52. } 

1. /** 
2.  * 对二值化Bitmap进行腐蚀运算后返回 
3.  * 
4.  * 腐蚀结构元素：3x3 全 
5.  * 
6.  * JNIEnv*  jni环境（jni必要参数） 
7.  * jobject  java对象（jni必要参数） 
8.  * jintArray    Bitmap所有像素值 
9.  * int  Bitmap宽度 
10.  * int  Bitmap高度 
11.  */ 
12. JNIEXPORT jintArray JNICALL Java_org_join_p_w_picpath_util_JoinImage_erosion( 
13.         JNIEnv* env, jobject obj, jintArray buf, int w, int h) { 
14.     LOGE("==erosion=="); 
15.  
16.     jint * cbuf; // 源图像 
17.     cbuf = (*env)->GetIntArrayElements(env, buf, 0); // 获取int数组元素 
18.  
19.     int white = 0xFFFFFFFF; // 不透明白色 
20.     int black = 0xFF000000; // 不透明黑色 
21.  
22.     int size = w * h; 
23.     jint rbuf[size]; // 目标图像 
24.     memset(rbuf, black, size * sizeof(jint)); // 将目标图像置成全黑 
25.  
26.     int i, j, m, n, gray; 
27.     jint *p, *q; 
28.     // 由于使用3×3的结构元素，为防止越界，所以不处理上下左右四边像素 
29.     for (i = 1; i < h - 1; i++) { 
30.         for (j = 1; j < w - 1; j++) { 
31.             p = cbuf + w * i + j; // 指向源图像i行j列 
32.  
33.             q = rbuf + w * i + j; // 指向目标图像i行j列 
34.             *q = white; // 将目标图像中的当前点赋成白色 
35.  
36.             // 遍历源图像对应结构元素的各点 
37.             for (m = -1; m <= 1; m++) { 
38.                 for (n = -1; n <= 1; n++) { 
39.                     gray = (*(p + w * m + n)) & 0xFF; // 获取源图像对应结构元素点的灰度值 
40.                     // 如果对应3x3范围内有黑点（其他色都算为白） 
41.                     if (gray == 0) { 
42.                         *q = black; // 将目标图像中的当前点赋成黑色 
43.                         break; 
44.                     } 
45.                 } 
46.             } 
47.         } 
48.     } 
49.  
50.     jintArray result = (*env)->NewIntArray(env, size); // 新建一个jintArray 
51.     (*env)->SetIntArrayRegion(env, result, 0, size, rbuf); // 将rbuf转存入result 
52.     (*env)->ReleaseIntArrayElements(env, buf, cbuf, 0); // 释放int数组元素 
53.     return result; 
54. } 

1. /** 
2.  * 对二值化Bitmap进行细化运算后返回 
3.  * 
4.  * 采用“Zhang快速并行细化方法” 
5.  * 
6.  * JNIEnv*  jni环境（jni必要参数） 
7.  * jobject  java对象（jni必要参数） 
8.  * jintArray    Bitmap所有像素值 
9.  * int  Bitmap宽度 
10.  * int  Bitmap高度 
11.  */ 
12. JNIEXPORT jintArray JNICALL Java_org_join_p_w_picpath_util_JoinImage_thinning( 
13.         JNIEnv* env, jobject obj, jintArray buf, int w, int h) { 
14.     LOGE("==thinning=="); 
15.  
16.     jint * cbuf; 
17.     cbuf = (*env)->GetIntArrayElements(env, buf, 0); // 获取int数组元素 
18.  
19.     int black = 0xFF000000; // 不透明黑色 
20.  
21.     unsigned char foreground = 0xFF; // 前景灰度值：255（白） 
22.     unsigned char background = 0; // 背景灰度值：0（黑） 
23.  
24.     jboolean modified = 1; // 设置脏标记：true 
25.     unsigned char count; // 计数器 
26.     unsigned char mark[w][h]; // 可删除标记 
27.  
28.     int size = w * h; // 数据数目 
29.  
30.     /* 
31.      * 8-领域示意图 
32.      * 
33.      * P9   P2  P3 
34.      * P8   P1  P4 
35.      * P7   P6  P5 
36.      */ 
37.  
38.     int i, j, m, n; // 循环标记 
39.     unsigned char gray; // 灰度值 
40.     unsigned char grays[3][3]; // 领域各点灰度值 
41.     jint *p; // 指向源图像像素的指针 
42.  
43.     // 一次迭代操作（直到没有点再满足标记条件） 
44.     while (modified) { 
45.         modified = 0; // 设置脏标记：false 
46.  
47.         /* 
48.          * 第一层子循环，删除条件： 
49.          * 
50.          * (1.1) 2<=N(p1)<=6 
51.          * (1.2) S(p1)=1 
52.          * (1.3) p2*p4*p6=0 
53.          * (1.4) p4*p6*p8=0 
54.          * 
55.          * N(p1)：p1的非零邻点的个数 
56.          * S(p1)：以p2 ，p3 ，…… ，p9为序时这些点的值从0到1变化的次数 
57.          */ 
58.  
59.         memset(mark, 0, sizeof(mark)); // 重置删除标记为false 
60.  
61.         // 防止越界，不处理上下左右四边像素 
62.         for (i = 1; i < h - 1; i++) { 
63.             for (j = 1; j < w - 1; j++) { 
64.  
65.                 p = cbuf + w * i + j; // 指向源图像i行j列 
66.                 gray = (*p) & 0xFF; // 获得灰度值 
67.  
68.                 if (gray == foreground) { // 判断是否为细化像素（前景像素） 
69.  
70.                     // 计算N(p1) 
71.                     count = 0; // 重置计数器 
72.                     for (m = -1; m <= 1; m++) { 
73.                         for (n = -1; n <= 1; n++) { 
74.                             gray = (*(p + w * m + n)) & 0xFF; // 获取领域各点的灰度值 
75.                             grays[m + 1][n + 1] = gray; // 同时存储领域各点的灰度值 
76.                             if (gray == foreground) { // 如果为前景像素 
77.                                 count++; 
78.                             } 
79.                         } 
80.                     } 
81.                     count--; // 去除中心点 
82.  
83.                     // 判断条件(1.1) 
84.                     if (2 <= count && count <= 6) { 
85.                     } else { 
86.                         continue; // 条件(1.1)不成立，跳出循环 
87.                     } 
88.  
89.                     // 计算S(p1)：四周像素由0变255的次数 
90.                     // 需先计算N(p1)，获取领域各点的灰度值 
91.                     count = 0; // 重置计数器 
92.                     if (grays[0][1] < grays[0][2]) 
93.                         count++; // p2->p3 
94.                     if (grays[0][2] < grays[1][2]) 
95.                         count++; // p3->p4 
96.                     if (grays[1][2] < grays[2][2]) 
97.                         count++; // p4->p5 
98.                     if (grays[2][2] < grays[2][1]) 
99.                         count++; // p5->p6 
100.                     if (grays[2][1] < grays[2][0]) 
101.                         count++; // p6->p7 
102.                     if (grays[2][0] < grays[1][0]) 
103.                         count++; // p7->p8 
104.                     if (grays[1][0] < grays[0][0]) 
105.                         count++; // p8->p9 
106.                     if (grays[0][0] < grays[0][1]) 
107.                         count++; // p9->p2 
108.  
109.                     // 判断条件(1.2) 
110.                     if (1 == count) { 
111.                     } else { 
112.                         continue; // 条件(1.2)不成立，跳出循环 
113.                     } 
114.  
115.                     // 判断条件(1.3) 
116.                     if (background == grays[0][1] || background == grays[1][2] 
117.                             || background == grays[2][1]) { 
118.                     } else { 
119.                         continue; // 条件(1.3)不成立，跳出循环 
120.                     } 
121.  
122.                     // 判断条件(1.4) 
123.                     if (background == grays[1][2] || background == grays[2][1] 
124.                             || background == grays[1][0]) { 
125.                     } else { 
126.                         continue; // 条件(1.4)不成立，跳出循环 
127.                     } 
128.  
129.                     /* 
130.                      * 四条件都成立时 
131.                      */ 
132.                     mark[j][i] = 1; // 删除标记为true 
133.                     modified = 1; // 脏标记为true 
134.                 } 
135.             } 
136.         } 
137.  
138.         // 由删除标记去除 
139.         if (modified) { 
140.             for (i = 1; i < h - 1; i++) { 
141.                 for (j = 1; j < w - 1; j++) { 
142.                     // 如果删除标记为true 
143.                     if (1 == mark[j][i]) { 
144.                         cbuf[w * i + j] = black; // 修改成背景色（黑） 
145.                     } 
146.                 } 
147.             } 
148.         } 
149.  
150.         /* 
151.          * 第二层子循环，删除条件： 
152.          * 
153.          * (1.1) 2<=N(p1)<=6 
154.          * (1.2) S(p1)=1 
155.          * (2.3) p2*p4*p8=0 
156.          * (2.4) p2*p6*p8=0 
157.          */ 
158.         memset(mark, 0, sizeof(mark)); // 重置删除标记为false 
159.  
160.         // 防止越界，不处理上下左右四边像素 
161.         for (i = 1; i < h - 1; i++) { 
162.             for (j = 1; j < w - 1; j++) { 
163.  
164.                 p = cbuf + w * i + j; // 指向源图像i行j列 
165.                 gray = (*p) & 0xFF; // 获得灰度值 
166.  
167.                 if (gray == foreground) { // 判断是否为细化像素（前景像素） 
168.  
169.                     // 计算N(p1) 
170.                     count = 0; // 重置计数器 
171.                     for (m = -1; m <= 1; m++) { 
172.                         for (n = -1; n <= 1; n++) { 
173.                             gray = (*(p + w * m + n)) & 0xFF; // 获取领域各点的灰度值 
174.                             grays[m + 1][n + 1] = gray; // 同时存储领域各点的灰度值 
175.                             if (gray == foreground) { // 如果为前景像素 
176.                                 count++; 
177.                             } 
178.                         } 
179.                     } 
180.                     count--; // 去除中心点 
181.  
182.                     // 判断条件(1.1) 
183.                     if (2 <= count && count <= 6) { 
184.                     } else { 
185.                         continue; // 条件(1.1)不成立，跳出循环 
186.                     } 
187.  
188.                     // 计算S(p1)：四周像素由0变255的次数 
189.                     // 需先计算N(p1)，获取领域各点的灰度值 
190.                     count = 0; // 重置计数器 
191.                     if (grays[0][1] < grays[0][2]) 
192.                         count++; // p2->p3 
193.                     if (grays[0][2] < grays[1][2]) 
194.                         count++; // p3->p4 
195.                     if (grays[1][2] < grays[2][2]) 
196.                         count++; // p4->p5 
197.                     if (grays[2][2] < grays[2][1]) 
198.                         count++; // p5->p6 
199.                     if (grays[2][1] < grays[2][0]) 
200.                         count++; // p6->p7 
201.                     if (grays[2][0] < grays[1][0]) 
202.                         count++; // p7->p8 
203.                     if (grays[1][0] < grays[0][0]) 
204.                         count++; // p8->p9 
205.                     if (grays[0][0] < grays[0][1]) 
206.                         count++; // p9->p2 
207.  
208.                     // 判断条件(1.2) 
209.                     if (1 == count) { 
210.                     } else { 
211.                         continue; // 条件(1.2)不成立，跳出循环 
212.                     } 
213.  
214.                     // 判断条件(2.3) 
215.                     if (background == grays[0][1] || background == grays[1][2] 
216.                             || background == grays[1][0]) { 
217.                     } else { 
218.                         continue; // 条件(2.3)不成立，跳出循环 
219.                     } 
220.  
221.                     // 判断条件(2.4) 
222.                     if (background == grays[0][1] || background == grays[2][1] 
223.                             || background == grays[1][0]) { 
224.                     } else { 
225.                         continue; // 条件(2.4)不成立，跳出循环 
226.                     } 
227.  
228.                     /* 
229.                      * 四条件都成立时 
230.                      */ 
231.                     mark[j][i] = 1; // 删除标记为true 
232.                     modified = 1; // 脏标记为true 
233.                 } 
234.             } 
235.         } 
236.  
237.         // 由删除标记去除 
238.         if (modified) { 
239.             for (i = 1; i < h - 1; i++) { 
240.                 for (j = 1; j < w - 1; j++) { 
241.                     // 如果删除标记为true 
242.                     if (1 == mark[j][i]) { 
243.                         cbuf[w * i + j] = black; // 修改成背景色（黑） 
244.                     } 
245.                 } 
246.             } 
247.         } 
248.     } 
249.  
250.     jintArray result = (*env)->NewIntArray(env, size); // 新建一个jintArray 
251.     (*env)->SetIntArrayRegion(env, result, 0, size, cbuf); // 将cbuf转存入result 
252.     (*env)->ReleaseIntArrayElements(env, buf, cbuf, 0); // 释放int数组元素 
253.     return result; 
254. }