边界跟踪（vc实现）

最新推荐文章于 2018-07-24 18:32:48 发布
最新推荐文章于 2018-07-24 18:32:48 发布
阅读量117 收藏
点赞数 



void CISLSView::OnEdgeSengOutlineTract()
	{
//程序编制：李立宗  lilizong@gmail.com
//2012-8-14
		if(myImage1.IsNull())
			OnOpenResourceFile();
		if(!myImage2.IsNull())
			myImage2.Destroy();
		if(myImage2.IsNull()){
			myImage2.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);
		}
		if(myImage3.IsNull()){
			myImage3.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);
		}
		//COLORREF pixel; 
		int maxY = myImage1.GetHeight();
		int maxX=myImage1.GetWidth();
		byte* pRealData;
		byte* pRealData2;
		byte* pRealData3;
		pRealData=(byte*)myImage1.GetBits();
		pRealData2=(byte*)myImage2.GetBits();
		pRealData3=(byte*)myImage3.GetBits();
		int pit=myImage1.GetPitch();
		int pit2=myImage2.GetPitch();
		int pit3=myImage3.GetPitch();
		//需要注意,pit和pit2的值并不一样,所以如果使用一个值,会导致不同的结果出现
		//CString str;
		//str.Format(TEXT("%d"),pit);
		//MessageBox(str);
		//str.Format(TEXT("%d"),pit2);
		//MessageBox(str);
		int bitCount=myImage1.GetBPP()/8;
		int bitCount2=myImage2.GetBPP()/8;
		int bitCount3=myImage3.GetBPP()/8;
		int tempR,tempG,tempB;
		//float temp,tempX,tempY;
		int temp;
		int T=128;
		//int pixel[4];
		float u0,u1;   //均值
		float w0,w1;   //概率
		float sum0,sum1;  //像素和
		int optIndex,optT;   //最优阈值，及其所在像素的值
		float fVaria,fMaxVaria=0;   //临时方差,最大方差

		//int pixelR[256],pixelG[256],pixelB[256];
		int pixel[256]={0};   //不要忘记初始化
		//灰度化
		for (int y=0; y<maxY; y++) {
			for (int x=0; x<maxX; x++) {
				temp=*(pRealData+pit*(y)+(x)*bitCount);
				if(bitCount==3)
				{
					tempR=*(pRealData+pit*(y)+(x)*bitCount);
					tempG=*(pRealData+pit*(y)+(x)*bitCount+1);
					tempB=*(pRealData+pit*(y)+(x)*bitCount+2);
					temp=(int)(tempR*0.49+tempG*0.31+tempB*0.2);
					//temp=(int)((tempR+tempG+tempB)/3);
				}
				*(pRealData3+pit3*(y)+(x)*bitCount3)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;

			}
		}
		//二值化
		for (int y=0; y<maxY; y++) {
			for (int x=0; x<maxX; x++) {
				temp=*(pRealData3+pit3*(y)+(x)*bitCount3);
				if(temp>128)
					temp=255;
				else
					temp=0;
				*(pRealData3+pit3*(y)+(x)*bitCount3)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;

			}
		}	
		int grayindex;
		int i,j;
		BOOL FindStartPoint;
		BOOL FindPoint;
		CPoint StartPoint,CurrentPoint;
		int Direction[8][2]={{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0}};
		int BeginDirect;
		for(int y=0;y<maxY;y++)
		{
			for(int x=0;x<maxX;x++)
			{
				*(pRealData2+pit2*(y)+(x)*bitCount2)=255;
				*(pRealData2+pit2*(y)+(x)*bitCount2+1)=255;
				*(pRealData2+pit2*(y)+(x)*bitCount2+2)=255;	
			}
		}
		FindStartPoint=FALSE;	
		for(int y=0;y<maxY && !FindStartPoint;y++)
		{
			for(int x=0;x<maxX && !FindStartPoint;x++)
			{
				if(*(pRealData3+pit3*(y)+(x)*bitCount3)==0)
				{
					FindStartPoint=TRUE;
					StartPoint.y=y;
					StartPoint.x=x;

					*(pRealData2+pit2*(y)+(x)*bitCount2)=0;
					*(pRealData2+pit2*(y)+(x)*bitCount2+1)=0;
					*(pRealData2+pit2*(y)+(x)*bitCount2+2)=0;		
				}
			}						
		}	
		BeginDirect=0;
		FindStartPoint=FALSE;
		CurrentPoint.y=StartPoint.y;
		CurrentPoint.x=StartPoint.x;
		while(!FindStartPoint)
		{
			FindPoint=FALSE;
			while(!FindPoint)
			{
				byte *pc=pRealData3 + pit3*(CurrentPoint.y+Direction[BeginDirect][1]) +bitCount3*(CurrentPoint.x+Direction[BeginDirect][0]);
				grayindex=pc[0];

				if(grayindex==0)
				{
					FindPoint=TRUE;
					CurrentPoint.y=CurrentPoint.y+Direction[BeginDirect][1];
					CurrentPoint.x=CurrentPoint.x+Direction[BeginDirect][0];

					if(CurrentPoint.y==StartPoint.y && CurrentPoint.x==StartPoint.x)
					{
						FindStartPoint=TRUE;
					}

					else
					{
						*(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2)=0;
						*(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+1)=0;
						*(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+2)=0;	

						BeginDirect -= 2;
						if(BeginDirect<0)
						{
							BeginDirect += 8;				
						}
					}

				}
				else
				{
					BeginDirect++;
					if(BeginDirect==8)
					{
						BeginDirect=0;
					}

				}	
			}
		}
		Invalidate();
	}

修改：

因为上述函数遇到灰度图像，或者有在边缘的图像时会遇到溢出，所以，进行了处理修改，如下：

	void CISLSView::OnEdgeSengOutlineTract()
	{
//程序编制：李立宗  lilizong@gmail.com
//2012-8-15 00:05
		if(myImage1.IsNull())
			OnOpenResourceFile();
		if(!myImage2.IsNull())
			myImage2.Destroy();
		if(myImage2.IsNull()){
			myImage2.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);
		}
		if(!myImage3.IsNull())
			myImage3.Destroy();
		if(myImage3.IsNull()){
			myImage3.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);
		}
		//COLORREF pixel; 
		int maxY = myImage1.GetHeight();
		int maxX=myImage1.GetWidth();
		byte* pRealData;
		byte* pRealData2;
		byte* pRealData3;
		pRealData=(byte*)myImage1.GetBits();
		pRealData2=(byte*)myImage2.GetBits();
		pRealData3=(byte*)myImage3.GetBits();
		int pit=myImage1.GetPitch();
		int pit2=myImage2.GetPitch();
		int pit3=myImage3.GetPitch();
		//需要注意,pit和pit2的值并不一样,所以如果使用一个值,会导致不同的结果出现
		//CString str;
		//str.Format(TEXT("%d"),pit);
		//MessageBox(str);
		//str.Format(TEXT("%d"),pit2);
		//MessageBox(str);
		int bitCount=myImage1.GetBPP()/8;
		int bitCount2=myImage2.GetBPP()/8;
		int bitCount3=myImage3.GetBPP()/8;
		int tempR,tempG,tempB;
		//float temp,tempX,tempY;
		int temp;
		int T=128;
		//int pixel[4];
		float u0,u1;   //均值
		float w0,w1;   //概率
		float sum0,sum1;  //像素和
		int optIndex,optT;   //最优阈值，及其所在像素的值
		float fVaria,fMaxVaria=0;   //临时方差,最大方差

		//int pixelR[256],pixelG[256],pixelB[256];
		int pixel[256]={0};   //不要忘记初始化
		//灰度化
		for (int y=0; y<maxY; y++) {
			for (int x=0; x<maxX; x++) {
				temp=*(pRealData+pit*(y)+(x)*bitCount);
				if(bitCount==3)
				{
					tempR=*(pRealData+pit*(y)+(x)*bitCount);
					tempG=*(pRealData+pit*(y)+(x)*bitCount+1);
					tempB=*(pRealData+pit*(y)+(x)*bitCount+2);
					temp=(int)(tempR*0.49+tempG*0.31+tempB*0.2);
					//temp=(int)((tempR+tempG+tempB)/3);
				}
				*(pRealData3+pit3*(y)+(x)*bitCount3)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;

			}
		}
		//二值化
		for (int y=0; y<maxY; y++) {
			for (int x=0; x<maxX; x++) {
				temp=*(pRealData3+pit3*(y)+(x)*bitCount3);
				if(temp>127)
					temp=255;
				else
					temp=0;
				/*	temp=0;*/
				*(pRealData3+pit3*(y)+(x)*bitCount3)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;

			}
		}
		//修理边界，防止溢出，写在了后面
	/*	for (int y=0; y<maxY; y++) {
			for (int x=0; x<=0; x++) {
				temp=255;
				*(pRealData3+pit3*(y)+(x)*bitCount3)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;

			}
		}
		for (int y=0; y<maxY; y++) {
			for (int x=maxX-1; x<maxX; x++) {
				temp=255;
				*(pRealData3+pit3*(y)+(x)*bitCount3)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;

			}
		}
		for (int y=0; y<1; y++) {
			for (int x=0; x<maxX; x++) {
				temp=255;
				*(pRealData3+pit3*(y)+(x)*bitCount3)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;

			}
		}
		for (int y=maxY-1; y<maxY; y++) {
			for (int x=0; x<maxX; x++) {
				temp=255;
				*(pRealData3+pit3*(y)+(x)*bitCount3)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;

			}
		}
*/


		int grayindex;
		int i,j;
		BOOL FindStartPoint;
		BOOL FindPoint;
		CPoint StartPoint,CurrentPoint;
		int Direction[8][2]={{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0}};
		int BeginDirect;
		for(int y=0;y<maxY;y++)
		{
			for(int x=0;x<maxX;x++)
			{
				*(pRealData2+pit2*(y)+(x)*bitCount2)=255;
				*(pRealData2+pit2*(y)+(x)*bitCount2+1)=255;
				*(pRealData2+pit2*(y)+(x)*bitCount2+2)=255;	
			}
		}
		FindStartPoint=FALSE;	
		//为了防止溢出，将myImage3的起始点选取在边界以内。?????此思路不对，因为无法保证寻找其邻域仍在图像内不溢出
		//对图像进行修边处理，将其四边军处理为255.确保不会溢出。开始将终止点设定为maxX，maxY，无法运算出
		for(int y=0;y<maxY;y++)
		{
			*(pRealData3+pit3*(y)+(0)*bitCount3)=255;
			*(pRealData3+pit3*(y)+(maxX-1)*bitCount3)=255;
		}
		for(int x=0;x<maxX ;x++)
		{
			*(pRealData3+pit3*(0)+(x)*bitCount3)=255;
			*(pRealData3+pit3*(maxY-1)+(x)*bitCount3)=255;
		}

		for(int y=0;y<maxY && !FindStartPoint;y++)
		{
			for(int x=0;x<maxX && !FindStartPoint;x++)
			{
				if(*(pRealData3+pit3*(y)+(x)*bitCount3)==0)
				{
					FindStartPoint=TRUE;
					StartPoint.y=y;
					StartPoint.x=x;

					*(pRealData2+pit2*(y)+(x)*bitCount2)=0;
					*(pRealData2+pit2*(y)+(x)*bitCount2+1)=0;
					*(pRealData2+pit2*(y)+(x)*bitCount2+2)=0;		
				}
			}						
		}	

		BeginDirect=0;
		FindStartPoint=FALSE;
		CurrentPoint.y=StartPoint.y;
		CurrentPoint.x=StartPoint.x;
		while(!FindStartPoint)
		{
			FindPoint=FALSE;
			while(!FindPoint)
			{
				grayindex=*(pRealData3 + pit3*(CurrentPoint.y+Direction[BeginDirect][1]) +bitCount3*(CurrentPoint.x+Direction[BeginDirect][0]));
				if(grayindex==0)
				{
					FindPoint=TRUE;
					CurrentPoint.y=CurrentPoint.y+Direction[BeginDirect][1];
					CurrentPoint.x=CurrentPoint.x+Direction[BeginDirect][0];

					if(CurrentPoint.y==StartPoint.y && CurrentPoint.x==StartPoint.x)
					{
						FindStartPoint=TRUE;
					}

					//else
					//{
					//	*(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2)=0;
					//	*(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+1)=0;
					//	*(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+2)=0;	

					//	BeginDirect -= 2;
					//	if(BeginDirect<0)
					//	{
					//		BeginDirect += 8;				
					//	}
					//}
					*(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2)=0;
					*(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+1)=0;
					*(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+2)=0;	

					BeginDirect -= 2;
					if(BeginDirect<0)
					{
						BeginDirect += 8;				
					}

				}
				else
				{
					BeginDirect++;
					if(BeginDirect==8)
					{
						BeginDirect=0;
					}

				}	
			}
		}
		Invalidate();
	}


iteye_12837
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
边界跟踪算法的实现，图像处理 c++
05-02
对输入的二值图像，进行边界跟踪，实现输出图像的边界，存在一维数组之中
【林轩田】机器学习基石（七）——VC维
sjz_hahalala479的博客
08-04 1216
Lecture 7: VC Dimension VC维 Definition of VC Dimension VC维的定义 复习1 上节课，林教授讲到了，当样本NNN足够大，且成长函数mH(N)mH(N)m_{H}(N)存在断点kkk时，可以概率性地推出Eout≃EinEout≃EinE_{out} \simeq E_{in} 即 有断点k的mH(N)≤B(N,k)≤∑i=0k−1(...
C实现moore边界跟踪算法
MikeDai的博客
09-21 2170
原理： 参照冈萨雷斯数字图像处理英文版第11章第一小节。C实现代码如下：static uint8_t* enlarge_gray_img(uint8_t* img, int w, int h, int scale, int pad_value) { uint32_t dst_row_bytes; uint32_t src_row_bytes; uint32_t src_of
视觉算法笔记 - 边缘线跟踪（边缘连接）
cdyhj的专栏
03-17 7910
分为两种情况 1 已知区域（二值图像），从中提取区域边界。固定的区域边界提取算法，提取4近邻或者8近邻的内边界，可进一步提取8近邻的外边界，参考Sonka的教材。 参考gonsaleza的书籍 1 找到最左边标记为1的点，记为b0，使用c0代表b0左边标记为0的点。 从c0开始顺时针方向扫描b0的邻点，直到遇到第一个标记为1的点，记为 B1，令c1是扫描过程中b1之前扫过的背景点。 
二值图像的边缘追踪（内边缘与外边缘）
热门推荐
wqvbjhc的专栏
04-17 1万+
二值图像的边缘追踪（内边缘与外边缘）　　近段时间来，在学习图像处理的课程。使用Lab Windows/CVI为平台。自己学过一些C语言，不过对于CVI可是第一次接触，虽说它是C语言环境，可不是纯C的。举个例子：变量的定义不可以在switch...case语句里面。　　对图像进行处理，首先要先将其二值化。二值化的关键是在于阈值的选择。CVI中利用IMAQ里的IPI_Threshold可以
边界检测，vc mfc
10-29
在本项目中，我们关注的是使用Visual C++（VC）的MFC（Microsoft Foundation Classes）库来实现这一功能，特别是通过Candy算子进行图形图像的边缘检测。 MFC是微软提供的一套面向对象的类库，它简化了Windows应用...
Canny-jiance.rar_vc canny_vc实现canny
09-23
这个“Canny-jiance.rar_vc”压缩包包含了一个使用VC++（Visual C++）编写的Canny算法实现。Canny算法是1986年由John F. Canny提出的，它的主要目标是提供一个具有高精度且低误检率的单步边缘检测方案。 Canny算法...
运动物体跟踪代码VC+OPENCV
10-07
在本文中，我们将深入探讨如何使用VC++与OpenCV库来实现运动物体的跟踪技术。OpenCV（开源计算机视觉库）是一个强大的工具，为开发者提供了丰富的功能，包括图像处理、机器学习以及计算机视觉算法，而VC++（Visual ...
VC 实现指定区域的图像填充技术.rar
07-10
通常，图像填充是通过边界跟踪或 Flood Fill 算法来完成的。Flood Fill 是一种递归算法，从一个种子点开始，检查其相邻像素的颜色是否与种子点颜色相同。如果相同，则改变该像素的颜色，并继续检查相邻的像素，直到...
图像处理VC算法实现
09-23
在图像处理领域，VC（Visual C++）是一种常用的编程工具，用于实现各种图像处理算法。本文将深入探讨图像处理的基本概念、VC算法实现的关键技术和应用，以及如何利用VC进行图像处理。 首先，图像处理是一门涉及...
物体跟踪 程序详解
08-08
基于粒子滤波算法的物体跟踪程序，需要结合opencv和GSL
图像边缘提取经典算法MFC实现
10-22
本代码是作者自己编写，采用MFC框架，运用C++语言对常用边缘提取算法进行实现，代码包中含有示例图片，从图片处理效果可以看出该代码稳定可靠，能为图像处理算法初学者带来一定启发。
vc++边缘跟踪-轮廓提取
03-04
采用边缘跟踪法提取物体轮廓，并给出了相应的在VC++环境下实现的代码。
基于边界的模板匹配的原理及算法实现 C++
05-07
文章地址： 基于边界的模板匹配的原理及算法实现 http://blog.csdn.net/huixingshao/article/details/45560643
一种快速边缘跟踪与提取的新算法
06-04
本文介绍了一种快速边缘跟踪与提取的新算法。
C++实现灰度图像的边缘检测、提取及轮廓跟踪
08-19
C++实现灰度图像的边缘检测、提取及轮廓跟踪；包括Roberts算子、Sobel算子、Prewitt算子、Krisch算子；hough变换；轮廓提取；种子填充。（bmp灰度图片），vc6.0运行无误
内边界跟踪算法C++实现
sinat_35862942的博客
07-24 2300
最近在学习数字图像处理的一些知识，在看《图像处理、分析与机器视觉》（Milan Sonka著）这本书，在将图像分割I那部分提到了一个内边界跟踪算法（算法6.6），于是尝试用C++去实现以下，由于本人编程基础很差且逻辑思维能力也差，实现的过程中走了很多弯路······最初的版本使用了很多for循环，导致代码的可读性差还有计算效率非常低（运行半天都得不到结果······），于是将部分循环用递归调用替换...
边界跟踪算法（二）——摩尔邻域跟踪算法
酷小川的博客
07-10 1万+
 摩尔领域也称为8邻域或者间接邻域。摩尔邻域跟踪算法的基本思想： 找到一个黑色像素，并将它定为你的起始像素。（定位一个起始像素可以以多种方式来完成的；我们将从网格的左下角开始，自下而上扫描每一列像素，从最左向右的每列像素，直到遇到一个黑色的像素，我们将其作为我们的起始像素）。 总的想法如下图所示：每次遇到黑色像素，将设置为当前边界像素点，然后原路返回到先前到达的白色像素，
灰度图像边界跟踪程序设计.docx
最新发布
11-29
学生需要使用MATLAB软件，通过学习图像处理理论，实现图像边缘检测和边界跟踪功能。任务包括选择256级灰度图像，应用不同边缘检测算子计算梯度图，进行边界跟踪，分析结果，并撰写课程设计报告。文中还提到了多种...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值