【openCV】二值图像基础操作

最新推荐文章于 2023-01-03 17:02:31 发布
最新推荐文章于 2023-01-03 17:02:31 发布
阅读量3.2k 收藏 2
点赞数 3
分类专栏： openCV 文章标签： openCV thin thick skeleton
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jhszh418762259/article/details/52788862
版权

实现了二值图像的Thin,Thicken和提取骨架的操作。

#include "opencv2/opencv.hpp"

#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("potota.jpg", CV_LOAD_IMAGE_UNCHANGED);// 从文件中加载原图  
	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(srcImage,i,j);
				s = CV_RGB(0,255,0);
				cvSet2D(srcImage,i,j,s);
			 }
		 }
	 }

	 cvReleaseImage(&skeletonImage);

	 cvShowImage("Skeleton",srcImage);
	 cvWaitKey(0);
	 cvDestroyWindow("Skeleton");
	 
	 cvReleaseImage(&srcImage);
}

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("potota.jpg", CV_LOAD_IMAGE_UNCHANGED);// 从文件中加载原图  
	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);


	 //把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(srcImage,i,j);
				s = CV_RGB(0,255,0);
				cvSet2D(srcImage,i,j,s);
			 }
		 }
	 }

	 cvReleaseImage(&thinImage);

	 cvShowImage("Thin",srcImage);
	 cvWaitKey(0);
	 cvDestroyWindow("Thin");
	 
	 cvReleaseImage(&srcImage);
}

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("potota.jpg", CV_LOAD_IMAGE_UNCHANGED);// 从文件中加载原图  
	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);


	 //把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(srcImage,i,j);
				s = CV_RGB(0,255,0);
				cvSet2D(srcImage,i,j,s);
			 }
		 }
	 }

	 cvReleaseImage(&thickenImage);

	 cvShowImage("Thicken",srcImage);
	 cvWaitKey(0);
	 cvDestroyWindow("Thicken");
	 
	 cvReleaseImage(&srcImage);

}

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


原图：


Skeleton效果：


Thin效果：


Thicken效果：


Thin和Thick使用的element:：


提取skeleton使用的elemeng（每四个方向只画一个）：



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


纯洁可爱小昊昊
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
opencv与numpy的图像基本操作
01-20
1. 像素基本操作 1.1 读取、修改像素 可以通过[行，列]坐标来访问像素点数据，对于多通道数据，返回一个数组，包含所有通道的值，对于单通道数据（如gray），返回指定坐标的值，也可以通过 [行，列，通道index] 来...
OpenCV入门函数API解析
web18334137065的博客
03-21 307
一切图像皆Mat cvtColor:用于将图像从一个颜色空间转换到另一个颜色空间的转换（目前常见的颜色空间均支持），并且在转换的过程中能够保证数据的类型不变，即转换后的图像的数据类型和位深与源图像一致。 cvtColor(image, hsv, COLOR_BGR2HSV, 0);//H 0-180 S,V 0-255 h,s是控制颜色 V控制亮度 . InputArray src: 输入图像即要进行颜色空间变换的原图像，可以是Mat类 . OutputArray dst: 输出图像即进行颜色空间变
opencv中 .at＜uchar＞（）和.ptr＜uchar＞（）使用方法的区别
xxhjxx的博客
04-22 5489
opencv中 .at（）和.ptr（）使用方法的区别 在opencv中，.at（）和.ptr（）都是获取像素值的函数，但是二者是有区别的。 在说明这两个函数的使用方法前，先补充一个知识： c语言中*和&的区别，num是有前提的，前提是num这个变量里要存放另一个变量的地址，所以num就代表取的num存放的变量的值,即： int *num = &a;（int *num = a；这种写法是错误的，a一定要取地址符） 那么num = a的地址 而&num则代表取num的地址。 ok，
opencv绘制基本形状的二值图像
yang6464158的专栏
11-14 1679
二值图像的创建很容易，本文的工作在于绘制有较大梯度变化的边缘图像，为后面的实验做准备，黑色变白色以及白色变黑色便会产生边缘。 还有倾斜的边缘。 首先，创建左右黑白二值图像： #include #include #include using namespace std; using namespace cv; int main() { Mat src(Size(200,200),CV_8
OpenCV3 4.8 用积分图像创建二值图
南航小菜鸡
12-22 646
对于一张黑白纸张图片，想要提取图片中的文字部分并创建二值图有几种常见的方法：使用固定阈值、使用自适应阈值等等。下面将依次介绍各类方法的优劣。
数字图像处理——形态学操作(二值图像篇)
Lavendelion的博客
10-03 8473
形态学操作内容简介 内容简介   本篇博客介绍的形态学图像处理操作。
OpenCV图像像素操作示例代码
09-04
这是一段使用OpenCV和NumPy库...通过运行这段代码，您可以学习如何使用OpenCV和NumPy库对图像进行基本的像素操作，以及如何访问和修改图像的通道数据。这对于图像处理和计算机视觉的初学者和从业者都是有用的参考示例。
(一)OpenCV图像处理基础_02_矩阵的掩膜操作
01-06
获取图像像素指针 CV_Assert(myImage.depth() == CV_8U) Mat.ptr(int i=0) 获取像素矩阵的指针，索引i表示第几行，从0开始计行数。 获得当前行指针const uchar* current= myImage.ptr(row ); 获取当前像素点P(row, ...
opencv图像处理基础参考Program.zip
07-15
16.二值化-threshold() 17.图像微分-Laplacian() 18.边界处理-copyMakeBorder() 19.改进微分-Scharr() 20.图像正确性-convertScaleAbs() 21.边缘检测-Canny() 22.霍夫直线-HoughLines() 23.霍夫圆-HoughCircles() 24...
(一)OpenCV图像处理基础_11_形态学操作
01-07
主要应用于 二值图像 morphologyEx(src, dest, CV_MOP_BLACKHAT, kernel); Mat src：输入图像 Mat dest：输出结果 int OPT：CV_MOP_OPEN/ CV_MOP_CLOSE/ CV_MOP_GRADIENT / CV_MOP_TOPHAT/ CV_MOP_BLACKHAT：形态学...
OpenCV——图像二值化
小铅笔
06-09 2045
OpenCV图像二值化提供了两种函数 threshold double threshold( InputArray src, OutputArray dst, double thresh, double maxval, int type );
【OpenCV基础】图像二值化操作
欢迎时常光顾我的干货超市，热衷于AIoT！！
07-12 2724
图像二值化操作 API- 函数原型中的参数： 参数含义
OpenCV图像处理----图像的二值化
热门推荐
bjsyc123456的博客
05-15 2万+
图像二值化（ Image Binarization）就是将图像上的像素点的灰度值设置为0或255，也就是将整个图像呈现出明显的黑白效果的过程。 二值化的原理 import cv2 img = cv2.imread('img/lena.jpg') # 转为灰度图 new_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) height, width = new_img.shape[0:2] # 设置阈值 thresh = 60 # 遍历每一个像素点 for row
opencv 二值化图像详解 一文看懂各种二值化方法
rainbow的博客
07-02 2741
本文介绍使用不同的阈值方法“二值化”图像 固定阈值分割 图解 代码 import cv2 as cv # 读入灰度图像 img = cv.imread('baby_g.jpg', 0) # 阈值127分割图像 ret, th = cv.threshold(img, 127, 255, cv.THRESH_BINARY) cv.imshow('thresh', th) cv.waitKey(0) cv.destroyAllWindows() 函数讲解 cv.threshold()用来
Opencv教程-图像二值化
Jamia
01-03 1936
图像二值化是指将指将256阶的通过合适的，转换为。即像素或0和255。其目的通常为将图像的前后景进行分割，使图像变得简单，数据量减小,能凸显出感兴趣的目标的轮廓。主要用于目标物体检测，目标跟踪、物体分离等领域g(x,y){255,0,​iff(x,y)>=THif==iff(x,y)
Opencv-二值图像
weixin_41709536的博客
09-17 1661
二值图像知识点python代码c++代码 知识点 二值图像介绍 二值图像就是只有黑白两种颜色表示的图像，其中0 – 表示黑色， 1 – 表示白色(255) 。二值图像处理与分析在机器视觉与机器人视觉中非常重要，涉及到非常多的图像处理相关的知识，常见的二值图像分析包括轮廓分析、对象测量、轮廓匹配与识别、形态学处理与分割、各种形状检测与拟合、投影与逻辑操作、轮廓特征提取与编码等。此外图像二值化的方法也...
CJ寻梦记：OpenCV uchar和Vec3b类型指针ptr的使用
JackPan2016的博客
07-22 1054
常用形式： mat.ptr(row)[col] 以下转载自：https://blog.csdn.net/github_35160620/article/details/51708659 单通道 cv::Mat image=cv::Mat(400,600,CV_8UC1); // 定义了一个Mat变量image。 uchar* data00=image.ptr(0); // data00是指向image第一行第一个元素的指针。 uchar* data10=image.ptr(1); // data10是指向i
opencv像素基本操作及图像遍历at
当你努力到把自己都感动的时候，你离成功就不远了。
07-25 1万+
矩阵元素的表达： 对于单通道图像，其元素类型一般为 8U （即 8位无符号整数），当然也可以 是 16S 、32F32F 等；这些类型可以直接用 uchar 、short 、float等 C/C++语言中的基本数据类型表达。 如果多通道图像，如RGB彩色图像，需要用三个通道来表示。在这种情况 下，如果依然将图像视作一个二维矩阵那么矩阵的元素不再是基本数据类型。 opencv中使用vec可表示
opencv图像二值化函数
最新发布
03-21
在OpenCV中，图像二值化是将图像转换为只有两个像素值的过程，通常是将图像转换为黑白二值图像。 OpenCV提供了多种图像二值化函数，其中最常用的是cv2.threshold()函数。该函数的基本语法如下： retval, threshold...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值