wzrange.hxx

Delaunay三角形的网格剖分程序

#ifndef wzrange_hxx
#define wzrange_hxx

#include "wzarray.hxx"

// this file defines the following classes:

class wzFixedRange;
class wzSimpleRange;
class wzRange;

class wzFixedRange: public wzMultipleArrayController{
public:
  wzIndex   none()              const {return 0;}
  wzIndex   first()             const {return 1;}
  wzIndex   begin()             const {return 1;}
  wzIndex   end() 		const {return Last+1;}
  wzIndex   last()              const {return Last;}
  wzIndex   length()            const {return Last;}
  wzIndex   create()		{if(Last<Max){require(++Last); return Last;} return 0;}
  wzIndex   append()		{if(Last<Max){require(++Last); return Last;} return 0;}
  wzIndex   create(wzIndex num)	
  {if(Last+num<=Max){wzIndex i=Last+1;    require(Last+=num); return i;  } return 0;}
  wzIndex   append(wzIndex num)
  {if(Last+num<=Max){wzIndex i=Last+1;    require(Last+=num); return i;  } return 0;}
  void      destroy() 		{Last=0; free();}
  void      reset() 		{Last=0;}
  wzBoolean used( wzIndex i)            const	{return 1;}
  wzBoolean valid(wzIndex i)            const	{return (i<=Last && i> 0);}
  wzBoolean invalid(wzIndex i)          const	{return (i >Last || i<=0);}
  //  wzBoolean operator()(wzIndex i)             {return create(i);}
  //  wzIndex   operator()(void)                  {return create();}
  operator wzIndex()	const {return Last;}
  wzIndex	operator++()	{return append();}
  void		operator++(int)	{append();}
  wzIndex	operator=(wzIndex l)	
  {if(l<Max && available(l)) Last=l; return Last;}
  wzFixedRange(wzIndex max, wzIndex size=sizeof(wzIndex));
  wzArray<wzByte> base;
protected:
  wzIndex Last;
  wzIndex Max;
};

class wzSimpleRange: public wzMultipleArrayController{
public:
  wzIndex   none()              const {return 0;}
  wzIndex   first()             const {return 1;}
  wzIndex   begin()             const {return 1;}
  wzIndex   end() 		const {return Last+1;}
  wzIndex   last()              const {return Last;}
  wzIndex   length()            const {return Last;}
  wzIndex   create()		{require(++Last); return Last;  }
  wzIndex   append()		{require(++Last); return Last;  }
  wzIndex   create(wzIndex num)	{wzIndex i=Last+1;    require(Last+=num); return i;  }
  wzIndex   append(wzIndex num)	{wzIndex i=Last+1;    require(Last+=num); return i;  }
  void      destroy() 		{Last=0; free();}
  void      reset() 		{Last=0;}
  wzBoolean used( wzIndex i)            const	{return 1;}
  wzBoolean valid(wzIndex i)            const	{return (i<=Last && i> 0);}
  wzBoolean invalid(wzIndex i)          const	{return (i> Last || i<=0);}
  //  wzBoolean operator()(wzIndex i)             {return create(i);}
  //  wzIndex   operator()(void)                  {return create();}
  operator wzIndex()	const {return Last;}
  wzIndex	operator++()	{return append();}
  void		operator++(int)	{append();}
  wzIndex	operator=(wzIndex l)	{if(available(l)) Last=l; return Last;}
  wzSimpleRange(wzIndex size=sizeof(wzIndex));
  wzArray<wzByte> base;
protected:
  wzIndex Last;
};

class wzRange: public wzMultipleArrayController{
  const wzIndex 	Mark;
  wzIndex		Unmark;
public:
  wzIndex   none()                      const {return 0;}
  wzIndex   first()                     const {return 1;}
  wzIndex   begin()                     const {return 1;}
  wzIndex   end() 			const {return Last+1;}
  wzIndex   last()                      const {return Last;}
  wzIndex   length()                    const {return Last;}
  wzBoolean valid(wzIndex i)            const;
  wzBoolean invalid(wzIndex i)          const;
  wzBoolean free( wzIndex i)            const	{return (Mark==M[i]);}
  wzBoolean used( wzIndex i)            const	{return (Mark!=M[i]);}
  
  wzIndex   create()
  {
    if(Free){wzIndex f=Free; Free=F[f]; unmark(f); return f;}
    require(++Last); return Last;
  }
  wzIndex   	append()  {    require(++Last); return Last;  }
  wzIndex   	create(wzIndex num)	{wzIndex i=Last+1;    require(Last+=num); return i;  }
  wzIndex   	append(wzIndex num)	{wzIndex i=Last+1;    require(Last+=num); return i;  }
  operator	wzIndex()	const {return Last;}
  wzIndex	operator++()	{return append();}
  void		operator++(int)	{append();}
  void      	reset() 	{Last=Free=0;}
  void      	destroy()      	{Last=Free=0; require(Last);}
  void      	destroy(wzIndex i);
  //  wzBoolean operator()(wzIndex i)             {return create(i);}
  //  wzIndex   operator()(void)                  {return create();}
  wzRange(wzIndex size=2*sizeof(wzIndex),wzIndex mark=0xdeffffff);
  wzArray<wzByte> base;
protected:
  wzIndex Last;
  wzIndex Free;
  //  wzIndex Moff;
  //  wzIndex Foff;
  wzArray<wzIndex> M;
  wzArray<wzIndex> F;
  void      mark  (wzIndex i)         {M[i]=Mark;}
  void      unmark(wzIndex i)         {M[i]=Unmark;}
};

#define wzRangeLoop(r,i) for(i=1;i<=(r).last();i++)if((r).used(i))

class wzStack{
protected:
friend class wzStackDerived;
  wzArray<wzIndex>	stack;
  wzIndex		first;
  wzIndex		last;
  wzIndex		end;
public:
  wzBoolean outside(wzIndex i) const {return (i<end)?stack[i]:1;}
  void push(wzIndex i) 
  {
    if(i>=end){for(int j=end;j<=i;j++)stack[j]=0;end=i+1;}
    else if(stack[i]) return;
    if(first)	{stack[i]=last; last=i;}
    else	{first=last=i; stack[i]=last;}
  }
  void append(wzIndex i) 
  {
    if(i>=end){for(int j=end;j<=i;j++)stack[j]=0;end=i+1;}
    else if(stack[i]) return;
    if(first)	{stack[first]=i; first=i;}
    else	{first=last=i;}
    stack[i] = last;
  }
  wzIndex pop() 
  {wzIndex i=last; if(i==first) first=last=0; else last = stack[i]; stack[i] = 0; return i;}
  wzIndex top() const {return last;}
  wzBoolean empty() const {return !last;}
  wzBoolean nonempty() const {return last;}
  wzStack(wzRange& r):stack(r),last(0),first(0),end(0){stack(0)=0;}
  wzStack(wzSimpleRange& r):stack(r),last(0),first(0),end(0){stack(0)=0;}
  wzStack(const wzRange& r):stack(r),last(0),first(0),end(0){stack(0)=0;}
  wzStack(const wzSimpleRange& r):stack(r),last(0),first(0),end(0){stack(0)=0;}
  wzStack(wzArray<wzIndex>& r, wzIndex off):stack(r,off),last(0),first(0),end(0){stack(0)=0;}
};

class wzStackDerived{
  wzArray<wzIndex>&	stack;
  wzIndex		first;
  wzIndex		last;
  wzIndex&		end;
public:
  wzBoolean outside(wzIndex i) const {return (i<end)?stack[i]:1;}
  void push(wzIndex i) 
  {
    if(i>=end){for(int j=end;j<=i;j++)stack[j]=0;end=i+1;}
    else if(stack[i]) return;
    if(first)	{stack[i]=last; last=i;}
    else	{first=last=i; stack[i]=last;}
  }
  void append(wzIndex i) 
  {
    if(i>=end){for(int j=end;j<=i;j++)stack[j]=0;end=i+1;}
    else if(stack[i]) return;
    if(first)	{stack[first]=i; first=i;}
    else	{first=last=i;}
    stack[i] = last;
  }
  wzIndex pop() 
  {wzIndex i=last; if(i==first) first=last=0; else last = stack[i]; stack[i] = 0; return i;}
  wzIndex top() const {return last;}
  wzBoolean empty() const {return !last;}
  wzBoolean nonempty() const {return last;}
  wzStackDerived(wzStack& r):stack(r.stack),last(0),first(0),end(r.end){}
};

inline wzBoolean wzRange::valid(wzIndex i) const
	{return (i<=last()) && (i>=first()) && (!Free || used(i));}
inline wzBoolean wzRange::invalid(wzIndex i) const
	{return (i>last()) || (i<first()) || (Free && free(i));}

inline void wzRange::destroy(wzIndex i)
{if(i==Last){Last--;
   while(Free==Last){if(Last)Last--;else return;Free=F[Free];} return;
 }
// if(Moff) return;
 mark(i);
// if(Foff) return;
 F[i]=Free; Free=i;
}

#endif