wzpoint.hxx

Delaunay三角形的网格剖分程序

#ifndef wzpoint_hxx
#define wzpoint_hxx

#ifndef wz_hxx
#include "wz.hxx"
#endif
#include "wzsafepointer.hxx"
#include "wzsegment.hxx"
#include "wzbox.hxx"

class	wzPoint;

const  	unsigned wzPointDim      = 3;
const  	unsigned wzPointDimFloat = 3;
const  	unsigned wzPointDimIndex = 1;
const  	unsigned wzPointDimFull  = 6; // == wzPointDim+wzPointDimFloat;

class wzPoint{
public:
  wzFloat       	X[wzPointDimFull];
  wzFloat  		operator[](unsigned i)  const {return X[i];}
  wzFloat&  		operator[](unsigned i)  {return X[i];}
  wzIndex    		I[wzPointDimIndex];
  wzSegment	     	S;
private:
  static 	wzIndex	Dim;
  static 	wzIndex	DimFloat;
  static 	wzIndex	DimIndex;
  static 	wzIndex	DimFull;
public:
  wzPoint(wzFloat x=0, wzFloat y=0, wzFloat z=0);
  wzPoint(const wzPoint&);
  wzPoint& operator=(const wzPoint&);
  wzFloat      	x()          const {return X[0];}
  wzFloat 	y()          const {return X[1];}
  wzFloat 	z()          const {return X[2];}
  wzFloat      	f()          const {return X[wzPointDim];}
  wzFloat 	g()          const {return X[wzPointDim+1];}
  wzFloat 	h()          const {return X[wzPointDim+2];}
  wzIndex 	i()          const {return I[0];}
  wzIndex 	j()          const {return I[1];}
  wzIndex 	k()          const {return I[2];}
  wzFloat     	f(int i)     const {return  ((wzFloat*)(X+wzPointDim))[i];}
  wzIndex      	i(int i)     const {return  ((wzIndex*)I)[i];}
  wzFloat&	x()          {return X[0];}
  wzFloat&	y()          {return X[1];}
  wzFloat&	z()          {return X[2];}
  wzFloat&	f()          {return X[wzPointDim];}
  wzFloat&	g()          {return X[wzPointDim+1];}
  wzFloat&	h()          {return X[wzPointDim+2];}
  wzIndex&	i()          {return I[0];}
  wzIndex&	j()          {return I[1];}
  wzIndex&	k()          {return I[2];}
  wzFloat&	f(int i)     {return  ((wzFloat*)(X+wzPointDim))[i];}
  wzIndex&	i(int i)     {return  ((wzIndex*)I)[i];}
  const wzSegment& segment()	const {return S;}
  wzSegment&   	segment()    	{return S;}
  operator      wzSegment() 	{return S;}
  wzIndex      	codim()      	const {return S.codim();}
  wzRegion	region() 	const {return S.region();}
  wzFace	face()   	const {return S.face();}
  wzEdge	edge()   	const {return S.edge();}
  wzVertex	vertex() 	const {return S.vertex();}
  wzBoolean	inRegion()	const {return S.isRegion();}
  wzBoolean	onFace()	const {return S.isFace();}
  wzBoolean	onEdge()	const {return S.isEdge();}
  wzBoolean	isVertex()	const {return S.isVertex();}
  // distances and equality:
  static wzFloat Epsilon;
  wzFloat      	distance(const wzPoint& p) const;
  wzPoint&     	operator*=(wzFloat f);
  wzPoint&     	operator+=(const wzPoint& p);
  wzPoint&     	operator-=(const wzPoint& p);
  wzFloat      	scalar(const wzPoint& p)  const;
  wzFloat      	scalar(const wzPoint& p0, const wzPoint& p1) const;
  wzFloat      	vector2(const wzPoint& p0, const wzPoint& p1) const;
  wzFloat  	operator*(const wzPoint& p)  const;
  wzBoolean	operator==(const wzPoint& p) const;
  wzBoolean	operator!=(const wzPoint& p) const;
  // equivalence
  wzBoolean	far( const wzPoint& p, wzFloat delta) const;
  wzBoolean	near(const wzPoint& p, wzFloat delta) const;
  void affine(wzFloat p, const wzPoint& p0, const wzPoint& p1);
  void print()	const;
  wzBoolean    	valid()       const {return S.valid();}
  wzBoolean    	invalid()     const {return S.invalid();}
  void          invalidate()  {S.invalidate();}
  //  static const wzIndex XOffset;
  void 		setFloatValues(unsigned i);
  void 		setIndexValues(unsigned i);
  void 		setSpaceDimension(unsigned i);
  unsigned	spaceDimension() const {return Dim;}
  unsigned	floatValues() const {return DimFloat;}
  unsigned	indexValues() const {return DimIndex;}
};

inline	wzPoint::wzPoint(wzFloat x, wzFloat y, wzFloat z)
:S(){X[0]=x;X[1]=y;X[2]=z;}

inline  wzPoint::wzPoint(const wzPoint& p)
:S(p.S)
{
  int i; 
  for(i=0;i<DimFull;i++) X[i] = p.X[i];
  for(i=0;i<DimIndex;i++) I[i] = p.I[i];
}

inline  wzPoint& wzPoint::operator=(const wzPoint& p)
{
  int i;
  for(i=0;i<DimFull;i++) X[i] = p.X[i]; 
  for(i=0;i<DimIndex;i++) I[i] = p.I[i];
  S=p.S; 
  return *this;
}

inline  wzFloat  wzPoint::distance(const wzPoint& p) const
{wzFloat       x  =  (X[0]>p[0])?(X[0]-p[0]):(p[0]-X[0]); 
 switch (Dim){
	case 3: x +=  (X[2]>p[2])?(X[2]-p[2]):(p[2]-X[2]);
	case 2: x +=  (X[1]>p[1])?(X[1]-p[1]):(p[1]-X[1]);
 } return x;
}

inline 	wzPoint& wzPoint::operator+=(const wzPoint& p)
{
  X[0]+=p.X[0]; X[1]+=p.X[1]; X[2]+=p.X[2];
  return *this;
}
inline 	wzPoint& wzPoint::operator-=(const wzPoint& p)
{
  X[0]-=p.X[0]; X[1]-=p.X[1]; X[2]-=p.X[2];
  return *this;
}
inline 	wzPoint& wzPoint::operator*=(wzFloat f)
{
  X[0]*=f; X[1]*=f; X[2]*=f;
  return *this;
}

inline  wzFloat  wzPoint::scalar(const wzPoint& p0, const wzPoint& p1) const
{wzFloat       x  =  (p0[0]-X[0]) * (p1[0]-X[0]); 
 switch (Dim){
	case 3: x +=  (p0[2]-X[2]) * (p1[2]-X[2]);
	case 2: x +=  (p0[1]-X[1]) * (p1[1]-X[1]);
 } return x;
}

inline  wzFloat  wzPoint::scalar(const wzPoint& p) const
{wzFloat       x  =  (p[0]) * (X[0]); 
 switch (Dim){
	case 3: x +=  (p[2]) * (X[2]);
	case 2: x +=  (p[1]) * (X[1]);
 } return x;
}

inline wzFloat scalar(const wzPoint& p0, const wzPoint& p1)
{return p0.scalar(p1);}

inline wzFloat wzPoint::operator*(const wzPoint& p) const 
{return scalar(p);}

inline 	wzBoolean wzPoint::operator==(const wzPoint& p) const
				{return distance(p) <=Epsilon;}
inline 	wzBoolean wzPoint::operator!=(const wzPoint& p) const
	        		{return !((*this)==p);}
inline 	wzBoolean wzPoint::far( const wzPoint& p, wzFloat delta) const
				{return distance(p) >= delta;}
inline 	wzBoolean wzPoint::near(const wzPoint& p, wzFloat delta) const
				{return distance(p) <  delta;}

inline  void 	wzPoint::setFloatValues(unsigned i)
{
  if(i>wzPointDimFull-wzPointDim){throw wzError("wzpointtest","baddim");}
  DimFloat=i; DimFull=wzPointDim+i;
}
inline  void 	wzPoint::setIndexValues(unsigned i) 
{
  if(i>wzPointDimIndex){throw wzError("wzpointtest","baddim");}DimIndex=i;
}
inline  void 	wzPoint::setSpaceDimension(unsigned i) 
{
  if(i>wzPointDim){throw wzError("wzpointtest","baddim");}Dim=i;
}

class wzPointList: 
  public wzProxyTarget, 
  public wzRange
{
public:
  int     spaceDim;
  int     fullDim;
  int     boxDim;
  int     fDim;
  wzArray<wzPoint> 	Point;
  wzArray<int>       	Near;
  wzFloat min[3];
  wzFloat max[3];
  wzPointList(char *filename);
  wzPointList(int dim=3,int fdim=0)
    :wzRange(sizeof(wzPoint)),spaceDim(dim),fullDim(dim+fdim),boxDim(0),fDim(fdim),
     Point(((wzRange*)this)->base),Near(*((wzRange*)this))
  {;}
  void computeBox();
  void setFloatValues(wzIndex fdim=0);
};

typedef wzProxy<wzPointList> wzpoints;
//typedef wzPointList*	wzpoints;

#define cogLoop wzRangeLoop
#endif