ibgotype.cxx

Delaunay三角形的网格剖分程序

#include "ibgoctree.hxx"
#include "wzoutput.hxx"

const ibgIndex		ibgOctreeType::XDim = 3;

typedef enum {
  ldirp,ldirn,ldir0
}ibgBintreedirection;

typedef enum {
  ldirp0,ldir0p,ldirn0,ldir0n,ldir00,ldirxx
}ibgQuadtreedirection;

typedef enum {
  ldirp00,ldir0p0,ldir00p,ldirn00,ldir0n0,ldir00n,ldir000
}ibgOctreedirection;

typedef enum {
  pdirnn,pdirpn,pdirnp,pdirpp,pdir00
}ibgQuadtreePlanedirection;

typedef enum {
  pdirnn0,pdirpn0,pdirnp0,pdirpp0,
  pdirn0n,pdirn0p,pdirp0n,pdirp0p,
  pdir0nn,pdir0pn,pdir0np,pdir0pp,
  pdir000
}ibgOctreePlanedirection;

const ibgIndex		ibgOctree1D::Lines =  ldir0;
const ibgIndex		ibgOctree2D::Lines =  ldir00;
const ibgIndex		ibgOctree3D::Lines =  ldir000;
const ibgIndex		ibgOctree2D::Planes =  pdir00;
const ibgIndex		ibgOctree3D::Planes =  pdir000;
const ibgIndex		ibgOctree3D::Corners =  cdir000;
const ibgIndex		ibgOctree2D::PlaneCorners =  pdir00;
const ibgIndex		ibgOctree3D::PlaneCorners =  pdir00;
const ibgIndex		ibgOctree2D::LineSides =  2;
const ibgIndex		ibgOctree3D::LineSides =  4;
const ibgIndex		ibgOctree3D::PlaneSides =  2;
const ibgIndex		ibgOctree3D::firstCorner = cdirnnn;
const ibgIndex		ibgOctree3D::lastCorner = cdirppp;

static ibgQuadtreePlanedirection pReverse2D[pdir00] = {
  pdirpp,pdirnp,pdirpn,pdirnn
};

static ibgQuadtreePlanedirection pReverse3D[pdir000] = {
  pdirpp,pdirnp,pdirpn,pdirnn,
  pdirpp,pdirnp,pdirpn,pdirnn,
  pdirpp,pdirnp,pdirpn,pdirnn
};

static ibgQuadtreedirection pSide0_2D[pdir00] = {
  ldirn0,ldir0n,ldir0p,ldirp0
};
static ibgQuadtreedirection pSide1_2D[pdir00] = {
  ldir0n,ldirp0,ldirn0,ldir0p
};
static ibgOctreedirection pSide0_3D[pdir000] = {
  //ldirnn0,ldirpn0,ldirnp0,ldirpp0,
  //ldirn0n,ldirn0p,ldirp0n,ldirp0p,
  //ldir0nn,ldir0pn,ldir0np,ldir0pp 
  ldirn00,ldir0n0,ldir0p0,ldirp00,
  ldir00n,ldirn00,ldirp00,ldir00p,
  ldir0n0,ldir00n,ldir00p,ldir0p0 
};
static ibgOctreedirection pSide1_3D[pdir000] = {
  ldir0n0,ldirp00,ldirn00,ldir0p0,
  ldirn00,ldir00p,ldir00n,ldirp00,
  ldir00n,ldir0p0,ldir0n0,ldir00p 
};
static ibgOctreedirection pOrtho3D[pdir000] = {
  ldir00p,ldir00p,ldir00p,ldir00p,
  ldir0p0,ldir0p0,ldir0p0,ldir0p0,
  ldirp00,ldirp00,ldirp00,ldirp00
};


static ibgOctreeCornerDirection cReverse3D[8]= {
  cdirppp,cdirnpp,cdirpnp,cdirnnp,cdirppn,cdirnpn,cdirpnn,cdirnnn
};

static ibgIndex sOther2D[3] = {
  1,0,1
};

static ibgIndex sOther3D[5] = {
  2,3,0,1,2
};

// lsLine[up][i] == lsLine[down][i]
  
static ibgQuadtreedirection lsLine2D[ldir00][3] = {
  {ldir0p,ldir0n,ldir0p},	// ldirp0
  {ldirp0,ldirn0,ldirp0},	// ldir0p
  {ldir0p,ldir0n,ldir0p},	// ldirn0
  {ldirp0,ldirn0,ldirp0}	// ldir0n
};

static ibgOctreedirection lsLine3D[ldir000][5] = {
  {ldir0p0,ldir00n,ldir0n0,ldir00p,ldir0p0},	// ldirp00
  {ldir00p,ldirn00,ldir00n,ldirp00,ldir00p},	// ldir0p0
  {ldirp00,ldir0n0,ldirn00,ldir0p0,ldirp00},	// ldir00p
  {ldir0p0,ldir00n,ldir0n0,ldir00p,ldir0p0},	// ldirn00
  {ldir00p,ldirn00,ldir00n,ldirp00,ldir00p},	// ldir0n0
  {ldirp00,ldir0n0,ldirn00,ldir0p0,ldirp00}	// ldir00n
};

static ibgOctreedirection llOrtho3D[ldir000][ldir000]={
  {ldir000,ldir00p,ldir0n0,ldir000,ldir00n,ldir0p0},	// ldirp00
  {ldir00n,ldir000,ldirp00,ldir00p,ldir000,ldirn00},	// ldir0p0
  {ldir0p0,ldirn00,ldir000,ldir0n0,ldirp00,ldir000},	// ldir00p
  {ldir000,ldir00n,ldir0p0,ldir000,ldir00p,ldir0n0},	// ldirn00
  {ldir00p,ldir000,ldirn00,ldir00n,ldir000,ldirp00},	// ldir0n0
  {ldir0n0,ldirp00,ldir000,ldir0p0,ldirn00,ldir000}	// ldir00n
};
static ibgQuadtreePlanedirection llPlane2D[ldir00][ldir00]={
  {pdir00,pdirpp,pdir00,pdirpn},	// ldirp0
  {pdirpp,pdir00,pdirnp,pdir00},	// ldir0p
  {pdir00,pdirnp,pdir00,pdirnn},	// ldirn0
  {pdirpn,pdir00,pdirnn,pdir00}		// ldir0n
};

static ibgQuadtreedirection llOrtho2D[ldir00][ldir00]={
  {ldir00,ldirxx,ldir00,ldirxx},	// ldirp0
  {ldirxx,ldir00,ldirxx,ldir00},	// ldir0p
  {ldir00,ldirxx,ldir00,ldirxx},	// ldirn0
  {ldirxx,ldir00,ldirxx,ldir00}		// ldir0n
};

static ibgOctreePlanedirection llPlane3D[ldir000][ldir000]={
  {pdir000,pdirpp0,pdirp0p,pdir000,pdirpn0,pdirp0n},	// ldirp00
  {pdirpp0,pdir000,pdir0pp,pdirnp0,pdir000,pdir0pn},	// ldir0p0
  {pdirp0p,pdir0pp,pdir000,pdirn0p,pdir0np,pdir000},	// ldir00p
  {pdir000,pdirnp0,pdirn0p,pdir000,pdirnn0,pdirn0n},	// ldirn00
  {pdirpn0,pdir000,pdir0np,pdirnn0,pdir000,pdir0nn},	// ldir0n0
  {pdirp0n,pdir0pn,pdir000,pdirn0n,pdir0nn,pdir000}	// ldir00n
};

static ibgOctreeCornerDirection lsCell3D[ldir000][5]=
	{{cdirppp,cdirppn,cdirpnn,cdirpnp,cdirppp}
	,{cdirppp,cdirnpp,cdirnpn,cdirppn,cdirppp}
	,{cdirppp,cdirpnp,cdirnnp,cdirnpp,cdirppp}
	,{cdirnpp,cdirnpn,cdirnnn,cdirnnp,cdirnpp}
	,{cdirpnp,cdirnnp,cdirnnn,cdirpnn,cdirpnp}
	,{cdirppn,cdirpnn,cdirnnn,cdirnpn,cdirppn}
};

static ibgOctreeCornerDirection llCell3D[ldir000][ldir000]=
	{{cdir000,cdirppp,cdirpnp,cdir000,cdirpnn,cdirppn}
	,{cdirppn,cdir000,cdirppp,cdirnpp,cdir000,cdirnpn}
	,{cdirppp,cdirnpp,cdir000,cdirnnp,cdirpnp,cdir000}
	,{cdir000,cdirnpn,cdirnpp,cdir000,cdirnnp,cdirnnn}
	,{cdirpnp,cdir000,cdirnnp,cdirnnn,cdir000,cdirpnn}
	,{cdirpnn,cdirppn,cdir000,cdirnpn,cdirnnn,cdir000}
};

ibgOctreeType::ibgOctreeType(ibgIndex dim)
{int i,j,e,c,t;
 GridDim = LinesUp = dim;
 switch(dim){
 case 3:
   Lines = ibgOctree3D::Lines;
   Planes = ibgOctree3D::Planes;
   LineSides = ibgOctree3D::LineSides;
   PlaneSides = ibgOctree3D::PlaneSides;
   PlaneCorners = ibgOctree3D::PlaneCorners;
   Corners = ibgOctree3D::Corners;
   for(i=0;i<Planes;i++){
     pSide[0][i] = pSide0[i]   = (int) pSide0_3D[i];
     pSide[1][i] = pSide1[i]   = (int) pSide1_3D[i];
     pSide[2][i] = pOrtho[i]   = t = (int) pOrtho3D[i];
     pReverse[i] = j = (int) pReverse3D[i];
     ptReverse[j][t] = i;
   }
   for(j=0;j<=LineSides;j++){
     sOther[j] = sOther3D[j];
   }
   for(i=0;i<Lines;i++){
     for(j=0;j<Lines;j++){
       llPlane[i][j]= (int) llPlane3D[i][j];
       llOrtho[i][j]= (int) llOrtho3D[i][j];
       llCell[i][j] = (int) llCell3D[i][j];
       llSide[i][j] = 0;
     }
     for(j=0;j<=LineSides;j++){
       lsLine[i][j] = e = (int) lsLine3D[i][j];
       lsCell[i][j] = (int) lsCell3D[i][j];
       llSide[i][e] = j;
     }
   }
   for(i=0;i<Corners;i++){
     cReverse[i]= (int) cReverse3D[i];
   }
   for(i=0;i<Planes;i++){
     c = cReverse[llCell[pSide0[i]][pSide1[i]]];
     t = pOrtho[i];
     csPlane[c][t] = i;
     csPlaneSide[c][t] = 0;
     c = cReverse[llCell[pSide1[i]][pSide0[i]]];
     csPlane[c][t] = i;
     csPlaneSide[c][t] = 1;
   }
   break;
 case 2:
   Lines = ibgOctree2D::Lines;
   Planes = ibgOctree2D::Planes;
   LineSides = ibgOctree2D::LineSides;
   PlaneCorners = ibgOctree2D::PlaneCorners;
   PlaneSides = 0;
   Corners = 0;
   for(i=0;i<Planes;i++){
     pReverse[i] = ptReverse[i][0] = (int) pReverse2D[i];
     pSide[0][i] = pSide0[i]   = (int) pSide0_2D[i];
     pSide[1][i] = pSide1[i]   = (int) pSide1_2D[i];
     pSide[2][i] = pOrtho[i]   = 0;
   }
   for(j=0;j<=LineSides;j++){
     sOther[j] = sOther2D[j];
   }
   for(i=0;i<Lines;i++){
     for(j=0;j<=Lines;j++){
       llPlane[i][j]= (int) llPlane2D[i][j];
       llOrtho[i][j]= (int) llOrtho2D[i][j];
       llCell[i][j] = 0;
       llSide[i][j] = 0;
     }
     for(j=0;j<=LineSides;j++){
       lsLine[i][j] = e = (int) lsLine2D[i][j];
       llSide[i][e] = j;
     }
   }break;
 case 1:
   Lines = ibgOctree1D::Lines;
   for(i=0;i<Lines;i++){
     for(j=0;j<=Lines;j++){
       llPlane[i][j]= 0;
       llOrtho[i][j]= Lines;
       llCell[i][j] = 0;
       llSide[i][j] = 0;
     }
   }
   Planes = 0;
   Corners = 0;
   LineSides = 0;
   PlaneSides = 0;
   break;
 case 0:
   Lines = 0;
   Planes = 0;
   Corners = 0;
   LineSides = 0;
   PlaneSides = 0;
   break;
 }
 for(i=0;i<Lines;i++){
     for(j=0;j<=LineSides;j++){
       e = (int) lsLine[i][j];
       lsPlane[i][j]= (int) llPlane[i][e];
     }
 }
}