wzmap.hxx

Delaunay三角形的网格剖分程序

#ifndef wzmap_hxx
#define wzmap_hxx

#include "wzpoint.hxx"
#include "wzsafepointer.hxx"

class wzMap;

class wz1Dmap;
class wz2Dmap;
class wz3Dmap;

class wz1Dcoordinates;
class wz2Dcoordinates;
class wz3Dcoordinates;

typedef wzProxy<wzMap>   wzmap;
typedef wzProxy<wz1Dmap> wz1dmap;
typedef wzProxy<wz2Dmap> wz2dmap;
typedef wzProxy<wz3Dmap> wz3dmap;

class wzMap: public wzProxyTarget{
protected:
  wzIndex   	Dim;   	   	// space dimension
  wzIndex   	DimLocal;   	// original, local space dimension
  wzIndex    	Properties;
  wzmap     	base;   	// for safe pointer handling
  wzMap*   	Base;   	// for fast access
public:
  wzName   	name;
  wzBox    	full;    	// contains full domain of definition
  wzBox    	chart;    	// contains homeomorphic domain of definition
  wzBox    	image;    	// contains the image of chart
  virtual void operator()(wzFloat *x, const wzFloat *u) const=0;
  virtual void inverse   (wzFloat *u, const wzFloat *x) const;
  wzIndex   dimension()         const {return Dim;}
  wzIndex   imageDimension()    const {return Dim;}
  wzIndex   preimageDimension() const {return DimLocal;}
  wzBoolean isInvertible()      const;
  wzBoolean isInvertibleLeft()  const;
  wzBoolean isInvertibleRight() const;
  wzBoolean isRectangular() const;
  wzBoolean isOrthogonal()  const;
  wzBoolean isConformal()   const;
  wz1dmap   map1D() const;
  wz2dmap   map2D() const;
  wz3dmap   map3D() const;
  wzMap(wzIndex d, int dl=-1);
  wzMap(wzmap base);
  void compose(wzmap base=0);
  void call(wzFloat *x, const wzFloat *u) const{operator()(x,u);}
  //  void call(wzFloat *x) const{operator()(x);}
  //  virtual void operator()(wzFloat *x) const=0;
  virtual void callDirect(wzFloat *x) const=0;
  virtual void callInverse   (wzFloat *u) const=0;
  void dx(const wzFloat *x, wzFloat *dx0=0,  wzFloat *dx1=0,  wzFloat *dx2=0) const;
  ~wzMap();
  virtual void print() const;
  void test() const;
};

#define wzMapPreprocessing(x,u)\
  wzFloat xtmp[3],utmp[3],*X; const wzFloat *U;\
  preprocessing(&X,x,xtmp,&U,u,utmp)
#define wzMapPostprocessing(x) postprocessing(x,X)
#define wzMapInversePreprocessing(u,x)\
  wzFloat utmp[3],xtmp[3],*U; const wzFloat *X;\
  inversePreprocessing(&U,u,utmp,&X,x,xtmp)
#define wzMapInversePostprocessing(u) inversePostprocessing(u,U)

typedef wzIndex wzAffineTransformationMode;
const wzAffineTransformationMode  wzAffineNone	= 0;
const wzAffineTransformationMode  wzAffineShift	= 1;
const wzAffineTransformationMode  wzAffineStretchShift	= 2;
const wzAffineTransformationMode  wzAffineGeneral	= 3;

class wz3Dmap
  :public wzMap
{
public:
  void shift(wzFloat sx, wzFloat sy, wzFloat sz);
  void stretch(wzFloat fx);
  void stretchAnisotropic(wzFloat fx, wzFloat fy=1, wzFloat fz=1);
  void switchXY();
  void switchXZ();
  void switchYZ();
  void rotateX(wzFloat phi);
  void rotateY(wzFloat phi);
  void rotateZ(wzFloat phi);
  void rotateXY(wzFloat phi) {rotateZ(phi);}
  void rotateYZ(wzFloat phi) {rotateX(phi);}
  void rotateZX(wzFloat phi) {rotateY(phi);}
  void rotateYX(wzFloat phi) {rotateZ(-phi);}
  void rotateZY(wzFloat phi) {rotateX(-phi);}
  void rotateXZ(wzFloat phi) {rotateY(-phi);}
  wz3Dmap(wz3dmap base=0, int localDim=-1);
  virtual void print() const;
  void callDirect(wzFloat *x) const;
  void callInverse   (wzFloat *u) const;
  void compose(wz3dmap base=0);
  virtual void operator()(wzFloat *x, const wzFloat *u) const=0;
  virtual void inverse(   wzFloat *u, const wzFloat *x) const;
  virtual void dx(const wzFloat *x, wzFloat *dx0,  wzFloat *dx1,  wzFloat *dx2) const;
protected:
  wzAffineTransformationMode	Mode;
  wzBoolean   	SingleMode;
  wzFloat     	Full[4][4];
  wzFloat     	Reverse[4][4];
  wzFloat     	Shift[3];
  wzFloat     	Factor[3];
  void preprocessing (wzFloat **X, wzFloat *x, wzFloat *xx,
	      	      const wzFloat **U, const wzFloat *u, wzFloat *uu) const;
  void postprocessing(wzFloat *x, wzFloat *X) const;
};

class wz2Dmap: public wzMap
{
public:
  void shift(wzFloat sx, wzFloat sy);
  void stretch(wzFloat fx);
  void stretchAnisotropic(wzFloat fx, wzFloat fy);
  void switchXY();
  void rotate(wzFloat phi);
  wz2Dmap(wz2dmap base=0, int localDim=2);
  virtual void print() const;
  void callDirect(wzFloat *x) const;
  void callInverse   (wzFloat *u) const;
  //  void operator()(wzFloat *x) const;
  //  void inverse   (wzFloat *u) const;
  void compose(wz2dmap base=0);
  virtual void operator()(wzFloat *x, const wzFloat *u) const=0;
  virtual void inverse(   wzFloat *u, const wzFloat *x) const;
  virtual void dx(const wzFloat *x, wzFloat *dx0,  wzFloat *dx1) const;
protected:
  wzAffineTransformationMode	Mode;
  wzBoolean 	SingleMode;
  wzFloat	Full[3][3];
  wzFloat	Reverse[3][3];
  wzFloat	Shift[2];
  wzFloat	Factor[2];
  void preprocessing (wzFloat **X, wzFloat *x, wzFloat *xx,
		      const wzFloat **U, const wzFloat *u, wzFloat *uu) const;
  void postprocessing(wzFloat *x, wzFloat *X) const;
};

class wz1Dmap: public wzMap
{
public:
  void shift(wzFloat sx, wzFloat sy);
  void shift(wzFloat sx);
  void stretch(wzFloat fx);
  wz1Dmap(wz1dmap base=0, int localDim=1);
  virtual void print() const;
  void callDirect	(wzFloat *x) const;
  void callInverse	(wzFloat *u) const;
  //  void operator()(wzFloat *x) const;
  //  void inverse   (wzFloat *u) const;
  void compose(wz1dmap base=0);
  virtual void operator()(wzFloat *x, const wzFloat *u) const=0;
  virtual void inverse(   wzFloat *u, const wzFloat *x) const;
  virtual void dx(const wzFloat *x, wzFloat *dx0) const;
protected:
  wzAffineTransformationMode	Mode;
  wzFloat	Shift;
  wzFloat	Factor;
  void preprocessing (wzFloat **X, wzFloat *x, wzFloat *xx,
		      const wzFloat **U, const wzFloat *u, wzFloat *uu) const;
  void postprocessing(wzFloat *x, wzFloat *X) const;
};

class wz3Dcoordinates: public wz3Dmap
{
public:
  virtual void operator()(wzFloat *x, const wzFloat *u) const;
  virtual void inverse(   wzFloat *u, const wzFloat *x) const;
  void inversePreprocessing(wzFloat **U, wzFloat *u, wzFloat *uu,
 	        const wzFloat **X, const wzFloat *x, wzFloat *xx) const;
  void inversePostprocessing(wzFloat *u, wzFloat *U) const;
  wz3Dcoordinates(wz3dmap base=0);
  virtual void print() const;
};

class wz2Dcoordinates: public wz2Dmap
{
public:
  virtual void operator()(wzFloat *x, const wzFloat *u) const;
  virtual void inverse(   wzFloat *u, const wzFloat *x) const;
  void inversePreprocessing(wzFloat **U, wzFloat *u, wzFloat *uu,
	        const wzFloat **X, const wzFloat *x, wzFloat *xx) const;
  void inversePostprocessing(wzFloat *u, wzFloat *U) const;
  wz2Dcoordinates(wz2dmap base=0);
  virtual void print() const;
};

class wz1Dcoordinates: public wz1Dmap
{
public:
  virtual void operator()(wzFloat *x, const wzFloat *u) const;
  virtual void inverse(   wzFloat *u, const wzFloat *x) const;
  void inversePreprocessing(wzFloat **U, wzFloat *u, wzFloat *uu,
	        const wzFloat **X, const wzFloat *x, wzFloat *xx) const;
  void inversePostprocessing(wzFloat *u, wzFloat *U) const;
  wz1Dcoordinates(wz1dmap base=0);
  virtual void print() const;
};

inline void wz3Dmap::preprocessing(wzFloat **X, wzFloat *x, wzFloat *xx,
   	               const wzFloat **U, const wzFloat *u, wzFloat *uu)const
{*X=SingleMode?x:xx;*U=Base?(*Base)(uu,u),uu:u;}

inline void wz2Dmap::preprocessing(wzFloat **X, wzFloat *x, wzFloat *xx,
   	               const wzFloat **U, const wzFloat *u, wzFloat *uu)const
{*X=SingleMode?x:xx;*U=Base?(*Base)(uu,u),uu:u;}
//{X=SingleMode?x:xx;if(Base)(*Base)(uu,u),U=uu;else U=u;}
inline void wz1Dmap::preprocessing(wzFloat **X, wzFloat *x, wzFloat *xx,
   	               const wzFloat **U, const wzFloat *u, wzFloat *uu)const
{*X=x;*U=Base?(*Base)(uu,u),uu:u;}
//{X=x;if(Base)(*Base)(uu,u),U=uu;else U=u;}

inline  void  wz3Dmap::postprocessing(wzFloat *x, wzFloat *X) const
{
  int i,j;
  switch(Mode){
  case wzAffineGeneral:
    for(i=0;i<3;i++){
      x[i] = Full[i][3];
      for(j=0;j<3;j++) x[i] += Full[i][j]*X[j];
    } break;
  case wzAffineStretchShift:
    x[0] *= Factor[0];   x[1] *= Factor[1];   x[2] *= Factor[2];
  case wzAffineShift:
    x[0] += Shift[0];    x[1] += Shift[1];    x[2] += Shift[2];
  }
}

inline  void  wz2Dmap::postprocessing(wzFloat *x, wzFloat *X) const
{
  int i,j;
  switch(Mode){
  case wzAffineGeneral:
    for(i=0;i<2;i++){
      x[i] = Full[i][2];
      for(j=0;j<2;j++) x[i] += Full[i][j]*X[j];
    } break;
  case wzAffineStretchShift:
    x[0] *= Factor[0];   x[1] *= Factor[1];
  case wzAffineShift:
    x[0] += Shift[0];    x[1] += Shift[1];
  }
}

inline  void  wz1Dmap::postprocessing(wzFloat *x, wzFloat *X) const
{
  switch(Mode){
  case wzAffineStretchShift:
    x[0] *= Factor;
  case wzAffineShift:
    x[0] += Shift;
  }
}

inline void wz3Dcoordinates::inversePreprocessing
  (wzFloat **U, wzFloat *u, wzFloat *uu,
   const wzFloat **X, const wzFloat *x, wzFloat *xx) const
{
  *U=(Base)?uu:u;
  int i,j;
  switch(Mode){
  case wzAffineGeneral:
    for(i=0;i<3;i++){
      xx[i] = Reverse[i][3];
      for(j=0;j<3;j++) xx[i] += Reverse[i][j]*x[j];
    }*X=xx;  break;
  case wzAffineStretchShift:
    xx[0] = x[0]-Shift[0];  xx[1] = x[1]-Shift[1];  xx[2] = x[2]-Shift[2];
    xx[0] /= Factor[0];     xx[1] /= Factor[1];     xx[2] /= Factor[2];
    *X=xx; break;
  case wzAffineShift:
    xx[0] = x[0]-Shift[0];  xx[1] = x[1]-Shift[1];  xx[2] = x[2]-Shift[2];
    *X=xx; break;
  case wzAffineNone:
    *X=x;
  }
}

inline void wz2Dcoordinates::inversePreprocessing
  (wzFloat **U, wzFloat *u, wzFloat *uu,
   const wzFloat **X, const wzFloat *x, wzFloat *xx) const
{
  *U=(Base)?uu:u;
  int i,j;
  switch(Mode){
  case wzAffineGeneral:
    for(i=0;i<2;i++){
      xx[i] = Reverse[i][2];
      for(j=0;j<2;j++) xx[i] += Reverse[i][j]*x[j];
    }*X=xx;  break;
  case wzAffineStretchShift:
    xx[0] = x[0]-Shift[0];  xx[1] = x[1]-Shift[1];
    xx[0] /= Factor[0];     xx[1] /= Factor[1];
    *X=xx; break;
  case wzAffineShift:
    xx[0] = x[0]-Shift[0];  xx[1] = x[1]-Shift[1];
    *X=xx; break;
  case wzAffineNone:
    *X=x;
  }
}

inline void wz1Dcoordinates::inversePreprocessing
  (wzFloat **U, wzFloat *u, wzFloat *uu,
   const wzFloat **X, const wzFloat *x, wzFloat *xx) const
{
  *U=(Base)?uu:u;
  switch(Mode){
  case wzAffineStretchShift:
    xx[0] = x[0]-Shift;
    xx[0] /= Factor;
    *X=xx; break;
  case wzAffineShift:
    xx[0] = x[0]-Shift;
    *X=xx; break;
  case wzAffineNone:
    *X=x;
  }
}

const wzIndex wzMapPropertyInvertibleRight = 0x01;
const wzIndex wzMapPropertyInvertibleLeft  = 0x02;
const wzIndex wzMapPropertyInvertible      = 0x04;
const wzIndex wzMapPropertyOrthogonal      = 0x08;
const wzIndex wzMapPropertyRectangular     = 0x10;
const wzIndex wzMapPropertyConformal       = 0x20;

const wzIndex wzIsCoordinate               = 0x07;
const wzIndex wzIsCoordinateOrthogonal     = 0x0f;
const wzIndex wzIsCoordinateRectangular    = 0x1f;
const wzIndex wzIsCoordinateConformal      = 0x2f;
const wzIndex wzIsCoordinateCarthesian     = 0x3f;

inline void wz3Dcoordinates::inversePostprocessing(wzFloat *u,wzFloat *U)const
{if(Base)Base->inverse(u,U);}
inline void wz2Dcoordinates::inversePostprocessing(wzFloat *u,wzFloat *U)const
{if(Base)Base->inverse(u,U);}
inline void wz1Dcoordinates::inversePostprocessing(wzFloat *u,wzFloat *U)const
{if(Base)Base->inverse(u,U);}

#endif