图像基本处理算法的简单实现（二）-阿里云开发者社区

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

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

4 ）膨胀腐蚀

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

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

膨胀：

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

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

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

腐蚀：

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

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

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

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

膨胀的实现：

/**
* 对二值化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;
}

腐蚀的实现：

/**
* 对二值化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 快速并行细化方法：

/**
* 对二值化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;
}

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

本文转自winorlose2000 51CTO博客，原文链接：http://blog.51cto.com/vaero/823000，如需转载请自行联系原作者

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

热门文章

最新文章

相关课程

相关电子书

相关实验场景