边界跟踪（vc实现）

最新推荐文章于 2024-04-16 18:41:24 发布
最新推荐文章于 2024-04-16 18:41:24 发布
阅读量583 收藏
点赞数
分类专栏： 图像处理

[cpp] view plain copy print ?
  1. void CISLSView::OnEdgeSengOutlineTract()  
  2.     {  
  3. //程序编制：李立宗  lilizong@gmail.com  
  4. //2012-8-14   
  5.         if(myImage1.IsNull())  
  6.             OnOpenResourceFile();  
  7.         if(!myImage2.IsNull())  
  8.             myImage2.Destroy();  
  9.         if(myImage2.IsNull()){  
  10.             myImage2.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);  
  11.         }  
  12.         if(myImage3.IsNull()){  
  13.             myImage3.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);  
  14.         }  
  15.         //COLORREF pixel;    
  16.         int maxY = myImage1.GetHeight();  
  17.         int maxX=myImage1.GetWidth();  
  18.         byte* pRealData;  
  19.         byte* pRealData2;  
  20.         byte* pRealData3;  
  21.         pRealData=(byte*)myImage1.GetBits();  
  22.         pRealData2=(byte*)myImage2.GetBits();  
  23.         pRealData3=(byte*)myImage3.GetBits();  
  24.         int pit=myImage1.GetPitch();  
  25.         int pit2=myImage2.GetPitch();  
  26.         int pit3=myImage3.GetPitch();  
  27.         //需要注意,pit和pit2的值并不一样,所以如果使用一个值,会导致不同的结果出现  
  28.         //CString str;   
  29.         //str.Format(TEXT("%d"),pit);  
  30.         //MessageBox(str);   
  31.         //str.Format(TEXT("%d"),pit2);  
  32.         //MessageBox(str);   
  33.         int bitCount=myImage1.GetBPP()/8;  
  34.         int bitCount2=myImage2.GetBPP()/8;  
  35.         int bitCount3=myImage3.GetBPP()/8;  
  36.         int tempR,tempG,tempB;  
  37.         //float temp,tempX,tempY;  
  38.         int temp;  
  39.         int T=128;  
  40.         //int pixel[4];   
  41.         float u0,u1;   //均值  
  42.         float w0,w1;   //概率  
  43.         float sum0,sum1;  //像素和  
  44.         int optIndex,optT;   //最优阈值，及其所在像素的值  
  45.         float fVaria,fMaxVaria=0;   //临时方差,最大方差  
  46.   
  47.         //int pixelR[256],pixelG[256],pixelB[256];  
  48.         int pixel[256]={0};   //不要忘记初始化  
  49.         //灰度化   
  50.         for (int y=0; y<maxY; y++) {  
  51.             for (int x=0; x<maxX; x++) {  
  52.                 temp=*(pRealData+pit*(y)+(x)*bitCount);  
  53.                 if(bitCount==3)  
  54.                 {  
  55.                     tempR=*(pRealData+pit*(y)+(x)*bitCount);  
  56.                     tempG=*(pRealData+pit*(y)+(x)*bitCount+1);  
  57.                     tempB=*(pRealData+pit*(y)+(x)*bitCount+2);  
  58.                     temp=(int)(tempR*0.49+tempG*0.31+tempB*0.2);  
  59.                     //temp=(int)((tempR+tempG+tempB)/3);  
  60.                 }  
  61.                 *(pRealData3+pit3*(y)+(x)*bitCount3)=temp;  
  62.                 *(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;  
  63.                 *(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;  
  64.   
  65.             }  
  66.         }  
  67.         //二值化   
  68.         for (int y=0; y<maxY; y++) {  
  69.             for (int x=0; x<maxX; x++) {  
  70.                 temp=*(pRealData3+pit3*(y)+(x)*bitCount3);  
  71.                 if(temp>128)  
  72.                     temp=255;  
  73.                 else  
  74.                     temp=0;  
  75.                 *(pRealData3+pit3*(y)+(x)*bitCount3)=temp;  
  76.                 *(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;  
  77.                 *(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;  
  78.   
  79.             }  
  80.         }     
  81.         int grayindex;  
  82.         int i,j;  
  83.         BOOL FindStartPoint;  
  84.         BOOL FindPoint;  
  85.         CPoint StartPoint,CurrentPoint;  
  86.         int Direction[8][2]={{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0}};  
  87.         int BeginDirect;  
  88.         for(int y=0;y<maxY;y++)  
  89.         {  
  90.             for(int x=0;x<maxX;x++)  
  91.             {  
  92.                 *(pRealData2+pit2*(y)+(x)*bitCount2)=255;  
  93.                 *(pRealData2+pit2*(y)+(x)*bitCount2+1)=255;  
  94.                 *(pRealData2+pit2*(y)+(x)*bitCount2+2)=255;   
  95.             }  
  96.         }  
  97.         FindStartPoint=FALSE;     
  98.         for(int y=0;y<maxY && !FindStartPoint;y++)  
  99.         {  
  100.             for(int x=0;x<maxX && !FindStartPoint;x++)  
  101.             {  
  102.                 if(*(pRealData3+pit3*(y)+(x)*bitCount3)==0)  
  103.                 {  
  104.                     FindStartPoint=TRUE;  
  105.                     StartPoint.y=y;  
  106.                     StartPoint.x=x;  
  107.   
  108.                     *(pRealData2+pit2*(y)+(x)*bitCount2)=0;  
  109.                     *(pRealData2+pit2*(y)+(x)*bitCount2+1)=0;  
  110.                     *(pRealData2+pit2*(y)+(x)*bitCount2+2)=0;         
  111.                 }  
  112.             }                         
  113.         }     
  114.         BeginDirect=0;  
  115.         FindStartPoint=FALSE;  
  116.         CurrentPoint.y=StartPoint.y;  
  117.         CurrentPoint.x=StartPoint.x;  
  118.         while(!FindStartPoint)  
  119.         {  
  120.             FindPoint=FALSE;  
  121.             while(!FindPoint)  
  122.             {  
  123.                 byte *pc=pRealData3 + pit3*(CurrentPoint.y+Direction[BeginDirect][1]) +bitCount3*(CurrentPoint.x+Direction[BeginDirect][0]);  
  124.                 grayindex=pc[0];  
  125.   
  126.                 if(grayindex==0)  
  127.                 {  
  128.                     FindPoint=TRUE;  
  129.                     CurrentPoint.y=CurrentPoint.y+Direction[BeginDirect][1];  
  130.                     CurrentPoint.x=CurrentPoint.x+Direction[BeginDirect][0];  
  131.   
  132.                     if(CurrentPoint.y==StartPoint.y && CurrentPoint.x==StartPoint.x)  
  133.                     {  
  134.                         FindStartPoint=TRUE;  
  135.                     }  
  136.   
  137.                     else  
  138.                     {  
  139.                         *(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2)=0;  
  140.                         *(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+1)=0;  
  141.                         *(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+2)=0;   
  142.   
  143.                         BeginDirect -= 2;  
  144.                         if(BeginDirect<0)  
  145.                         {  
  146.                             BeginDirect += 8;                 
  147.                         }  
  148.                     }  
  149.   
  150.                 }  
  151.                 else  
  152.                 {  
  153.                     BeginDirect++;  
  154.                     if(BeginDirect==8)  
  155.                     {  
  156.                         BeginDirect=0;  
  157.                     }  
  158.   
  159.                 }     
  160.             }  
  161.         }  
  162.         Invalidate();  
  163.     }  
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();
	}

修改：

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

[cpp] view plain copy print ?
  1.     void CISLSView::OnEdgeSengOutlineTract()  
  2.     {  
  3. //程序编制：李立宗  lilizong@gmail.com  
  4. //2012-8-15 00:05   
  5.         if(myImage1.IsNull())  
  6.             OnOpenResourceFile();  
  7.         if(!myImage2.IsNull())  
  8.             myImage2.Destroy();  
  9.         if(myImage2.IsNull()){  
  10.             myImage2.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);  
  11.         }  
  12.         if(!myImage3.IsNull())  
  13.             myImage3.Destroy();  
  14.         if(myImage3.IsNull()){  
  15.             myImage3.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);  
  16.         }  
  17.         //COLORREF pixel;    
  18.         int maxY = myImage1.GetHeight();  
  19.         int maxX=myImage1.GetWidth();  
  20.         byte* pRealData;  
  21.         byte* pRealData2;  
  22.         byte* pRealData3;  
  23.         pRealData=(byte*)myImage1.GetBits();  
  24.         pRealData2=(byte*)myImage2.GetBits();  
  25.         pRealData3=(byte*)myImage3.GetBits();  
  26.         int pit=myImage1.GetPitch();  
  27.         int pit2=myImage2.GetPitch();  
  28.         int pit3=myImage3.GetPitch();  
  29.         //需要注意,pit和pit2的值并不一样,所以如果使用一个值,会导致不同的结果出现  
  30.         //CString str;   
  31.         //str.Format(TEXT("%d"),pit);  
  32.         //MessageBox(str);   
  33.         //str.Format(TEXT("%d"),pit2);  
  34.         //MessageBox(str);   
  35.         int bitCount=myImage1.GetBPP()/8;  
  36.         int bitCount2=myImage2.GetBPP()/8;  
  37.         int bitCount3=myImage3.GetBPP()/8;  
  38.         int tempR,tempG,tempB;  
  39.         //float temp,tempX,tempY;  
  40.         int temp;  
  41.         int T=128;  
  42.         //int pixel[4];   
  43.         float u0,u1;   //均值  
  44.         float w0,w1;   //概率  
  45.         float sum0,sum1;  //像素和  
  46.         int optIndex,optT;   //最优阈值，及其所在像素的值  
  47.         float fVaria,fMaxVaria=0;   //临时方差,最大方差  
  48.   
  49.         //int pixelR[256],pixelG[256],pixelB[256];  
  50.         int pixel[256]={0};   //不要忘记初始化  
  51.         //灰度化   
  52.         for (int y=0; y<maxY; y++) {  
  53.             for (int x=0; x<maxX; x++) {  
  54.                 temp=*(pRealData+pit*(y)+(x)*bitCount);  
  55.                 if(bitCount==3)  
  56.                 {  
  57.                     tempR=*(pRealData+pit*(y)+(x)*bitCount);  
  58.                     tempG=*(pRealData+pit*(y)+(x)*bitCount+1);  
  59.                     tempB=*(pRealData+pit*(y)+(x)*bitCount+2);  
  60.                     temp=(int)(tempR*0.49+tempG*0.31+tempB*0.2);  
  61.                     //temp=(int)((tempR+tempG+tempB)/3);  
  62.                 }  
  63.                 *(pRealData3+pit3*(y)+(x)*bitCount3)=temp;  
  64.                 *(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;  
  65.                 *(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;  
  66.   
  67.             }  
  68.         }  
  69.         //二值化   
  70.         for (int y=0; y<maxY; y++) {  
  71.             for (int x=0; x<maxX; x++) {  
  72.                 temp=*(pRealData3+pit3*(y)+(x)*bitCount3);  
  73.                 if(temp>127)  
  74.                     temp=255;  
  75.                 else  
  76.                     temp=0;  
  77.                 /*  temp=0;*/  
  78.                 *(pRealData3+pit3*(y)+(x)*bitCount3)=temp;  
  79.                 *(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;  
  80.                 *(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;  
  81.   
  82.             }  
  83.         }  
  84.         //修理边界，防止溢出，写在了后面   
  85.     /*  for (int y=0; y<maxY; y++) { 
  86.             for (int x=0; x<=0; x++) { 
  87.                 temp=255; 
  88.                 *(pRealData3+pit3*(y)+(x)*bitCount3)=temp; 
  89.                 *(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp; 
  90.                 *(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp; 
  91.  
  92.             } 
  93.         } 
  94.         for (int y=0; y<maxY; y++) { 
  95.             for (int x=maxX-1; x<maxX; x++) { 
  96.                 temp=255; 
  97.                 *(pRealData3+pit3*(y)+(x)*bitCount3)=temp; 
  98.                 *(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp; 
  99.                 *(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp; 
  100.  
  101.             } 
  102.         } 
  103.         for (int y=0; y<1; y++) { 
  104.             for (int x=0; x<maxX; x++) { 
  105.                 temp=255; 
  106.                 *(pRealData3+pit3*(y)+(x)*bitCount3)=temp; 
  107.                 *(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp; 
  108.                 *(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp; 
  109.  
  110.             } 
  111.         } 
  112.         for (int y=maxY-1; y<maxY; y++) { 
  113.             for (int x=0; x<maxX; x++) { 
  114.                 temp=255; 
  115.                 *(pRealData3+pit3*(y)+(x)*bitCount3)=temp; 
  116.                 *(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp; 
  117.                 *(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp; 
  118.  
  119.             } 
  120.         } 
  121. */  
  122.   
  123.   
  124.         int grayindex;  
  125.         int i,j;  
  126.         BOOL FindStartPoint;  
  127.         BOOL FindPoint;  
  128.         CPoint StartPoint,CurrentPoint;  
  129.         int Direction[8][2]={{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0}};  
  130.         int BeginDirect;  
  131.         for(int y=0;y<maxY;y++)  
  132.         {  
  133.             for(int x=0;x<maxX;x++)  
  134.             {  
  135.                 *(pRealData2+pit2*(y)+(x)*bitCount2)=255;  
  136.                 *(pRealData2+pit2*(y)+(x)*bitCount2+1)=255;  
  137.                 *(pRealData2+pit2*(y)+(x)*bitCount2+2)=255;   
  138.             }  
  139.         }  
  140.         FindStartPoint=FALSE;     
  141.         //为了防止溢出，将myImage3的起始点选取在边界以内。?????此思路不对，因为无法保证寻找其邻域仍在图像内不溢出  
  142.         //对图像进行修边处理，将其四边军处理为255.确保不会溢出。开始将终止点设定为maxX，maxY，无法运算出  
  143.         for(int y=0;y<maxY;y++)  
  144.         {  
  145.             *(pRealData3+pit3*(y)+(0)*bitCount3)=255;  
  146.             *(pRealData3+pit3*(y)+(maxX-1)*bitCount3)=255;  
  147.         }  
  148.         for(int x=0;x<maxX ;x++)  
  149.         {  
  150.             *(pRealData3+pit3*(0)+(x)*bitCount3)=255;  
  151.             *(pRealData3+pit3*(maxY-1)+(x)*bitCount3)=255;  
  152.         }  
  153.   
  154.         for(int y=0;y<maxY && !FindStartPoint;y++)  
  155.         {  
  156.             for(int x=0;x<maxX && !FindStartPoint;x++)  
  157.             {  
  158.                 if(*(pRealData3+pit3*(y)+(x)*bitCount3)==0)  
  159.                 {  
  160.                     FindStartPoint=TRUE;  
  161.                     StartPoint.y=y;  
  162.                     StartPoint.x=x;  
  163.   
  164.                     *(pRealData2+pit2*(y)+(x)*bitCount2)=0;  
  165.                     *(pRealData2+pit2*(y)+(x)*bitCount2+1)=0;  
  166.                     *(pRealData2+pit2*(y)+(x)*bitCount2+2)=0;         
  167.                 }  
  168.             }                         
  169.         }     
  170.   
  171.         BeginDirect=0;  
  172.         FindStartPoint=FALSE;  
  173.         CurrentPoint.y=StartPoint.y;  
  174.         CurrentPoint.x=StartPoint.x;  
  175.         while(!FindStartPoint)  
  176.         {  
  177.             FindPoint=FALSE;  
  178.             while(!FindPoint)  
  179.             {  
  180.                 grayindex=*(pRealData3 + pit3*(CurrentPoint.y+Direction[BeginDirect][1]) +bitCount3*(CurrentPoint.x+Direction[BeginDirect][0]));  
  181.                 if(grayindex==0)  
  182.                 {  
  183.                     FindPoint=TRUE;  
  184.                     CurrentPoint.y=CurrentPoint.y+Direction[BeginDirect][1];  
  185.                     CurrentPoint.x=CurrentPoint.x+Direction[BeginDirect][0];  
  186.   
  187.                     if(CurrentPoint.y==StartPoint.y && CurrentPoint.x==StartPoint.x)  
  188.                     {  
  189.                         FindStartPoint=TRUE;  
  190.                     }  
  191.   
  192.                     //else   
  193.                     //{   
  194.                     //  *(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2)=0;  
  195.                     //  *(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+1)=0;  
  196.                     //  *(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+2)=0;   
  197.   
  198.                     //  BeginDirect -= 2;   
  199.                     //  if(BeginDirect<0)  
  200.                     //  {   
  201.                     //      BeginDirect += 8;                 
  202.                     //  }   
  203.                     //}   
  204.                     *(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2)=0;  
  205.                     *(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+1)=0;  
  206.                     *(pRealData2+pit2*(CurrentPoint.y)+(CurrentPoint.x)*bitCount2+2)=0;   
  207.   
  208.                     BeginDirect -= 2;  
  209.                     if(BeginDirect<0)  
  210.                     {  
  211.                         BeginDirect += 8;                 
  212.                     }  
  213.   
  214.                 }  
  215.                 else  
  216.                 {  
  217.                     BeginDirect++;  
  218.                     if(BeginDirect==8)  
  219.                     {  
  220.                         BeginDirect=0;  
  221.                     }  
  222.   
  223.                 }     
  224.             }  
  225.         }  
  226.         Invalidate();  
  227.     } 
wujinting007
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
内边界跟踪算法C++实现
sinat_35862942的博客
07-24 2309
最近在学习数字图像处理的一些知识，在看《图像处理、分析与机器视觉》（Milan Sonka著）这本书，在将图像分割I那部分提到了一个内边界跟踪算法（算法6.6），于是尝试用C++去实现以下，由于本人编程基础很差且逻辑思维能力也差，实现的过程中走了很多弯路······最初的版本使用了很多for循环，导致代码的可读性差还有计算效率非常低（运行半天都得不到结果······），于是将部分循环用递归调用替换...
边界检测，vc mfc
10-29
在本项目中，我们关注的是使用Visual C++（VC）的MFC（Microsoft Foundation Classes）库来实现这一功能，特别是通过Candy算子进行图形图像的边缘检测。 MFC是微软提供的一套面向对象的类库，它简化了Windows应用...
【MATLAB源码-第30期】基于matlab的内边界边缘检测算法。
最新发布
weixin_67624305的博客
04-16 1205
边缘检测在图像处理中比较重要，边缘检测的结果是图像分割技术所依赖的重要特征，因此边缘检测是图像分割领域的一部分。图像分割的结果是图像上子区域的集合（这些子区域的全体覆盖了整个图像），或是从图像中提取的轮廓线的集合（例如边缘检测）。邻接区域在某种特性的度量下有很大的不同。首先介绍图像边缘检测，具体就梯度算子、kirsch算子、laplacian-gauss算子、canny算子、log滤波算子、sobel算子、Robert算子、prewitt算子边缘检测方法介绍检测原理并通过编程实现，比较各种方法的处理结果。
matlab图像处理之二值图像内外边界跟踪
热门推荐
zyb_123的博客
03-09 1万+
matlab图像处理之二值图像内外边界跟踪 注：原文链接：http://www.cnblogs.com/tiandsp/archive/2013/04/26/3045747.html        目标内边界的像素全都在目标里面，目标外边界的像素全都不在目标上，是包围着目标的。 二值图像内外边界的计算都是有两种方法的，所以一共是4种算法，不过实际用到跟踪的只有一个而已。
图像八领域c语言,八领域边界追踪算法
weixin_39952190的博客
05-24 825
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...
【数字图像处理】Canny边缘检测C语言实现
yy197696的博客
11-25 4700
文章目录（一）边缘检测步骤1. 彩色图像转换为灰度图像2. 对图像进行高斯模糊3. 计算图像梯度，根据梯度计算图像边缘幅值与角度（这里其实用到了微分边缘检测算子来计算梯度幅值方向）4. 非最大信号压制处理（边缘细化）5. 双阈值边缘连接处理6. 二值化图像输出结果（二）图像的梯度与方向角计算（1）sobel算子（2） Prewitt算子（3） Robert算子（4）三种算子效果比较（三）非极大值抑制（四）图像双阈值化与边缘连接（五）代码实现li_can
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进行图像处理。 首先，图像处理是一门涉及...
边界跟踪算法的实现，图像处理 c++
05-02
对输入的二值图像，进行边界跟踪，实现输出图像的边界，存在一维数组之中
MFC画圆自定义|位置|半径|边界和内部颜色|填充图案
08-16
MFC画圆：可以自定义圆形的位置，圆的半径，圆的边界颜色，圆的内部颜色以及内部填充图案
轮廓边界跟踪
12-03
一种有效地图像边缘提取方法，该代码利用VC++语言编写，系在后编译一下就OK了！
边界跟踪算法(PDF版)
06-07
边界跟踪算法，一种很详细的说明，pdf版的。希望对大家有帮助，边界跟踪算法
使用摩尔邻域的边界追踪：使用摩尔邻域的二维边界追踪。-matlab开发
06-01
使用摩尔邻域进行边界追踪============================================== 亚当 H.艾特肯黑德adam.aitkenhead@physics.cr.man.ac.uk 克里斯蒂 NHS 基金会信托2010 年 5 月 17 日使用 Moore 邻域的 2D 边界跟踪。 用法====== >> [listCONTOUR,listNORMALS] = TRACE_MooreNeighbourhood(data2D,pixelFIRST) 获取逻辑数组 并跟踪 1s 区域的边界。 起始像素的坐标可选地由 定义。 输入参数================ data2D - 大小为 (L,M) 的二维逻辑数组（1 => 区域内，0 => 区域外） pixelFIRST（可选） - 一个 (2x1) 数组，包含位
边界跟踪算法实现：C语言与Delphi代码解析
本文档提供了详细的算法描述和程序代码，帮助开发者理解和实现边界跟踪算法。" 边界提取是图像处理中的关键步骤，它有助于识别图像中的形状和特征。在C和Delphi编程环境下，可以编写算法来实现这一功能。本文档介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值