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

柔情只为你懂 2022-08-06 01:17 178阅读 0赞

[原文地址链接][Link 1]

4）膨胀腐蚀

属于什么心态学==，膨胀、腐蚀、击中/击不中变换、细化…（又晕了T^T）。简单点好像就是集合运算，图像与一结构元素的交差补什么的。图像一点的周围是否符合结构元素，然后该怎么处理。

结构元素（B）由0和1组成，用于扫描比较二值化图像（A）。

膨胀：

1、用结构元素B，扫描图像A的每一个像素

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

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

腐蚀：

1、用结构元素B，扫描图像A的每一个像素

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

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

膨胀腐蚀是形态学处理的基础。（copy的==）

膨胀的实现：

<span style="font-family:KaiTi_GB2312;font-size:14px;">/** 
     * 对二值化Bitmap进行膨胀运算后返回 
     * 
     * 膨胀结构元素：3x3 全 
     * 
     * JNIEnv*  jni环境（jni必要参数） 
     * jobject  java对象（jni必要参数） 
     * jintArray    Bitmap所有像素值 
     * int  Bitmap宽度 
     * int  Bitmap高度 
     */ 
    JNIEXPORT jintArray JNICALL Java_org_join_image_util_JoinImage_dilation( 
            JNIEnv* env, jobject obj, jintArray buf, int w, int h) { 
        LOGE("==dilation=="); 
     
        jint * cbuf; // 源图像 
        cbuf = (*env)->GetIntArrayElements(env, buf, 0); // 获取int数组元素 
     
        int white = 0xFFFFFFFF; // 不透明白色 
        int black = 0xFF000000; // 不透明黑色 
     
        int size = w * h; 
        jint rbuf[size]; // 目标图像 
        memset(rbuf, black, size * sizeof(jint)); // 将目标图像置成全黑 
     
        int i, j, m, n, gray; 
        jint *p, *q; 
        // 由于使用3×3的结构元素，为防止越界，所以不处理上下左右四边像素 
        for (i = 1; i < h - 1; i++) { 
            for (j = 1; j < w - 1; j++) { 
                p = cbuf + w * i + j; // 指向源图像i行j列 
     
                // 遍历源图像对应结构元素的各点 
                for (m = -1; m <= 1; m++) { 
                    for (n = -1; n <= 1; n++) { 
                        gray = (*(p + w * m + n)) & 0xFF; // 获取源图像对应结构元素点的灰度值 
                        // 如果对应3x3范围内有白点（其他色都算为黑） 
                        if (gray == 255) { 
                            q = rbuf + w * i + j; // 指向目标图像i行j列 
                            *q = white; // 将目标图像中的当前点赋成白色 
                            break; 
                        } 
                    } 
                } 
            } 
        } 
     
        jintArray result = (*env)->NewIntArray(env, size); // 新建一个jintArray 
        (*env)->SetIntArrayRegion(env, result, 0, size, rbuf); // 将rbuf转存入result 
        (*env)->ReleaseIntArrayElements(env, buf, cbuf, 0); // 释放int数组元素 
        return result; 
    } </span>

腐蚀的实现：

/** 
     * 对二值化Bitmap进行腐蚀运算后返回 
     * 
     * 腐蚀结构元素：3x3 全 
     * 
     * JNIEnv*  jni环境（jni必要参数） 
     * jobject  java对象（jni必要参数） 
     * jintArray    Bitmap所有像素值 
     * int  Bitmap宽度 
     * int  Bitmap高度 
     */ 
    JNIEXPORT jintArray JNICALL Java_org_join_image_util_JoinImage_erosion( 
            JNIEnv* env, jobject obj, jintArray buf, int w, int h) { 
        LOGE("==erosion=="); 
     
        jint * cbuf; // 源图像 
        cbuf = (*env)->GetIntArrayElements(env, buf, 0); // 获取int数组元素 
     
        int white = 0xFFFFFFFF; // 不透明白色 
        int black = 0xFF000000; // 不透明黑色 
     
        int size = w * h; 
        jint rbuf[size]; // 目标图像 
        memset(rbuf, black, size * sizeof(jint)); // 将目标图像置成全黑 
     
        int i, j, m, n, gray; 
        jint *p, *q; 
        // 由于使用3×3的结构元素，为防止越界，所以不处理上下左右四边像素 
        for (i = 1; i < h - 1; i++) { 
            for (j = 1; j < w - 1; j++) { 
                p = cbuf + w * i + j; // 指向源图像i行j列 
     
                q = rbuf + w * i + j; // 指向目标图像i行j列 
                *q = white; // 将目标图像中的当前点赋成白色 
     
                // 遍历源图像对应结构元素的各点 
                for (m = -1; m <= 1; m++) { 
                    for (n = -1; n <= 1; n++) { 
                        gray = (*(p + w * m + n)) & 0xFF; // 获取源图像对应结构元素点的灰度值 
                        // 如果对应3x3范围内有黑点（其他色都算为白） 
                        if (gray == 0) { 
                            *q = black; // 将目标图像中的当前点赋成黑色 
                            break; 
                        } 
                    } 
                } 
            } 
        } 
     
        jintArray result = (*env)->NewIntArray(env, size); // 新建一个jintArray 
        (*env)->SetIntArrayRegion(env, result, 0, size, rbuf); // 将rbuf转存入result 
        (*env)->ReleaseIntArrayElements(env, buf, cbuf, 0); // 释放int数组元素 
        return result; 
    }

好吧，都一样的结构元素==，这是偷懒呢。没必要非这样，也可以如“背景色点上下左右>=3点为前景色，则将其填充为前景色”什么的。

5）细化

提取图像骨架的。主要有Zhang快速并行细化方法、Hilditch、Pavlidis、Rosenfeld、索引表细化方法等。

简述下连通图概念先：分为四连通和八连通（或者称之为邻域）。四连通就是图像上下左右有一点时，才算这两点是连接的；而八连通则周围一圈有一点都行。也就是一点只有右上角有邻点，则是八连通非四连通^^。

算法按着名字查找下就好==，不想再表述了（实现代码注释了其实有了的^^）。

Zhang快速并行细化方法：

<span style="font-family:KaiTi_GB2312;font-size:14px;">/** 
     * 对二值化Bitmap进行细化运算后返回 
     * 
     * 采用“Zhang快速并行细化方法” 
     * 
     * JNIEnv*  jni环境（jni必要参数） 
     * jobject  java对象（jni必要参数） 
     * jintArray    Bitmap所有像素值 
     * int  Bitmap宽度 
     * int  Bitmap高度 
     */ 
    JNIEXPORT jintArray JNICALL Java_org_join_image_util_JoinImage_thinning( 
            JNIEnv* env, jobject obj, jintArray buf, int w, int h) { 
        LOGE("==thinning=="); 
     
        jint * cbuf; 
        cbuf = (*env)->GetIntArrayElements(env, buf, 0); // 获取int数组元素 
     
        int black = 0xFF000000; // 不透明黑色 
     
        unsigned char foreground = 0xFF; // 前景灰度值：255（白） 
        unsigned char background = 0; // 背景灰度值：0（黑） 
     
        jboolean modified = 1; // 设置脏标记：true 
        unsigned char count; // 计数器 
        unsigned char mark[w][h]; // 可删除标记 
     
        int size = w * h; // 数据数目 
     
        /* 
         * 8-领域示意图 
         * 
         * P9   P2  P3 
         * P8   P1  P4 
         * P7   P6  P5 
         */ 
     
        int i, j, m, n; // 循环标记 
        unsigned char gray; // 灰度值 
        unsigned char grays[3][3]; // 领域各点灰度值 
        jint *p; // 指向源图像像素的指针 
     
        // 一次迭代操作（直到没有点再满足标记条件） 
        while (modified) { 
            modified = 0; // 设置脏标记：false 
     
            /* 
             * 第一层子循环，删除条件： 
             * 
             * (1.1) 2<=N(p1)<=6 
             * (1.2) S(p1)=1 
             * (1.3) p2*p4*p6=0 
             * (1.4) p4*p6*p8=0 
             * 
             * N(p1)：p1的非零邻点的个数 
             * S(p1)：以p2 ，p3 ，…… ，p9为序时这些点的值从0到1变化的次数 
             */ 
     
            memset(mark, 0, sizeof(mark)); // 重置删除标记为false 
     
            // 防止越界，不处理上下左右四边像素 
            for (i = 1; i < h - 1; i++) { 
                for (j = 1; j < w - 1; j++) { 
     
                    p = cbuf + w * i + j; // 指向源图像i行j列 
                    gray = (*p) & 0xFF; // 获得灰度值 
     
                    if (gray == foreground) { // 判断是否为细化像素（前景像素） 
     
                        // 计算N(p1) 
                        count = 0; // 重置计数器 
                        for (m = -1; m <= 1; m++) { 
                            for (n = -1; n <= 1; n++) { 
                                gray = (*(p + w * m + n)) & 0xFF; // 获取领域各点的灰度值 
                                grays[m + 1][n + 1] = gray; // 同时存储领域各点的灰度值 
                                if (gray == foreground) { // 如果为前景像素 
                                    count++; 
                                } 
                            } 
                        } 
                        count--; // 去除中心点 
     
                        // 判断条件(1.1) 
                        if (2 <= count && count <= 6) { 
                        } else { 
                            continue; // 条件(1.1)不成立，跳出循环 
                        } 
     
                        // 计算S(p1)：四周像素由0变255的次数 
                        // 需先计算N(p1)，获取领域各点的灰度值 
                        count = 0; // 重置计数器 
                        if (grays[0][1] < grays[0][2]) 
                            count++; // p2->p3 
                        if (grays[0][2] < grays[1][2]) 
                            count++; // p3->p4 
                        if (grays[1][2] < grays[2][2]) 
                            count++; // p4->p5 
                        if (grays[2][2] < grays[2][1]) 
                            count++; // p5->p6 
                        if (grays[2][1] < grays[2][0]) 
                            count++; // p6->p7 
                        if (grays[2][0] < grays[1][0]) 
                            count++; // p7->p8 
                        if (grays[1][0] < grays[0][0]) 
                            count++; // p8->p9 
                        if (grays[0][0] < grays[0][1]) 
                            count++; // p9->p2 
     
                        // 判断条件(1.2) 
                        if (1 == count) { 
                        } else { 
                            continue; // 条件(1.2)不成立，跳出循环 
                        } 
     
                        // 判断条件(1.3) 
                        if (background == grays[0][1] || background == grays[1][2] 
                                || background == grays[2][1]) { 
                        } else { 
                            continue; // 条件(1.3)不成立，跳出循环 
                        } 
     
                        // 判断条件(1.4) 
                        if (background == grays[1][2] || background == grays[2][1] 
                                || background == grays[1][0]) { 
                        } else { 
                            continue; // 条件(1.4)不成立，跳出循环 
                        } 
     
                        /* 
                         * 四条件都成立时 
                         */ 
                        mark[j][i] = 1; // 删除标记为true 
                        modified = 1; // 脏标记为true 
                    } 
                } 
            } 
     
            // 由删除标记去除 
            if (modified) { 
                for (i = 1; i < h - 1; i++) { 
                    for (j = 1; j < w - 1; j++) { 
                        // 如果删除标记为true 
                        if (1 == mark[j][i]) { 
                            cbuf[w * i + j] = black; // 修改成背景色（黑） 
                        } 
                    } 
                } 
            } 
     
            /* 
             * 第二层子循环，删除条件： 
             * 
             * (1.1) 2<=N(p1)<=6 
             * (1.2) S(p1)=1 
             * (2.3) p2*p4*p8=0 
             * (2.4) p2*p6*p8=0 
             */ 
            memset(mark, 0, sizeof(mark)); // 重置删除标记为false 
     
            // 防止越界，不处理上下左右四边像素 
            for (i = 1; i < h - 1; i++) { 
                for (j = 1; j < w - 1; j++) { 
     
                    p = cbuf + w * i + j; // 指向源图像i行j列 
                    gray = (*p) & 0xFF; // 获得灰度值 
     
                    if (gray == foreground) { // 判断是否为细化像素（前景像素） 
     
                        // 计算N(p1) 
                        count = 0; // 重置计数器 
                        for (m = -1; m <= 1; m++) { 
                            for (n = -1; n <= 1; n++) { 
                                gray = (*(p + w * m + n)) & 0xFF; // 获取领域各点的灰度值 
                                grays[m + 1][n + 1] = gray; // 同时存储领域各点的灰度值 
                                if (gray == foreground) { // 如果为前景像素 
                                    count++; 
                                } 
                            } 
                        } 
                        count--; // 去除中心点 
     
                        // 判断条件(1.1) 
                        if (2 <= count && count <= 6) { 
                        } else { 
                            continue; // 条件(1.1)不成立，跳出循环 
                        } 
     
                        // 计算S(p1)：四周像素由0变255的次数 
                        // 需先计算N(p1)，获取领域各点的灰度值 
                        count = 0; // 重置计数器 
                        if (grays[0][1] < grays[0][2]) 
                            count++; // p2->p3 
                        if (grays[0][2] < grays[1][2]) 
                            count++; // p3->p4 
                        if (grays[1][2] < grays[2][2]) 
                            count++; // p4->p5 
                        if (grays[2][2] < grays[2][1]) 
                            count++; // p5->p6 
                        if (grays[2][1] < grays[2][0]) 
                            count++; // p6->p7 
                        if (grays[2][0] < grays[1][0]) 
                            count++; // p7->p8 
                        if (grays[1][0] < grays[0][0]) 
                            count++; // p8->p9 
                        if (grays[0][0] < grays[0][1]) 
                            count++; // p9->p2 
     
                        // 判断条件(1.2) 
                        if (1 == count) { 
                        } else { 
                            continue; // 条件(1.2)不成立，跳出循环 
                        } 
     
                        // 判断条件(2.3) 
                        if (background == grays[0][1] || background == grays[1][2] 
                                || background == grays[1][0]) { 
                        } else { 
                            continue; // 条件(2.3)不成立，跳出循环 
                        } 
     
                        // 判断条件(2.4) 
                        if (background == grays[0][1] || background == grays[2][1] 
                                || background == grays[1][0]) { 
                        } else { 
                            continue; // 条件(2.4)不成立，跳出循环 
                        } 
     
                        /* 
                         * 四条件都成立时 
                         */ 
                        mark[j][i] = 1; // 删除标记为true 
                        modified = 1; // 脏标记为true 
                    } 
                } 
            } 
     
            // 由删除标记去除 
            if (modified) { 
                for (i = 1; i < h - 1; i++) { 
                    for (j = 1; j < w - 1; j++) { 
                        // 如果删除标记为true 
                        if (1 == mark[j][i]) { 
                            cbuf[w * i + j] = black; // 修改成背景色（黑） 
                        } 
                    } 
                } 
            } 
        } 
     
        jintArray result = (*env)->NewIntArray(env, size); // 新建一个jintArray 
        (*env)->SetIntArrayRegion(env, result, 0, size, cbuf); // 将cbuf转存入result 
        (*env)->ReleaseIntArrayElements(env, buf, cbuf, 0); // 释放int数组元素 
        return result; 
    } </span>

[Link 1]: http://vaero.blog.51cto.com/4350852/823000