八领域边界追踪算法

最新推荐文章于 2021-11-02 16:36:11 发布
最新推荐文章于 2021-11-02 16:36:11 发布
阅读量9.6k 收藏 81
点赞数 7
分类专栏： Image algorithm 文章标签： 边界追踪
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dopamy_BusyMonkey/article/details/42524771
版权

八领域边界追踪 C语言

其中_Binary为输入的bmp二值化图像，_TracingPtr为轮廓空间点（类型为结构体）

typedef struct Contours
{
	int height;
	int width;
	int stateFlag;
} contour;

void edgeTracing( const unsigned char* _Binary, contour** _TracingPtr, const int _Width, const int _Height )
{
	unsigned char* _Mark = NULL;//标记矩阵
	int direction[8][2] = { 0,-1, -1,-1, -1,0, -1,1, 0,1, 1,1, 1,0, 1,-1 };//方向数组
	int i = 0, j = 0;//行、列计数
	int start_I = 0, start_J = 0;//轮廓的起始点
	int rec_I = 0, rec_J = 0;//待检测轮廓点坐标
	int mov_I = 0, mov_J = 0;//待检测轮廓点周围8领域逆时针旋转点
	int tmp_I = 0, tmp_J = 0;//临时点保存
	int point_Count = 0;//轮廓点计数
	int direc_Count = 0;//方向转次数计数
	int rot_Direct = 0;//方向数组计数
	int stepWidth = (_Width + 3) & ~3;//灰度图行步长
	int contour_Succe_Flag = 0;//轮廓寻找成功标志位
	int contour_Point_Now = 0;//现已开辟轮廓空间点数量
	int contour_Point_Add = 0;//需要增加的轮廓空间点数量
	contour* ptr_Contour_First = NULL;//轮廓点数组首地址


	contour_Point_Now = 4 * (_Width+_Height);
	contour_Point_Add = _Width + _Height;
	*_TracingPtr = (  contour *)malloc( contour_Point_Now * sizeof( contour) );//为储存轮廓点创建内存块
	ptr_Contour_First = *_TracingPtr;
	_Mark = ( unsigned char*)malloc( stepWidth*_Height );//轮廓标记矩阵
	memset(_Mark, 0, stepWidth*_Height);//轮廓标记矩阵清零
	for ( i = 0; i < _Height; i ++ )
	{
		for ( j = 1; j < _Width; j ++ )
		{
			if ( 255 == _Binary[ i*stepWidth + j - 1] && 0 == _Binary[ i*stepWidth + j] && 0 == _Mark[i*stepWidth + j] )
			{
				direc_Count = 0;//方向计数置零
				rot_Direct = 0;//旋转方向计数置零
				start_I = i;//保存每个轮廓的起始点
				start_J = j;
				rec_I = i;//存储第一个b点的行坐标
				rec_J = j;//存储第一个b点的列坐标
				mov_I = i;//存储第一个c点的行坐标
				mov_J = j-1;//存储第一个c点的列坐标
				while ( direc_Count < 8 && mov_I > 0 && mov_I < _Height && mov_J > 0 && mov_J < _Width )
				{
					direc_Count ++;
					rot_Direct ++;//顺时针方向转45°
					if ( 8 == rot_Direct) rot_Direct = 0;//使方向循环且不溢出
					mov_I = rec_I + direction[rot_Direct][0];//转完之后c点的行坐标
					mov_J = rec_J + direction[rot_Direct][1];//转完之后c点的列坐标
					if ( 0 == _Binary[ mov_I*stepWidth + mov_J]
						&& mov_I > 0 && mov_I < _Height
						&& mov_J > 0 && mov_J < _Width
						&& ( start_I != mov_I || start_J != mov_J ) )
					{
						if ( 0 == rot_Direct ) rot_Direct = 7;//方向回到上一个角度
						else rot_Direct --;
						
						tmp_I = rec_I;//记录变换前b点行坐标
						tmp_J = rec_J;//记录变换前b点列坐标
						rec_I = mov_I;//新的c点坐标赋值给b点
						rec_J = mov_J;
						mov_I = tmp_I + direction[rot_Direct][0];//将上一个c点坐标赋值给新c点坐标
						mov_J = tmp_J + direction[rot_Direct][1];

						direc_Count = 0;//方向次数计数清零

						if ( rec_I > mov_I )//计算现在c点相对b点的方位
							rot_Direct = 2;
						else if ( rec_I < mov_I )
							rot_Direct = 6;
						else if ( rec_J > mov_J )
							rot_Direct = 0;
						else if ( rec_J < mov_J )
							rot_Direct = 4;
					}
					else if ( start_I == mov_I && start_J == mov_J )
					{
						//如果等于起始点，则重新遍历该轮廓，标记轮廓并储存轮廓点
						if ( point_Count > contour_Point_Now-1 )
						{
							//若轮廓空间点超出范围，则加入额外轮廓空间点
							ptr_Contour_First = (  contour *)malloc( contour_Point_Now * sizeof( contour) );
							memcpy( ptr_Contour_First, *_TracingPtr, contour_Point_Now * sizeof( contour) );
							*_TracingPtr = (  contour *)malloc( (contour_Point_Now + contour_Point_Add) * sizeof( contour) );
							memcpy( *_TracingPtr, ptr_Contour_First, contour_Point_Now * sizeof( contour) );
							contour_Point_Now += contour_Point_Add;
							free( ptr_Contour_First);
							ptr_Contour_First = NULL;
							ptr_Contour_First = *_TracingPtr;
						}
						
						ptr_Contour_First[ point_Count].height = start_I;//储存起始点
						ptr_Contour_First[ point_Count].width = start_J;
						ptr_Contour_First[ point_Count].stateFlag = 1;//状态标志位stateFlag：
																	  //1为起始点，0为普通边缘点，2为结束点
						_Mark[ start_I*stepWidth + start_J] = 255;//标记为已搜索过的点

						direc_Count = 0;//方向计数置零
						rot_Direct = 0;//旋转方向计数置零
						rec_I = start_I;//存储b点的行坐标
						rec_J = start_J;//存储b点的列坐标
						mov_I = start_I;//存储 c点的行坐标
						mov_J = start_J-1;//存储c点的列坐标
						while ( direc_Count < 8 && mov_I > 0 && mov_I < _Height && mov_J > 0 && mov_J < _Width )
						{
							direc_Count ++;
							rot_Direct ++;//顺时针方向转45°
							if ( 8 == rot_Direct) rot_Direct = 0;//使方向循环且不溢出
							mov_I = rec_I + direction[rot_Direct][0];//转完之后c点的行坐标
							mov_J = rec_J + direction[rot_Direct][1];//转完之后c点的列坐标
							if ( 0 == _Binary[ mov_I*stepWidth + mov_J]
								&& mov_I > 0 && mov_I < _Height
								&& mov_J > 0 && mov_J < _Width
								&& ( start_I != mov_I || start_J != mov_J ) )
							{
								if ( 0 == rot_Direct ) rot_Direct = 7;//方向回到上一个角度
								else rot_Direct --;

								tmp_I = rec_I;//记录变换前b点行坐标
								tmp_J = rec_J;//记录变换前b点列坐标
								rec_I = mov_I;//新的c点坐标赋值给b点
								rec_J = mov_J;
								mov_I = tmp_I + direction[rot_Direct][0];//将上一个c点坐标赋值给新c点坐标
								mov_J = tmp_J + direction[rot_Direct][1];

								direc_Count = 0;//方向次数计数清零

								if ( rec_I > mov_I )//计算现在c点相对b点的方位
									rot_Direct = 2;
								else if ( rec_I < mov_I )
									rot_Direct = 6;
								else if ( rec_J > mov_J )
									rot_Direct = 0;
								else if ( rec_J < mov_J )
									rot_Direct = 4;

								point_Count ++;//压入新点之前，轮廓计数自加

								if ( point_Count > contour_Point_Now-1 )
								{
									//若轮廓空间点超出范围，则加入额外轮廓空间点
									ptr_Contour_First = (  contour *)malloc( contour_Point_Now * sizeof( contour) );
									memcpy( ptr_Contour_First, *_TracingPtr, contour_Point_Now * sizeof( contour) );
									*_TracingPtr = (  contour *)malloc( (contour_Point_Now + contour_Point_Add) * sizeof( contour) );
									memcpy( *_TracingPtr, ptr_Contour_First, contour_Point_Now * sizeof( contour) );
									contour_Point_Now += contour_Point_Add;
									free( ptr_Contour_First);
									ptr_Contour_First = NULL;
									ptr_Contour_First = *_TracingPtr;
								}

								ptr_Contour_First[ point_Count].height = rec_I;//储存新轮廓点
								ptr_Contour_First[ point_Count].width = rec_J;
								ptr_Contour_First[ point_Count].stateFlag = 0;//状态标志位stateFlag：
																			  //1为起始点，0为普通边缘点，2为结束点
								_Mark[ rec_I*stepWidth + rec_J] = 255;//标记为已搜索过的点
							}
							else if ( start_I == mov_I && start_J == mov_J )
							{
								//如果等于起始点，则把之前最后一个点改为终点，跳出开始新的搜索
								ptr_Contour_First[ point_Count].stateFlag = 2;//状态标志位stateFlag：
																			  //1为起始点，0为普通边缘点，2为结束点
								contour_Succe_Flag = 1;//轮廓完整，标志位置一
								point_Count ++;//为下一个轮廓开辟一个新点
								break;
							}
						}						
					}

					if ( contour_Succe_Flag )//如果一个轮廓搜索并储存成功，则开始找新的起始点
					{
						contour_Succe_Flag = 0;//轮廓搜索成功标志位置零
						break;
					}
				}
			}
		}
	}
	ptr_Contour_First[0].stateFlag = point_Count;//将轮廓点数量保存在第一个空间点的状态位
}


BusyMonkey
关注
专栏目录
8邻域算法边缘跟踪
08-29
图像边缘获取，自己实现的基于matlab的8邻域算法，获取图像的边缘。需要手动设置阈值对图像进行二值化。包涵实现程序和测试程序
图像处理（五）：八邻域边缘跟踪与区域生长算法
热门推荐
sinat_31425585的博客
11-17 5万+
通常在进行边缘检测之后，需要通过边缘跟踪来将离散的边缘串接起来，常使用的方法为：边缘跟踪和区域生长两种方法。边缘跟踪又分为八邻域和四邻域两种，具体原理可以参考残影、的博客。 实现步骤： 1、灰度化并进行Canny边缘检测 2、按照预先设定的跟踪方向（顺时针）进行边缘跟踪 3、每次跟踪的终止条件为：8邻域都不存在轮廓 这里需要理解的点： 代码中为什么更新当前方向时，需要curr_d -=...
opencv 八邻域轮廓跟踪算法
liumangmao1314的博客
12-23 2万+
opencv 八邻域轮廓跟踪算法 图像处理中，往往需要用到轮廓跟踪解决一些问题，诸如轮廓点的排序得到相邻点。当使用findContours()查找轮廓的时候，我们希望得到Freeman码，但是实验发现并不是一个参数CV_CHAIN_CODE那么回事，网上一大堆的蜻蜓点水，说这个参数可以实现Freeman码生成，我怎么就没搜到一个生成结果，哪怕告诉我怎么才能得带到Freeman码，多方查阅相关书籍
智能车摄像头边界跟踪（八近邻）
Jackson的博客
07-30 2572
下面展示一些 内联代码片。 // 智能车摄像头边界跟踪 // 边界跟踪 #include "boundary_following.h" void boundary_following(uint8*image,uint8*image_border) //image为二值化后图像，image_border为计算后得到图像64*94 { int i=63,j,dir_left=2,dir_right=2; int x,y; int border_left,border_right;
matlab中8邻域边界跟踪算法 程序,【数字图像处理】边界跟踪算法
weixin_33539834的博客
03-18 3151
轮廓提取轮廓提取：对于一副二值化图像，物体与背景分开，如果背景是白物体，物体为黑的话，我们可以采用掏空内部点法进行轮廓提取。具体算法如下:首先开辟新的内存空间，然后遍历图像，如果8个邻域像素都和中心点不相同，则对新的内存空间的该点进行置值。这里原图背景是白，物体为黑的，新的内存空间全部置为白，对原图像的每点进行判断，如果8个邻域像素都和中心点不相同，则将内存缓冲区中的该点置为黑。 边界跟踪算法基于...
使用摩尔邻域的边界追踪：使用摩尔邻域的二维边界追踪。-matlab开发
06-01
使用摩尔邻域进行边界追踪============================================== 亚当 H.艾特肯黑德adam.aitkenhead@physics.cr.man.ac.uk 克里斯蒂 NHS 基金会信托2010 年 5 月 17 日使用 Moore 邻域的 2D 边界跟踪。 ...
二值图像目标邻域点法边界跟踪算法
08-29
二值图像目标邻域点法边界跟踪算法是一种用于处理图像分割和分析的高效技术，尤其在计算机视觉和图像处理领域中具有广泛的应用。该算法由论文作者提出，并在MATLAB环境中实现，相比于传统的8邻域算法，其优势在于...
边界跟踪算法的实现，图像处理 c++
05-02
对输入的二值图像，进行边界跟踪，实现输出图像的边界，存在一维数组之中
基于8邻域的区域增长算法 matlab实现
12-22
实现种子点的动态选取， dicom图片的读取和保存，基于8邻域的区域增长算法，可以直接运行。（运行前需要修改自己要处理的图片目录）
轮廓跟踪小程序
04-07
这可以很容易在原图像中标记出轮廓，但仅适用于二值图像。
四邻域规则和八邻域的规则边界跟踪的源程序
07-04
可以完成图像目标的边界自动跟踪，基于四邻域规则和八邻域的规则。有对应的实验图片，matlab代码
二值图像轮廓跟踪算法
05-07
基于八邻域的轮廓跟踪算法，用matlab实现
python实现图像外边界跟踪
szfhy的博客
09-01 5480
share一些python实现的code #!/usr/bin/env python #coding=utf-8 import cv2 img = cv2.imread("trace_border2.bmp") [img_h, img_w, img_channel] = img.shape trace = [] start_x = 0 start_y = 0 gray = img[:,...
OpenCV 【二】————计算时间---八近邻细化边缘跟踪（图像边缘提取与填充）——边缘提取实现
格物致知
05-25 544
auto start_time = std::chrono::high_resolution_clock::now(); //do{ for (int process_direction = 2; process_direction != 0; --process_direction) { count_holefill++; for (int y = 1; y < binaryImage.rows - 1; y++) { ...
边界跟踪----摩尔边界跟踪算法
qq_42598935的博客
11-02 1303
参考链接 基本思想： （1）从一个封闭空间的左上角像素点开始，如下图中的p1点，以该点为起始点。 从该起始点的领域的空白像素点，以逆时针方向寻找，直到找到下一个边界点（图中为P2）。 2.每次遇到黑色像素点（即边界点），将它设置为当前边界像素点，然后原路返回到先前到达的白色像素，以顺时针方向搜索当前点的8邻域内的每一个像素，直到遇到下一个黑色像素。 3，重复步骤2，直到第二次访问到初始边界点，终止。在整个运行过程走过的黒色像素就是目标的边界像素。 ...
边缘跟踪算法
AI.PLAY
03-31 5585
该算法来源于论文《二值图像中目标物体轮廓的边界跟踪算法》，在实际使用中速度很快，效果很好。 该算法基于常见的“虫随”法进行改进，具有以下优点： 既能有效跟踪外边界又能克服内边界的存在对算法的影响。 对于不封闭的线段能实现很好的跟踪 算法思路： 边界跟踪从二值图像的左上角点还是逐点扫描，当遇到目标点是开始顺序跟踪。 封闭轮廓 直至跟踪的后续点回到起始点。 对于非封闭轮廓 其后续点再没有新的后续点...
八邻域搜索算法,封闭区间检测算法源代码
LPR_Pro的专栏
08-20 8208
 /*******************************************************************************************************        如果此代码对您有帮助的话,请多来踩我的Blog******************************************************
基于向量边界追踪的高效缓冲区生成方法
此外，文中提到的边界追踪原理展示了其在设计更多高级空间分析算法方面的潜力。 这种基于向量边界追踪的缓冲区生成方法不仅简化了数据处理流程，降低了计算负担，还提升了结果的精度，对于优化GIS工具和地理数据...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值