waku.cpp

用于自动商业集版的源代码

#include "stdafx.h"
#include "waku.h"
#include <fstream>
#include <string>
#include <assert.h>
#include <algorithm>

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

int nTotalputputcount = 0;
int globalinputt[10][12];
layoutpolicy policystatus;
int nglobaltitlenum = 0;
int nfullcolumnwakuaverage = 1;
int ncurpagenum = 0;
int bestresult = 0;
int nbakoffullcolumnwaku = 1;
int nfullcolumnintitlepage = 0;
int nfullcolumnleft = 0;

/////////////////////////////////////////////////////////////////////////////
// The one and only application object
wakuinterface::~wakuinterface()
{
	//cout<<"delete a wakuinterface"<<endl;
}
wakuinterface* basewaku::duplicate()
{
	basewaku* pret = NULL;
	pret = new basewaku(getheight(),getwidth(),getwidthscale());
	pret->setpos(xpos,ypos);
	return pret;
}

basewaku::~basewaku()
{ 
	//cout<<"delete a basewaku"<<endl;
}

bool basewaku::equal(wakuinterface* pwaku)
{
	return pwaku->equalbasewaku(this);
}

bool basewaku::equalbasewaku(wakuinterface* pwaku)
{
	int xpos1,xpos2,ypos1,ypos2;
	getpos(xpos1,ypos1);
	pwaku->getpos(xpos2,ypos2);
	if(getwidthscale()==pwaku->getwidthscale()&&
		getheight()==pwaku->getheight()&&
		getwidth()==pwaku->getwidth()&&
		xpos1==xpos2&&ypos1==ypos2)
		return TRUE;
	else
		return FALSE;
}

bool basewaku::equalcompositewaku(wakuinterface* pwaku)
{
	return false;
}

void basewaku::OutputResult(ofstream& out,int xorg,int yorg,bool beps)
{
	nTotalputputcount++;
	//globalinputt[nHeight-1][nWidth*nWidthScale-1]-=1;
	if(beps)
	{
		//out<<"gsave 0.7 setgray 0 0 moveto 0 0 "<<endl;
		out<<"gsave 0.7 setgray "<<xorg<<" "<<yorg<<" ";
		out<<nWidth<<" "<<nWidthScale<<" mul "<<" "<<nHeight<<" rectfill grestore"<<endl;
		//out<<"gsave 0.5 setgray 0 0 moveto 0 0 "<<endl;
		out<<"gsave 0.5 setgray "<<xorg<<" "<<yorg<<" ";
		out<<(nWidth*nWidthScale)<<" "<<nHeight<<" rectstroke grestore"<<endl;
	}else{
		out<<xorg<<" "<<yorg<<" "<<nHeight<<" "<<(nWidth*nWidthScale)<<endl;
	}
}

void compositewaku::OutputResult(ofstream& out,int xorg,int yorg,bool beps)
{
	vector< wakuinterface* >::iterator iter = wakupattern.begin();
	vector< wakuinterface* >::iterator iterend = wakupattern.end();
	int xpos,ypos;
	getpos(xpos,ypos);
	for(;iter!=iterend;++iter)
	{
		(*iter)->getpos(xpos,ypos);
		xpos*=(*iter)->getwidthscale();
		if(beps)
		{
			//out<<"gsave "<<xpos<<" "<<ypos<<" translate"<<endl;
			//(*iter)->OutputResult(out);
			out<<"gsave "<<endl;
			(*iter)->OutputResult(out,xorg+xpos,yorg+ypos,beps);
			out<<"grestore"<<endl;
		}else{
			(*iter)->OutputResult(out,xorg+xpos,yorg+ypos,beps);
		}
	}
}

compositewaku::~compositewaku()
{
	//cout<<"begin delete compositewaku"<<endl;
	vector< wakuinterface* >::iterator iter = wakupattern.begin();
	vector< wakuinterface* >::iterator iterend = wakupattern.end();
	for(;iter!=iterend;++iter)
	{
		delete (*iter);
	}
	//cout<<"end delete compositewaku"<<endl;
}
void compositewaku::getwakus(vector< wakuinterface* >& tmpwaku)
{
	if(wakupattern.begin()!=wakupattern.end())
	{
		tmpwaku.resize(wakupattern.size());
		copy(wakupattern.begin(),wakupattern.end(),tmpwaku.begin());
	}
}

bool compositewaku::isempty()
{
	vector< wakuinterface* >::iterator iter = wakupattern.begin();
	vector< wakuinterface* >::iterator iterend = wakupattern.end();
	return (iter==iterend);
}

wakuinterface* compositewaku::duplicate()
{
	compositewaku* pret = NULL;
	pret = new compositewaku();
	pret->nWidth = nWidth;
	pret->nHeight=nHeight;
	pret->nWidthScale=nWidthScale;
	pret->setpos(xpos,ypos);
	vector< wakuinterface* >::iterator iter = wakupattern.begin();
	vector< wakuinterface* >::iterator iterend = wakupattern.end();
	for(;iter!=iterend;++iter)
	{
		pret->wakupattern.push_back( (*iter)->duplicate());
	}
	return pret;
}

bool compositewaku::equal(wakuinterface* pwaku)
{
	return pwaku->equalcompositewaku(this);
}

bool compositewaku::equalbasewaku(wakuinterface* pwaku)
{
	return false;
}

bool compositewaku::equalcompositewaku(wakuinterface* pwaku)
{
	int xpos1,xpos2,ypos1,ypos2;
	getpos(xpos1,ypos1);
	pwaku->getpos(xpos2,ypos2);
	if(!(getwidthscale()==pwaku->getwidthscale()&&
		getheight()==pwaku->getheight()&&
		getwidth()==pwaku->getwidth()&&
		xpos1==xpos2&&ypos1==ypos2))
		return FALSE;
	compositewaku* pcompsite = (compositewaku*)pwaku;
	if(wakupattern.size()!=pcompsite->wakupattern.size())
		return false;

	vector< wakuinterface* >::iterator iter = wakupattern.begin();
	vector< wakuinterface* >::iterator iterend = wakupattern.end();
	vector< wakuinterface* >::iterator iter1 = pcompsite->wakupattern.begin();
	vector< wakuinterface* >::iterator iterend1 = pcompsite->wakupattern.end();
	for(;iter!=iterend&&iter1!=iterend1;++iter,++iter1)
	{
		if(!(*iter)->equal((*iter1)))
			return false;
	}
	return true;
}


int compositewaku::gettotalarea()
{
	int narea = 0;
	vector< wakuinterface* >::iterator iter = wakupattern.begin();
	vector< wakuinterface* >::iterator iterend = wakupattern.end();
	for(;iter!=iterend;++iter)
	{
		narea+=(*iter)->gettotalarea();
	}
	return narea;
}

int compositewaku::getbasicnum()
{
	int num = 0;
	vector< wakuinterface* >::iterator iter = wakupattern.begin();
	vector< wakuinterface* >::iterator iterend = wakupattern.end();
	for(;iter!=iterend;++iter)
	{
		num+=(*iter)->getbasicnum();
	}
	return num;
}
int compositewaku::gettotalspace()
{
	int narea = gettotalarea();
	narea = nWidth*nHeight-narea;
	return narea;
}

int compositewaku:: gettotalscaledarea()
{
	int narea = 0;
	vector< wakuinterface* >::iterator iter = wakupattern.begin();
	vector< wakuinterface* >::iterator iterend = wakupattern.end();
	for(;iter!=iterend;++iter)
	{
		narea+=(*iter)->gettotalscaledarea();
	}
	return narea;
}

int compositewaku::getscaledspace()
{
	int narea = gettotalscaledarea();
	narea = nWidth*nHeight*nWidthScale-narea;
	return narea;
}

void compositewaku::AddWaku(wakuinterface* pWaku)
{
	wakupattern.push_back(pWaku);
}

index::index(int w,int h)
{
	width = w;
	height = h;

	pindex = new int[w*h];
	int nIndex = w*h-1;
	for(int i = 0;i<h;i++)
	{
		for(int j = 0;j<w;j++)
		{
			pindex[i*w+j] = nIndex;
			nIndex--;
		}
	}

}

index::~index()
{
	//cout<<"begin delete index"<<endl;
	delete []pindex;
}

int index::getindex(int w,int h)
{
	int ret = 0;
	if(w>0&&w<=width&&h>0&&h<=height)
		ret =  pindex[(h-1)*width+w-1];
	return ret;
}

int wakuslot::gettotalarea()
{
	if(pPWaku==NULL)
		return 0;
	return GetTotal()*pPWaku->gettotalarea();
}

int wakuslot::gettotalscaledarea()
{
	if(pPWaku==NULL)
		return 0;
	return GetTotal()*pPWaku->gettotalscaledarea();
}

int wakuslot::gettotalspace()
{
	if(pPWaku==NULL)
		return 0;
	return GetTotal()*pPWaku->gettotalspace();
}

int wakuslot::getbasicnum()
{
	if(pPWaku==NULL)
		return 0;
	return GetTotal()*pPWaku->getbasicnum();
}

void wakubag::addwakuslot(std::vector< wakuslot* >& wakusinsert)
{
	vector< wakuslot* >::iterator iter = wakusinsert.begin();
	vector< wakuslot* >::iterator iterend = wakusinsert.end();
	for(;iter!=iterend;++iter)
	{
		vector< wakuslot* >::iterator iter1 = wakus.begin();
		vector< wakuslot* >::iterator iterend1 = wakus.end();
		for(;iter1!=iterend1;++iter1)
		{
			if((*(*iter1))==(*(*iter)))
			{
				(*iter1)->SetTotal((*iter1)->GetTotal()+(*iter)->GetTotal());
				(*iter1)->SetCurTotal((*iter1)->GetTotal());
				nTotal+=(*iter)->GetTotal();
				nCurTotal+=(*iter)->GetTotal();
				break;
			}
		}
		if(iter1==iterend1)
		{
			wakus.push_back(new wakuslot((*iter)->GetWidth(),(*iter)->GetHeight(),(*iter)->GetWidthScale(),(*iter)->GetTotal(),(*iter)->getwaku()->duplicate()));
			nTotal+=(*iter)->GetTotal();
			nCurTotal+=(*iter)->GetTotal();
		}
	}

}

wakubag::wakubag()
{
	nTotal = 0;
	nCurTotal = 0;
	nHeight = 0;
	nWidth = 0;
	nwscale = 0;
}

wakubag::~wakubag()
{
	//cout<<"begin delete wakubag"<<endl;
	vector< wakuslot* >::iterator iter = wakus.begin();
	vector< wakuslot* >::iterator iterend = wakus.end();
	for(;iter!=iterend;++iter)
	{
		delete (*iter);
	}
	//cout<<"end delete a wakubag!"<<endl;
}

void wakubag::removewakuslot(std::vector< wakuslot* >& wakusout,int num)
{
	vector< wakuslot* >::iterator iter = wakus.begin();
	vector< wakuslot* >::iterator iterend = wakus.end();
	nTotal-=num;
	nCurTotal-=num;
	for(;iter!=iterend;++iter)
	{
		if((*iter)->GetTotal()<num)
		{
			wakusout.push_back(new wakuslot((*iter)->GetWidth(),(*iter)->GetHeight(),(*iter)->GetWidthScale(),(*iter)->GetTotal(),(*iter)->getwaku()->duplicate()));
			num-=(*iter)->GetTotal();
			(*iter)->SetCurTotal(0);
			(*iter)->SetTotal(0);
		}else{
			wakusout.push_back(new wakuslot((*iter)->GetWidth(),(*iter)->GetHeight(),(*iter)->GetWidthScale(),num,(*iter)->getwaku()->duplicate()));
			(*iter)->SetTotal((*iter)->GetTotal()-num);
			(*iter)->SetCurTotal((*iter)->GetTotal());
			num = 0;
		}
	}
	if((*wakus.begin())->GetTotal()==0)
	{
		iter = remove_if(wakus.begin(),wakus.end(),equalvalue());
		vector< wakuslot* >::iterator tmp = iter;
		for(;tmp!=wakus.end();++tmp)
			delete (*tmp);
		wakus.erase(iter,wakus.end());
	}

}

int wakubag::gettotalarea()
{
	int narea = 0;
	vector< wakuslot* >::iterator iter = wakus.begin();
	vector< wakuslot* >::iterator iterend = wakus.end();
	for(;iter!=iterend;++iter)
	{
		narea+=(*iter)->gettotalarea();
	}
	return narea;
}

int wakubag::gettotalscaledarea()
{
	int narea = 0;
	vector< wakuslot* >::iterator iter = wakus.begin();
	vector< wakuslot* >::iterator iterend = wakus.end();
	for(;iter!=iterend;++iter)
	{
		narea+=(*iter)->gettotalscaledarea();
	}
	return narea;

}

int wakubag::gettotalspace()
{
	int nspace = 0;
	vector< wakuslot* >::iterator iter = wakus.begin();
	vector< wakuslot* >::iterator iterend = wakus.end();
	for(;iter!=iterend;++iter)
	{
		nspace+=(*iter)->gettotalspace();
	}
	return nspace;
}

int wakubag::getbasicnum()
{
	int nwakunum = 0;
	vector< wakuslot* >::iterator iter = wakus.begin();
	vector< wakuslot* >::iterator iterend = wakus.end();
	for(;iter!=iterend;++iter)
	{
		nwakunum+=(*iter)->getbasicnum();
	}
	return nwakunum;
}

bool operator==(wakubag& pa,wakubag& pb)
{
	return ((pa.getheight()==pb.getheight())&&(pa.getwidth()==pb.getwidth()));
}

wakubags::wakubags(int width,int height,int wscale)
{
	nwidth = width;
	nheight = height;
	nwscale = wscale;
	pindex = new index(width,height);
	pbags = new wakubag*[width*height];
	for(int i = 0;i<height;i++)
	{
		for(int j = 0;j<width;j++)
		{
			wakubag* pbag = new wakubag();
			pbag->setwidth(j+1);
			pbag->setheight(i+1);
			pbag->setwscale(wscale);
			int k = pindex->getindex(j+1,i+1);
			pbags[k] = pbag;
		}
	}
}

wakubags::~wakubags()
{
	//cout<<"begin delete bags"<<endl;
	for(int i = 0;i<nwidth*nheight;i++)
	{
		delete pbags[i];
	}
	delete pbags;
	delete pindex;
	//cout<<"end delete bags"<<endl;
}

void wakubags::addwakubag(wakubag* pwaku)
{
	if(pwaku->GetTotal()==0)
		return ;
	for(int i = 0;i<nwidth*nheight;i++)
	{
		if((*(pbags[i]))==(*pwaku))
		{
			vector< wakuslot* > wakus;
			pwaku->removewakuslot(wakus,pwaku->GetTotal());
			pbags[i]->addwakuslot(wakus);

			vector< wakuslot* >::iterator iter = wakus.begin();
			vector< wakuslot* >::iterator iterend = wakus.end();
			for(;iter!=iterend;++iter)
			{
				delete (*iter);
			}
			break;
		}
	}
}

int wakubags::gettotalscaledarea()
{
	int num = Itemnum();
	int narea = 0;
	for(int i = 0;i<num;i++)
	{
		narea+=pbags[i]->gettotalscaledarea();
	}
	return narea;
}

int wakubags::getbasicnum()
{
	int num = Itemnum();
	int nwakunum = 0;
	for(int i = 0;i<num;i++)
	{
		nwakunum+=pbags[i]->getbasicnum();
	}
	return nwakunum;
}

bool wakubags::HasContentToProcess(bagsvistinterface& vistor)
{
	int num = Itemnum();
	bool result = false;
	wakuinterface* presult;
	presult = NULL;
	vistor.baginfo(pbags,pindex);
	int i;
	do{
		for( i= vistor.getvistfrompos();i<num;i++)
		{
			if(pbags[i]->HasContentToProcess(&presult,vistor.canprocessfullcolumn()))
			{
				if(vistor.cansetwaku(presult))
				{
					vistor.lastvistindex(i);
					result = true;
					
				}
				break;
			}
			
		}
	}while(!result&&vistor.canvistoncemore(i));

	return result;
}

void wakubags::Processawaku(bagsvistinterface& vistor)
{
	int num = Itemnum();
	wakuinterface* presult;
	presult = vistor.getwaku();
	for(int i = vistor.getvistfrompos();i<num;i++)
	{
		if(pbags[i]->Processawaku(&presult))
			return;
	}
}

bool wakuslot::HasContentToProcess(wakuinterface** presult)
{
	if(nCurTotal>0)
	{
		*presult = pPWaku;