区域生长法的编程实现——程序员数字图像处理第一步

最新推荐文章于 2024-07-27 12:41:49 发布
最新推荐文章于 2024-07-27 12:41:49 发布
阅读量2.2w 收藏 19
点赞数 5
分类专栏： 图像处理 c++ 文章标签： 图像处理 编程 iterator class dst
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sera_ph/article/details/7674847
版权

数字图像处理的书数不胜数。相关的方法，从直方图、卷积到小波、机器学习方面的方法也举不胜举。


OpenCV库给我们提供了一整套图像存储、显示方法外，也集成了很多很多的图像、视频处理算法以及机器学习算法，以函数的形式提供给我们使用。

然而在初学阶段，我们往往过分依赖于OpenCV中的那些库函数。

虽说OpenCV集成了很多高效算法，然而，毕竟不是无所不包。

OpenCV中基础的算法有时会缺失，有时用起来不是很得心应手。


区域生长算法就是一例（OpenCV的FloodFill用起来非常不顺手）。


区域生长法，思路很简单：将一个图像中的一点作为种子，此种子会沿8邻域/4邻域进行扩展，扩展具有一定限制（即差值不能过大，当然你可以引入梯度这个概念，甚至二维偏导数……），求出种子生长的最终结果。

把示例程序的几张结果发过来，何谓区域生长法，大家一看便知。


区域生长法对于较为均衡的背景中提取目标物而言，效果较为理想。与阈值法、边缘检测法孰优孰劣，俺笔力及精力有限，不进行比较了。单从工程角度，区域生长法是统计闭合图形个数的基础。


这里自己写了一下这个程序的演示代码，只负责将背景同生长不上去的区域分开：

#define INIT 0  
#define SEED -1  
#define CONT -2  
#define INVAL -3  

int color_templ[5*6*3]
= {
	0,0,0,		40,40,40,	80,80,80,	120,120,120,160,160,160,	200,200,200,
	76,0,13,	113,52,0,	127,91,0,	188,114,0,	203,140,68,		236,211,190,
	0,0,121,	93,0,158,	91,20,237,	255,61,255,	170,110,240,	200,161,245,
	38,88,0,	77,118,46,	66,130,98,	112,182,46,	118,197,124,	174,221,178,
	19,57,96,	10,98,163,	0,160,171,	0,242,255,	59,245,255,		139,247,255
};

class g_point  
{  
public:  
	g_point();  
	g_point(int x_i, int y_i);  
	g_point(int x_i, int y_i, int lbl_i);  
public:  
	int x;  
	int y;  
	int lbl;      //标签  
};  

g_point::g_point(int x_i, int y_i)  
{  
	x = x_i;  
	y = y_i;  
	lbl = SEED;  
}  

g_point::g_point()  
{  
	x = 0;  
	y = 0;  
	lbl = INIT;  
}  

g_point::g_point(int x_i, int y_i, int lbl_i)  
{  
	x = x_i;  
	y = y_i;  
	lbl = lbl_i;  
}  

void regionGrowth(IplImage* img, int* p_mat, int x_g, int y_g, int threshold_g)  
{  
	//常用变量：  
	int x;  
	int y;  
	int gradient = 0;  


	//设置前次边缘点  
	std::list<class g_point> cont_pts_pre;  
	std::list<class g_point> * pcont_pts_pre = &cont_pts_pre;


	//设置边缘点  
	std::list<class g_point> cont_pts;  
	std::list<class g_point> * pcont_pts = &cont_pts;


	//种子点+边缘点 = 下次的种子点  
	//上次的边缘点 = 前次边缘点（用于下次减少点数)   
	cont_pts_pre.push_back(class g_point(x_g, y_g, CONT));  
	p_mat[y_g * img->width + x_g] = SEED;  

	std::list<class g_point>::iterator iter_cont;  
	std::list<class g_point>::iterator iter_prt;  
	std::list<class g_point>::iterator iter_swap;  




	while( !cont_pts_pre.empty() )  
	{  



		//一轮生长  
		iter_cont = cont_pts_pre.begin();  
		while(iter_cont != cont_pts_pre.end())  
		{  
			x = (*iter_cont).x;  
			y = (*iter_cont).y;  
			//         if( !(x-1<0 || y-1<0) )                       //#1  
			//         {     
			//             if(p_mat[(y-1)*img->width + (x-1)] == INIT)  
			//             {  
			//                 gradient = ((char*)(img->imageData + y*img->widthStep))[x] -   
			//                     ((char*)(img->imageData + (y-1)*img->widthStep))[x-1];  
			//                 if(abs(gradient) < threshold_g)      //满足阈值要求  
			//                 {  
			//                     cont_pts.push_back(class g_point(x-1, y-1, CONT));  
			//                     p_mat[(y-1)*img->width + (x-1)] = SEED;  
			//                 }  
			//                 else                                //不满足阈值要求  
			//                 {  
			//                     p_mat[(y-1)*img->width + (x-1)] = INVAL;  
			//                 }  
			//             }  
			//         }  
			if( !(x-1<0) )                                   //#2  
			{  
				if(p_mat[(y)*img->width + (x-1)] == INIT)  
				{  
					gradient = ((char*)(img->imageData + y*img->widthStep))[x] -   
						((char*)(img->imageData + (y)*img->widthStep))[x-1];  
					if(abs(gradient) < threshold_g)      //满足阈值要求  
					{  
						cont_pts.push_back(class g_point(x-1, y, CONT));  
						p_mat[(y)*img->width + (x-1)] = SEED;  
					}  
					else                                //不满足阈值要求  
					{  
						p_mat[(y)*img->width + (x-1)] = INVAL;  
					}         

				}  
			}  
			//         if( !(x-1<0 || y+1 >= img->height) )           //#3  
			//         {  
			//             if(p_mat[(y+1)*img->width + (x-1)] == INIT)  
			//             {  
			//                 gradient = ((char*)(img->imageData + y*img->widthStep))[x] -   
			//                     ((char*)(img->imageData + (y+1)*img->widthStep))[x-1];  
			//                 if(abs(gradient) < threshold_g)      //满足阈值要求  
			//                 {  
			//                     cont_pts.push_back(class g_point(x-1, y+1, CONT));  
			//                     p_mat[(y+1)*img->width + (x-1)] = SEED;  
			//                 }  
			//                 else                                //不满足阈值要求  
			//                 {  
			//                     p_mat[(y+1)*img->width + (x-1)] = INVAL;  
			//                 }  
			//                   
			//             }  
			//         }  
			if( !(y+1 >= img->height) )                       //#4  
			{  
				if(p_mat[(y+1)*img->width + (x)] == INIT)  
				{  
					gradient = ((char*)(img->imageData + y*img->widthStep))[x] -   
						((char*)(img->imageData + (y+1)*img->widthStep))[x];  
					if(abs(gradient) < threshold_g)      //满足阈值要求  
					{  
						cont_pts.push_back(class g_point(x, y+1, CONT));  
						p_mat[(y+1)*img->width + (x)] = SEED;  
					}  
					else                                //不满足阈值要求  
					{  
						p_mat[(y+1)*img->width + (x)] = INVAL;  
					}  
				}  
			}  
			//         if( !(x+1>=img->width || y+1>=img->height) )    //#5  
			//         {  
			//             if(p_mat[(y+1)*img->width + (x+1)] == INIT)  
			//             {  
			//                 gradient = ((char*)(img->imageData + y*img->widthStep))[x] -   
			//                     ((char*)(img->imageData + (y+1)*img->widthStep))[x+1];  
			//                 if(abs(gradient) < threshold_g)      //满足阈值要求  
			//                 {  
			//                     cont_pts.push_back(class g_point(x+1, y+1, CONT));  
			//                     p_mat[(y+1)*img->width + (x+1)] = SEED;  
			//                 }  
			//                 else                                //不满足阈值要求  
			//                 {  
			//                     p_mat[(y+1)*img->width + (x+1)] = INVAL;  
			//                 }  
			//                   
			//             }  
			//         }  
			if( !(x+1>=img->width) )                      //#6  
			{  
				if(p_mat[(y)*img->width + (x+1)] == INIT)  
				{  
					gradient = ((char*)(img->imageData + y*img->widthStep))[x] -   
						((char*)(img->imageData + (y)*img->widthStep))[x+1];  
					if(abs(gradient) < threshold_g)      //满足阈值要求  
					{  
						cont_pts.push_back(class g_point(x+1, y, CONT));  
						p_mat[(y)*img->width + (x+1)] = SEED;  
					}  
					else                                //不满足阈值要求  
					{  
						p_mat[(y)*img->width + (x+1)] = INVAL;  
					}  

				}  
			}  
			//         if( !(x+1>=img->width || y-1<0) )              //#7  
			//         {  
			//             if(p_mat[(y-1)*img->width + (x+1)] == INIT)  
			//             {  
			//                 gradient = ((char*)(img->imageData + y*img->widthStep))[x] -   
			//                     ((char*)(img->imageData + (y-1)*img->widthStep))[x+1];  
			//                 if(abs(gradient) < threshold_g)      //满足阈值要求  
			//                 {  
			//                     cont_pts.push_back(class g_point(x+1, y-1, CONT));  
			//                     p_mat[(y-1)*img->width + (x+1)] = SEED;  
			//                 }  
			//                 else                                //不满足阈值要求  
			//                 {  
			//                     p_mat[(y-1)*img->width + (x+1)] = INVAL;  
			//                 }  
			//                   
			//             }  
			//         }  
			if( !(y-1<0) )                                   //#8  
			{  
				if(p_mat[(y-1)*img->width + (x)] == INIT)  
				{  
					gradient = ((char*)(img->imageData + y*img->widthStep))[x] -   
						((char*)(img->imageData + (y-1)*img->widthStep))[x];  
					if(abs(gradient) < threshold_g)      //满足阈值要求  
					{  
						cont_pts.push_back(class g_point(x, y-1, CONT));  
						p_mat[(y-1)*img->width + (x)] = SEED;  
					}  
					else                                //不满足阈值要求  
					{  
						p_mat[(y-1)*img->width + (x)] = INVAL;  
					}  
				}  
			}  

			iter_cont ++;  
		}  

		//将cont_pts中的点赋给cont_pts_pre  
		cont_pts_pre.clear();
		iter_swap = cont_pts.begin();  
		while(iter_swap != cont_pts.end() )  
		{  
			cont_pts_pre.push_back((*iter_swap));  
			iter_swap ++;  
		}
		cont_pts.clear();


	}  
	//结束while  




	cont_pts_pre.clear(); 
	cont_pts.clear();

	// 	delete pseed_pts;
	// 	delete pcont_pts_pre;
	// 	delete pcont_pts;
}  


void display_mat(int * p_mat, int width, int height)
{
	IplImage* disp;
	disp = cvCreateImage( cvSize(width, height), 8, 3 );
	cvZero(disp);

	for(int h = 0; h < height; h++)
	{
		for(int w = 0; w < width; w++)
		{
			if(p_mat[h * width + w] == SEED)
			{
 				((UCHAR *)(disp->imageData + h*disp->widthStep))[w*3 + 0] = color_templ[0*18 + 0*3 + 0];
 				((UCHAR *)(disp->imageData + h*disp->widthStep))[w*3 + 1] = color_templ[0*18 + 0*3 + 1];
 				((UCHAR *)(disp->imageData + h*disp->widthStep))[w*3 + 2] = color_templ[0*18 + 0*3 + 2];
			}
			else if(p_mat[h * width + w] == INIT)
			{
				((UCHAR *)(disp->imageData + h*disp->widthStep))[w*3 + 0] = color_templ[0*18 + 2*3 + 0];
 				((UCHAR *)(disp->imageData + h*disp->widthStep))[w*3 + 1] = color_templ[0*18 + 2*3 + 1];
 				((UCHAR *)(disp->imageData + h*disp->widthStep))[w*3 + 2] = color_templ[0*18 + 2*3 + 2];
			}
			else if(p_mat[h * width + w] == INVAL)
			{
 				((UCHAR *)(disp->imageData + h*disp->widthStep))[w*3 + 0] = color_templ[0*18 + 4*3 + 0];
 				((UCHAR *)(disp->imageData + h*disp->widthStep))[w*3 + 1] = color_templ[0*18 + 4*3 + 1];
 				((UCHAR *)(disp->imageData + h*disp->widthStep))[w*3 + 2] = color_templ[0*18 + 4*3 + 2];
			}
		}
	}
	cvNamedWindow("display");
	cvShowImage("display", disp);
	cvWaitKey(0);

	cvDestroyWindow("display");
	cvReleaseImage(&disp);
}


int _tmain(int argc, _TCHAR* argv[])
{
	IplImage* img;
	img = cvLoadImage("1.bmp", CV_LOAD_IMAGE_ANYCOLOR);


	//建立需要使用的单通道8位深图像
	IplImage* img_gray;
	img_gray = cvCreateImage(cvGetSize(img), img->depth, 1);
	cvSplit(img, NULL, img_gray, NULL, NULL);

	cvNamedWindow("original image", -1);
	cvShowImage("original image", img_gray);
	cvWaitKey(0);

	//建立所需的与图像同样宽高的整型数矩阵并赋初值
	int * pres_mat;
	pres_mat = new int[img_gray->width * img_gray->height];
	for(int i = 0; i < img_gray->width * img_gray->height; i++)
	{
		pres_mat[i] = INIT;
	}

	//开始进行区域生长
	regionGrowth(img_gray, pres_mat, 1, 1, 50);

	display_mat(pres_mat, img_gray->width, img_gray->height);

	return 0;
}
regionGrowth函数详解

参数：
img：需要进行区域生长的图像，8位单通道的IplImage
p_map：整型数矩阵指针，宽高与图像相同，用于储存图像生长结果
矩阵已经被全部赋值为INIT(#define INIT 0)
x_g, y_g区域生长初始种子点
threshold_g区域生长邻域梯度的阈值
 
生长过程中存储中间数据的容器：
list<class g_point> cont_pts                 
//contour points 生长边缘链表
list<class g_point> cont_pts_pre            
//contour points previously前次生长边缘链表
class g_point为自定义的一个类，具有3个整型数成员变量：x,y坐标以及点点类型函数lbl
 
 
处理过程：
第一步，初始生长点(x_g, y_g)：将此点坐标压入cont_pts_pre矩阵，并在矩阵上将此点标注为SEED
 
第二步，第一轮生长：
将cont_pts清空，存储此轮生长点边缘点。访问cont_pts_pre中的每一个点，对点进行四邻域/八邻域生长条件判断。
若满足生长条件，1、将该点接到cont_pts末尾；供下轮生长使用。2、在矩阵上将词典标注为SEED。
若不满足生长条件，之在矩阵上将此点标注为INVAL。（以后的边界，便可由INVAL来确定）
这一步骤，是由程序中连着的8个if语句完成。
 
第三步，为下一轮生长做准备。将cont_pts_pre清空，将cont_pts赋值给cont_pts_pre
 
接下来的步骤，第2、3、4、……轮生长
 
迭代终止条件：cont_pts_pre为空，则无点可生长。
 
处理结果
在p_map中，生长到的点取值为：SEED；未生长到的点：INIT；边界点：INVAL
 




在编写过程中，考虑过迭代次数、各类点的存储选择的数据结构等限制区域生长法效率的因素。俺将日后写一个运算量、处理时间的评估报告。


RegionGrowth经过优化后的程序，在此处。

http://download.csdn.net/detail/sera_ph/4505725

第一次上传资源，没有设置资源积分。希望大家能用得爽快。

此程序可将不同的联通区域用区别开来，处理的结果为：


Sera_ph
关注
专栏目录
From LowCode to ZeroCode: AI Code 系统架构实现方案——系统日志分析方案
程序员光剑
08-07 857
7月份，在当下热火朝天的AI、区块链等新技术的浪潮中，代码编写越来越多变成了一个大众化的职业。很多企业为了提升生产效率，把开发的流程自动化，推行LowCode模式，通过减少人的参与程度，提高工作效率，使得软件开发的成本大幅下降。在这个领域，提升自动化开发效率的关键，就是要用AI来分析系统日志数据，从而快速发现潜在风险点并解决问题。其中系统日志数据包括服务器日志、应用日志、业务日志等。那么如何将低代码模式中的日志分析系统迁移到零代码模式？
聪明程序员的算法思维:聪明程序员的算法思维
程序员光剑
08-10 263
在互联网时代，算法成为了解决复杂问题的必备工具。算法不仅能够帮助我们解决一些实际问题，同时也会影响到很多人的工作、生活、科研、理财等方面。作为一个合格的技术人员，掌握算法的思维方法可以帮助我们更好地理解并应用它。本文将通过图文并茂的方式，分享一些算法思维的经验教训及最佳实践。首先，让我们回顾一下什么是算法？1957年，蒂姆·麦卡洛克提出了“计算 machines that think”，即通过机器来思考。
基于opencv的区域生长算法
08-21
基于opencv的区域生长，可以进行阈值和一个生长点的选择，也可以转换为多个生长点的区域生长
【Opencv】图像分割——区域生长
weixin_53598445的博客
03-29 1万+
文章目录1 环境2 效果3 原理4 案例 1 环境 Python 3.8.8 PyCharm 2021 opencv-python 2 效果 3 原理   区域生长的基本思想是将具有相似性质的像素集合起来构成区域。具体先对每个需要分割的区域找一个种子像素作为生长的起点，然后将种子像素周围邻域中与种子像素具有相同或相似性质的像素（根据某种事先确定的生长或相似准则来判定）合并到种子像素所在的区域中。将这些新像素当做新的种子像素继续进行上面的过程，直到再没有满足条件的像素可被包括进来，这样，一个区域就长成
图像处理之图像分割算法：区域生长：基于纹理的区域生长算法
最新发布
kkchenjj的博客
07-27 455
区域生长算法是一种基于像素间相似性的图像分割方法。它从一个或多个种子像素开始，根据预定义的相似性准则，逐步将与种子像素相似的相邻像素合并到同一区域中。基于纹理的区域生长算法进一步利用纹理特征作为相似性准则，能够更准确地识别和分割具有复杂纹理的图像区域。纹理特征是图像分割中用于描述图像局部区域结构的重要属性。灰度级变化：图像中像素值的分布情况，可以使用灰度直方图或灰度共生矩阵来描述。方向性：纹理元素的方向信息，通过计算图像梯度或使用Gabor滤波器来获取。频率。
openCV区域生长算法demo
03-03
基于openCV区域生长算法demo，使用VS2010直接打开
OpenCV与图像处理学习十——区域生长算法（含代码）
qq_40467656的博客
10-26 1万+
OpenCV与图像处理学习十——区域生长算法（含代码）一、区域生长算法概要二、区域生长算法原理三、代码应用 一、区域生长算法概要 区域生长是一种串行区域分割的图像分割方法。区域生长是指从某个像素出发，按照一定的准则，逐步加入邻近像素，当满足一定的条件时，区域生长终止。 区域生长的好坏决定于： 初始点（种子点）的选取。 生长准则。 终止条件。 区域生长是从某个或者某些像素点出发，最后得到整个区域，进而实现目标的提取。 二、区域生长算法原理 基本思想：将具有相似性质的像素集合起来构成区域。 步骤： 对图像
floodfill 区域生长法 opencv
11-24
基于vs2010与opencv采用区域生长法实现的图像分割法，经调试可用，一个挺简单的源程序，可供初学者参考
C语言GUI编程之数字记忆游戏——游戏玩法核心代码开发
lch1990的博客
10-31 1446
上一篇文章 C语言GUI编程之数字记忆游戏——项目目录结构和初步的窗口布局完成了基本的项目框架，接下来介绍游戏的核心代码开发。
第一篇:从零开始，理解机器学习
程序员光剑
07-31 1622
1959年，加拿大达特茅斯分校的教授费尔南多·费罗斯和皮埃尔·马库斯共同发明了著名的“西瓜书”。之后该书迅速走红全球，并成为了许多数据科学领域的经典教材。今年的“第四十一届美国科技奖”又推出了一项““最佳数据分析工具奖”，颁给了另一本经典的数据科学入门书——斯坦福大学公开课“机器学习”（CS109）的作者。此外，还有一些高质量的博文、教程、开源项目等资源也涌现出来，为广大的程序员提供了丰富的学习资源。
信息收集的有效方法——为企业搭建信息架构，优化信息管理
程序员光剑
08-04 1532
20世纪末，互联网爆炸席卷全球，产生了海量的数据，而这些数据极大的激发了人们对数据分析的需求。为应对这个数据分析需求，网络安全专家、程序员和科学家们一起合作，开发出了各种基于机器学习的方法。当今，人工智能正成为企业解决复杂问题的核心驱动力，越来越多的企业也将其用于信息管理中，帮助他们更好地发现信息价值并对其进行加工整理。本文从收集、整理、存储、分析等四个方面综述了信息收集过程，并给出了最佳实践方案。非结构化数据：指没有固定格式或标准的、易于被计算机处理的数据，如图像、视频、文本、音频、文档等；结构化数据。
区域生长算法
06-03
区域增长算法c++和opencv的完整代码，包括测试函数，只是一个cpp文件，自己创建工程后，改写图像目录即可运行。
基于c++的区域生长法算法
04-08
用visual studio2015编译实现的区域生长法去实现图像分割。注意opencv的环境配置。
区域生长法VS实现。C++
04-11
区域生长法VS实现。C++
opencv 区域生长算法实现眼睛虹膜中心定位
yangminlingyang的博客
03-26 623
笔记小工具 根据人脸landmark点检测获取眼睛区域,以及虹膜中心的初始位置,利用传统区域生长精确定位虹膜中心. 眼睛ROI: 生长结果取 canny图 获取虹膜区域和虹膜中心 直接上代码 #include <iostream> #include <stack> #include <opencv2\opencv.hpp> int main() { static cv::Point connects[8] = { cv::Point(-1, -1), cv
七、opencv学习笔记——区域生长算法
u010409517的博客
07-27 4963
简要介绍了区域生长算法原理，并基于opencv进行了一个实例分析。
opencv区域生长/区域扩散
qq_36638362的博客
01-09 1943
区域生长：就是以某个像素值进行扩散，查找颜色相近的范围区域。 这里主要介绍四种方法：固定灰度值、动态灰度值、固定RGB值、动态RGB值。这四种方法对应不同图片。经测试效果可以 1.固定灰度值区域生长 //固定灰度值区域生长 cv::Mat RegionGrow(cv::Mat src, cv::Point2i pt, int th) { cv::Point2i ptGrowing; ...
OpenCV - 区域生长算法
热门推荐
翼遥君的博客
11-27 4万+
1、理论基础       区域生长算法的基本思想是将有相似性质的像素点合并到一起。对每一个区域要先指定一个种子点作为生长的起点，然后将种子点周围领域的像素点和种子点进行对比，将具有相似性质的点合并起来继续向外生长，直到没有满足条件的像素被包括进来为止。这样一个区域的生长就完成了。这个过程中有几个关键的问题： a> 给定种子点(种子点如何选取？)       种子点的选取很多时候都采用人工交互
openCV实现区域生长算法
weixin_57511504的博客
06-30 539
案例:Fu Xianjun. All Rights Reserved. import cv2 import numpy as np class Point(object): def init(self,x,y): self.x = x self.y = y def getX(self): return self.x def getY(self): return self.y def getGrayDiff(img,currentPoint,tmpPoint): return abs
Windows环境下数字图像处理编程实战
"《数字图像处理编程入门》是一本...《数字图像处理编程入门》是一本实用的指南，适合对图像处理感兴趣的程序员和学生，它不仅提供了理论知识，更强调了实际编程经验，让读者能够快速上手并实现自己的图像处理程序。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值