fytaskcreategratingimage.cpp

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

// fyTaskCreateGratingImage.cpp: implementation of the fyTaskCreateGratingImage class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "fyTaskCreateGratingImage.h"

#include "inc/TaskData/fyTaskDataCreateGratingImage.h"

static fyTaskDataCreateGratingImage default_data;

fyTaskCreateGratingImage::fyTaskCreateGratingImage()
{
	MiddleTriaX = 0;

}

long fyTaskCreateGratingImage::CheckLicense()
{
	return 1;
}

fyTaskData*	fyTaskCreateGratingImage::CreateTaskData() 
{
	return new fyTaskDataCreateGratingImage;
}

fyTaskData*	fyTaskCreateGratingImage::GetDefaultTaskData()
{
	return &default_data;
}

void fyTaskCreateGratingImage::CopyTaskData(fyTaskData* from, fyTaskData* to)
{
	fyTaskDataCreateGratingImage * _from	= dynamic_cast<fyTaskDataCreateGratingImage *>(from);
	fyTaskDataCreateGratingImage * _to		= dynamic_cast<fyTaskDataCreateGratingImage *>(to);

	*_to = *_from;
}

bool fyTaskCreateGratingImage::Execute(fyTaskData* data)
{
	if(!data) return false;
	fyTaskDataCreateGratingImage * _data = dynamic_cast<fyTaskDataCreateGratingImage *>(data);
	if (!_data) return false;

	switch(_data->action)
	{
	
    	case fyTaskDataCreateGratingImage::EnumAction::eCreateGratingImage:
		{
			return CreateImage(data);
		}
		break;
		case fyTaskDataCreateGratingImage::EnumAction::eEditStandGrating:
		{
			return EditStandGrating(data);
		}
		case fyTaskDataCreateGratingImage::EnumAction::exihuaImage:
		{
			return XiHuaGrating(data);
		}
		
		break;
	
	}

	return false;
}

bool fyTaskCreateGratingImage::Abort(bool)
{
	//do the abort operator
	
	return false;
}

bool fyTaskCreateGratingImage::CreateImage(fyTaskData* data)
{
	if(!data) return false;
	fyTaskDataCreateGratingImage * _data = dynamic_cast<fyTaskDataCreateGratingImage *>(data);
	if (!_data) return false;
	
	long nWidth = _data->image_width;
	long nHeight = _data->image_height;   	
	if(nWidth == 0 || nHeight == 0) 
		return false;
	long Image_id = _data->image_id;
	if(Image_id == -1)
	{
		Image_id = GetTheApp()->GetImageMgr()->CreateImage(nWidth, nHeight, 24);
		_data->image_id = Image_id;
	}
	if(Image_id == -1) return false;

	fyImage* m_Image = GetTheApp()->GetImageMgr()->GetImage(Image_id);
	if(!m_Image) return false;
	
	
	switch(_data->grating_style)
	{
	case fyTaskDataCreateGratingImage::EnumGratingStyle::eSine:
		{
			return CreatSineGrating(_data,m_Image);
		}
		break;
	case fyTaskDataCreateGratingImage::EnumGratingStyle::eSquare:
		{
			return CreateSquareGrating(_data,m_Image);
		}
		break;
	default:
		return CreateNormalGrating(_data,m_Image);
		break;
	}	
	return false;	
}

bool fyTaskCreateGratingImage::CreateNormalGrating(fyTaskData* data,fyImage* m_Image)
{
	if(!data) return false;
	fyTaskDataCreateGratingImage * _data = dynamic_cast<fyTaskDataCreateGratingImage *>(data);
	if (!_data) 
		return false;

	long nWidth = _data->image_width;
	long nHeight = _data->image_height;
  	int line_width = _data->tria_width;
 	

	RGBQUAD m_IBrack;
	RGBQUAD m_IWhite;
	RGBQUAD m_IMiddle;
	
	m_IBrack.rgbBlue = 0;
	m_IBrack.rgbGreen = 0;
	m_IBrack.rgbRed = 0;

	m_IWhite.rgbBlue = 255;
	m_IWhite.rgbGreen = 255;
	m_IWhite.rgbRed = 255;
   
    m_IMiddle.rgbBlue = 128;
    m_IMiddle.rgbGreen = 128;
    m_IMiddle.rgbRed = 128;	
	int TriaNum;
	int TPTriaNum,TPWith;
   	int TPHight;
	
	if (line_width != 0)
	{
		TriaNum = (int)(nWidth/line_width);   
	    	
        for (TPTriaNum=0;TPTriaNum<TriaNum;TPTriaNum++)
		{
            if (TPTriaNum%2 == 0)
            {
				for (TPWith=0;TPWith<line_width;TPWith++)
				{
					for (TPHight=0;TPHight<nHeight;TPHight++)
					{
						m_Image->SetValue(TPTriaNum*line_width+TPWith,TPHight,m_IWhite);
					}					
				}				
            }
			else
			{
				for (TPWith=0;TPWith<line_width;TPWith++)
				{
					for (TPHight=0;TPHight<nHeight;TPHight++)
					{
						m_Image->SetValue(TPTriaNum*line_width+TPWith,TPHight,m_IBrack);
					}					
				}
			}			
		}
		
    }
	
	int TTPTriaNmu = (int)(TriaNum/2);
	TPTriaNum  = (TTPTriaNmu%2 == 0) ? TTPTriaNmu : TTPTriaNmu+1;
	for (TPWith=0;TPWith<line_width;TPWith++)
	{
		for (TPHight=0;TPHight<nHeight;TPHight++)
		{
			m_Image->SetValue(TPTriaNum*line_width+TPWith,TPHight,m_IMiddle);
		}
					
	}
	return false;
}
bool fyTaskCreateGratingImage::CreatSineGrating(fyTaskData* data,fyImage* m_Image)
{
	if(!data) return false;
	fyTaskDataCreateGratingImage * _data = dynamic_cast<fyTaskDataCreateGratingImage *>(data);
	if (!_data) 
		return false;

	long nWidth = _data->image_width;
	long nHeight = _data->image_height;
	RGBQUAD m_IValue;
	

	m_IValue.rgbBlue = 0;
	m_IValue.rgbGreen = 0;
	m_IValue.rgbRed = 0;
	

	int TriaNum,TPTriaCycleNum;
	int TriaWith = _data->tria_width;
	int TriaCycleNum = _data->color_cycle_num;
	int TPValue;
	int TPTriaNum,TPWith;
   	int TPHight;


	
	if (TriaWith != 0)
	{
		TriaNum = (int)(nWidth/TriaWith);	
     
	    
    	for (TPTriaNum=0;TPTriaNum<TriaNum;TPTriaNum++)
		{
	    	for (TPWith=0;TPWith<TriaWith;TPWith++)
			{
				if (TriaCycleNum == 0)  //black and white grating
				{
					TPValue = (int)(sin(((float)TPWith/(float)(TriaWith-1)) * 3.14159) * 255);
		        	m_IValue.rgbRed = TPValue;
		        	m_IValue.rgbGreen = TPValue;
		        	m_IValue.rgbBlue = TPValue;
		        	for (TPHight=0;TPHight<nHeight;TPHight++)
					{
				    	m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
					}
				}
				else
				{
					switch(TPTriaNum%TriaCycleNum)  //set color grating number in a cycle
					{
					case 0:
						{
							TPValue = (int)(sin(((float)TPWith/(float)(TriaWith-1)) * 3.14159) * 255);
		                	m_IValue.rgbRed = TPValue;
		                	m_IValue.rgbGreen = 0;
		                	m_IValue.rgbBlue = 0;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
						break;
					case 1:
						{
							TPValue = (int)(sin(((float)TPWith/(float)(TriaWith-1)) * 3.14159) * 255);
		                	m_IValue.rgbRed = 0;
		                	m_IValue.rgbGreen = TPValue;
		                	m_IValue.rgbBlue = 0;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
						break;
					case 2:
						{
							TPValue = (int)(sin(((float)TPWith/(float)(TriaWith-1)) * 3.14159) * 255);
		                	m_IValue.rgbRed = 0;
		                	m_IValue.rgbGreen = 0;
		                	m_IValue.rgbBlue = TPValue;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
					    break;
					case 3:
						{
							TPValue = (int)(sin(((float)TPWith/(float)(TriaWith-1)) * 3.14159) * 255);
		                	m_IValue.rgbRed = TPValue;
		                	m_IValue.rgbGreen = TPValue;
		                	m_IValue.rgbBlue = 0;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
					    break;
					case 4:
						{
							TPValue = (int)(sin(((float)TPWith/(float)(TriaWith-1)) * 3.14159) * 255);
		                	m_IValue.rgbRed = 0;
		                	m_IValue.rgbGreen = TPValue;
		                	m_IValue.rgbBlue = TPValue;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
					    break;
					case 5:
						{
							TPValue = (int)(sin(((float)TPWith/(float)(TriaWith-1)) * 3.14159) * 255);
		                	m_IValue.rgbRed = TPValue;
		                	m_IValue.rgbGreen = 0;
		                	m_IValue.rgbBlue = TPValue;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
					    break;
					}
				}	 			
			}
		}
 //set middle grating tria
        if (TriaCycleNum != 0)
        {
			 int TTPTriaNum = (int)(TriaNum / TriaCycleNum);
             TPTriaNum  = (int)(TTPTriaNum/2) * TriaCycleNum;
             for (TPWith=0;TPWith<TriaWith;TPWith++)
			 {	
	           	TPValue = (int)(sin(((float)TPWith/(float)(TriaWith-1)) * 3.14159) * 255);
	          	m_IValue.rgbRed = TPValue;
	          	m_IValue.rgbGreen = TPValue;
	         	m_IValue.rgbBlue = TPValue;
	           	for (TPHight=0;TPHight<nHeight;TPHight++)
				{
	             	m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
				}
			 }
			
        }
      

   }
	
	
	return false;

}
bool fyTaskCreateGratingImage::CreateSquareGrating(fyTaskData* data,fyImage* m_Image)
{
    if(!data) return false;
	fyTaskDataCreateGratingImage * _data = dynamic_cast<fyTaskDataCreateGratingImage *>(data);
	if (!_data) 
		return false;

	long nWidth = _data->image_width;
	long nHeight = _data->image_height;
	RGBQUAD m_IValue;
	
	
	m_IValue.rgbBlue = 0;
	m_IValue.rgbGreen = 0;
	m_IValue.rgbRed = 0;
	

	int TriaNum,TPTriaCycleNum;
	int TriaWith = _data->tria_width;
	int TriaCycleNum = _data->color_cycle_num;
	int TPValue;
	int TPTriaNum,TPWith;
    int TPHight;


	if (TriaWith != 0)
	{
		TriaNum = (int)(nWidth/TriaWith);	
     
	    
    	for (TPTriaNum=0;TPTriaNum<TriaNum;TPTriaNum++)
		{
	    	for (TPWith=0;TPWith<TriaWith;TPWith++)
			{
				if (TriaCycleNum == 0)  //black and white grating
				{
					return false;
				}
				else
				{
					switch(TPTriaNum%TriaCycleNum)  //set color grating number in a cycle
					{
					case 0:
						{
							TPValue = 255;
		                	m_IValue.rgbRed = TPValue;
		                	m_IValue.rgbGreen = 0;
		                	m_IValue.rgbBlue = 0;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
						break;
					case 1:
						{
							TPValue = 255;
		                	m_IValue.rgbRed = 0;
		                	m_IValue.rgbGreen = TPValue;
		                	m_IValue.rgbBlue = 0;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
						break;
					case 2:
						{
							TPValue = 255;
		                	m_IValue.rgbRed = 0;
		                	m_IValue.rgbGreen = 0;
		                	m_IValue.rgbBlue = TPValue;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
					    break;
					case 3:
						{
							TPValue = 255;
		                	m_IValue.rgbRed = TPValue;
		                	m_IValue.rgbGreen = TPValue;
		                	m_IValue.rgbBlue = 0;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
					    break;
					case 4:
						{
							TPValue = 255;
		                	m_IValue.rgbRed = 0;
		                	m_IValue.rgbGreen = TPValue;
		                	m_IValue.rgbBlue = TPValue;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
					    break;
					case 5:
						{
							TPValue = 255;
		                	m_IValue.rgbRed = TPValue;
		                	m_IValue.rgbGreen = 0;
		                	m_IValue.rgbBlue = TPValue;
		                	for (TPHight=0;TPHight<nHeight;TPHight++)
							{
				            	  m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
							}

						}
					    break;
					}
				}	 			
			}
		}
		//Set Middle tria
		if (TriaCycleNum != 0)
		{
			int TTPTriaNum = (int)(TriaNum / TriaCycleNum);
            TPTriaNum  = (int)(TTPTriaNum/2) * TriaCycleNum;
	        for (TPWith=0;TPWith<TriaWith;TPWith++)
			{	
	 	        TPValue = 255;
		        m_IValue.rgbRed = TPValue;
	 	        m_IValue.rgbGreen = TPValue;
		        m_IValue.rgbBlue = TPValue;
	 	        for (TPHight=0;TPHight<nHeight;TPHight++)
				{
		         	m_Image->SetValue(TPTriaNum*TriaWith+TPWith,TPHight,m_IValue);
				}
		}
		}
		
	}
		
	return false;

}
bool fyTaskCreateGratingImage::XiHuaGrating(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;

	float TPv=0.0;
	int TPv1;
	RGBQUAD m_IVALUE1,m_IVALUE2;
	m_IVALUE1.rgbBlue = 0;
	m_IVALUE1.rgbGreen =0;
	m_IVALUE1.rgbRed = 0;
	m_IVALUE2.rgbRed=255;
	m_IVALUE2.rgbBlue =255;
	m_IVALUE2.rgbGreen =255;
	long nWidth = m_LaserImage->GetWidth();
	long nHeight = m_LaserImage->GetHeight();
    
	for (int TpHigh=0;TpHigh<nHeight;TpHigh++)
	{
		for (int TpWith=0;TpWith<nWidth;TpWith++)
		{
            TPv = 0.299* m_LaserImage->GetValue(TpWith,TpHigh).rgbRed
				 +0.587* m_LaserImage->GetValue(TpWith,TpHigh).rgbGreen
				 +0.114* m_LaserImage->GetValue(TpWith,TpHigh).rgbBlue;
			if (TPv < 250)
			{
                
				 m_LaserImage->SetValue(TpWith,TpHigh,m_IVALUE1);
			}