fytaskcreategratingimage.cpp

我老师写的关于RGB格式图片提取线条的源代码

			else
			{
				m_LaserImage->SetValue(TpWith,TpHigh,m_IVALUE2);
			}
		}
		
	}
	
    return false;
}
bool fyTaskCreateGratingImage::EditStandGrating(fyTaskData* data)
{
	if(!data) return false;
	fyTaskDataCreateGratingImage * _data = dynamic_cast<fyTaskDataCreateGratingImage *>(data);
	if (!_data) 
		return false;

	long Image_Num,Image_id;
	Image_Num = GetTheApp()->GetImageMgr()->GetImageTotal();
	Image_id = GetTheApp()->GetImageMgr()->GetIndexImageId(Image_Num-1);
	if(Image_id == -1) return false;
	
	m_LaserImage = GetTheApp()->GetImageMgr()->GetImage(Image_id);
	if(!m_LaserImage) return false;

	long nWidth = m_LaserImage->GetWidth();
	long nHeight = m_LaserImage->GetHeight();
	int TPWith,TPHight;
	bool FindFlag = 0,FindUpFlag = 0,FindDownFlage = 0;
	RGBQUAD m_IVALUE;
	m_IVALUE.rgbBlue=0;
	m_IVALUE.rgbGreen=0;
	m_IVALUE.rgbRed = 0;


	long nFindHigh;
	nFindHigh = nHeight/2;
	int NeedFindNum;

	//find the first middle tria,if it can't be fond,try the next
	FindFlag = FindMiddleTria(nFindHigh);
	for (int FindNum=1;FindNum<4;FindNum++)
	{
		if (FindFlag == 0)
		{
	    	nFindHigh = nHeight/pow(2,FindNum);
	    	FindFlag = FindMiddleTria(nFindHigh);
		}
		else
		{
			break;
		}
	}

	if (FindFlag)
	{
		ResetMaxValueWith = MaxValueWith;
		MidianWave(MaxValueWith,nFindHigh); //method 1
    	BaryCenter(MaxValueWith,nFindHigh); //method 1
		for (NeedFindNum=0;NeedFindNum< nFindHigh;NeedFindNum++)
		{
			FindUpFlag = FindUpMiddleTria(nFindHigh+NeedFindNum);
			if (FindUpFlag == 0)
			break;
		}
		MaxValueWith = ResetMaxValueWith;
		for (NeedFindNum=0;NeedFindNum< nFindHigh;NeedFindNum++)
		{
			FindDownFlage = FindDownMiddleTria(nFindHigh - NeedFindNum);
			if (FindDownFlage == 0)
			break;
		}	
		
	}
	

	return false;
}
bool fyTaskCreateGratingImage::FindMiddleTria(long FindHight)
{
    long nWidth = m_LaserImage->GetWidth();
	int TPWith;
	bool ValidFlag=0;

	RGBQUAD m_IVALUE,m_TPValue,m_Red;
    
	m_IVALUE.rgbBlue = 0;
	m_IVALUE.rgbGreen = 0;
	m_IVALUE.rgbRed = 0;

	m_Red.rgbBlue =0;
	m_Red.rgbGreen = 255;
	m_Red.rgbRed = 0;
	for (TPWith=0;TPWith<nWidth;TPWith++)
	{
	    m_TPValue =	m_LaserImage->GetValue(TPWith,FindHight);
		if (m_TPValue.rgbGreen > m_IVALUE.rgbGreen)
		{
			m_IVALUE.rgbGreen = m_TPValue.rgbGreen;
			MaxValueWith = TPWith;
		}
	}
	for (TPWith=MaxValueWith-2;TPWith<=MaxValueWith+2;TPWith++)
	{
		if (m_LaserImage->GetValue(TPWith,FindHight).rgbGreen < 100)
		{
             ValidFlag = 1;
		}
	}
	if (!ValidFlag)
	{
	//	m_LaserImage->SetValue(MaxValueWith,FindHight,m_Red);
	//	MidianWave(MaxValueWith,FindHight); //method 2
    	
		BYTE Value = 0;
	    int num=0,Tpnum = 0,Mnum=0;
		TPWith = MaxValueWith;
     	for (int x=TPWith-5;x<=TPWith+5;x++)
		{
	    	if (Value < m_LaserImage->GetValue(x,FindHight).rgbBlue)
			{
		    	Value = m_LaserImage->GetValue(x,FindHight).rgbBlue;
		    	MaxValueWith = x;
		    	Tpnum = x;
			}
		
		}
    	for (num=Tpnum+1;num<Tpnum + 11;num++)
		{
             if (Value == m_LaserImage->GetValue(num,FindHight).rgbBlue)
			 {
                  Mnum++;
			 }
		}
    	if (Mnum)
		{
	    	MaxValueWith += (int)(Mnum/2);
		}

	//	BaryCenter(MaxValueWith,FindHight); //method 2
        	return true;
	}
	else
		return false;
    
}
void fyTaskCreateGratingImage::MidianWave(long MTx,long MTy)
{
	RGBQUAD m_IVALUE;
	RGBQUAD m_Red;
	m_Red.rgbBlue =0;
	m_Red.rgbGreen =0;
	m_Red.rgbRed = 255;
	float p[9],s;
	float f[11];
	int i,j;
	int x;
	for(x=MTx-5;x<=MTx+5;x++)
	{
		
			p[0]=0.299* m_LaserImage->GetValue(x-1,MTy-1).rgbRed
				 +0.587* m_LaserImage->GetValue(x-1,MTy-1).rgbGreen
				 +0.114* m_LaserImage->GetValue(x-1,MTy-1).rgbBlue;
			p[1]=0.299* m_LaserImage->GetValue(x,MTy-1).rgbRed
				 +0.587* m_LaserImage->GetValue(x,MTy-1).rgbGreen
				 +0.114* m_LaserImage->GetValue(x,MTy-1).rgbBlue;				
			p[2]=0.299* m_LaserImage->GetValue(x+1,MTy-1).rgbRed
				 +0.587* m_LaserImage->GetValue(x+1,MTy-1).rgbGreen
				 +0.114* m_LaserImage->GetValue(x+1,MTy-1).rgbBlue;
				
			p[3]=0.299* m_LaserImage->GetValue(x-1,MTy).rgbRed
				 +0.587* m_LaserImage->GetValue(x-1,MTy).rgbGreen
				 +0.114* m_LaserImage->GetValue(x-1,MTy).rgbBlue;
			p[4]=0.299* m_LaserImage->GetValue(x,MTy).rgbRed
				 +0.587* m_LaserImage->GetValue(x,MTy).rgbGreen
				 +0.114* m_LaserImage->GetValue(x,MTy).rgbBlue;
			p[5]=0.299* m_LaserImage->GetValue(x+1,MTy).rgbRed
				 +0.587* m_LaserImage->GetValue(x+1,MTy).rgbGreen
				 +0.114* m_LaserImage->GetValue(x+1,MTy).rgbBlue;

			p[6]=0.299* m_LaserImage->GetValue(x-1,MTy+1).rgbRed
				 +0.587* m_LaserImage->GetValue(x-1,MTy+1).rgbGreen
				 +0.114* m_LaserImage->GetValue(x-1,MTy+1).rgbBlue;
			p[7]=0.299* m_LaserImage->GetValue(x,MTy+1).rgbRed
				 +0.587* m_LaserImage->GetValue(x,MTy+1).rgbGreen
				 +0.114* m_LaserImage->GetValue(x,MTy+1).rgbBlue;
			p[8]=0.299* m_LaserImage->GetValue(x+1,MTy+1).rgbRed
				 +0.587* m_LaserImage->GetValue(x+1,MTy+1).rgbGreen
				 +0.114* m_LaserImage->GetValue(x+1,MTy+1).rgbBlue;
			for(j=0;j<5;j++)
			{
				for(i=j+1;i<9;i++)
				{
					if (p[j]>p[i])
					{
						s=p[j];
						p[j]=p[i];
						p[i]=s;
					}
				}
			}
			f[x-MTx+5] = p[4];
			m_IVALUE.rgbGreen = (BYTE)(p[4]);
			m_IVALUE.rgbBlue = (BYTE)(p[4]);
			m_IVALUE.rgbRed = (BYTE)(p[4]);
			m_LaserImage->SetValue(x,MTy,m_IVALUE);
	}

 /*   BYTE Value=-1;
    for(x=MTx-3;x<=MTx+3;x++)
	{
		if (Value < m_LaserImage->GetValue(x,MTy).rgbGreen)
		{

			MaxValueWith = x;
			Value = m_LaserImage->GetValue(x,MTy).rgbGreen;
		}
        
	}
*/	
	//method 1 find the max directly
	float Value = 0.0;
	int num=0,Tpnum = 0,Mnum=0;
	for (x=0;x<11;x++)
	{
		if (Value<f[x])
		{
			Value = f[x];
			MaxValueWith = MTx-5+x;
			Tpnum = x;
		}
		
	}
	for (num=Tpnum+1;num<11;num++)
	{
         if (Value == f[num])
         {
              Mnum++;
         }
	}
	if (Mnum)
	{
		MaxValueWith += (int)(Mnum/2);
	}
		//method 2 find the max in the 3*3 pixel()
//	m_LaserImage->SetValue(MaxValueWith,MTy,m_Red);
}
void fyTaskCreateGratingImage::BaryCenter(long MTx,long MTy)
{
	long SumValue = 0,everyValue = 0;
	int TpX;
	float RealMiddle;
	BYTE TPValue;

	RGBQUAD m_Red;
	m_Red.rgbBlue =0;
	m_Red.rgbGreen =0;
	m_Red.rgbRed = 255;
	for (TpX=MTx-3;TpX<=MTx+3;TpX++)
	{
        TPValue = m_LaserImage->GetValue(TpX,MTy).rgbGreen;
		SumValue += TPValue;
		everyValue += (TpX-MTx+3)*TPValue;
 
	}

        RealMiddle = MTx-3+(float)everyValue/(float)SumValue;
		MaxValueWith = (int)RealMiddle;	 
		m_LaserImage->SetValue(MaxValueWith,MTy,m_Red);
}
bool fyTaskCreateGratingImage::FindUpMiddleTria(long FindHigh)
{
   	RGBQUAD m_IVALUE,m_TPValue,m_Red;
    m_Red.rgbBlue =0;
	m_Red.rgbGreen = 0;
	m_Red.rgbRed = 255;
	int TPMaxValueWith = MaxValueWith;
	int TPMaxValueHigh = FindHigh+1;
	int TpWithNum;
	bool ValidFlag=0;
	BYTE TpValue=-1;
	m_TPValue.rgbBlue = 0;
	float RefernceY=0.0,TpY = 1.0000;

	for (TpWithNum=TPMaxValueWith-2;TpWithNum<=TPMaxValueWith+2;TpWithNum++)
	{
		if (m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbBlue < 100)
		{
             ValidFlag = 1;
		}
	}
	if (!ValidFlag)
	{
	    MidianWave(MaxValueWith,TPMaxValueHigh);
/*
		for (TpWithNum=MaxValueWith-3;TpWithNum <=MaxValueWith+3;TpWithNum++)
		{

			TpY = 0.222* m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbRed
				 +0.707* m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbGreen
				 +0.114* m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbBlue;
			if (RefernceY < TpY)
			{
				RefernceY = TpY;
				TPMaxValueWith = TpWithNum;
			}
			

		}
       
	*/	m_TPValue.rgbBlue = m_LaserImage->GetValue(MaxValueWith-1,FindHigh).rgbBlue;
    	TPMaxValueWith = MaxValueWith - 1;
    	

    	if (m_TPValue.rgbBlue<
	    	m_LaserImage->GetValue(MaxValueWith+1,FindHigh).rgbBlue)
		{
	    	TPMaxValueWith = MaxValueWith+1;
	    	m_TPValue.rgbBlue = m_LaserImage->GetValue(MaxValueWith+1,FindHigh).rgbBlue;
		}
		else if (m_TPValue.rgbBlue==
	    	m_LaserImage->GetValue(MaxValueWith+1,FindHigh).rgbBlue)
		{
			TPMaxValueWith = MaxValueWith;
		}
        
    	for (TpWithNum=MaxValueWith-1;TpWithNum <=MaxValueWith+1;TpWithNum++)
		{
	    	if (m_TPValue.rgbBlue < m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbBlue)
			{
	        	TPMaxValueWith = TpWithNum;
		    	
                m_TPValue.rgbBlue =  m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbBlue;
			}
			else if (m_TPValue.rgbBlue == m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbBlue)
			{
				TPMaxValueWith += int((float)(TpWithNum - TPMaxValueWith)/2);
			}
		}
		
    	MaxValueWith = TPMaxValueWith;
       BaryCenter(MaxValueWith,TPMaxValueHigh);
	//	m_LaserImage->SetValue(MaxValueWith,TPMaxValueHigh,m_Red);
    	return true;
	}
	else
		return false;

    
}
bool fyTaskCreateGratingImage::FindDownMiddleTria(long FindHigh)
{
	RGBQUAD m_IVALUE,m_TPValue,m_Red;
    m_Red.rgbBlue =0;
	m_Red.rgbGreen = 0;
	m_Red.rgbRed = 255;
	int TPMaxValueWith = MaxValueWith;
	int TPMaxValueHigh = FindHigh-1;
	int TpWithNum;
	bool ValidFlag=0;
	BYTE TpValue=-1;
	float RefernceY=0.0,TpY = 1.0000;

	for (TpWithNum=TPMaxValueWith-2;TpWithNum<=TPMaxValueWith+2;TpWithNum++)
	{
		if (m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbBlue < 100)
		{
             ValidFlag = 1;
		}
	}
	if (!ValidFlag)
	{
	    MidianWave(MaxValueWith,TPMaxValueHigh);

       /* for (TpWithNum=MaxValueWith-3;TpWithNum <=MaxValueWith+3;TpWithNum++)
		{

			TpY = 0.222* m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbRed
				 +0.707* m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbGreen
				 +0.114* m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbBlue;
			if (RefernceY < TpY)
			{
				RefernceY = TpY;
				TPMaxValueWith = TpWithNum;
			}
		}
*/
        m_TPValue.rgbBlue = m_LaserImage->GetValue(MaxValueWith-1,FindHigh).rgbBlue;
    	TPMaxValueWith = MaxValueWith - 1;
    	TPMaxValueHigh = FindHigh;
	

    	if (m_TPValue.rgbBlue<=
	    	m_LaserImage->GetValue(MaxValueWith+1,FindHigh).rgbBlue)
		{
	    	TPMaxValueWith = MaxValueWith+1;
	    	m_TPValue.rgbBlue = m_LaserImage->GetValue(MaxValueWith+1,FindHigh).rgbBlue;
		}
        
    	for (TpWithNum=MaxValueWith-1;TpWithNum <=MaxValueWith+1;TpWithNum++)
		{
	    	if (m_TPValue.rgbBlue < m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbBlue)
			{
	        	TPMaxValueWith = TpWithNum;
                m_TPValue.rgbBlue =  m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbBlue;
			}
			else if (m_TPValue.rgbBlue == m_LaserImage->GetValue(TpWithNum,TPMaxValueHigh).rgbBlue)
			{
				TPMaxValueWith += int((float)(TpWithNum - TPMaxValueWith)/2);
			}
		}
		
    	 MaxValueWith = TPMaxValueWith;
    	 BaryCenter(MaxValueWith,TPMaxValueHigh);
	//	 m_LaserImage->SetValue(MaxValueWith,TPMaxValueHigh,m_Red);
    	return true;
	}
	else
		return false;


}

void fyTaskCreateGratingImage::Hilditch(int x,int y,int Dx,int Dy)
{
	int i,j,k,m,n,flag;
	int sum=0,f[10];
	char **List;
    
//	List = (BYTE**)malloc(Dy * sizeof(char*));
	for (i=0;i<Dy;i++)
	{
//		List[i] = (BYTE*)malloc(Dx*sizeof(char));

	}
	i=1;
	do 
	{
		flag = 0;
		for (k=1;k<Dy-1;k++)
		{
			for (j=1;j<Dx-1;j++)
			{
				if (List[k][j] != 1) continue;
				{
					f[1] = List[k][j+1]; f[2] = List[k-1][j+1];
					f[3] = List[k-1][j]; f[4] = List[k-1][j-1];
					f[5] = List[k][j-1]; f[6] = List[k+1][j-1];
					f[7] = List[k+1][j]; f[8] = List[k+1][j-1];

					for (m=1,n=0;m<=3;m++)
					{
						if (f[m] == -i)
						{
							f[m]=1;
							n++;
						}
						else if (f[m]<0)
						{
							f[m] = 0;
						}
					}
					sum = f[1]+f[3]+f[5]+f[7];
					if (sum>=4)
					{
						continue;
					}
					
					f[9] = f[1];
					for (m=1,sum=0;m<=8;m++)
					{
						if (f[m] == 1)
						{
							sum++;
						}
					}
					if ((sum <=1)||(sum-n==0))
					{
						continue;
					}
					
					sum=Cross(f);
					if (sum!=1)
					{
						continue;
					}
					if (List[k-1][j]==-i)
					{
						f[3]=0;
						sum = Cross(f);
						if (sum!=1)
						{
							continue;
						}
					}
					if (List[k][j-1]==-i)
					{
						f[5]=0;
						sum = Cross(f);
						if (sum!=1)
						{
							continue;
						}
					}
				//	put_pixel(x+j,y+k,0);
					List[k][j] = -1;
					flag = 1;
				}
			}
			i++;
		}
	} while(flag == 1);
	for (i=0;i<Dy;i++)
	{
		if (List[i])
		{
			free(List[i]);
		}
	}
	free(List);

}
int fyTaskCreateGratingImage::Cross(int *f)
{
	int i,sum;
	for (i=1,sum=0;i<=7;i+=2)
	{
		if ((!f[i]) && (f[i+1] || f[i+2]) )
		{
			sum++;
		}
	}
	return sum;
}