waku.cpp

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

bool pattern2_2vistor::cansetwaku(wakuinterface* pwaku)
{
	bool beresult = false;
	presult = pwaku;
	if((curpageheight!=16)&&pwaku->getmaxwidth()==12)
	{
		lastvist++;
		return false;
	}
	if((curpageheight==16)&&canprocessfullcolumn()&&(pwaku->getmaxwidth()!=12))
	{
		lastvist++;
		return false;
	}
	if(pwaku->getmaxwidth()==12&&canprocessfullcolumn())
	{
		return true;
	}

	if(ncurpagedifferenceright>ncurpagedifferenceleft)
	{
		if(!(ncurpagedifferenceright==0||ncurpagedifferenceright<pwaku->getheight()))
		{
			wakuvector[pwaku->getheight()-1]-=1;
			beresult = outputnumberseqiter(ncurpagedifferenceright-pwaku->getheight(),pwaku->getheight(),wakuvector);
			wakuvector[pwaku->getheight()-1]+=1;
			if(beresult)
				policystatus.rightpreference = true;
		}

		if(!beresult)
		{
			if(!(ncurpagedifferenceleft==0||ncurpagedifferenceleft<pwaku->getheight()))
			{
				wakuvector[pwaku->getheight()-1]-=1;
				beresult = outputnumberseqiter(ncurpagedifferenceleft-pwaku->getheight(),pwaku->getheight(),wakuvector);
				wakuvector[pwaku->getheight()-1]+=1;
			}
			if(!beresult)
				lastvist++;
			else
				policystatus.rightpreference = false;
		
		}
	}else{
		if(!(ncurpagedifferenceleft==0||ncurpagedifferenceleft<pwaku->getheight()))
		{
			wakuvector[pwaku->getheight()-1]-=1;
			beresult = outputnumberseqiter(ncurpagedifferenceleft-pwaku->getheight(),pwaku->getheight(),wakuvector);
			wakuvector[pwaku->getheight()-1]+=1;
			if(beresult)
				policystatus.rightpreference = false;
		}

		if(!beresult)
		{
			if(!(ncurpagedifferenceright==0||ncurpagedifferenceright<pwaku->getheight()))
			{
				wakuvector[pwaku->getheight()-1]-=1;
				beresult = outputnumberseqiter(ncurpagedifferenceright-pwaku->getheight(),pwaku->getheight(),wakuvector);
				wakuvector[pwaku->getheight()-1]+=1;
			}
			if(!beresult)
				lastvist++;
			else
				policystatus.rightpreference = true;
		
		}
	}

	return beresult;
}

void pattern2_2vistor::baginfo(wakubag** pbags,index* pindex) 
{
	if(beinitbag)
		return;
	ncurpagedifferenceleft = curpageheight;
	ncurpagedifferenceright = curpageheight;
	ntimes = 0;
	int count1 = 1;
	for(int i = 1;i<=npageheight;i++)
	{
		wakuvector.push_back(pbags[pindex->getindex(2,i)]->GetTotal());
		if(pbags[pindex->getindex(2,i)]->GetTotal()>0)
		{
			count1 = i;
			ntimes = max(ntimes,pindex->getindex(2,i));
		}
	}
	
	wakuvector.resize(count1);
	beinitbag = true;
}

bool pattern2_2vistor::canvistoncemore(int ncueindex)
{
	if(ncueindex<ntimes)
		return true;
	else
		return false;
}

void pattern2_2vistor::beginonepage(int ncurpageheight)
{
	policystatus.rightpreference = false;
	bsuclasttime = true;
	lastvist = 0;
	bemaxwidth = true;
	presult = NULL;
	beinitbag  = false;
	ntimes = 0;
	curpageheight = ncurpageheight;
	curfull = 0;
	maxfull = min(nfullcolumnleft,nfullcolumnwakuaverage);
}

void pattern2_2vistor::layoutstatusoflastwaku(bool besuc)
{
	if(besuc&&presult!=NULL)
	{
		if(presult->getmaxwidth()==12)
		{
			curfull++;
			if(curfull==maxfull)
				lastvist = 0;//reset.
			nfullcolumnleft--;
			if(nfullcolumnleft==0)
				maxfull = curfull;
			ncurpagedifferenceright-=presult->getheight();
			ncurpagedifferenceleft-=presult->getheight();
		}else{
			wakuvector[presult->getheight()-1]-=1;
			if(policystatus.rightpreference)
			{
				ncurpagedifferenceright-=presult->getheight();
			}
			else
			{
				ncurpagedifferenceleft-=presult->getheight();
			}
		}
	}
	bsuclasttime = besuc;
}

void layout::addonepage(layoutrect* ppage)
{
	layoutrect* ptmp = ppage;
	for(int i=0;i<Pages.size();i++)
	{
		ptmp = Pages[i];
		Pages[i] = ppage;
		ppage = ptmp;
	}
	Pages.push_back(ptmp);
}

bool comparexpos(wakuinterface* pwaku1,wakuinterface* pwaku2)
{
	int xpos1,ypos1,xpos2,ypos2;
	pwaku1->getpos(xpos1,ypos1);
	pwaku2->getpos(xpos2,ypos2);
	if(xpos1>xpos2)
		return false;
	else if(xpos1<xpos2)
		return true;
	else{
		if(ypos1>ypos2)
			return false;
		else
			return true;
	}
}

bool compareypos(wakuinterface* pwaku1,wakuinterface* pwaku2)
{
	int xpos1,ypos1,xpos2,ypos2;
	pwaku1->getpos(xpos1,ypos1);
	pwaku2->getpos(xpos2,ypos2);
	if(ypos1>ypos2)
		return false;
	else if(ypos1<ypos2)
		return true;
	else{
		if(xpos1>xpos2)
			return false;
		else
			return true;
	}
}

int curcolumnwidth = 1;
bool compareheight(wakuinterface* pwaku1,wakuinterface* pwaku2)
{
	if((pwaku1->getmaxwidth()==curcolumnwidth)&&(pwaku2->getmaxwidth()==curcolumnwidth))
	{
		return pwaku1->getmaxwakuheight()>=pwaku2->getmaxwakuheight();
	}
	else if(pwaku1->getmaxwidth()==curcolumnwidth)
	{
		return true;
	}
	else if(pwaku2->getmaxwidth()==curcolumnwidth)
	{
		return false;
	}
	else
	{
		return pwaku1->getmaxwakuheight()>pwaku2->getmaxwakuheight();
	}
}

void compositewaku::getbasicwaku(vector< wakuinterface* >& vecwaku,int xorg,int yorg)
{
	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();
		(*iter)->getbasicwaku(vecwaku,xorg+xpos,yorg+ypos);
	}
}

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

void basewaku::getbasicwaku(vector< wakuinterface* >& vecwaku,int xorg,int yorg)
{
	setpos(xorg,yorg);
	nWidth*=nWidthScale;
	nWidthScale = 1;
	vecwaku.push_back(this->duplicate());
}

void compositewaku::clearwaku()
{
	vector< wakuinterface* >::iterator iter = wakupattern.begin();
	vector< wakuinterface* >::iterator iterend = wakupattern.end();
	for(;iter!=iterend;++iter)
	{
		delete (*iter);
	}
	wakupattern.resize(0);
}

void compositewaku::sortwakuinfullsize()
{
	vector< wakuinterface* > wakubasicpattern;
	getbasicwaku(wakubasicpattern,0,0);
	clearwaku();
	
	stable_sort( wakubasicpattern.begin(),wakubasicpattern.end(),compareypos);
	//push a waku on the last for barrier
	basewaku* pwakubarrier = new basewaku(1,12,1);
	pwakubarrier->setpos(0,getheight());
	wakubasicpattern.push_back(pwakubarrier);

	vector< wakuinterface* >::iterator iter = wakubasicpattern.begin();
	vector< wakuinterface* >::iterator iterend = wakubasicpattern.end();
	vector< wakuinterface* >::iterator columniterbegin;
	vector< wakuinterface* >::iterator columniterend;
	int ncolumnwidth = 0;
	int nmaxwidth = 12;
	int nypos = 0;
	int nxpos = 0;
	int nyposlast = 0;
	int nyposcolumn = 0;
	columniterbegin = iter;
	for(;iter!=iterend;++iter)
	{
		(*iter)->getpos(nxpos,nypos);
		if(nxpos==0)
			columniterend = iter;
		if(nypos==nyposlast)
			ncolumnwidth+=(*iter)->getwidth();
		else{
			ncolumnwidth = (*iter)->getwidth();
			nyposlast = nypos;
		}
		if(ncolumnwidth==nmaxwidth)
		{//find a full column
			if(columniterbegin != columniterend)
			{
				wakuinterface* pwaku = NULL;
				int xtmppos,ytmppos;
				if((columniterend-columniterbegin)>1)
				{//multi waku
					compositewaku* pcompwaku = new compositewaku();
					pcompwaku->setheight(nyposlast-nyposcolumn);
					pcompwaku->setwidth(12);
					pcompwaku->setwidthscale(1);
					for(;columniterbegin!=columniterend;++columniterbegin)
					{
						pwaku = (*columniterbegin)->duplicate();
						pwaku->getpos(xtmppos,ytmppos);
						pwaku->setpos(xtmppos,ytmppos-nyposcolumn);
						pcompwaku->AddWaku(pwaku);
					}
					wakupattern.push_back(pcompwaku);
				}else{//single waku
					pwaku = (*columniterbegin)->duplicate();
					pwaku->getpos(xtmppos,ytmppos);
					pwaku->setpos(xtmppos,ytmppos-nyposcolumn);
					wakupattern.push_back(pwaku);
				}
				columniterbegin = columniterend;
				nyposcolumn = nyposlast;
			}
		}
	}
	{
		iter = wakubasicpattern.begin();
		iterend = wakubasicpattern.end();
		for(;iter!=iterend;++iter)
		{
			delete (*iter);
		}
	}
	curcolumnwidth = nmaxwidth;
	stable_sort( wakupattern.begin(),wakupattern.end(),compareheight);

	iter = wakupattern.begin();
	iterend = wakupattern.end();
	nyposcolumn = 0;
	for(;iter!=iterend;++iter)
	{
		(*iter)->getpos(nxpos,nypos);
		(*iter)->setpos(nxpos,nypos+nyposcolumn);
		nyposcolumn+=(*iter)->getheight();
	}

	//wakupattern.resize(wakubasicpattern.size());
	//copy(wakubasicpattern.begin(),wakubasicpattern.end(),wakupattern.begin());
}

void compositewaku::sortxpos(int ncolumnsize)
{
	vector< wakuinterface* > wakubasicpattern;
	getbasicwaku(wakubasicpattern,0,0);
	clearwaku();

	stable_sort( wakubasicpattern.begin(),wakubasicpattern.end(),comparexpos);
	//push a waku on the last for barrier
	basewaku* pwakubarrier = new basewaku(17,12,1);
	pwakubarrier->setpos(0,getheight());
	wakubasicpattern.push_back(pwakubarrier);

	vector< wakuinterface* >::iterator iter = wakubasicpattern.begin();
	vector< wakuinterface* >::iterator iterend = wakubasicpattern.end();
	vector< wakuinterface* >::iterator columniterbegin;
	int ncolumnwidth = ncolumnsize;
	int nypos = 0;
	int nxpos = 0;
	int nyposcolumn = 0;
	columniterbegin = iter;
	int nlastxpos = 0;
	wakuinterface* pwaku = NULL;
	int nlastypos  = 0;
	for(;iter!=iterend;++iter)
	{
		(*iter)->getpos(nxpos,nypos);
		if(nlastxpos==nxpos)
		{
			if(((*iter)->getwidth()!=ncolumnwidth)||(nypos!=nlastypos))
			{
				if((iter-columniterbegin)>0)
				{//multi waku
					if((iter-columniterbegin)>1)
					{
						(*columniterbegin)->getpos(nxpos,nypos);
						nyposcolumn = nypos;
						stable_sort( columniterbegin,iter,compareheight);
						for(;columniterbegin!=iter;++columniterbegin)
						{
							pwaku = (*columniterbegin)->duplicate();
							pwaku->getpos(nxpos,nypos);
							pwaku->setpos(nxpos,nyposcolumn);
							nyposcolumn+=pwaku->getheight();
							wakupattern.push_back(pwaku);
						}
					}else{
						pwaku = (*columniterbegin)->duplicate();
						wakupattern.push_back(pwaku);
					}
				}

				{//last waku not a halfsize
					if((*iter)->getheight()<17)
					{
						pwaku = (*iter)->duplicate();
						wakupattern.push_back(pwaku);
					}
				}
				columniterbegin = iter;
				++columniterbegin;//pass this waku

				if(columniterbegin!=iterend)
				{
					if(columniterbegin==iter)
						nlastypos=nypos+(*columniterbegin)->getheight();
					else{
						int x,y;
						(*columniterbegin)->getpos(x,y);
						nlastypos = y;
					}
				}
			}else{
				nlastypos+=(*iter)->getheight();
				assert(nlastypos==(nypos+(*iter)->getheight()));
			}

			
		}else{//process xposition change
			nlastxpos=nxpos;
			
			if((iter-columniterbegin)>0)
			{//multi waku
				if((iter-columniterbegin)>1)
				{
					(*columniterbegin)->getpos(nxpos,nypos);
					nyposcolumn = nypos;
					stable_sort( columniterbegin,iter,compareheight);
					for(;columniterbegin!=iter;++columniterbegin)
					{
						pwaku = (*columniterbegin)->duplicate();
						pwaku->getpos(nxpos,nypos);
						pwaku->setpos(nxpos,nyposcolumn);
						nyposcolumn+=pwaku->getheight();
						wakupattern.push_back(pwaku);
					}
				}else{
					pwaku = (*columniterbegin)->duplicate();
					wakupattern.push_back(pwaku);
				}
			}

			if((*iter)->getwidth()!=ncolumnwidth)
			{
				if((*iter)->getheight()<17)
				{
					pwaku = (*iter)->duplicate();
					wakupattern.push_back(pwaku);
				}
				columniterbegin = iter;
				++columniterbegin;//pass this waku
			}else{//process this waku later
				columniterbegin = iter;
			}
			if(columniterbegin!=iterend)
			{
				if(columniterbegin==iter)
					nlastypos=nypos+(*columniterbegin)->getheight();
				else{
					int x,y;
					(*columniterbegin)->getpos(x,y);
					nlastypos = y;
				}
			}
		}
	}

	iter = wakubasicpattern.begin();
	iterend = wakubasicpattern.end();
	for(;iter!=iterend;++iter)
	{
		delete (*iter);
	}
}

void compositewaku::sorthalfsize()
{
	sortxpos(6);
}

void compositewaku::sortquarter()
{
	sortxpos(3);
}

void compositewaku::sortsymetry()
{
	vector< wakuinterface* > wakubasicpattern;
	getbasicwaku(wakubasicpattern,0,0);
	clearwaku();
	
	stable_sort( wakubasicpattern.begin(),wakubasicpattern.end(),compareypos);
	//push a waku on the last for barrier
	basewaku* pwakubarrier = new basewaku(1,12,1);
	pwakubarrier->setpos(0,getheight());
	wakubasicpattern.push_back(pwakubarrier);

	vector< wakuinterface* >::iterator iter = wakubasicpattern.begin();
	vector< wakuinterface* >::iterator iterend = wakubasicpattern.end();
	vector< wakuinterface* >::iterator columniterbegin;
	vector< wakuinterface* >::iterator columniterend;
	int ncolumnwidth = 0;
	int nmaxwidth = 12;
	int nypos = 0;
	int nxpos = 0;
	int nyposlast = 0;
	int nyposcolumn = 0;
	columniterbegin = iter;
	for(;iter!=iterend;++iter)
	{
		(*iter)->getpos(nxpos,nypos);
		if(nxpos==0)
			columniterend = iter;
		if(nypos==nyposlast)
			ncolumnwidth+=(*iter)->getwidth();
		else{
			ncolumnwidth = (*iter)->getwidth();
			nyposlast = nypos;
		}
		if(ncolumnwidth==nmaxwidth)
		{//find a full column
			if(columniterbegin != columniterend)
			{
				wakuinterface* pwaku = NULL;
				int xtmppos,ytmppos;
				if((columniterend-columniterbegin)>1)
				{//multi waku
					compositewaku* pcompwaku = new compositewaku();
					pcompwaku->setheight(nyposlast-nyposcolumn);
					pcompwaku->setwidth(12);
					pcompwaku->setwidthscale(1);
					for(;columniterbegin!=columniterend;++columniterbegin)
					{
						pwaku = (*columniterbegin)->duplicate();
						pwaku->getpos(xtmppos,ytmppos);
						pwaku->setpos(xtmppos,ytmppos-nyposcolumn);
						pcompwaku->AddWaku(pwaku);
					}
					wakupattern.push_back(pcompwaku);
				}else{//single waku
					pwaku = (*columniterbegin)->duplicate();
					pwaku->getpos(xtmppos,ytmppos);
					pwaku->setpos(xtmppos,ytmppos-nyposcolumn);
					wakupattern.push_back(pwaku);
				}
				columniterbegin = columniterend;
				nyposcolumn = nyposlast;
			}
		}
	}
	{