waku.h

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

//class for waku layout
#if !defined(FOUNDER_WAKU_H_)
#define FOUNDER_WAKU_H_

#include <vector>
using namespace std;
class wakuinterface
{
protected:
	int nWidth;
	int nHeight;
	int nWidthScale;
	int xpos;
	int ypos;
public:
	wakuinterface()
	{nWidth = 0;nHeight = 0;nWidthScale = 0;xpos = 0;ypos = 0;}
	virtual ~wakuinterface();
	virtual wakuinterface* duplicate()=0;
	virtual int getwidth(){return nWidth;};
	virtual void setwidth(int nset) { nWidth = nset;};
	virtual int getheight(){return nHeight;};
	virtual void setheight(int nset) { nHeight = nset;};
	virtual int getwidthscale(){return nWidthScale;};
	virtual void setwidthscale(int nset){nWidthScale = nset;};
	virtual void getpos(int& x,int& y){x = xpos;y = ypos;};
	virtual void setpos(int x,int y){xpos = x;ypos = y;};
	virtual int gettotalarea(){return 0;};
	virtual int gettotalspace(){ return 0;};
	virtual int gettotalscaledarea(){return 0;};
	virtual int getscaledspace(){return 0;};
	virtual bool equal(wakuinterface* pwaku)=0;
	virtual bool equalbasewaku(wakuinterface* pwaku)=0;
	virtual bool equalcompositewaku(wakuinterface* pwaku)=0;
	virtual int getbasicnum() = 0;
	virtual void OutputResult(ofstream& out,int xorg,int yorg,bool beps) = 0;
	virtual void getbasicwaku(vector< wakuinterface* >& vecwaku,int xorg,int yorg) = 0;
	virtual int getmaxwidth() = 0;
	virtual int getmaxwakuheight() = 0;
	virtual void symetry() = 0;
	virtual void getheighttype(vector<int>& vecint) = 0;
	virtual bool allbe_halfsizewaku() = 0;
};

class basewaku:public wakuinterface
{
	
public:
	basewaku(int height,int width,int widthscale)
	{
		setwidthscale( widthscale);
		setheight( height);
		setwidth(width);
	}
	~basewaku();

	int gettotalarea()
	{
		return getheight()*getwidth();
	}
	int gettotalscaledarea()
	{
		return getheight()*getwidth()*getwidthscale();
	}
	int getbasicnum() {return 1;};
	wakuinterface* duplicate();
	bool equal(wakuinterface* pwaku);
	bool equalbasewaku(wakuinterface* pwaku);
	bool equalcompositewaku(wakuinterface* pwaku);
	void OutputResult(ofstream& out,int xorg,int yorg,bool beps);
	void getbasicwaku(vector< wakuinterface* >& vecwaku,int xorg,int yorg);
	int getmaxwidth() { return nWidth*nWidthScale;};
	int getmaxwakuheight() {return getheight();};
	void symetry(){};
	void getheighttype(vector<int>& vecint);
	bool allbe_halfsizewaku();

};
bool comparexpos(wakuinterface* pwaku1,wakuinterface* pwaku2);
bool compareypos(wakuinterface* pwaku1,wakuinterface* pwaku2);
bool compareheight(wakuinterface* pwaku1,wakuinterface* pwaku2);

class compositewaku:public wakuinterface
{
	vector< wakuinterface* > wakupattern;
	void clearwaku();
	void sortwakuinfullsize();
	void sorthalfsize();
	void sortquarter();
	void sortxpos(int ncolumnsize);
	void sortsymetry();
	void matchpattern();
	

public:
	compositewaku(){};
	~compositewaku();
	wakuinterface* duplicate();
	void AddWaku(wakuinterface* pWaku);
	int gettotalarea();
	int gettotalspace();
	int gettotalscaledarea();
	int getscaledspace();
	bool equal(wakuinterface* pwaku);
	bool equalbasewaku(wakuinterface* pwaku);
	bool equalcompositewaku(wakuinterface* pwaku);
	void getwakus(vector< wakuinterface* >& tmpwaku);
	bool isempty();
	int getbasicnum();
	void OutputResult(ofstream& out,int xorg,int yorg,bool beps);
	void getbasicwaku(vector< wakuinterface* >& vecwaku,int xorg,int yorg);
	int getmaxwidth() {return 1;};
	int getmaxwakuheight();
	void sortwaku();
	void symetry();
	void getheighttype(vector<int>& vecint);
	bool allbe_halfsizewaku();
};


class wakuslot
{
	int nTotal;
	int nCurTotal;
	int nWidth;
	int nHeight;
	int nWidthScale;
	wakuinterface* pPWaku;
public:
	wakuslot()
	{
		nTotal = 0;nCurTotal = 0;
		pPWaku=NULL;
	}
	~wakuslot()
	{
		//cout<<"begin delete slot"<<endl;
		delete pPWaku;
		//cout<<"end delete slot"<<endl;
	}
	wakuslot(int Width,int Height,int WidthScale,int Total,wakuinterface* pset)
	{
		nTotal = Total;nCurTotal = Total;
		nWidth = Width;
		nHeight = Height;
		nWidthScale = WidthScale;
		pPWaku = pset;
	};

	wakuinterface* getwaku()
	{
		return pPWaku;
	}
	void setwaku(wakuinterface* pset)
	{
		pPWaku = pset;
	}
	int GetWidth() 
	{
		return nWidth;
	};
	int GetHeight() 
	{
		return nHeight;
	};
	int GetWidthScale(){return nWidthScale;};

	int GetTotal() {return nTotal;};
	int GetCurTotal() {return nCurTotal;};
	void SetCurTotal(int nSet) { nCurTotal = nSet;};
	void SetTotal(int nSet) { nTotal = nSet;};
	int gettotalarea();
	int gettotalscaledarea();
	int gettotalspace();
	int getbasicnum();
	bool HasContentToProcess(wakuinterface** presult);
	bool Processawaku(wakuinterface** presult);
	void debgout();
};

bool operator==(wakuslot& a,wakuslot& b)
{
	if(a.getwaku()!=NULL&&b.getwaku()!=NULL)
	{
		return a.getwaku()->equal(b.getwaku());
	}
	return false;
}

class wakubag
{
	int nTotal;
	int nCurTotal;
	int nwscale;
	int nHeight;
	int nWidth;
	std::vector< wakuslot* > wakus;

	class equalvalue
	{
	public:
		bool operator()(wakuslot* pwaku)
		{
			return (pwaku->GetTotal()==0);
		}
	};
public:
	wakubag();
	~wakubag();
	int GetTotal() {return nTotal;};
	int GetCurTotal() {return nCurTotal;};
	void SetCurTotal(int nSet) { nCurTotal = nSet;};
	void SetTotal(int nSet) { nTotal = nSet;};
	int  getwidth() { return nWidth;};
	void setwidth(int nset) { nWidth = nset;};
	int  getheight() {return nHeight;};
	void setheight(int nset) { nHeight = nset;};
	void setwscale(int nset){ nwscale = nset;};
	int getwscale() {return nwscale;};
	void addwakuslot(std::vector< wakuslot* >& wakus);
	void removewakuslot(std::vector< wakuslot* >& wakus,int num);
	int gettotalarea();
	int gettotalscaledarea();
	int gettotalspace();
	int getbasicnum();
	bool HasContentToProcess(wakuinterface** presult,bool canprocessbasic);
	bool Processawaku(wakuinterface** presult);
	void debgout();

};
bool operator==(wakubag& pa,wakubag& pb);


class index
{
	int width;
	int height;
	int * pindex;
public:
	index(int w,int h);
	~index();
	int getindex(int w,int h);
};

class bagsvistinterface
{
public:
	virtual ~bagsvistinterface() {};
	virtual wakuinterface* getwaku() = 0;
	virtual bool cansetwaku(wakuinterface* pwaku) = 0;
	virtual int getvistfrompos() = 0;
	virtual void layoutstatusoflastwaku(bool besuc) = 0;
	virtual void pageinfo(int pagewidth,int pageheight) = 0;
	virtual bool canvistoncemore(int ncueindex) = 0;
	virtual void beginonepage(int curpageheight) = 0;
	virtual void lastvistindex(int last) = 0;
	virtual void endpage(bool befull) = 0;
	virtual void baginfo(wakubag** pbags,index* pindex) = 0;
	virtual bool canprocessfullcolumn() = 0;

};
class bagsvistornormal:public bagsvistinterface
{
protected:
	bool bsuclasttime;
	int lastvist;
	bool bemaxwidth;
	wakuinterface* presult;
	int npagewidth;
	int npageheight;
	int npreferencewidth;
	int npreferenceheight;
	int lastpos;
	bool beinit;
	int curpageheight;
	int curfull;
	int maxfull;
public:
	~bagsvistornormal() {};
	bagsvistornormal()
	{ 
		bsuclasttime = true;lastvist = 0;curfull = 0;maxfull = 1;
		bemaxwidth = true;presult = NULL;npagewidth = 4;npageheight = 16;
		npreferencewidth = 0;npreferenceheight = 0;beinit = false;lastpos = 0;
	};
	wakuinterface* getwaku() { return presult;};
	bool cansetwaku(wakuinterface* pwaku);
	int getvistfrompos(){return lastvist;};
	void layoutstatusoflastwaku(bool besuc);
	void pageinfo(int pagewidth,int pageheight)
	{npagewidth = pagewidth;npageheight = pageheight;};
	void setpreferencewidth(int nset){npreferencewidth = nset;}
	void setpreferenceheight(int nset){npreferenceheight = nset;}
	bool canvistoncemore(int ncueindex);
	void beginonepage(int curpageheight);
	void lastvistindex(int last) {lastvist = last;};
	void endpage(bool befull) {};
	void baginfo(wakubag** pbags,index* pindex) ;
	bool canprocessfullcolumn();
};

class pattern3_1vistor:public bagsvistornormal
{
	vector<int> wakuvector1;
	vector<int> wakuvector3;
	int ncurpagedifference3;
	int ncurpagedifference1;
	bool beinitbag;
	int ntimes;
public:
	pattern3_1vistor()
	{ ncurpagedifference3 = 0;
	ncurpagedifference1 = 0;
	beinitbag = false;ntimes = 0;
	};
	bool cansetwaku(wakuinterface* pwaku);
	void baginfo(wakubag** pbags,index* pindex) ;
	bool canvistoncemore(int ncueindex);
	void beginonepage(int curpageheight);
	void layoutstatusoflastwaku(bool besuc);
	//bool canprocessfullcolumn() { return true;};
};

class pattern2_2vistor:public bagsvistornormal
{
	vector<int> wakuvector;
	int ncurpagedifferenceleft;
	int ncurpagedifferenceright;
	bool beinitbag;
	int ntimes;
public:
	pattern2_2vistor()
	{ ncurpagedifferenceleft = 0;
	ncurpagedifferenceright = 0;
	beinitbag = false;ntimes = 0;
	};
	bool cansetwaku(wakuinterface* pwaku);
	void baginfo(wakubag** pbags,index* pindex) ;
	bool canvistoncemore(int ncueindex);
	void beginonepage(int curpageheight);
	void layoutstatusoflastwaku(bool besuc);
	//bool canprocessfullcolumn() {return true;};
};

class wakubags
{
	wakubag** pbags;
	int nwidth;
	int nheight;
	int nwscale;
	index* pindex;
	/*
	int lastvist;
	bool bemaxwidth;
	int nmax;
	*/
public:
	wakubags(int width,int height,int wscale);
	~wakubags();
	void setwscale(int nset){ nwscale = nset;};
	int getwscale() {return nwscale;};
	int getheight() {return nheight;};
	int getwidth() {return nwidth;};
	int Itemnum () { return nwidth*nheight;};
	void addwakubag(wakubag* pwaku);
	bool HasContentToProcess(bagsvistinterface& vistor);
	void Processawaku(bagsvistinterface& vistor);
	//void resetvist() { lastvist = 0;bemaxwidth = true;};
	void getsubbags(wakubags& subbags,int nheight);
	void addsubbags(wakubags& subbags,int height);
	void exchangebags(wakubags& subbags,vector < pair<int,int> >& vecitem);
	wakubag* getwakubagatpos(int i);
	void setwakubagatpos(wakubag* pset,int i);
	int gettotalscaledarea();
	int getbasicnum();
	//void setmax(int nset) {nmax = nset;};
	void debgout();
	void addwakubags(wakubags& bags);
};

class BandLine
{
	int* posuse;
	int num;
public:
	BandLine(int nset);
	~BandLine();
	bool IsBlankAtPos(int x,int Width);
	void MarkLayout(int nWidth,int xpos);
	bool HaveBlankPos(int& xpos,int width);
};

class layoutpolicy
{
public:
	bool ignorevalidate;
	bool rightpreference;

};

class layoutrect
{
	int nwidth;
	int nheight;
	int nwscale;
	int nremainarea;
	bool bFull;
	compositewaku waku;
	BandLine** pBand;
	bool CanLayoutinner(int nWidth,int nHeight,int& xpos,int& ypos);
public:
	layoutrect(int width,int height,int wscale);
	~layoutrect();
	void setwscale(int nset){ nwscale = nset;};
	int getwscale() {return nwscale;};
	bool CanFindSpaceAtPos(int nWidth,int nHeight,int& xpos,int& ypos);
	bool InitSpace(int nWidth,int nHeight,int& xpos,int& ypos);
	bool ValidateSpace(int nWidth,int nHeight,int& xpos1,int& ypos1);
	bool CanAdjustPos(int nWidth,int nHeight,int& xpos,int& ypos);
	bool CanLayout(int nWidth,int nHeight,int& xpos,int& ypos);
	void OutputResult(ofstream& out,bool beps);
	int RemainArea();
	void SetBeFullOfWaku(bool bSet);
	bool BeFullOfWaku();
	void MarkLayout(int nWidth,int nHeight,int& xpos,int& ypos);
	bool LayoutAWaku(wakuinterface* pwaku);
	compositewaku* getwaku(){ return &waku;};


};

class layout
{
	vector< layoutrect* > Pages;
	int nHeight;
	int nWidth;
	int nheightbarrier;
	int nwidthbarrier;
public:
	layout(int height,int width,int hbarrier,int wbarrier);
	~layout();
	bool LayoutWakus(wakubags& Wakus,bool bfullonly,bagsvistinterface& vistor);
	void getlayoutrect(vector< layoutrect* >& result);
	void OutputResult(ofstream& out,bool beps);
	int TotalRemain();
	int GetFullUsedPageNums();
	void addonepage(layoutrect* ppage);
};
void initfromfile(const char* szfilename);
#endif // !defined(FOUNDER_WAKU_H_)