rip.cpp

合成4个代表K,C,M,Y通道的BMP位图为打印数据

// Rip.cpp: implementation of the CRip class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Rip.h"
#include "math.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CRip::CRip()
{			

	 lpmemc1=NULL,lpmemm1=NULL,lpmemy1=NULL,lpmemk1=NULL;
	 lpmemc2=NULL,lpmemm2=NULL,lpmemy2=NULL,lpmemk2=NULL;

	InkNums.Inkc=0;
	InkNums.Inkm=0;
	InkNums.Inky=0;
	InkNums.Inkk=0;
	pass=0;
	count=0;
	
}

CRip::~CRip()
{    
	if(lpmemc1)
	delete[] lpmemc1;
	if(lpmemm1)
	delete [] lpmemm1;
	if(lpmemy1)
	delete [] lpmemy1;
	if(lpmemk1)
	delete [] lpmemk1;
	if(lpmemc2)
	delete [] lpmemc2;
	if(lpmemm2)
	delete [] lpmemm2;
	if(lpmemy2)
	delete [] lpmemy2;
	if(lpmemk2)
	delete [] lpmemk2;
	if(filer!=CFile::hFileNull)
		filer.Close();

}


////////////////////////////////////////////////////////////////////////////////////
////////////////	INITIALIZE CRip CLASS DATA MEMBER  ///////////////	
///////////////////////////////////////////////////////////////////////////////////
bool CRip::LoadRipFile(LPCTSTR lpfilename)  
{
	 strs=CString(lpfilename); 
	
	filer.Open(LPCTSTR(strs),CFile::modeRead);
	filer.Read(&rh,sizeof(RipHeader));
		return true;

}
///////////////////////////rip to 4 bmp file ////////////////////////////////////////
bool CRip::Gener4bmp()
{
	::SetCursor(LoadCursor( NULL,IDC_WAIT ));
	CString strc,strm,stry,strk;
	RGBQUAD color[2];  
	CFile filec,filem,filey,filek;

 /////////////  set FOUR FILE NAME;  /////////////////////////
	strc=strs.Left(strs.GetLength()-4);
	strc=strc+"_c.bmp";
	strm=strs.Left(strs.GetLength()-4);
	strm=strm+"_m.bmp";	
	stry=strs.Left(strs.GetLength()-4);
	stry=stry+"_y.bmp";	
	strk=strs.Left(strs.GetLength()-4);
	strk=strk+"_k.bmp";

	bf.bfType=0x4d42;
	bf.bfSize=rh.BytesPerLine*rh.Height+2*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
	bf.bfReserved1=0;
	bf.bfReserved2=0;
	bf.bfOffBits=2*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
		
		bih.biBitCount=1;
		bih.biClrImportant=0;
		bih.biClrUsed=0;
		bih.biCompression=0;
		bih.biHeight=rh.Height;
		bih.biWidth=rh.Width;
		bih.biPlanes=1;
		bih.biSize=sizeof(BITMAPINFOHEADER);
		bih.biSizeImage=rh.BytesPerLine*rh.Height;
		bih.biXPelsPerMeter=(long)ceil(10000*rh.XDPI/254.0);
		bih.biYPelsPerMeter=(long)ceil(10000*rh.YDPI/254.0);
			
		color[0].rgbBlue=0xff;
		color[0].rgbGreen=0xff;
		color[0].rgbRed=0xff;
		color[0].rgbReserved=0;
		color[1].rgbBlue=0x0;
		color[1].rgbGreen=0x0;
		color[1].rgbRed=0x0;
		color[1].rgbReserved=0x0;

/////////////////////////////////////////////////////////////////////////////////////////////
		//	initialize four cfile object , the same time generate four CFile object.;
////////////////////////////////////////////////////////////////////////////////////////			

	LPBYTE lchar=new BYTE[rh.BytesPerLine];
	
	if(!filec.Open(strc,CFile::modeCreate|CFile::modeWrite))
		return false ;
	if(!filem.Open(strm,CFile::modeCreate|CFile::modeWrite))
		return false;
	if(!filey.Open(stry,CFile::modeCreate|CFile::modeWrite))
		return false ;
	if(!filek.Open(strk,CFile::modeCreate|CFile::modeWrite))
		return false;
	filec.Write(&bf,sizeof(BITMAPFILEHEADER));
	filem.Write(&bf,sizeof(BITMAPFILEHEADER));
	filey.Write(&bf,sizeof(BITMAPFILEHEADER));
	filek.Write(&bf,sizeof(BITMAPFILEHEADER));
	filec.Write(&bih,sizeof(BITMAPINFOHEADER));
	filem.Write(&bih,sizeof(BITMAPINFOHEADER));
	filey.Write(&bih,sizeof(BITMAPINFOHEADER));
	filek.Write(&bih,sizeof(BITMAPINFOHEADER));
	filec.Write(color,sizeof(color));
	filem.Write(color,sizeof(color));
	filey.Write(color,sizeof(color));
	filek.Write(color,sizeof(color));

	filec.Seek(62l,FILE_BEGIN);
	filem.Seek(62l,FILE_BEGIN);
	filey.Seek(62l,FILE_BEGIN);
	filek.Seek(62l,FILE_BEGIN);
//------------------------read from rip file begin to end------------------------------
/*	filer.Seek(sizeof(RipHeader),CFile::begin);
	for(DWORD i=0;i<rh.Height;i++)
	{   
		filer.Read(lchar,rh.BytesPerLine);		
		filey.Write(lchar,rh.BytesPerLine);
	   	filer.Read(lchar,rh.BytesPerLine);
		filem.Write(lchar,rh.BytesPerLine);
	   	filer.Read(lchar,rh.BytesPerLine);
		filec.Write(lchar,rh.BytesPerLine);
		filer.Read(lchar,rh.BytesPerLine);
		filek.Write(lchar,rh.BytesPerLine);
	}
*/
//-------------------read rip file from end to begin-----------------------------------
	
for(DWORD i=0;i<rh.Height;i++)
	{
		filer.Seek(-4*rh.BytesPerLine*(i+1),CFile::end);
		filer.Read(lchar,rh.BytesPerLine);		
		filey.Write(lchar,rh.BytesPerLine);
	   	filer.Read(lchar,rh.BytesPerLine);
		filem.Write(lchar,rh.BytesPerLine);
	   	filer.Read(lchar,rh.BytesPerLine);
		filec.Write(lchar,rh.BytesPerLine);
		filer.Read(lchar,rh.BytesPerLine);
		filek.Write(lchar,rh.BytesPerLine);
	}

	if(lchar)
	delete [] lchar;
	lchar=NULL;
	filec.Close();
	filem.Close();
	filey.Close();
	filek.Close();

	::SetCursor(LoadCursor( NULL,IDC_ARROW ));
	return true;

}

////////////////////////////////////////////////////////////////////////////////////////////
//------------- generate  color bmp file -------------------------------------------------------------
void CRip::Genercolor()
{
	colorstr=strs.Left(strs.GetLength()-4);
	colorstr=colorstr+"_color.bmp";
	CFile colorpic(colorstr,CFile::modeCreate|CFile::modeWrite);
//------------------------GET BITMAPFILEHEADER, BITMAPINFOHEADER-----------------------------
	BITMAPINFOHEADER bihcolor;
	BITMAPFILEHEADER bfhcolor;
                                                                                        
	bfhcolor.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
	bfhcolor.bfReserved1=0;
	bfhcolor.bfReserved2=0;
	bfhcolor.bfType=0x4d42;
                                                                      
	bihcolor.biBitCount=24;
	bihcolor.biClrImportant=0;
	bihcolor.biClrUsed=0;
	bihcolor.biCompression=BI_RGB; 
	bihcolor.biPlanes=1;
	bihcolor.biSize=sizeof(BITMAPINFOHEADER);
	bihcolor.biXPelsPerMeter=(long)ceil(10000*rh.XDPI/254.0);
	bihcolor.biYPelsPerMeter=(long)ceil(10000*rh.XDPI/254.0);
	bihcolor.biHeight=(long)(rh.Height/16.0);// height :pixel
	bihcolor.biWidth=rh.BytesPerLine/2; // width pixel 
	bihcolor.biSizeImage=((((rh.BytesPerLine/2)*24)+31)/32*4)*bihcolor.biHeight;

	bfhcolor.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+bihcolor.biSizeImage;
	colorpic.Write(&bfhcolor,sizeof(BITMAPFILEHEADER));
	colorpic.Write(&bihcolor,sizeof(BITMAPINFOHEADER));

	BYTE dotnum[256]={0};
	for(unsigned i=0;i<256;i++)
	{
		if(i&1)
			dotnum[i]++;
		if(i&2)
			dotnum[i]++;
		if(i&4)
			dotnum[i]++;
		if(i&8)
			dotnum[i]++;
		if(i&16)
			dotnum[i]++;
		if(i&32)
			dotnum[i]++;
		if(i&64)
			dotnum[i]++;
		if(i&128)
			dotnum[i]++;
	}	                                                                         

///////////////////////////////////////////////////////////////////////////////////////
	LPBYTE lpc=new BYTE[rh.BytesPerLine*16];
	LPBYTE lpm=new BYTE[rh.BytesPerLine*16];
	LPBYTE lpy=new BYTE[rh.BytesPerLine*16];
	LPBYTE lpk=new BYTE[rh.BytesPerLine*16];
	LPBYTE lpcolor=new BYTE[(((rh.BytesPerLine/2)*24)+31)/32*4];

	LPBYTE lpr,lpg,lpb,lpblack,lpic;	                                              
	BYTE grayrc=0,graygm=0,grayby=0,grayk=0;
//--------------- read rip file from begin to end -------------------------------------
/*
	for(DWORD x=0;x<rh.Height*4/64;x++)   //read 16 lines data each mono file
	{		
		filer.Seek(sizeof(RipHeader)+(x*64)*rh.BytesPerLine,CFile::begin);
*/
//--------------------  read rip file from end to begin -------------------------------

	for(DWORD x=0;x<rh.Height*4/64;x++)   //read 16 lines data each mono file
	{		
		filer.Seek(-64*(x+1)*rh.BytesPerLine,CFile::end);
 
//-------------------------------------------------------------------------------------
		 lpr=lpc,lpg=lpm,lpb=lpy,lpblack=lpk,lpic=lpcolor;
		for(int y=0;y<16;y++)
		{
		filer.Read(lpy+y*rh.BytesPerLine,rh.BytesPerLine);
		filer.Read(lpm+y*rh.BytesPerLine,rh.BytesPerLine);
		filer.Read(lpc+y*rh.BytesPerLine,rh.BytesPerLine);
		filer.Read(lpk+y*rh.BytesPerLine,rh.BytesPerLine);
		}                                                        

		 for(DWORD m=0;m<rh.BytesPerLine/2;m++) 
		 {
		for(int z=0;z<16;z++)  
		{
			grayrc+=dotnum[*(lpr+z*rh.BytesPerLine+m*2)];
			graygm+=dotnum[*(lpg+z*rh.BytesPerLine+m*2)];
			grayby+=dotnum[*(lpb+z*rh.BytesPerLine+m*2)];
			grayk+=dotnum[*(lpblack+z*rh.BytesPerLine+m*2)];

			grayrc+=dotnum[*(lpr+z*rh.BytesPerLine+m*2+1)];            
			graygm+=dotnum[*(lpg+z*rh.BytesPerLine+m*2+1)];
			grayby+=dotnum[*(lpb+z*rh.BytesPerLine+m*2+1)];	
			grayk+=dotnum[*(lpblack+z*rh.BytesPerLine+m*2+1)];
		}
		grayrc=255-grayrc;
		graygm=255-graygm;
		grayby=255-grayby;
		
		*lpic++=grayby;
		*lpic++=graygm;
		*lpic++=grayrc;
		grayrc=0,graygm=0,grayby=0,grayk=0;
		 }
		 colorpic.Write(lpcolor,(((rh.BytesPerLine/2)*24)+31)/32*4);
	}
                                                                 
	colorpic.Close();
	delete [] lpc;delete [] lpm;delete [] lpy;delete [] lpk;delete [] lpcolor;
	lpc=0;lpm=0;lpy=0;lpk=0,lpcolor=0;
}


/////////////////////////////////////////////////////////////////////////////////////////
/////////////// INITIALIZE PASS AND COUNT DATA MEMBER(first assume p is 3,4); ////////////////
////////////////////////////////////////////////////////////////////////////////////////

void CRip::SetPass(int p)
{
	pass=p;	                                              
		count=(ULONG)ceil((float)rh.Height/(500/pass))+(pass-1);	

}

////////////////////////////////////////////////////////////////////////////////////////
	///////////// INITIALIZE MEMORY ////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
void CRip::Initmemory()
{
				// cache 1.
	lpmemc1=new BYTE[(500/pass)*pass*rh.BytesPerLine];
	lpmemm1=new BYTE[(500/pass)*pass*rh.BytesPerLine];
	lpmemy1=new BYTE[(500/pass)*pass*rh.BytesPerLine];
	lpmemk1=new BYTE[(500/pass)*pass*rh.BytesPerLine];
	ZeroMemory(lpmemc1,(500/pass)*pass*rh.BytesPerLine);
	ZeroMemory(lpmemm1,(500/pass)*pass*rh.BytesPerLine);
	ZeroMemory(lpmemy1,(500/pass)*pass*rh.BytesPerLine);
	ZeroMemory(lpmemk1,(500/pass)*pass*rh.BytesPerLine);

			// cache 2.
	lpmemc2=new BYTE[500*rh.BytesPerLine];
	lpmemm2=new BYTE[500*rh.BytesPerLine];
	lpmemy2=new BYTE[500*rh.BytesPerLine];
	lpmemk2=new BYTE[500*rh.BytesPerLine];
	ZeroMemory(lpmemc2,500*rh.BytesPerLine);
	ZeroMemory(lpmemm2,500*rh.BytesPerLine);
	ZeroMemory(lpmemy2,500*rh.BytesPerLine);
	ZeroMemory(lpmemk2,500*rh.BytesPerLine);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////  from cache1 to 2 by change order of strip  /////////////////////////////////////////////////
void CRip::Mem1to2(DWORD i)
{
	int x;
	LPBYTE lbc=lpmemc2,lbm=lpmemm2,lby=lpmemy2,lbk=lpmemk2;
	for(x=0;x<pass;x++)
	{
	CopyMemory(lbc,lpmemc1+(i%pass)*(500/pass)*rh.BytesPerLine,(500/pass)*rh.BytesPerLine);

	CopyMemory(lbm,lpmemm1+(i%pass)*(500/pass)*rh.BytesPerLine,(500/pass)*rh.BytesPerLine);
		
	CopyMemory(lby,lpmemy1+(i%pass)*(500/pass)*rh.BytesPerLine,(500/pass)*rh.BytesPerLine);

	CopyMemory(lbk,lpmemk1+(i%pass)*(500/pass)*rh.BytesPerLine,(500/pass)*rh.BytesPerLine);

	lbc=lbc+(500/pass)*rh.BytesPerLine;
	lbm=lbm+(500/pass)*rh.BytesPerLine;
	lby=lby+(500/pass)*rh.BytesPerLine;
	lbk=lbk+(500/pass)*rh.BytesPerLine;
	i++;
	}
}

/////////////////////////////////////////////////////////////////////////////////
	/////////////  3 or 4 pass , i is loop count  ////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
				
void CRip::Pumpdot(DWORD i)
{	
	LPBYTE lbc2=lpmemc2,lbm2=lpmemm2,lby2=lpmemy2,lbk2=lpmemk2;

/////////////////  pass=3  /////////////////////////////////////////////
 if(pass==3)
 {
	if(i%3==0)	
	for(int x=0;x<500;x++)	
	for(DWORD y=0;y<rh.BytesPerLine;y++)
	{	
		if(y%3==0)
		{
		*lbc2=*(lbc2++)&0x92;
		*lbm2=*(lbm2++)&0x92;
		*lby2=*(lby2++)&0x92;
		*lbk2=*(lbk2++)&0x92;
		}
		else if(y%3==1)
		{
		*lbc2=*(lbc2++)&0x49;
		*lbm2=*(lbm2++)&0x49;
		*lby2=*(lby2++)&0x49;
		*lbk2=*(lbk2++)&0x49;
		}
	    else
		{
		*lbc2=*(lbc2++)&0x24;
		*lbm2=*(lbm2++)&0x24;
		*lby2=*(lby2++)&0x24;
		*lbk2=*(lbk2++)&0x24;
		}
	}

		else if(i%3==1)		
	for(int x=0;x<500;x++)	
	for(DWORD y=0;y<rh.BytesPerLine;y++)
	{