基于opencv的数学形态学的操作，涉及数学形态学细化、击中击不中变换

最新推荐文章于 2024-09-17 16:52:47 发布
转载 最新推荐文章于 2024-09-17 16:52:47 发布 · 880 阅读 · 0

本文介绍了一种使用特定结构元素进行图像骨架提取的方法，并实现了骨架提取、图像加厚(thicken)与减薄(thin)等形态学运算。通过多次迭代直至图像稳定不变来完成骨架提取过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


#include"cmath"

#include"ctime"
#include"iostream"
#include<opencv2\opencv.hpp>
#include"cstring"
using namespace std;


#define HIT 1  
#define MISS 0  


using namespace cv;
//using namespace std;


const int dir[9][2] = { { -1,-1 },{ -1,0 },{ -1,1 },{ 0,-1 },{ 0,0 },{ 0,1 },{ 1,-1 },{ 1,0 },{ 1,1 } };


//定义了skeleton和convex hull操作用到的各八个structuring element  
//structuring element可根据不同需要改变，这里只是一种  
#define ELE_STR_SIZE 3  


#define SKELETON_STR_ELE_NUM 8  
const unsigned char skeleton_str_ele[SKELETON_STR_ELE_NUM][ELE_STR_SIZE][ELE_STR_SIZE] = {
{
{ 0,0,0 },
{ 2,1,2 },
{ 1,1,1 }
},


{
{ 2,0,0 },
{ 1,1,0 },
{ 2,1,2 }
},


{
{ 1,2,0 },
{ 1,1,0 },
{ 1,2,0 }
},


{
{ 2,1,2 },
{ 1,1,0 },
{ 2,0,0 }
},


{
{ 1,1,1 },
{ 2,1,2 },
{ 0,0,0 }
},


{
{ 2,1,2 },
{ 0,1,1 },
{ 0,0,2 }
},


{
{ 0,2,1 },
{ 0,1,1 },
{ 0,2,1 }
},


{
{ 0,0,2 },
{ 0,1,1 },
{ 2,1,2 }
}
};


#define CONVEX_HULL_STR_ELE_NUM 8  
const unsigned char convex_hull_str_ele[CONVEX_HULL_STR_ELE_NUM][ELE_STR_SIZE][ELE_STR_SIZE] = {
{
{ 1,1,2 },
{ 1,0,2 },
{ 1,2,0 }
},


{
{ 2,1,1 },
{ 2,0,1 },
{ 0,2,1 }
},


{
{ 1,1,1 },
{ 2,0,1 },
{ 0,2,2 }
},


{
{ 0,2,2 },
{ 2,0,1 },
{ 1,1,1 }
},


{
{ 0,2,1 },
{ 2,0,1 },
{ 2,1,1 }
},


{
{ 1,2,0 },
{ 1,0,2 },
{ 1,1,2 }
},


{
{ 2,2,0 },
{ 1,0,2 },
{ 1,1,1 }
},


{
{ 1,1,1 },
{ 1,0,2 },
{ 2,2,0 }
}
};




unsigned char hit_and_miss(unsigned char src[][ELE_STR_SIZE], const unsigned char str_ele[][ELE_STR_SIZE]) {
//对一块区域的hit_and_miss判定  
for (int i = 0; i < ELE_STR_SIZE; i++) {
for (int j = 0; j < ELE_STR_SIZE; j++) {
if (str_ele[i][j] == 0 || str_ele[i][j] == 1) {
if (str_ele[i][j] != src[i][j]) return MISS;
}
}
}
return HIT;
}


void hit_and_miss(IplImage *src, IplImage **dst, const unsigned char str_ele[][ELE_STR_SIZE])
{
//对一个二值图像的hit_and_miss操作  
unsigned char matrix[ELE_STR_SIZE][ELE_STR_SIZE];
int i1, j1, nx, ny;
CvSize size = cvGetSize(src);
if ((*dst) != NULL) cvReleaseImage(dst);
(*dst) = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
cvZero(*dst);


for (int i = 0; i<size.height; i++) {
for (int j = 0; j<size.width; j++) {


i1 = 0;
j1 = 0;
for (int k = 0; k < 9; k++) {
//把自身及相邻共九个格子放入一个矩阵中  
nx = i + dir[k][0];
ny = j + dir[k][1];
if (nx<0 || nx >= size.height || ny<0 || ny >= size.width) break;//超出边界，无需判断  
matrix[i1][j1] = CV_IMAGE_ELEM(src, uchar, nx, ny);
++j1;
if (j1 == ELE_STR_SIZE) {
++i1;
j1 = 0;
}
}


if (i1 != ELE_STR_SIZE) {
CV_IMAGE_ELEM(*dst, uchar, i, j) = 0;
}
else {
CV_IMAGE_ELEM(*dst, uchar, i, j) = hit_and_miss(matrix, str_ele);
}


}
}
}


void biImageSubstract(IplImage *src1, IplImage *src2, IplImage **dst) {
//二值图像减法操作  
CvSize size1 = cvGetSize(src1);
CvSize size2 = cvGetSize(src2);
if ((*dst) != NULL) cvReleaseImage(dst);
if ((size1.height != size2.height) || (size1.width != size2.width)) {
(*dst) = NULL;//大小不同则直接退出  
return;
}


//产生一张用于保存结果的空图  
(*dst) = cvCreateImage(cvGetSize(src1), IPL_DEPTH_8U, 1);
cvZero(*dst);


//按减法即为交补集的定义计算  
for (int i = 0; i<size1.height; i++) {
for (int j = 0; j<size1.width; j++) {
CV_IMAGE_ELEM(*dst, uchar, i, j) = CV_IMAGE_ELEM(src1, uchar, i, j) & (CV_IMAGE_ELEM(src2, uchar, i, j) ^ 1);
}
}
}


void biImageUnion(IplImage *src1, IplImage *src2, IplImage **dst) {
//二值图像的并操作  
CvSize size1 = cvGetSize(src1);
CvSize size2 = cvGetSize(src2);
if ((*dst) != NULL) cvReleaseImage(dst);
if ((size1.height != size2.height) || (size1.width != size2.width)) {
(*dst) = NULL;//大小不同则直接退出  
return;
}
//产生一张用于保存结果的空图  
(*dst) = cvCreateImage(cvGetSize(src1), IPL_DEPTH_8U, 1);
cvZero(*dst);
for (int i = 0; i<size1.height; i++) {
for (int j = 0; j<size1.width; j++) {
CV_IMAGE_ELEM(*dst, uchar, i, j) = CV_IMAGE_ELEM(src1, uchar, i, j) | CV_IMAGE_ELEM(src2, uchar, i, j);
}
}
}


bool equals(IplImage *src1, IplImage *src2) {
//判定两个二值图像是否相同  
CvSize size1 = cvGetSize(src1);
CvSize size2 = cvGetSize(src2);
if ((size1.height != size2.height) || (size1.width != size2.width)) return false; //大小不同则直接退出  
for (int i = 0; i<size1.height; i++) {
for (int j = 0; j<size1.width; j++) {
if (CV_IMAGE_ELEM(src1, uchar, i, j) != CV_IMAGE_ELEM(src2, uchar, i, j)) return false; //判定到不同则直接退出  
}
}
return true;
}


void thicken(IplImage *src, const unsigned char str_ele[][ELE_STR_SIZE], IplImage**dst) {
//二值图像thicken操作  
IplImage *hitnmiss = NULL;


//产生一张用于保存结果的空图  
if ((*dst) != NULL) cvReleaseImage(dst);
(*dst) = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
cvZero(*dst);


//按定义执行thicken操作  
hit_and_miss(src, &hitnmiss, str_ele);
biImageUnion(src, hitnmiss, dst);


cvReleaseImage(&hitnmiss);
}






void thin(IplImage *src, const unsigned char str_ele[][ELE_STR_SIZE], IplImage**dst) {
//二值图像thin操作  
IplImage *hitnmiss = NULL;


//产生一张用于保存结果的空图  
if ((*dst) != NULL) cvReleaseImage(dst);
(*dst) = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
cvZero(*dst);


//按定义执行thin操作  
hit_and_miss(src, &hitnmiss, str_ele);
biImageSubstract(src, hitnmiss, dst);


cvReleaseImage(&hitnmiss);
}


void skeleton(IplImage *src, IplImage **dst) {
//二值图像提取骨架操作  
bool flag = true;


IplImage *cp_src = NULL;
IplImage *tmp = NULL;


//拷贝原图  
cp_src = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
cvCopy(src, cp_src, NULL);


//用给出的八个structuring element对原图不断做thin操作直至图片没有变化  
while (flag) {
flag = false;
for (int i = 0; i < SKELETON_STR_ELE_NUM; i++) {
thin(cp_src, skeleton_str_ele[i], &tmp);
if (!flag && !equals(cp_src, tmp)) flag = true;


cvReleaseImage(&cp_src);
cp_src = tmp;
tmp = NULL;
}
}


if ((*dst) != NULL) cvReleaseImage(dst);
(*dst) = cp_src;
}


void getBinaryImage(IplImage *src, IplImage **dst) {
IplImage *grayImage = NULL;
// 转为灰度图   
grayImage = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1);
cvCvtColor(src, grayImage, CV_BGR2GRAY);


//创建二值图  
if ((*dst) != NULL) cvReleaseImage(dst);
(*dst) = cvCreateImage(cvGetSize(grayImage), IPL_DEPTH_8U, 1);
cvZero(*dst);//清零   
cvThreshold(grayImage, *dst, 128, 1, CV_THRESH_BINARY_INV);


cvReleaseImage(&grayImage);
}


void reverseBinaryImage(IplImage *src) {
//将一个二值图像反转  
CvSize size = cvGetSize(src);
for (int i = 0; i < size.height; i++) {
for (int j = 0; j < size.width; j++) {
CV_IMAGE_ELEM(src, uchar, i, j) ^= 1;
}
}
}










void job1() {
//提取土豆骨架  
//以二值图片src为输入，以提取到的skeleton以二值图片输出到dst中。  
//做法是在每次迭代中不断用八个Structuring Element去对原图做Thin操作,  
//直到某次迭代中图片不再有变化。  
IplImage *srcImage = cvLoadImage("E:\\二值像素图像保存\\8_3\\aa\\(2)_3_取.bmp", CV_LOAD_IMAGE_UNCHANGED);// 从文件中加载原图   

//======
int height1 = srcImage->height;
int width1 = srcImage->width;
CvSize cvSize;
cvSize.height = height1;
cvSize.width = width1;
IplImage *srcImage2 = cvCreateImage(cvSize,IPL_DEPTH_8U,3);
//==============================================================
IplImage *binaryImage = NULL;
IplImage *skeletonImage = NULL;
if (srcImage == NULL)
{//如果读入图像失败  
fprintf(stderr, "Can not load image\n");
return;
}
getBinaryImage(srcImage, &binaryImage);
reverseBinaryImage(binaryImage);//因为原图黑底白色，将前后反转  




skeleton(binaryImage, &skeletonImage);//提取骨架  


cvReleaseImage(&binaryImage);




//把提取到的skeleton用绿色标注在原图上  
CvSize size = cvGetSize(skeletonImage);
for (int i = 0; i < size.height; i++) {
for (int j = 0; j < size.width; j++) {
if (CV_IMAGE_ELEM(skeletonImage, uchar, i, j) == 1) {
CvScalar s = cvGet2D(srcImage2, i, j);
s = CV_RGB(0, 255, 0);
cvSet2D(srcImage2, i, j, s);
}
}
}


cvReleaseImage(&skeletonImage);
cvReleaseImage(&srcImage);
cvShowImage("Skeleton", srcImage2);
cvSaveImage("E:\\二值像素图像保存\\8_3\\aa\\11_17\\(1)_1_lenna.bmp", srcImage2);
cvWaitKey(0);
cvDestroyWindow("Skeleton");


cvReleaseImage(&srcImage2);

}


void job2() {
//做一次thin操作  
//以二值图片src和结构元素str_ele作为输入，把操作结果以二值图片输出到dst中。  
//做法是先将原图和结果元素做一次Hit-and-Miss操作，再用原图减去操作结果。  
unsigned char str_ele[3][3] = {
{ 2,1,2 },
{ 1,1,1 },
{ 2,1,2 }
};//操作用到的structuring element  
IplImage *srcImage = cvLoadImage("E:\\二值像素图像保存\\8_3\\aa\\(2)_3_取.bmp", CV_LOAD_IMAGE_UNCHANGED);// 从文件中加载原图    
int height1 = srcImage->height;
int width1 = srcImage->width;
CvSize cvSize;
cvSize.height = height1;
cvSize.width = width1;
IplImage *srcImage2 = cvCreateImage(cvSize, IPL_DEPTH_8U, 3);


IplImage *binaryImage = NULL;
IplImage *thinImage = NULL;
if (srcImage == NULL)
{//如果读入图像失败  
fprintf(stderr, "Can not load image\n");
return;
}
getBinaryImage(srcImage, &binaryImage);
reverseBinaryImage(binaryImage);//因为原图黑底白色，将前后反转  




thin(binaryImage, str_ele, &thinImage);//thin操作  


cvReleaseImage(&binaryImage);
cvReleaseImage(&srcImage);


//把thin操作的结果用绿色标注在原图上  
CvSize size = cvGetSize(thinImage);
for (int i = 0; i < size.height; i++) {
for (int j = 0; j < size.width; j++) {
if (CV_IMAGE_ELEM(thinImage, uchar, i, j) == 1) {
CvScalar s = cvGet2D(srcImage2, i, j);
s = CV_RGB(0, 255, 0);
cvSet2D(srcImage2, i, j, s);
}
}
}


cvReleaseImage(&thinImage);


cvShowImage("Thin", srcImage2);
cvSaveImage("E:\\二值像素图像保存\\8_3\\aa\\(2)_1_lenna.bmp", srcImage2);
cvWaitKey(0);
cvDestroyWindow("Thin");


cvReleaseImage(&srcImage2);
}


void job3() {
//做一次thicken操作  
//以二值图片src和结构元素str_ele作为输入，把操作结果以二值图片输出到dst中。  
//做法是先将原图和结果元素做一次Hit-and-Miss操作，再用原图并上操作结果。  
unsigned char str_ele[3][3] = {
{ 2,1,2 },
{ 1,1,1 },
{ 2,1,2 }
};//操作用到的structuring element  
IplImage *srcImage = cvLoadImage("E:\\二值像素图像保存\\8_3\\aa\\(2)_3_取.bmp", CV_LOAD_IMAGE_UNCHANGED);// 从文件中加载原图    

int height1 = srcImage->height;
int width1 = srcImage->width;
CvSize cvSize;
cvSize.height = height1;
cvSize.width = width1;
IplImage *srcImage2 = cvCreateImage(cvSize, IPL_DEPTH_8U, 3);

IplImage *binaryImage = NULL;
IplImage *thickenImage = NULL;
if (srcImage == NULL)
{//如果读入图像失败  
fprintf(stderr, "Can not load image\n");
return;
}
getBinaryImage(srcImage, &binaryImage);
reverseBinaryImage(binaryImage);//因为原图黑底白色，将前后反转  




thicken(binaryImage, str_ele, &thickenImage);//thicken操作  


cvReleaseImage(&binaryImage);


cvReleaseImage(&srcImage);
//把thicken操作的结果用绿色标注在原图上  
CvSize size = cvGetSize(thickenImage);
for (int i = 0; i < size.height; i++) {
for (int j = 0; j < size.width; j++) {
if (CV_IMAGE_ELEM(thickenImage, uchar, i, j) == 1) {
CvScalar s = cvGet2D(srcImage2, i, j);
s = CV_RGB(0, 255, 0);
cvSet2D(srcImage2, i, j, s);
}
}
}


cvReleaseImage(&thickenImage);


cvShowImage("Thicken", srcImage2);
cvSaveImage("E:\\二值像素图像保存\\8_3\\aa\\(3)_1_lenna.bmp", srcImage2);
cvWaitKey(0);
cvDestroyWindow("Thicken");


cvReleaseImage(&srcImage2);


}


int main()
{
job1();
job2();
job3();
return 0;

}


相关操作的概念见：http://homepages.inf.ed.ac.uk/rbf/HIPR2/morops.htm

形态学 - 细化
Henry的博客
10-29 1539
定义为 B 对前景像素集合 A 的细化定义为 B 对前景像素集合 A 的 击中-击不中 变换结构元 B 常用的有八个，如下图所示细化的步骤为：1. 用结构元B1 对 A 做 击中-击不中 变换，然后用原图减去变换的结果A12. 将上步的结果A1，用B2 做 击中-击不中 变换，然后用A1减去B2变换的结果得到A23 . 将八个结构元循环迭代 记作一次细化的迭代4. 如果两次细化的迭代结果相同，则认为细化完成；否则，重复前面三步骤。
形态学---细化
青灵_Yaffa的博客
04-16 1505
形态学---细化细化的应用领域位图 细化的应用领域 主要应用领域是位图矢量化的预处理阶段，相关研究表明，利用细化技术生成的位图的骨架质量受到多种因素的影响，其中包括图像自身的噪声、线条粗细不均匀、端点的确定以及线条交叉点选定等，因而对线划图像进行细化从而生成高质量骨架的方法进行研究具有现实意义。 位图 1.位图是和矢量图对应的，位图图像(bitmap), 亦称为点阵图像或绘制图像，是由称作像素（图片元素）的单个点组成的。这些点可以进行不同的排列和染色以构成图样。 由于位图图像是以排列的像素集合体形式创建的，
数学形态学的细化算法（涉及击中击不中变换）
12-07
数学形态学的细化算法，涉及数学形态的膨胀、腐蚀、开、闭、击中击不中变换
opencv学习_8 ( 图像细化)
热门推荐
小村长技术blog
11-06 1万+
图像细化——针对的是二值图像 或者用阀值处理的二值图像 (1)：例子 左边为输入图像 右边为细化的效果图 (2)思想： 公式: y = p0*2^0 + p1*2^1+ p2*2^2 + p3*2^3 + p4*2^4 + p5*2^5 + p6*2^6 +p7*2^7          前辈们对此作出了总结，得出每个点周围8领域的256种情况，放在一个char data
opencv---击中击不中
m0_37992521的博客
03-14 1233
击中击不中属于图像形态学操作范畴，通过定义一定形状的结构元素，然后在图像中寻找与该结构元素相同的区域，找到即为击中，找不到即为击不中。 代码如下 #include<iostream> #include<opencv.hpp> using namespace std; using namespace cv; int main() { //加载图像 Mat src =...
【OpenCV】71 形态学操作—击中击不中
刘小胖的博客
03-19 984
71 代码 实验结果 解释 优点 所有内容均来源于贾志刚老师的知识星球——OpenCV研习社，本文为个人整理学习，已获得贾老师授权，有兴趣、有能力的可以加入贾老师的知识星球进行深入学习。 ...
形态学：击中、不击中
zzyczzyc的博客
12-11 1805
原理 作用：在二值图像中找到匹配 公式：A⊛B=(A⊖B1)∩(Ac⊖B2)A⊛B=(A⊖B1)∩(A^c⊖B2)A⊛B=(A⊖B1)∩(Ac⊖B2) 用 kernel B1B1B1 腐蚀A 用 kernel B2B2B2 腐蚀A的补集 求1和2所得结果的交集 解释：比如kernel B1 B2如下左中，目的找到匹配B1，但是不匹配B2的区域，B1和B2也可以直接由B（右）表示。...
【OpenCV C++20 学习笔记】击中击不中(Hit-or-Miss)
TeamLee的博客
08-02 946
简要介绍OpenCV中的击中不击中变换(Hit-or-Miss transformation)的原理及实现
OpenCV||超详细的形态学应用
m0_56230886的博客
08-11 1315
数学上的形态学，特别是数学形态学（Mathematical morphology），是一门建立在格论和拓扑学基础之上的图像分析学科，它是数学形态学图像处理的基本理论。数学形态学具有坚实的理论基础和广泛的应用价值，其基本思想和方法对图像处理的理论和技术产生了重大影响。数学形态学是法国和德国的科学家在研究岩石结构时建立的一门学科，旨在通过物体和结构元素相互作用的某些运算，获取物体更本质的形态信息。在数学中，格是其非空有限子集都有一个上确界（叫并）和一个下确界（叫交）的偏序集合。
opencv-python学习笔记10-图像形态学处理
最新发布
The_xz的博客
09-17 1396
【代码】opencv-python学习笔记10-图像形态学处理。
图象处理与分析-数学形态学方法及应用（催屹）
03-10
3. **击中击不中变换**：这是一种形态学操作，用于检测图像中的特定形状或结构。击中表示结构元素完全匹配到图像中的某个位置，而击不中则表示没有匹配。这种方法在识别和定位特定形状时非常有用。 4. **二值图像的...
图像形态学算法 c++ 腐蚀 膨胀 击中击不中
04-26
图像形态学算法 c++ 腐蚀 膨胀 击中击不中
数学形态学变换，粗化，细化
04-15
数学形态学基本变换方法代码，很小，但很实用
OpenCV-Python击中击不中变换案例：真图作核的绳网结匹配.rar
09-16
OpenCV-Python击中击不中变换案例：真图作核的绳网结匹配.rar
图像形态学——击中击不中
WaitFoF
11-22 3881
击中击不中变换 击中击不中变换是形状检测的一个基本工具。 设X为目标图像，B为结构元素，且B由两个不相交的部分B1B_1B1​和B2B_2B2​组成，即B=B1∪B2B=B_1∪B_2B=B1​∪B2​,且B1∩B2=ϕB_1∩B_2=\phiB1​∩B2​=ϕ。则目标图像X被结构元素B击中的数学表达式： X⊗B={x∣(B1)x⊆X,(B2)x⊆Xc}X \otimes B= \{x|(B_1)...
【Emgu CV教程】9.8、形态学常用操作之击中击不中
活宝的博客
03-21 680
Emgu CV教程、形态学操作、击中击不中、MorphologyEx()、MorphOp.HitMiss
OpenCV实现击中击不中变换和形态学细化
小学僧的博客
03-28 4896
1 击中击不中变换 1.1 HMT概述 形态学Hit-or-Miss是形状检测基本工具，只要结构元设置得当，就可以检测一些基本的形状图案，HMT变换只能作用于二值图像，结构元（核）元素值由0、1、-1组成。 操作时，结构元在图像上滑动，覆盖一小片与核大小一样的区域，然后逐一对比，核的值为1时，覆盖区域对应位置必须为255，而核值为-1时，则必须为0，核值为0时0和255均可，如果覆盖区域所有的位置均满足上述要求，则表示击中，锚点位置设置为255，如果有任意一个位置不满足，则表示击不中，锚点位置设置为0。 不
Opencv图像处理——数学形态学操作
ivan_9的博客
02-24 2763
文章目录前言二、1.2、总结参考来源 前言 本文讲述图像处理的形态学操作 # 一、 二、 1. 2、 总结 参考来源 如有疑问，请留言！ 如有错误，敬请指正！
【OpenCV图像处理】十九、数学形态学方法（中）
Damu
05-08 3773
1.击中击不中运算 击中击不中（hit or miss）定义在交集为空集的两个结构元素的膨胀和腐蚀运算的基础上。设B =（B1，B2）表示结构元素对，且B1 ∩ B2 = ∅ 则结构元素B对集合A的击中积补种运算，记做  定义为： →运算过程为： （→当且仅当B1平移某一z值包含在集合A的内部，也就是B1击中A且B2平移同一z值包含在集合A的外部（也就是B2击不中A），这个条件同
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值