sampledlg.cpp

capture the image of the inpu object from the user and then detect image edge of the object

				     ( (Umin<=u) && (u<=Umax) ) &&
				     ( (Vmin<=v) && (v<=Vmax) ) )
					{
						
					patchcount[patchobj]++;

				   
                   emptyrow1=false;
					// break;
					}			  
					  }

				   bool emptyrow2=true;
					
                  for(i=prey-1;i<=endy+1;i++)
					  {	
						  pBmpdata = 	lpDIBBits 	+
				(ImgW*(i+posy) + endx+1+posx)*bytes;
                   blue  = *pBmpdata;
                  green = *(pBmpdata+1);
				  red   = *(pBmpdata+2);
				  	RGB2YUV(red,green,blue,y,u,v);

				   	if (( (Ymin<=y) && (y<=Ymax) ) &&
				     ( (Umin<=u) && (u<=Umax) ) &&
				     ( (Vmin<=v) && (v<=Vmax) ) )
					{
						
					patchcount[patchobj]++;

				   
                   emptyrow2=false;
					// break;
					}			  
					  }

					  /////////// start col scan
					  bool emptycol01=true;
					
					  for(i=prex-1;i<=endx+1;i++)
					  {	
				pBmpdata = 	lpDIBBits 	+
				(ImgW*(prey+posy) + i+posx)*bytes;
                  blue  = *pBmpdata;
                  green = *(pBmpdata+1);
				  red   = *(pBmpdata+2);
				  RGB2YUV(red,green,blue,y,u,v);

				   	if (( (Ymin<=y) && (y<=Ymax) ) &&
				     ( (Umin<=u) && (u<=Umax) ) &&
				     ( (Vmin<=v) && (v<=Vmax) ) )
					{
					if(i!=prex && i!=endx &&
						i!=prex-1 && i!=endx+1)
				    patchcount[patchobj]++;
						
				
                     emptycol01= false;
					   
					// break;
					}			  
					  }



					   bool emptycol02=true;
					
					  for(i=prex-1;i<=endx+1;i++)
					  {	
				pBmpdata = 	lpDIBBits 	+
				(ImgW*(prey-1+posy) + i+posx)*bytes;
                  blue  = *pBmpdata;
                  green = *(pBmpdata+1);
				  red   = *(pBmpdata+2);
				  RGB2YUV(red,green,blue,y,u,v);

				   	if (( (Ymin<=y) && (y<=Ymax) ) &&
				     ( (Umin<=u) && (u<=Umax) ) &&
				     ( (Vmin<=v) && (v<=Vmax) ) )
					{
					if(i!=prex && i!=endx &&
						i!=prex-1 && i!=endx+1)
						patchcount[patchobj]++;
						
						
				
                     emptycol02= false;
					   
					// break;
					}			  
					  }
					                        
                           ////end of col scan

					  ///start of row scan
					    bool emptyrow01=true;
					 
                  for(i=prey-1;i<=endy+1;i++)
					  {	
			     pBmpdata = 	lpDIBBits 	+
				(ImgW*(i+posy) + prex+posx)*bytes;
                  blue  = *pBmpdata;
                  green = *(pBmpdata+1);
				  red   = *(pBmpdata+2);
				  	RGB2YUV(red,green,blue,y,u,v);

				   	if (( (Ymin<=y) && (y<=Ymax) ) &&
				     ( (Umin<=u) && (u<=Umax) ) &&
				     ( (Vmin<=v) && (v<=Vmax) ) )
					{
					
						 patchcount[patchobj]++;

                    
                      
                     emptyrow01=false;
					  
			//		 break;
					}			  
					  }


				    bool emptyrow02=true;
					 
                  for(i=prey-1;i<=endy+1;i++)
					  {	
			     pBmpdata = 	lpDIBBits 	+
				(ImgW*(i+posy) + prex-1+posx)*bytes;
                  blue  = *pBmpdata;
                  green = *(pBmpdata+1);
				  red   = *(pBmpdata+2);
				  	RGB2YUV(red,green,blue,y,u,v);

				   	if (( (Ymin<=y) && (y<=Ymax) ) &&
				     ( (Umin<=u) && (u<=Umax) ) &&
				     ( (Vmin<=v) && (v<=Vmax) ) )
					{
					
						 patchcount[patchobj]++;

                    
                      
                     emptyrow02=false;
					  
			//		 break;
					}			  
					  }

               
                            ////end of row scan            
                    
							 
						   
						 	

                      	 
					  ////////////1
			
                     

                    
                    if((emptyrow1 && emptyrow2 &&  
						emptycol2 && emptycol1 &&
						emptyrow01 && emptyrow02 &&  
						emptycol02 && emptycol01)	
						 ||
						prex<=posx || endx>=ImgW || prey<=posy || endy>=ImgH)
					{
						finished=true;				

					}

					else
					{
						  if(!emptycol2)
						   {
                           			 endy+=2;
						   }
					       else
							   if(!emptycol1)
								   endy++;



							    if(!emptyrow2)
						   {
                           			 endx+=2;
						   }
					       else
							   if(!emptyrow1)
								   endx++;


							   
							    if(!emptycol02)
						   {
                           			 prey-=2;
						   }
					       else
							   if(!emptycol01)
								   prey--;


							   
							    if(!emptyrow02)
						   {
                           			 prex-=2;
						   }
					       else
							   if(!emptyrow01)
								   prex--;


					
					
					
					}
			

				  
				  }//end while
                 
                 //           if(prex<=posx)
                   //       patchxl[patchobj]=posx;
					//			else
                          patchxl[patchobj]=prex+1;

					//	if(endx>=ImgW)
                        //  patchxr[patchobj]=ImgW;
						//		else
						  patchxr[patchobj]=endx-1;


						  patchyt[patchobj]=prey+1;
						  patchyb[patchobj]=endy-1;
						  

                           if(patchcount[patchobj]<4 )
						   {
							   patchcount[patchobj]=0;
							   patchobj--;

						   }

		   

				} ////////patch	 
				else
				{
				*pBmpdata=0;
               	*(pBmpdata+1)=0;
				*(pBmpdata+2)=0;

				}
				}//end of Scaned con
/////////////////
}
}


BYTE temp=1;
/*
for(i=1;i<=patchobj;i++)//array from big to small
 
	if(patchcount[temp]<patchcount[i])
	{
	  temp=i;
	}  	

	////get patch position in pixel
//patchx=(patchxl[i]+patchxr[i])/2;
//patchy=(patchyt[i]+patchyb[i])/2;*/


int mergepatch=0;
short thdis=3;



m_Pixel0=patchcount[1];
m_Pixel1=patchcount[2];
m_Pixel2=patchcount[3];
m_Pixel3=patchcount[4];
m_Pixel4=patchcount[5];



UpdateData(FALSE);


//for(i=1;i<=patchobj;i++)
  //for(j=i+1;j<=patchobj;j++)
  //{
    //     if( (patchxl[i]<=patchxl[j] && patchxr[i]>=patchxr[j] && )
  
  
  //}

    Resultx=new int[patchobj];
    Resulty=new int[patchobj];
    xl=new int[patchobj];
    xr=new int[patchobj];
	yt=new int[patchobj];
	yb=new int[patchobj];

	Maxpatch[0]=patchxl[1]; 
    Maxpatch[1]=patchyt[1];
    Maxpatch[2]=patchxr[1];
    Maxpatch[3]=patchyb[1];

   FILE* ff;
   ff=fopen("infor\\patch","w");
    fprintf(ff,"\n");
	for(i=1;i<=patchobj;i++)
	{     
		xl[i-1]=patchxl[i];
	    xr[i-1]=patchxr[i];
        yt[i-1]=patchyt[i];
		yb[i-1]=patchyb[i];
		fprintf(ff,"%d %d %d %d %d\n",xl[i-1],xr[i-1],
			yt[i-1],yb[i-1],patchcount[i]);
	   Resultx[i-1]=(patchxl[i]+patchxr[i])/2;
      Resulty[i-1]=h-(patchyt[i]+patchyb[i])/2;

   }
   
      fclose(ff);
	Patchnum=patchobj;

}

void SampleDlg::DisplayResult()
{

  UpdateData(TRUE);
  char ss[2];
 
  CPen pen;
  pen.CreatePen(PS_SOLID,1,RGB(255,255,255)) ;
  gDC->SelectObject(&pen); 
  for(int i=0;i<Patchnum;i++)
  {
  sprintf(ss,"%d",i);
  if(m_ShowSymbal)
  gDC->TextOut(xr[i],h-yb[i],ss); 
  gDC->MoveTo(xl[i],h-yt[i]);
  gDC->LineTo(xr[i],h-yt[i]);
  gDC->LineTo(xr[i],h-yb[i]);
  gDC->LineTo(xl[i],h-yb[i]);
  gDC->LineTo(xl[i],h-yt[i]);
  }

 
  m_Var=Patchnum;
  UpdateData(FALSE);

}





void SampleDlg::OnSave() 
{

	
FILE* fp;
fp=fopen(ColorFile,"w");
fprintf(fp,"%d %d %d %d %d %d\n ",
		colorinfor->redcolYmin,colorinfor->redcolUmin,colorinfor->redcolVmin,
		colorinfor->redcolYmax,colorinfor->redcolUmax,colorinfor->redcolVmax);
	
fprintf(fp,"%d %d %d %d %d %d\n ",
		colorinfor->bluecolYmin,colorinfor->bluecolUmin,colorinfor->bluecolVmin,
		colorinfor->bluecolYmax,colorinfor->bluecolUmax,colorinfor->bluecolVmax);

fprintf(fp,"%d %d %d %d %d %d\n ",
		colorinfor->greencolYmin,colorinfor->greencolUmin,colorinfor->greencolVmin,
		colorinfor->greencolYmax,colorinfor->greencolUmax,colorinfor->greencolVmax);

fprintf(fp,"%d %d %d %d %d %d\n ",
		colorinfor->othercolYmin,colorinfor->othercolUmin,colorinfor->othercolVmin,
		colorinfor->othercolYmax,colorinfor->othercolUmax,colorinfor->othercolVmax);
fclose(fp);

}








void SampleDlg::OnPatch() 
{

    UpdateData(TRUE);
   //  StretchDIBits(gDC->m_hDC,0,0,w,h,0,0,
		  //w,h,lpDIBBits,lpbi,DIB_RGB_COLORS,SRCCOPY);

	switch(m_ColType)
	{ 
	case 0:
			//FindPatch(0,0,w,h,w,h,
			///	colorinfor->redcolYmin,colorinfor->redcolUmin,colorinfor->redcolVmin,
			//	colorinfor->redcolYmax,colorinfor->redcolUmax,colorinfor->redcolVmax);
			
		 GetPos21();
		break;
	case 1:
			//FindPatch(0,0,w,h,w,h,
		//		colorinfor->bluecolYmin,colorinfor->bluecolUmin,colorinfor->bluecolVmin,
		//		colorinfor->bluecolYmax,colorinfor->bluecolUmax,colorinfor->bluecolVmax);
			GetPos21();
			break;
	case 2:
		//	FindPatch(0,0,w,h,w,h,
		//		colorinfor->greencolYmin,colorinfor->greencolUmin,colorinfor->greencolVmin,
		//		colorinfor->greencolYmax,colorinfor->greencolUmax,colorinfor->greencolVmax);
		GetPos21();
		break;
			
	case 3:
			//FindPatch(0,0,w,h,w,h,
			///	colorinfor->othercolYmin,colorinfor->othercolUmin,colorinfor->othercolVmin,
			//	colorinfor->othercolYmax,colorinfor->othercolUmax,colorinfor->othercolVmax);
			GetPos21();
			break;
	}	
		 
		  //DisplayResult();
}




void SampleDlg::GetPos21( )


{
	  short Res=3;
    BYTE red, green, blue; 	
    UpdateData(TRUE);

    LPBYTE pBmpdata;	//-- pointer to the bitmap
	int y, u, v;
    int i,j; 

    short PatchDis =3;   

    int  RedxlArray[maxpatch];
    int  RedytArray[maxpatch];
    int  RedxrArray[maxpatch];
	int  RedybArray[maxpatch];
    int  redcount[maxpatch];
//   int   lastredcol[maxpatch];
//	 int   lastredrow[maxpatch];
     short redobj=-1;
   
	 for(i=0;i<maxpatch;i++)
	{
	   RedxlArray[i]=0;
	   RedxrArray[i]=0;
	   RedytArray[i]=0;
	   RedybArray[i]=0;
       redcount[i]=0;   	
	}


     int  bluexl[maxpatch];
     int  blueyt[maxpatch];
     int  bluexr[maxpatch];
	 int  blueyb[maxpatch];
     int  bluecount[maxpatch];
//  int    lastbluecol[maxpatch];
//	 int    lastbluerow[maxpatch];
     short blueobj=-1;
    

	 for(i=0;i<maxpatch;i++)
	{
	   bluexl[i]=0;
	   bluexr[i]=0;
	   blueyt[i]=0;
	   blueyb[i]=0;
       bluecount[i]=0;
     //  lastbluecol[i]=0;
	 //  lastbluerow[i]=0;
	
	}
	 
 

for (int row=10; row<h-10; row++)
		{			
	 for (int col=10; col<w-10; col++)
			{

   if(row==h-11 && col==w-11)
   {
    int ccs=0;
   }

	          // if(col>Fieldxl && col<Fieldxr &&
				//  row<VideoH-Fieldyt && row>VideoH-Fieldyb)
				 //  if(col>Fieldxl && col<Fieldxr &&
				   //row>Fieldyt && row<Fieldyb)			
			   {	
      	        pBmpdata = lpDIBBits	+
				(w*row + col)*Res;
               
				  blue  = *pBmpdata;
                  green = *(pBmpdata+1);
			      red=    *(pBmpdata+2);
      
               

				  /////////////////////////////*************/////////////
				  
				  RGB2YUV(red,green,blue,y,u,v);
	        
				 
			  	if ( ( (colorinfor->redcolYmin<=y) && (y<=colorinfor->redcolYmax) ) &&
				     ( (colorinfor->redcolUmin<=u) && (u<=colorinfor->redcolUmax) ) &&
				     ( (colorinfor->redcolVmin<=v) && (v<=colorinfor->redcolVmax) ) )

				{	
                   
				bool Scaned=FALSE; 
				for(i=0;i<=redobj;i++)
				  if(col<=RedxrArray[i] && col>=RedxlArray[i] &&
					  row>=RedytArray[i] && row<=RedybArray[i])
					  Scaned=TRUE;
                     

                     if(!Scaned && redobj<maxpatch-1)
			 {
                   redobj++;    
				   redcount[redobj]=1;
                    
				   
				   int prex=col-1;
				   int prey=row-1;

                   int endx=col+1;
                   int endy=row+1;
                   bool finished=false;
              	
				   while(!finished)
				  {
				          
				/////////// start col scan
					  bool emptycol=true;
					  //if(prex<=w && endx >=0 && endy<=h && prey >=0)