图像基本处理算法的简单实现(一)

 图像基本处理算法的简单实现(二)

 

4)膨胀腐蚀
         属于什么心态学==,膨胀、腐蚀、击中/击不中变换、细化…(又晕了T^T)。简单点好像就是集合运算,图像与一结构元素的交差补什么的。图像一点的周围是否符合结构元素,然后该怎么处理。
 
         结构元素(B)由0和1组成,用于扫描比较二值化图像(A)。
 
膨胀:
         1、用结构元素B,扫描图像A的每一个像素
         2、用结构元素与其覆盖的二值图像做“与”操作
         3、如果都为0,结果图像的该像素为0。否则为1
 
腐蚀:
         1、用结构元素B,扫描图像A的每一个像素
         2、用结构元素与其覆盖的二值图像做“与”操作
         3、如果都为1,结果图像的该像素为1。否则为0
 
         膨胀腐蚀是形态学处理的基础。(copy的==)
 
膨胀的实现:
  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_image_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; 
 
腐蚀的实现:
  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_image_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; 
 
         好吧,都一样的结构元素==,这是偷懒呢。没必要非这样,也可以如“背景色点上下左右>=3点为前景色,则将其填充为前景色”什么的。
 
5)细化
         提取图像骨架的。主要有Zhang快速并行细化方法、Hilditch、Pavlidis、Rosenfeld、索引表细化方法等。
         简述下连通图概念先:分为四连通和八连通(或者称之为邻域)。四连通就是图像上下左右有一点时,才算这两点是连接的;而八连通则周围一圈有一点都行。也就是一点只有右上角有邻点,则是八连通非四连通^^。
         算法按着名字查找下就好==,不想再表述了(实现代码注释了其实有了的^^)。
 
Zhang快速并行细化方法:
  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_image_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; 

 

 图像基本处理算法的简单实现(三)