Classes | Public Types | Public Member Functions | Public Attributes | Static Public Attributes | List of all members
tetgenmesh Class Reference

#include <tetgen.h>

Classes

class  arraypool
 
struct  badface
 
class  elemflip
 
class  face
 
class  list
 
class  memorypool
 
struct  pbcdata
 
class  queue
 
class  triface
 

Public Types

enum  { FILENAMESIZE = 1024 }
 
enum  { VERPERBLOCK = 4092 , SUBPERBLOCK = 4092 , ELEPERBLOCK = 8188 }
 
enum  { SAMPLEFACTOR = 11 }
 
enum  { CCW = 0 , CW = 1 }
 
enum  wordtype { POINTER , FLOATINGPOINT }
 
enum  verttype {
  UNUSEDVERTEX , DUPLICATEDVERTEX , NACUTEVERTEX , ACUTEVERTEX ,
  FREESEGVERTEX , FREESUBVERTEX , FREEVOLVERTEX , DEADVERTEX = -32768
}
 
enum  shestype { NSHARP , SHARP }
 
enum  fliptype {
  T23 , T32 , T22 , T44 ,
  N32 , N40 , FORBIDDENFACE , FORBIDDENEDGE
}
 
enum  interresult {
  DISJOINT , INTERSECT , SHAREVERTEX , SHAREEDGE ,
  SHAREFACE , TOUCHEDGE , TOUCHFACE , INTERVERT ,
  INTEREDGE , INTERFACE , INTERTET , TRIEDGEINT ,
  EDGETRIINT , COLLISIONFACE , INTERSUBSEG , INTERSUBFACE ,
  BELOWHULL2
}
 
enum  locateresult {
  INTETRAHEDRON , ONFACE , ONEDGE , ONVERTEX ,
  OUTSIDE , ENCSEGMENT
}
 
enum  insertsiteresult {
  SUCCESSINTET , SUCCESSONFACE , SUCCESSONEDGE , DUPLICATEPOINT ,
  OUTSIDEPOINT
}
 
enum  finddirectionresult {
  ACROSSEDGE , ACROSSFACE , LEFTCOLLINEAR , RIGHTCOLLINEAR ,
  TOPCOLLINEAR , BELOWHULL
}
 
typedef REAL ** tetrahedron
 
typedef REAL ** shellface
 
typedef REAL * point
 
typedef int(* compfunc) (const void *, const void *)
 

Public Member Functions

void decode (tetrahedron ptr, triface &t)
 
tetrahedron encode (triface &t)
 
void sym (triface &t1, triface &t2)
 
void symself (triface &t)
 
void bond (triface &t1, triface &t2)
 
void dissolve (triface &t)
 
point org (triface &t)
 
point dest (triface &t)
 
point apex (triface &t)
 
point oppo (triface &t)
 
void setorg (triface &t, point pointptr)
 
void setdest (triface &t, point pointptr)
 
void setapex (triface &t, point pointptr)
 
void setoppo (triface &t, point pointptr)
 
void esym (triface &t1, triface &t2)
 
void esymself (triface &t)
 
void enext (triface &t1, triface &t2)
 
void enextself (triface &t)
 
void enext2 (triface &t1, triface &t2)
 
void enext2self (triface &t)
 
bool fnext (triface &t1, triface &t2)
 
bool fnextself (triface &t)
 
void symedge (triface &t1, triface &t2)
 
void symedgeself (triface &t)
 
void tfnext (triface &t1, triface &t2)
 
void tfnextself (triface &t)
 
void enextfnext (triface &t1, triface &t2)
 
void enextfnextself (triface &t)
 
void enext2fnext (triface &t1, triface &t2)
 
void enext2fnextself (triface &t)
 
REAL elemattribute (tetrahedron *ptr, int attnum)
 
void setelemattribute (tetrahedron *ptr, int attnum, REAL value)
 
REAL volumebound (tetrahedron *ptr)
 
void setvolumebound (tetrahedron *ptr, REAL value)
 
int getelemmarker (tetrahedron *ptr)
 
void setelemmarker (tetrahedron *ptr, int value)
 
void infect (triface &t)
 
void uninfect (triface &t)
 
bool infected (triface &t)
 
void marktest (triface &t)
 
void unmarktest (triface &t)
 
bool marktested (triface &t)
 
void markface (triface &t)
 
void unmarkface (triface &t)
 
bool facemarked (triface &t)
 
void markedge (triface &t)
 
void unmarkedge (triface &t)
 
bool edgemarked (triface &t)
 
void sdecode (shellface sptr, face &s)
 
shellface sencode (face &s)
 
void spivot (face &s1, face &s2)
 
void spivotself (face &s)
 
void sbond (face &s1, face &s2)
 
void sbond1 (face &s1, face &s2)
 
void sdissolve (face &s)
 
point sorg (face &s)
 
point sdest (face &s)
 
point sapex (face &s)
 
void setsorg (face &s, point pointptr)
 
void setsdest (face &s, point pointptr)
 
void setsapex (face &s, point pointptr)
 
void sesym (face &s1, face &s2)
 
void sesymself (face &s)
 
void senext (face &s1, face &s2)
 
void senextself (face &s)
 
void senext2 (face &s1, face &s2)
 
void senext2self (face &s)
 
void sfnext (face &, face &)
 
void sfnextself (face &)
 
badface * shell2badface (face &s)
 
void setshell2badface (face &s, badface *value)
 
REAL areabound (face &s)
 
void setareabound (face &s, REAL value)
 
int shellmark (face &s)
 
void setshellmark (face &s, int value)
 
enum shestype shelltype (face &s)
 
void setshelltype (face &s, enum shestype value)
 
int shellpbcgroup (face &s)
 
void setshellpbcgroup (face &s, int value)
 
void sinfect (face &s)
 
void suninfect (face &s)
 
bool sinfected (face &s)
 
void tspivot (triface &t, face &s)
 
void stpivot (face &s, triface &t)
 
void tsbond (triface &t, face &s)
 
void tsdissolve (triface &t)
 
void stdissolve (face &s)
 
void sspivot (face &s, face &edge)
 
void ssbond (face &s, face &edge)
 
void ssdissolve (face &s)
 
void tsspivot1 (triface &t, face &seg)
 
void tssbond1 (triface &t, face &seg)
 
void tssdissolve1 (triface &t)
 
int pointmark (point pt)
 
void setpointmark (point pt, int value)
 
enum verttype pointtype (point pt)
 
void setpointtype (point pt, enum verttype value)
 
void pinfect (point pt)
 
void puninfect (point pt)
 
bool pinfected (point pt)
 
tetrahedron point2tet (point pt)
 
void setpoint2tet (point pt, tetrahedron value)
 
shellface point2sh (point pt)
 
void setpoint2sh (point pt, shellface value)
 
shellface point2seg (point pt)
 
void setpoint2seg (point pt, shellface value)
 
point point2ppt (point pt)
 
void setpoint2ppt (point pt, point value)
 
tetrahedron point2bgmtet (point pt)
 
void setpoint2bgmtet (point pt, tetrahedron value)
 
point point2pbcpt (point pt)
 
void setpoint2pbcpt (point pt, point value)
 
void adjustedgering (triface &t, int direction)
 
void adjustedgering (face &s, int direction)
 
bool isdead (triface *t)
 
bool isdead (face *s)
 
bool isfacehaspoint (triface *t, point testpoint)
 
bool isfacehaspoint (face *t, point testpoint)
 
bool isfacehasedge (face *s, point tend1, point tend2)
 
bool issymexist (triface *t)
 
void getnextsface (face *, face *)
 
void tsspivot (triface *, face *)
 
void sstpivot (face *, triface *)
 
void point2tetorg (point, triface &)
 
void point2shorg (point, face &)
 
void point2segorg (point, face &)
 
bool findorg (triface *t, point dorg)
 
bool findorg (face *s, point dorg)
 
void findedge (triface *t, point eorg, point edest)
 
void findedge (face *s, point eorg, point edest)
 
void getonextseg (face *s, face *lseg)
 
void getseghasorg (face *sseg, point dorg)
 
point getsubsegfarorg (face *sseg)
 
point getsubsegfardest (face *sseg)
 
void printtet (triface *)
 
void printsh (face *)
 
void dummyinit (int, int)
 
void initializepools ()
 
void tetrahedrondealloc (tetrahedron *)
 
tetrahedron * tetrahedrontraverse ()
 
void shellfacedealloc (memorypool *, shellface *)
 
shellface * shellfacetraverse (memorypool *)
 
void badfacedealloc (memorypool *, badface *)
 
badface * badfacetraverse (memorypool *)
 
void pointdealloc (point)
 
point pointtraverse ()
 
void maketetrahedron (triface *)
 
void makeshellface (memorypool *, face *)
 
void makepoint (point *)
 
void makepoint2tetmap ()
 
void makepoint2segmap ()
 
void makeindex2pointmap (point *&)
 
void makesegmentmap (int *&, shellface **&)
 
void makesubfacemap (int *&, shellface **&)
 
void maketetrahedronmap (int *&, tetrahedron **&)
 
enum interresult edge_vert_col_inter (REAL *, REAL *, REAL *)
 
enum interresult edge_edge_cop_inter (REAL *, REAL *, REAL *, REAL *, REAL *)
 
enum interresult tri_vert_cop_inter (REAL *, REAL *, REAL *, REAL *, REAL *)
 
enum interresult tri_edge_cop_inter (REAL *, REAL *, REAL *, REAL *, REAL *, REAL *)
 
enum interresult tri_edge_inter_tail (REAL *, REAL *, REAL *, REAL *, REAL *, REAL, REAL)
 
enum interresult tri_edge_inter (REAL *, REAL *, REAL *, REAL *, REAL *)
 
enum interresult tri_tri_inter (REAL *, REAL *, REAL *, REAL *, REAL *, REAL *)
 
int tri_edge_2d (point, point, point, point, point, point, int, int *, int *)
 
int tri_edge_test (point, point, point, point, point, point, int, int *, int *)
 
REAL incircle3d (point pa, point pb, point pc, point pd)
 
REAL insphere_s (REAL *, REAL *, REAL *, REAL *, REAL *)
 
bool iscollinear (REAL *, REAL *, REAL *, REAL eps)
 
bool iscoplanar (REAL *, REAL *, REAL *, REAL *, REAL vol6, REAL eps)
 
bool iscospheric (REAL *, REAL *, REAL *, REAL *, REAL *, REAL vol24, REAL eps)
 
REAL dot (REAL *v1, REAL *v2)
 
void cross (REAL *v1, REAL *v2, REAL *n)
 
bool lu_decmp (REAL lu[4][4], int n, int *ps, REAL *d, int N)
 
void lu_solve (REAL lu[4][4], int n, int *ps, REAL *b, int N)
 
REAL distance (REAL *p1, REAL *p2)
 
REAL shortdistance (REAL *p, REAL *e1, REAL *e2)
 
REAL shortdistance (REAL *p, REAL *e1, REAL *e2, REAL *e3)
 
REAL interiorangle (REAL *o, REAL *p1, REAL *p2, REAL *n)
 
void projpt2edge (REAL *p, REAL *e1, REAL *e2, REAL *prj)
 
void projpt2face (REAL *p, REAL *f1, REAL *f2, REAL *f3, REAL *prj)
 
void facenormal (REAL *pa, REAL *pb, REAL *pc, REAL *n, REAL *nlen)
 
void facenormal2 (point pa, point pb, point pc, REAL *n, int pivot)
 
void edgeorthonormal (REAL *e1, REAL *e2, REAL *op, REAL *n)
 
REAL facedihedral (REAL *pa, REAL *pb, REAL *pc1, REAL *pc2)
 
void tetalldihedral (point, point, point, point, REAL *, REAL *, REAL *)
 
void tetallnormal (point, point, point, point, REAL N[4][3], REAL *volume)
 
REAL tetaspectratio (point, point, point, point)
 
bool circumsphere (REAL *, REAL *, REAL *, REAL *, REAL *cent, REAL *radius)
 
void inscribedsphere (REAL *, REAL *, REAL *, REAL *, REAL *cent, REAL *radius)
 
void rotatepoint (REAL *p, REAL rotangle, REAL *p1, REAL *p2)
 
void planelineint (REAL *, REAL *, REAL *, REAL *, REAL *, REAL *, REAL *)
 
unsigned long randomnation (unsigned int choices)
 
REAL distance2 (tetrahedron *tetptr, point p)
 
void randomsample (point searchpt, triface *searchtet)
 
enum locateresult locate (point searchpt, triface *searchtet)
 
enum locateresult locate2 (point searchpt, triface *searchtet, arraypool *)
 
enum locateresult preciselocate (point searchpt, triface *searchtet, long)
 
enum locateresult adjustlocate (point, triface *, enum locateresult, REAL)
 
enum locateresult hullwalk (point searchpt, triface *hulltet)
 
enum locateresult locatesub (point searchpt, face *searchsh, int, REAL)
 
enum locateresult adjustlocatesub (point, face *, enum locateresult, REAL)
 
enum locateresult locateseg (point searchpt, face *searchseg)
 
enum locateresult adjustlocateseg (point, face *, enum locateresult, REAL)
 
void enqueueflipface (triface &, queue *)
 
void enqueueflipedge (face &, queue *)
 
void flip23 (triface *, queue *)
 
void flip32 (triface *, queue *)
 
void flip22 (triface *, queue *)
 
void flip22sub (face *, queue *)
 
long lawson3d (queue *flipqueue)
 
long lawson (queue *flipqueue)
 
bool removetetbypeeloff (triface *striptet, triface *)
 
bool removefacebyflip23 (REAL *key, triface *, triface *, queue *)
 
bool removeedgebyflip22 (REAL *key, int, triface *, queue *)
 
bool removeedgebyflip32 (REAL *key, triface *, triface *, queue *)
 
bool removeedgebytranNM (REAL *, int, triface *, triface *, point, point, queue *)
 
bool removeedgebycombNM (REAL *, int, triface *, int *, triface *, triface *, queue *)
 
void splittetrahedron (point, triface *, queue *)
 
void splittetface (point, triface *, queue *)
 
void splitsubface (point, face *, queue *)
 
bool splittetedge (point, triface *, queue *)
 
void splitsubedge (point, face *, queue *)
 
void formstarpolyhedron (point pt, list *tetlist, list *verlist, bool)
 
void formbowatcavitysub (point, face *, list *, list *)
 
void formbowatcavityquad (point, list *, list *)
 
void formbowatcavitysegquad (point, list *, list *)
 
void formbowatcavity (point bp, face *bpseg, face *bpsh, int *n, int *nmax, list **sublists, list **subceillists, list **tetlists, list **ceillists)
 
void releasebowatcavity (face *, int, list **, list **, list **, list **)
 
bool validatebowatcavityquad (point bp, list *ceillist, REAL maxcosd)
 
void updatebowatcavityquad (list *tetlist, list *ceillist)
 
void updatebowatcavitysub (list *sublist, list *subceillist, int *cutcount)
 
bool trimbowatcavity (point bp, face *bpseg, int n, list **sublists, list **subceillists, list **tetlists, list **ceillists, REAL maxcosd)
 
void bowatinsertsite (point bp, face *splitseg, int n, list **sublists, list **subceillists, list **tetlists, list **ceillists, list *verlist, queue *flipque, bool chkencseg, bool chkencsub, bool chkbadtet)
 
void btree_sort (point *, int, int, REAL, REAL, REAL, REAL, REAL, REAL, int)
 
void btree_insert (point insertpt)
 
void btree_search (point searchpt, triface *searchtet)
 
void ordervertices (point *vertexarray, int arraysize)
 
enum locateresult insertvertexbw (point insertpt, triface *searchtet, bool bwflag, bool visflag, bool noencsegflag, bool noencsubflag)
 
bool unifypoint (point testpt, triface *, enum locateresult, REAL)
 
bool incrflipdelaunay (triface *, point *, long, bool, bool, REAL, queue *)
 
long delaunizevertices ()
 
enum locateresult sinsertvertex (point insertpt, face *splitsh, face *splitseg, bool bwflag, bool cflag)
 
void formstarpolygon (point pt, list *trilist, list *verlist)
 
void getfacetabovepoint (face *facetsh)
 
bool incrflipdelaunaysub (int shmark, REAL eps, list *, int, REAL *, queue *)
 
enum finddirectionresult finddirectionsub (face *searchsh, point tend)
 
void insertsubseg (face *tri)
 
bool scoutsegmentsub (face *searchsh, point tend)
 
void flipedgerecursive (face *flipedge, queue *flipqueue)
 
void constrainededge (face *startsh, point tend, queue *flipqueue)
 
void recoversegment (point tstart, point tend, queue *flipqueue)
 
void infecthullsub (memorypool *viri)
 
void plaguesub (memorypool *viri)
 
void carveholessub (int holes, REAL *holelist, memorypool *viri)
 
void triangulate (int shmark, REAL eps, list *ptlist, list *conlist, int holes, REAL *holelist, memorypool *viri, queue *)
 
void retrievenewsubs (list *newshlist, bool removeseg)
 
void unifysegments ()
 
void assignsegmentmarkers ()
 
void mergefacets (queue *flipqueue)
 
long meshsurface ()
 
void interecursive (shellface **subfacearray, int arraysize, int axis, REAL bxmin, REAL bxmax, REAL bymin, REAL bymax, REAL bzmin, REAL bzmax, int *internum)
 
void detectinterfaces ()
 
void markacutevertices (REAL acuteangle)
 
enum finddirectionresult finddirection (triface *searchtet, point, long)
 
enum interresult finddirection2 (triface *searchtet, point)
 
enum interresult finddirection3 (triface *searchtet, point)
 
enum interresult scoutsegment2 (face *, triface *, point *)
 
void getsegmentsplitpoint2 (face *sseg, point refpt, REAL *vt)
 
void getsegmentsplitpoint3 (face *sseg, point refpt, REAL *vt)
 
void delaunizesegments2 ()
 
enum interresult scoutsubface (face *ssub, triface *searchtet, int)
 
enum interresult scoutcrosstet (face *ssub, triface *searchtet, arraypool *)
 
void recoversubfacebyflips (face *pssub, triface *crossface, arraypool *)
 
void formcavity (face *, arraypool *, arraypool *, arraypool *, arraypool *, arraypool *, arraypool *, arraypool *)
 
bool delaunizecavity (arraypool *, arraypool *, arraypool *, arraypool *, arraypool *, arraypool *)
 
bool fillcavity (arraypool *, arraypool *, arraypool *, arraypool *)
 
void carvecavity (arraypool *, arraypool *, arraypool *)
 
void restorecavity (arraypool *, arraypool *, arraypool *)
 
void splitsubedge (point, face *, arraypool *, arraypool *)
 
void constrainedfacets2 ()
 
void formskeleton (clock_t &)
 
void infecthull (memorypool *viri)
 
void plague (memorypool *viri)
 
void regionplague (memorypool *viri, REAL attribute, REAL volume)
 
void removeholetets (memorypool *viri)
 
void assignregionattribs ()
 
void carveholes ()
 
void initializecavity (list *floorlist, list *ceillist, list *frontlist, list *ptlist, list *gluelist)
 
bool delaunizecavvertices (triface *, list *, list *, list *, queue *)
 
void retrievenewtets (list *newtetlist)
 
void insertauxsubface (triface *front, triface *idfront)
 
bool scoutfront (triface *front, triface *idfront)
 
void gluefronts (triface *front, triface *front1, list *gluetetlist, list *glueshlist)
 
bool identifyfronts (list *frontlist, list *misfrontlist, list *gluetetlist, list *glueshlist)
 
void detachauxsubfaces (list *newtetlist)
 
bool carvecavity (list *newtetlist, list *outtetlist, list *gluetetlist, queue *flipque)
 
void replacepolygonsubs (list *oldshlist, list *newshlist)
 
void orientnewsubs (list *newshlist, face *orientsh, REAL *norm)
 
bool registerelemflip (enum fliptype ft, point pa1, point pb1, point pc1, point pa2, point pb2, point pc2)
 
bool check4fixededge (point pa, point pb)
 
bool removeedgebyflips (triface *remedge, int *)
 
bool removefacebyflips (triface *remface, int *)
 
bool recoveredgebyflips (triface *searchtet, point pb, int *)
 
bool recoverfacebyflips (triface *front, int *)
 
bool constrainedcavity (triface *oldtet, list *floorlist, list *ceillist, list *ptlist, list *frontlist, list *misfrontlist, list *newtetlist, list *gluetetlist, list *glueshlist, queue *flipque)
 
bool findrelocatepoint2 (point sp, point np, REAL *n, list *, list *)
 
bool relocatepoint (point steinpt, triface *oldtet, list *, list *, queue *)
 
bool findcollapseedge (point suppt, point *conpt, list *oldtetlist, list *)
 
void collapseedge (point suppt, point conpt, list *oldtetlist, list *)
 
void deallocfaketets (list *frontlist)
 
void restorepolyhedron (list *oldtetlist)
 
bool suppressfacetpoint (face *supsh, list *frontlist, list *misfrontlist, list *ptlist, list *conlist, memorypool *viri, queue *flipque, bool noreloc, bool optflag)
 
bool suppresssegpoint (face *supseg, list *spinshlist, list *newsegshlist, list *frontlist, list *misfrontlist, list *ptlist, list *conlist, memorypool *viri, queue *flipque, bool noreloc, bool optflag)
 
bool suppressvolpoint (triface *suptet, list *frontlist, list *misfrontlist, list *ptlist, queue *flipque, bool optflag)
 
void removesteiners2 ()
 
void transfernodes ()
 
long reconstructmesh ()
 
void insertconstrainedpoints (tetgenio *addio)
 
bool p1interpolatebgm (point pt, triface *bgmtet, long *scount)
 
void interpolatesizemap ()
 
void duplicatebgmesh ()
 
void marksharpsegments (REAL sharpangle)
 
void decidefeaturepointsizes ()
 
void enqueueencsub (face *ss, point encpt, int quenumber, REAL *cent)
 
badface * dequeueencsub (int *quenumber)
 
void enqueuebadtet (triface *tt, REAL key, REAL *cent)
 
badface * topbadtetra ()
 
void dequeuebadtet ()
 
bool checkseg4encroach (face *testseg, point testpt, point *, bool enqflag)
 
bool checksub4encroach (face *testsub, point testpt, bool enqflag)
 
bool checktet4badqual (triface *testtet, bool enqflag)
 
bool acceptsegpt (point segpt, point refpt, face *splitseg)
 
bool acceptfacpt (point facpt, list *subceillist, list *verlist)
 
bool acceptvolpt (point volpt, list *ceillist, list *verlist)
 
void getsplitpoint (point e1, point e2, point refpt, point newpt)
 
void setnewpointsize (point newpt, point e1, point e2)
 
bool splitencseg (point, face *, list *, list *, list *, queue *, bool, bool, bool)
 
bool tallencsegs (point testpt, int n, list **ceillists)
 
bool tallencsubs (point testpt, int n, list **ceillists)
 
void tallbadtetrahedrons ()
 
void repairencsegs (bool chkencsub, bool chkbadtet)
 
void repairencsubs (bool chkbadtet)
 
void repairbadtets ()
 
void enforcequality ()
 
bool checktet4ill (triface *testtet, bool enqflag)
 
bool checktet4opt (triface *testtet, bool enqflag)
 
bool removeedge (badface *remedge, bool optflag)
 
bool smoothpoint (point smthpt, point, point, list *, bool, REAL *)
 
bool smoothsliver (badface *remedge, list *starlist)
 
bool splitsliver (badface *remedge, list *tetlist, list *ceillist)
 
void tallslivers (bool optflag)
 
void optimizemesh2 (bool optflag)
 
void jettisonnodes ()
 
void highorder ()
 
void numberedges ()
 
void outnodes (tetgenio *)
 
void outmetrics (tetgenio *)
 
void outelements (tetgenio *)
 
void outfaces (tetgenio *)
 
void outhullfaces (tetgenio *)
 
void outsubfaces (tetgenio *)
 
void outedges (tetgenio *)
 
void outsubsegments (tetgenio *)
 
void outneighbors (tetgenio *)
 
void outvoronoi (tetgenio *)
 
void outsmesh (char *)
 
void outmesh2medit (char *)
 
void outmesh2gid (char *)
 
void outmesh2off (char *)
 
void outmesh2vtk (char *)
 
int checkmesh ()
 
int checkshells ()
 
int checksegments ()
 
int checkdelaunay (REAL, queue *)
 
void checkconforming ()
 
void algorithmicstatistics ()
 
void qualitystatistics ()
 
void statistics ()
 
 tetgenmesh ()
 
 ~tetgenmesh ()
 

Public Attributes

tetgenio * in
 
tetgenbehavior * b
 
tetgenmesh * bgm
 
memorypool * tetrahedrons
 
memorypool * subfaces
 
memorypool * subsegs
 
memorypool * points
 
memorypool * badsubsegs
 
memorypool * badsubfaces
 
memorypool * badtetrahedrons
 
memorypool * tet2segpool
 
memorypool * tet2subpool
 
tetrahedron * dummytet
 
tetrahedron * dummytetbase
 
shellface * dummysh
 
shellface * dummyshbase
 
arraypool * btreenode_list
 
int max_btreenode_size
 
int max_btree_depth
 
arraypool * cavetetlist
 
arraypool * cavebdrylist
 
arraypool * caveoldtetlist
 
arraypool * caveshlist
 
arraypool * caveshbdlist
 
arraypool * subsegstack
 
arraypool * subfacstack
 
triface firsttopface
 
triface firstbotface
 
arraypool * elemfliplist
 
arraypool * fixededgelist
 
point * facetabovepointarray
 
point abovepoint
 
point dummypoint
 
point * highordertable
 
pbcdata * subpbcgrouptable
 
list * segpbcgrouptable
 
int * idx2segpglist
 
int * segpglist
 
badface * subquefront [3]
 
badface ** subquetail [3]
 
badface * tetquefront [64]
 
badface * tetquetail [64]
 
int nextnonemptyq [64]
 
int firstnonemptyq
 
int recentq
 
triface recenttet
 
REAL xmax
 
REAL xmin
 
REAL ymax
 
REAL ymin
 
REAL zmax
 
REAL zmin
 
REAL longest
 
REAL lengthlimit
 
long hullsize
 
long insegments
 
long meshedges
 
int steinerleft
 
int sizeoftensor
 
int pointmtrindex
 
int point2simindex
 
int pointmarkindex
 
int point2pbcptindex
 
int highorderindex
 
int elemattribindex
 
int volumeboundindex
 
int elemmarkerindex
 
int shmarkindex
 
int areaboundindex
 
int checksubfaces
 
int checksubsegs
 
int checkpbcs
 
int varconstraint
 
int nonconvex
 
int dupverts
 
int unuverts
 
int relverts
 
int suprelverts
 
int collapverts
 
int unsupverts
 
int smoothsegverts
 
int jettisoninverts
 
long samples
 
unsigned long randomseed
 
REAL macheps
 
REAL cosmaxdihed
 
REAL cosmindihed
 
REAL minfaceang
 
REAL minfacetdihed
 
int maxcavfaces
 
int maxcavverts
 
bool b_steinerflag
 
long ptloc_count
 
long ptloc_max_count
 
long orient3dcount
 
long inspherecount
 
long insphere_sos_count
 
long flip14count
 
long flip26count
 
long flipn2ncount
 
long flip22count
 
long inserthullcount
 
long maxbowatcavsize
 
long totalbowatcavsize
 
long totaldeadtets
 
long across_face_count
 
long across_edge_count
 
long across_max_count
 
long maxcavsize
 
long maxregionsize
 
long ndelaunayedgecount
 
long cavityexpcount
 
long opt_tet_peels
 
long opt_face_flips
 
long opt_edge_flips
 
long abovecount
 
long bowatvolcount
 
long bowatsubcount
 
long bowatsegcount
 
long updvolcount
 
long updsubcount
 
long updsegcount
 
long failvolcount
 
long failsubcount
 
long failsegcount
 
long outbowatcircumcount
 
long r1count
 
long r2count
 
long r3count
 
long cdtenforcesegpts
 
long rejsegpts
 
long rejsubpts
 
long rejtetpts
 
long optcount [10]
 
long flip23s
 
long flip32s
 
long flip22s
 
long flip44s
 

Static Public Attributes

static int ve [6]
 
static int vo [6]
 
static int vd [6]
 
static int va [6]
 
static int locver2org [4][6]
 
static int locver2dest [4][6]
 
static int locver2apex [4][6]
 
static int loc2oppo [4]
 
static int locver2nextf [4][6][2]
 
static int locver2edge [4][6]
 
static int edge2locver [6][2]
 
static int locpivot [4][3]
 
static int locverpivot [4][6][2]
 
static int plus1mod3 [3]
 
static int minus1mod3 [3]
 
static REAL PI
 

Member Typedef Documentation

◆ compfunc

typedef int(* tetgenmesh::compfunc) (const void *, const void *)

◆ point

typedef REAL* tetgenmesh::point

◆ shellface

typedef REAL** tetgenmesh::shellface

◆ tetrahedron

typedef REAL** tetgenmesh::tetrahedron

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
Enumerator
FILENAMESIZE 
810 {FILENAMESIZE = 1024};
tetgenmesh::FILENAMESIZE
@ FILENAMESIZE
Definition: tetgen.h:810

◆ anonymous enum

anonymous enum
Enumerator
VERPERBLOCK 
SUBPERBLOCK 
ELEPERBLOCK 
815 {VERPERBLOCK = 4092, SUBPERBLOCK = 4092, ELEPERBLOCK = 8188};
tetgenmesh::ELEPERBLOCK
@ ELEPERBLOCK
Definition: tetgen.h:815
tetgenmesh::VERPERBLOCK
@ VERPERBLOCK
Definition: tetgen.h:815
tetgenmesh::SUBPERBLOCK
@ SUBPERBLOCK
Definition: tetgen.h:815

◆ anonymous enum

anonymous enum
Enumerator
SAMPLEFACTOR 
819 {SAMPLEFACTOR = 11};
tetgenmesh::SAMPLEFACTOR
@ SAMPLEFACTOR
Definition: tetgen.h:819

◆ anonymous enum

anonymous enum
Enumerator
CCW 
CW 
822 {CCW = 0, CW = 1};
tetgenmesh::CCW
@ CCW
Definition: tetgen.h:822
tetgenmesh::CW
@ CW
Definition: tetgen.h:822

◆ finddirectionresult

enum tetgenmesh::finddirectionresult
Enumerator
ACROSSEDGE 
ACROSSFACE 
LEFTCOLLINEAR 
RIGHTCOLLINEAR 
TOPCOLLINEAR 
BELOWHULL 
853  {ACROSSEDGE, ACROSSFACE, LEFTCOLLINEAR,
854  RIGHTCOLLINEAR, TOPCOLLINEAR, BELOWHULL};
tetgenmesh::TOPCOLLINEAR
@ TOPCOLLINEAR
Definition: tetgen.h:854
tetgenmesh::RIGHTCOLLINEAR
@ RIGHTCOLLINEAR
Definition: tetgen.h:854
tetgenmesh::ACROSSEDGE
@ ACROSSEDGE
Definition: tetgen.h:853
tetgenmesh::LEFTCOLLINEAR
@ LEFTCOLLINEAR
Definition: tetgen.h:853
tetgenmesh::BELOWHULL
@ BELOWHULL
Definition: tetgen.h:854
tetgenmesh::ACROSSFACE
@ ACROSSFACE
Definition: tetgen.h:853

◆ fliptype

enum tetgenmesh::fliptype
Enumerator
T23 
T32 
T22 
T44 
N32 
N40 
FORBIDDENFACE 
FORBIDDENEDGE 
836 {T23, T32, T22, T44, N32, N40, FORBIDDENFACE, FORBIDDENEDGE};
tetgenmesh::N32
@ N32
Definition: tetgen.h:836
tetgenmesh::T44
@ T44
Definition: tetgen.h:836
tetgenmesh::T22
@ T22
Definition: tetgen.h:836
tetgenmesh::FORBIDDENFACE
@ FORBIDDENFACE
Definition: tetgen.h:836
tetgenmesh::T23
@ T23
Definition: tetgen.h:836
tetgenmesh::T32
@ T32
Definition: tetgen.h:836
tetgenmesh::FORBIDDENEDGE
@ FORBIDDENEDGE
Definition: tetgen.h:836
tetgenmesh::N40
@ N40
Definition: tetgen.h:836

◆ insertsiteresult

enum tetgenmesh::insertsiteresult
Enumerator
SUCCESSINTET 
SUCCESSONFACE 
SUCCESSONEDGE 
DUPLICATEPOINT 
OUTSIDEPOINT 
849  {SUCCESSINTET, SUCCESSONFACE, SUCCESSONEDGE,
850  DUPLICATEPOINT, OUTSIDEPOINT};
tetgenmesh::SUCCESSONEDGE
@ SUCCESSONEDGE
Definition: tetgen.h:849
tetgenmesh::SUCCESSINTET
@ SUCCESSINTET
Definition: tetgen.h:849
tetgenmesh::DUPLICATEPOINT
@ DUPLICATEPOINT
Definition: tetgen.h:850
tetgenmesh::OUTSIDEPOINT
@ OUTSIDEPOINT
Definition: tetgen.h:850
tetgenmesh::SUCCESSONFACE
@ SUCCESSONFACE
Definition: tetgen.h:849

◆ interresult

enum tetgenmesh::interresult
Enumerator
DISJOINT 
INTERSECT 
SHAREVERTEX 
SHAREEDGE 
SHAREFACE 
TOUCHEDGE 
TOUCHFACE 
INTERVERT 
INTEREDGE 
INTERFACE 
INTERTET 
TRIEDGEINT 
EDGETRIINT 
COLLISIONFACE 
INTERSUBSEG 
INTERSUBFACE 
BELOWHULL2 
839  {DISJOINT, INTERSECT, SHAREVERTEX, SHAREEDGE, SHAREFACE,
840  TOUCHEDGE, TOUCHFACE, INTERVERT, INTEREDGE, INTERFACE, INTERTET,
841  TRIEDGEINT, EDGETRIINT, COLLISIONFACE, INTERSUBSEG, INTERSUBFACE,
842  BELOWHULL2};
tetgenmesh::INTERSUBFACE
@ INTERSUBFACE
Definition: tetgen.h:841
tetgenmesh::TOUCHEDGE
@ TOUCHEDGE
Definition: tetgen.h:840
tetgenmesh::TOUCHFACE
@ TOUCHFACE
Definition: tetgen.h:840
tetgenmesh::INTERVERT
@ INTERVERT
Definition: tetgen.h:840
tetgenmesh::SHAREFACE
@ SHAREFACE
Definition: tetgen.h:839
tetgenmesh::SHAREEDGE
@ SHAREEDGE
Definition: tetgen.h:839
tetgenmesh::DISJOINT
@ DISJOINT
Definition: tetgen.h:839
tetgenmesh::COLLISIONFACE
@ COLLISIONFACE
Definition: tetgen.h:841
tetgenmesh::INTERFACE
@ INTERFACE
Definition: tetgen.h:840
tetgenmesh::INTERTET
@ INTERTET
Definition: tetgen.h:840
tetgenmesh::SHAREVERTEX
@ SHAREVERTEX
Definition: tetgen.h:839
tetgenmesh::INTEREDGE
@ INTEREDGE
Definition: tetgen.h:840
tetgenmesh::BELOWHULL2
@ BELOWHULL2
Definition: tetgen.h:842
tetgenmesh::INTERSECT
@ INTERSECT
Definition: tetgen.h:839
tetgenmesh::TRIEDGEINT
@ TRIEDGEINT
Definition: tetgen.h:841
tetgenmesh::EDGETRIINT
@ EDGETRIINT
Definition: tetgen.h:841
tetgenmesh::INTERSUBSEG
@ INTERSUBSEG
Definition: tetgen.h:841

◆ locateresult

enum tetgenmesh::locateresult
Enumerator
INTETRAHEDRON 
ONFACE 
ONEDGE 
ONVERTEX 
OUTSIDE 
ENCSEGMENT 
845  {INTETRAHEDRON, ONFACE, ONEDGE, ONVERTEX, OUTSIDE,
846  ENCSEGMENT};
tetgenmesh::ONVERTEX
@ ONVERTEX
Definition: tetgen.h:845
tetgenmesh::ONEDGE
@ ONEDGE
Definition: tetgen.h:845
tetgenmesh::ENCSEGMENT
@ ENCSEGMENT
Definition: tetgen.h:846
tetgenmesh::ONFACE
@ ONFACE
Definition: tetgen.h:845
tetgenmesh::OUTSIDE
@ OUTSIDE
Definition: tetgen.h:845
tetgenmesh::INTETRAHEDRON
@ INTETRAHEDRON
Definition: tetgen.h:845

◆ shestype

enum tetgenmesh::shestype
Enumerator
NSHARP 
SHARP 
833 {NSHARP, SHARP};
tetgenmesh::SHARP
@ SHARP
Definition: tetgen.h:833
tetgenmesh::NSHARP
@ NSHARP
Definition: tetgen.h:833

◆ verttype

enum tetgenmesh::verttype
Enumerator
UNUSEDVERTEX 
DUPLICATEDVERTEX 
NACUTEVERTEX 
ACUTEVERTEX 
FREESEGVERTEX 
FREESUBVERTEX 
FREEVOLVERTEX 
DEADVERTEX 
829  {UNUSEDVERTEX, DUPLICATEDVERTEX, NACUTEVERTEX, ACUTEVERTEX,
830  FREESEGVERTEX, FREESUBVERTEX, FREEVOLVERTEX, DEADVERTEX = -32768};
tetgenmesh::ACUTEVERTEX
@ ACUTEVERTEX
Definition: tetgen.h:829
tetgenmesh::FREESEGVERTEX
@ FREESEGVERTEX
Definition: tetgen.h:830
tetgenmesh::DUPLICATEDVERTEX
@ DUPLICATEDVERTEX
Definition: tetgen.h:829
tetgenmesh::UNUSEDVERTEX
@ UNUSEDVERTEX
Definition: tetgen.h:829
tetgenmesh::FREEVOLVERTEX
@ FREEVOLVERTEX
Definition: tetgen.h:830
tetgenmesh::NACUTEVERTEX
@ NACUTEVERTEX
Definition: tetgen.h:829
tetgenmesh::DEADVERTEX
@ DEADVERTEX
Definition: tetgen.h:830
tetgenmesh::FREESUBVERTEX
@ FREESUBVERTEX
Definition: tetgen.h:830

◆ wordtype

enum tetgenmesh::wordtype
Enumerator
POINTER 
FLOATINGPOINT 
826 {POINTER, FLOATINGPOINT};
tetgenmesh::POINTER
@ POINTER
Definition: tetgen.h:826
tetgenmesh::FLOATINGPOINT
@ FLOATINGPOINT
Definition: tetgen.h:826

Constructor & Destructor Documentation

◆ tetgenmesh()

tetgenmesh::tetgenmesh ( )
inline
2183  {
2184  bgm = (tetgenmesh *) NULL;
2185  in = (tetgenio *) NULL;
2186  b = (tetgenbehavior *) NULL;
2187 
2188  tetrahedrons = (memorypool *) NULL;
2189  subfaces = (memorypool *) NULL;
2190  subsegs = (memorypool *) NULL;
2191  points = (memorypool *) NULL;
2192  badsubsegs = (memorypool *) NULL;
2193  badsubfaces = (memorypool *) NULL;
2194  badtetrahedrons = (memorypool *) NULL;
2195  tet2segpool = NULL;
2196  tet2subpool = NULL;
2197 
2198  dummytet = (tetrahedron *) NULL;
2199  dummytetbase = (tetrahedron *) NULL;
2200  dummysh = (shellface *) NULL;
2201  dummyshbase = (shellface *) NULL;
2202 
2203  facetabovepointarray = (point *) NULL;
2204  abovepoint = (point) NULL;
2205  dummypoint = NULL;
2206  btreenode_list = (arraypool *) NULL;
2207  highordertable = (point *) NULL;
2208  subpbcgrouptable = (pbcdata *) NULL;
2209  segpbcgrouptable = (list *) NULL;
2210  idx2segpglist = (int *) NULL;
2211  segpglist = (int *) NULL;
2212 
2213  cavetetlist = NULL;
2214  cavebdrylist = NULL;
2215  caveoldtetlist = NULL;
2216  caveshlist = caveshbdlist = NULL;
2217  subsegstack = subfacstack = NULL;
2218 
2219  elemfliplist = (arraypool *) NULL;
2220  fixededgelist = (arraypool *) NULL;
2221 
2222  xmax = xmin = ymax = ymin = zmax = zmin = 0.0;
2223  longest = 0.0;
2224  hullsize = 0l;
2225  insegments = 0l;
2226  meshedges = 0l;
2227  pointmtrindex = 0;
2228  pointmarkindex = 0;
2229  point2simindex = 0;
2230  point2pbcptindex = 0;
2231  highorderindex = 0;
2232  elemattribindex = 0;
2233  volumeboundindex = 0;
2234  shmarkindex = 0;
2235  areaboundindex = 0;
2236  checksubfaces = 0;
2237  checksubsegs = 0;
2238  checkpbcs = 0;
2239  varconstraint = 0;
2240  nonconvex = 0;
2241  dupverts = 0;
2242  unuverts = 0;
2243  relverts = 0;
2244  suprelverts = 0;
2245  collapverts = 0;
2246  unsupverts = 0;
2247  jettisoninverts = 0;
2248  samples = 0l;
2249  randomseed = 1l;
2250  macheps = 0.0;
2251  minfaceang = minfacetdihed = PI;
2252  b_steinerflag = false;
2253 
2254  ptloc_count = ptloc_max_count = 0l;
2255  orient3dcount = 0l;
2256  inspherecount = insphere_sos_count = 0l;
2257  flip14count = flip26count = flipn2ncount = 0l;
2258  flip22count = 0l;
2259  inserthullcount = 0l;
2260  maxbowatcavsize = totalbowatcavsize = totaldeadtets = 0l;
2261  across_face_count = across_edge_count = across_max_count = 0l;
2262  maxcavsize = maxregionsize = 0l;
2263  ndelaunayedgecount = cavityexpcount = 0l;
2264  opt_tet_peels = opt_face_flips = opt_edge_flips = 0l;
2265 
2266  maxcavfaces = maxcavverts = 0;
2267  abovecount = 0l;
2268  bowatvolcount = bowatsubcount = bowatsegcount = 0l;
2269  updvolcount = updsubcount = updsegcount = 0l;
2270  outbowatcircumcount = 0l;
2271  failvolcount = failsubcount = failsegcount = 0l;
2272  r1count = r2count = r3count = 0l;
2273  cdtenforcesegpts = 0l;
2274  rejsegpts = rejsubpts = rejtetpts = 0l;
2275  flip23s = flip32s = flip22s = flip44s = 0l;
2276  } // tetgenmesh()
tetgenbehavior
Definition: tetgen.h:630
tetgenio
Definition: tetgen.h:201
tetgenmesh
Definition: tetgen.h:805
tetgenmesh::updvolcount
long updvolcount
Definition: tetgen.h:2167
tetgenmesh::badtetrahedrons
memorypool * badtetrahedrons
Definition: tetgen.h:2047
tetgenmesh::xmax
REAL xmax
Definition: tetgen.h:2113
tetgenmesh::highordertable
point * highordertable
Definition: tetgen.h:2087
tetgenmesh::pointmarkindex
int pointmarkindex
Definition: tetgen.h:2123
tetgenmesh::samples
long samples
Definition: tetgen.h:2144
tetgenmesh::totaldeadtets
long totaldeadtets
Definition: tetgen.h:2159
tetgenmesh::highorderindex
int highorderindex
Definition: tetgen.h:2125
tetgenmesh::idx2segpglist
int * idx2segpglist
Definition: tetgen.h:2098
tetgenmesh::rejsubpts
long rejsubpts
Definition: tetgen.h:2172
tetgenmesh::tet2segpool
memorypool * tet2segpool
Definition: tetgen.h:2048
tetgenmesh::r2count
long r2count
Definition: tetgen.h:2170
tetgenmesh::subsegs
memorypool * subsegs
Definition: tetgen.h:2043
tetgenmesh::outbowatcircumcount
long outbowatcircumcount
Definition: tetgen.h:2169
tetgenmesh::meshedges
long meshedges
Definition: tetgen.h:2118
tetgenmesh::across_edge_count
long across_edge_count
Definition: tetgen.h:2160
tetgenmesh::insphere_sos_count
long insphere_sos_count
Definition: tetgen.h:2155
tetgenmesh::opt_edge_flips
long opt_edge_flips
Definition: tetgen.h:2163
tetgenmesh::collapverts
int collapverts
Definition: tetgen.h:2140
tetgenmesh::inspherecount
long inspherecount
Definition: tetgen.h:2155
tetgenmesh::r1count
long r1count
Definition: tetgen.h:2170
tetgenmesh::point2pbcptindex
int point2pbcptindex
Definition: tetgen.h:2124
tetgenmesh::bowatsubcount
long bowatsubcount
Definition: tetgen.h:2166
tetgenmesh::subpbcgrouptable
pbcdata * subpbcgrouptable
Definition: tetgen.h:2094
tetgenmesh::pointmtrindex
int pointmtrindex
Definition: tetgen.h:2121
tetgenmesh::elemfliplist
arraypool * elemfliplist
Definition: tetgen.h:2076
tetgenmesh::ptloc_count
long ptloc_count
Definition: tetgen.h:2153
tetgenmesh::dummyshbase
shellface * dummyshbase
Definition: tetgen.h:2057
tetgenmesh::btreenode_list
arraypool * btreenode_list
Definition: tetgen.h:2060
tetgenmesh::opt_face_flips
long opt_face_flips
Definition: tetgen.h:2163
tetgenmesh::flip22count
long flip22count
Definition: tetgen.h:2157
tetgenmesh::relverts
int relverts
Definition: tetgen.h:2138
tetgenmesh::abovecount
long abovecount
Definition: tetgen.h:2165
tetgenmesh::tet2subpool
memorypool * tet2subpool
Definition: tetgen.h:2048
tetgenmesh::maxcavfaces
int maxcavfaces
Definition: tetgen.h:2149
tetgenmesh::rejsegpts
long rejsegpts
Definition: tetgen.h:2172
tetgenmesh::subsegstack
arraypool * subsegstack
Definition: tetgen.h:2070
tetgenmesh::subfaces
memorypool * subfaces
Definition: tetgen.h:2042
tetgenmesh::maxcavsize
long maxcavsize
Definition: tetgen.h:2161
tetgenmesh::flip44s
long flip44s
Definition: tetgen.h:2174
tetgenmesh::flip23s
long flip23s
Definition: tetgen.h:2174
tetgenmesh::maxregionsize
long maxregionsize
Definition: tetgen.h:2161
tetgenmesh::failsegcount
long failsegcount
Definition: tetgen.h:2168
tetgenmesh::elemattribindex
int elemattribindex
Definition: tetgen.h:2126
tetgenmesh::flip22s
long flip22s
Definition: tetgen.h:2174
tetgenmesh::xmin
REAL xmin
Definition: tetgen.h:2113
tetgenmesh::orient3dcount
long orient3dcount
Definition: tetgen.h:2154
tetgenmesh::caveshbdlist
arraypool * caveshbdlist
Definition: tetgen.h:2068
tetgenmesh::flip32s
long flip32s
Definition: tetgen.h:2174
tetgenmesh::flip26count
long flip26count
Definition: tetgen.h:2156
tetgenmesh::dummypoint
point dummypoint
Definition: tetgen.h:2083
tetgenmesh::across_face_count
long across_face_count
Definition: tetgen.h:2160
tetgenmesh::segpglist
int * segpglist
Definition: tetgen.h:2098
tetgenmesh::jettisoninverts
int jettisoninverts
Definition: tetgen.h:2143
tetgenmesh::maxbowatcavsize
long maxbowatcavsize
Definition: tetgen.h:2159
tetgenmesh::tetrahedron
REAL ** tetrahedron
Definition: tetgen.h:972
tetgenmesh::across_max_count
long across_max_count
Definition: tetgen.h:2160
tetgenmesh::minfaceang
REAL minfaceang
Definition: tetgen.h:2148
tetgenmesh::dummytet
tetrahedron * dummytet
Definition: tetgen.h:2051
tetgenmesh::checksubsegs
int checksubsegs
Definition: tetgen.h:2132
tetgenmesh::failsubcount
long failsubcount
Definition: tetgen.h:2168
tetgenmesh::ptloc_max_count
long ptloc_max_count
Definition: tetgen.h:2153
tetgenmesh::badsubsegs
memorypool * badsubsegs
Definition: tetgen.h:2045
tetgenmesh::flipn2ncount
long flipn2ncount
Definition: tetgen.h:2156
tetgenmesh::totalbowatcavsize
long totalbowatcavsize
Definition: tetgen.h:2159
tetgenmesh::randomseed
unsigned long randomseed
Definition: tetgen.h:2145
tetgenmesh::fixededgelist
arraypool * fixededgelist
Definition: tetgen.h:2079
tetgenmesh::b_steinerflag
bool b_steinerflag
Definition: tetgen.h:2150
tetgenmesh::bgm
tetgenmesh * bgm
Definition: tetgen.h:2036
tetgenmesh::cdtenforcesegpts
long cdtenforcesegpts
Definition: tetgen.h:2171
tetgenmesh::hullsize
long hullsize
Definition: tetgen.h:2116
tetgenmesh::rejtetpts
long rejtetpts
Definition: tetgen.h:2172
tetgenmesh::updsegcount
long updsegcount
Definition: tetgen.h:2167
tetgenmesh::shmarkindex
int shmarkindex
Definition: tetgen.h:2129
tetgenmesh::segpbcgrouptable
list * segpbcgrouptable
Definition: tetgen.h:2095
tetgenmesh::macheps
REAL macheps
Definition: tetgen.h:2146
tetgenmesh::checksubfaces
int checksubfaces
Definition: tetgen.h:2131
tetgenmesh::ndelaunayedgecount
long ndelaunayedgecount
Definition: tetgen.h:2162
tetgenmesh::badsubfaces
memorypool * badsubfaces
Definition: tetgen.h:2046
tetgenmesh::suprelverts
int suprelverts
Definition: tetgen.h:2139
tetgenmesh::maxcavverts
int maxcavverts
Definition: tetgen.h:2149
tetgenmesh::unsupverts
int unsupverts
Definition: tetgen.h:2141
tetgenmesh::dummysh
shellface * dummysh
Definition: tetgen.h:2056
tetgenmesh::nonconvex
int nonconvex
Definition: tetgen.h:2135
tetgenmesh::abovepoint
point abovepoint
Definition: tetgen.h:2083
tetgenmesh::areaboundindex
int areaboundindex
Definition: tetgen.h:2130
tetgenmesh::r3count
long r3count
Definition: tetgen.h:2170
tetgenmesh::cavityexpcount
long cavityexpcount
Definition: tetgen.h:2162
tetgenmesh::zmax
REAL zmax
Definition: tetgen.h:2113
tetgenmesh::bowatvolcount
long bowatvolcount
Definition: tetgen.h:2166
tetgenmesh::ymax
REAL ymax
Definition: tetgen.h:2113
tetgenmesh::insegments
long insegments
Definition: tetgen.h:2117
tetgenmesh::cavebdrylist
arraypool * cavebdrylist
Definition: tetgen.h:2067
tetgenmesh::point
REAL * point
Definition: tetgen.h:998
tetgenmesh::caveoldtetlist
arraypool * caveoldtetlist
Definition: tetgen.h:2067
tetgenmesh::in
tetgenio * in
Definition: tetgen.h:2030
tetgenmesh::shellface
REAL ** shellface
Definition: tetgen.h:985
tetgenmesh::bowatsegcount
long bowatsegcount
Definition: tetgen.h:2166
tetgenmesh::opt_tet_peels
long opt_tet_peels
Definition: tetgen.h:2163
tetgenmesh::zmin
REAL zmin
Definition: tetgen.h:2113
tetgenmesh::PI
static REAL PI
Definition: tetgen.h:1641
tetgenmesh::flip14count
long flip14count
Definition: tetgen.h:2156
tetgenmesh::b
tetgenbehavior * b
Definition: tetgen.h:2033
tetgenmesh::tetrahedrons
memorypool * tetrahedrons
Definition: tetgen.h:2041
tetgenmesh::dummytetbase
tetrahedron * dummytetbase
Definition: tetgen.h:2052
tetgenmesh::dupverts
int dupverts
Definition: tetgen.h:2136
tetgenmesh::point2simindex
int point2simindex
Definition: tetgen.h:2122
tetgenmesh::ymin
REAL ymin
Definition: tetgen.h:2113
tetgenmesh::minfacetdihed
REAL minfacetdihed
Definition: tetgen.h:2148
tetgenmesh::facetabovepointarray
point * facetabovepointarray
Definition: tetgen.h:2083
tetgenmesh::checkpbcs
int checkpbcs
Definition: tetgen.h:2133
tetgenmesh::varconstraint
int varconstraint
Definition: tetgen.h:2134
tetgenmesh::longest
REAL longest
Definition: tetgen.h:2114
tetgenmesh::unuverts
int unuverts
Definition: tetgen.h:2137
tetgenmesh::inserthullcount
long inserthullcount
Definition: tetgen.h:2158
tetgenmesh::points
memorypool * points
Definition: tetgen.h:2044
tetgenmesh::updsubcount
long updsubcount
Definition: tetgen.h:2167
tetgenmesh::caveshlist
arraypool * caveshlist
Definition: tetgen.h:2068
tetgenmesh::volumeboundindex
int volumeboundindex
Definition: tetgen.h:2127
tetgenmesh::failvolcount
long failvolcount
Definition: tetgen.h:2168
tetgenmesh::cavetetlist
arraypool * cavetetlist
Definition: tetgen.h:2067
tetgenmesh::subfacstack
arraypool * subfacstack
Definition: tetgen.h:2070

References abovecount, abovepoint, across_edge_count, across_face_count, across_max_count, areaboundindex, b, b_steinerflag, badsubfaces, badsubsegs, badtetrahedrons, bgm, bowatsegcount, bowatsubcount, bowatvolcount, btreenode_list, cavebdrylist, caveoldtetlist, caveshbdlist, caveshlist, cavetetlist, cavityexpcount, cdtenforcesegpts, checkpbcs, checksubfaces, checksubsegs, collapverts, dummypoint, dummysh, dummyshbase, dummytet, dummytetbase, dupverts, elemattribindex, elemfliplist, facetabovepointarray, failsegcount, failsubcount, failvolcount, fixededgelist, flip14count, flip22count, flip22s, flip23s, flip26count, flip32s, flip44s, flipn2ncount, highorderindex, highordertable, hullsize, idx2segpglist, in, insegments, inserthullcount, insphere_sos_count, inspherecount, jettisoninverts, longest, macheps, maxbowatcavsize, maxcavfaces, maxcavsize, maxcavverts, maxregionsize, meshedges, minfaceang, minfacetdihed, ndelaunayedgecount, nonconvex, opt_edge_flips, opt_face_flips, opt_tet_peels, orient3dcount, outbowatcircumcount, PI, point2pbcptindex, point2simindex, pointmarkindex, pointmtrindex, points, ptloc_count, ptloc_max_count, r1count, r2count, r3count, randomseed, rejsegpts, rejsubpts, rejtetpts, relverts, samples, segpbcgrouptable, segpglist, shmarkindex, subfaces, subfacstack, subpbcgrouptable, subsegs, subsegstack, suprelverts, tet2segpool, tet2subpool, tetrahedrons, totalbowatcavsize, totaldeadtets, unsupverts, unuverts, updsegcount, updsubcount, updvolcount, varconstraint, volumeboundindex, xmax, xmin, ymax, ymin, zmax, and zmin.

◆ ~tetgenmesh()

tetgenmesh::~tetgenmesh ( )
inline
2279  {
2280  bgm = (tetgenmesh *) NULL;
2281  in = (tetgenio *) NULL;
2282  b = (tetgenbehavior *) NULL;
2283 
2284  if (tetrahedrons != (memorypool *) NULL) {
2285  delete tetrahedrons;
2286  }
2287  if (subfaces != (memorypool *) NULL) {
2288  delete subfaces;
2289  }
2290  if (subsegs != (memorypool *) NULL) {
2291  delete subsegs;
2292  }
2293  if (points != (memorypool *) NULL) {
2294  delete points;
2295  }
2296  if (tet2segpool != NULL) {
2297  delete tet2segpool;
2298  }
2299  if (tet2subpool != NULL) {
2300  delete tet2subpool;
2301  }
2302  if (dummytetbase != (tetrahedron *) NULL) {
2303  delete [] dummytetbase;
2304  }
2305  if (dummyshbase != (shellface *) NULL) {
2306  delete [] dummyshbase;
2307  }
2308  if (facetabovepointarray != (point *) NULL) {
2309  delete [] facetabovepointarray;
2310  }
2311  if (dummypoint != NULL) {
2312  delete [] dummypoint;
2313  }
2314  if (highordertable != (point *) NULL) {
2315  delete [] highordertable;
2316  }
2317  if (subpbcgrouptable != (pbcdata *) NULL) {
2318  delete [] subpbcgrouptable;
2319  }
2320  if (segpbcgrouptable != (list *) NULL) {
2321  delete segpbcgrouptable;
2322  delete [] idx2segpglist;
2323  delete [] segpglist;
2324  }
2325 
2326  if (cavetetlist != NULL) {
2327  delete cavetetlist;
2328  delete cavebdrylist;
2329  delete caveoldtetlist;
2330  }
2331  if (subsegstack != NULL) {
2332  delete subsegstack;
2333  }
2334  if (subfacstack != NULL) {
2335  delete subfacstack;
2336  }
2337  } // ~tetgenmesh()

References b, bgm, cavebdrylist, caveoldtetlist, cavetetlist, dummypoint, dummyshbase, dummytetbase, facetabovepointarray, highordertable, idx2segpglist, in, points, segpbcgrouptable, segpglist, subfaces, subfacstack, subpbcgrouptable, subsegs, subsegstack, tet2segpool, tet2subpool, and tetrahedrons.

Member Function Documentation

◆ acceptfacpt()

bool tetgenmesh::acceptfacpt ( point  facpt,
list *  subceillist,
list *  verlist 
)

◆ acceptsegpt()

bool tetgenmesh::acceptsegpt ( point  segpt,
point  refpt,
face *  splitseg 
)

◆ acceptvolpt()

bool tetgenmesh::acceptvolpt ( point  volpt,
list *  ceillist,
list *  verlist 
)

◆ adjustedgering() [1/2]

void tetgenmesh::adjustedgering ( face &  s,
int  direction 
)
inline
3314  {
3315  if (EdgeRing(s.shver) != direction) {
3316  sesymself(s);
3317  }
3318 }
tetgenmesh::sesymself
void sesymself(face &s)
Definition: tetgen.h:2947
s
RealScalar s
Definition: level1_cplx_impl.h:130
EdgeRing
#define EdgeRing(V)
Definition: tetgen.h:2442

References EdgeRing, s, and sesymself().

◆ adjustedgering() [2/2]

void tetgenmesh::adjustedgering ( triface &  t,
int  direction 
)
inline
3308  {
3309  if (EdgeRing(t.ver) != direction) {
3310  esymself(t);
3311  }
3312 }
tetgenmesh::esymself
void esymself(triface &t)
Definition: tetgen.h:2542
plotPSD.t
t
Definition: plotPSD.py:36

References EdgeRing, esymself(), and plotPSD::t.

◆ adjustlocate()

enum locateresult tetgenmesh::adjustlocate ( point  ,
triface *  ,
enum  locateresult,
REAL   
)

◆ adjustlocateseg()

enum locateresult tetgenmesh::adjustlocateseg ( point  ,
face *  ,
enum  locateresult,
REAL   
)

◆ adjustlocatesub()

enum locateresult tetgenmesh::adjustlocatesub ( point  ,
face *  ,
enum  locateresult,
REAL   
)

◆ algorithmicstatistics()

void tetgenmesh::algorithmicstatistics ( )

◆ apex()

tetgenmesh::point tetgenmesh::apex ( triface &  t)
inline
2505  {
2506  return (point) t.tet[locver2apex[t.loc][t.ver] + 4];
2507 }
tetgenmesh::locver2apex
static int locver2apex[4][6]
Definition: tetgen.h:1193

References locver2apex, and plotPSD::t.

Referenced by isfacehaspoint(), symedge(), and symedgeself().

◆ areabound()

REAL tetgenmesh::areabound ( face &  s)
inline
2992  {
2993  return ((REAL *) (s.sh))[areaboundindex];
2994 }
REAL
#define REAL
Definition: tetgen.h:146

References areaboundindex, REAL, and s.

◆ assignregionattribs()

void tetgenmesh::assignregionattribs ( )

◆ assignsegmentmarkers()

void tetgenmesh::assignsegmentmarkers ( )

◆ badfacedealloc()

void tetgenmesh::badfacedealloc ( memorypool *  ,
badface *   
)

◆ badfacetraverse()

badface* tetgenmesh::badfacetraverse ( memorypool *  )

◆ bond()

void tetgenmesh::bond ( triface &  t1,
triface &  t2 
)
inline
2480  {
2481  t1.tet[t1.loc] = encode(t2);
2482  t2.tet[t2.loc] = encode(t1);
2483 }
tetgenmesh::encode
tetrahedron encode(triface &t)
Definition: tetgen.h:2462

References encode(), tetgenmesh::triface::loc, and tetgenmesh::triface::tet.

◆ bowatinsertsite()

void tetgenmesh::bowatinsertsite ( point  bp,
face *  splitseg,
int  n,
list **  sublists,
list **  subceillists,
list **  tetlists,
list **  ceillists,
list *  verlist,
queue *  flipque,
bool  chkencseg,
bool  chkencsub,
bool  chkbadtet 
)

◆ btree_insert()

void tetgenmesh::btree_insert ( point  insertpt)

◆ btree_search()

void tetgenmesh::btree_search ( point  searchpt,
triface *  searchtet 
)

◆ btree_sort()

void tetgenmesh::btree_sort ( point *  ,
int  ,
int  ,
REAL  ,
REAL  ,
REAL  ,
REAL  ,
REAL  ,
REAL  ,
int   
)

◆ carvecavity() [1/2]

void tetgenmesh::carvecavity ( arraypool *  ,
arraypool *  ,
arraypool *   
)

◆ carvecavity() [2/2]

bool tetgenmesh::carvecavity ( list *  newtetlist,
list *  outtetlist,
list *  gluetetlist,
queue *  flipque 
)

◆ carveholes()

void tetgenmesh::carveholes ( )

◆ carveholessub()

void tetgenmesh::carveholessub ( int  holes,
REAL *  holelist,
memorypool *  viri 
)

◆ check4fixededge()

bool tetgenmesh::check4fixededge ( point  pa,
point  pb 
)

◆ checkconforming()

void tetgenmesh::checkconforming ( )

◆ checkdelaunay()

int tetgenmesh::checkdelaunay ( REAL  ,
queue *   
)

◆ checkmesh()

int tetgenmesh::checkmesh ( )

◆ checkseg4encroach()

bool tetgenmesh::checkseg4encroach ( face *  testseg,
point  testpt,
point *  ,
bool  enqflag 
)

◆ checksegments()

int tetgenmesh::checksegments ( )

◆ checkshells()

int tetgenmesh::checkshells ( )

◆ checksub4encroach()

bool tetgenmesh::checksub4encroach ( face *  testsub,
point  testpt,
bool  enqflag 
)

◆ checktet4badqual()

bool tetgenmesh::checktet4badqual ( triface *  testtet,
bool  enqflag 
)

◆ checktet4ill()

bool tetgenmesh::checktet4ill ( triface *  testtet,
bool  enqflag 
)

◆ checktet4opt()

bool tetgenmesh::checktet4opt ( triface *  testtet,
bool  enqflag 
)

◆ circumsphere()

bool tetgenmesh::circumsphere ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *  cent,
REAL *  radius 
)

◆ collapseedge()

void tetgenmesh::collapseedge ( point  suppt,
point  conpt,
list *  oldtetlist,
list *   
)

◆ constrainedcavity()

bool tetgenmesh::constrainedcavity ( triface *  oldtet,
list *  floorlist,
list *  ceillist,
list *  ptlist,
list *  frontlist,
list *  misfrontlist,
list *  newtetlist,
list *  gluetetlist,
list *  glueshlist,
queue *  flipque 
)

◆ constrainededge()

void tetgenmesh::constrainededge ( face *  startsh,
point  tend,
queue *  flipqueue 
)

◆ constrainedfacets2()

void tetgenmesh::constrainedfacets2 ( )

◆ cross()

void tetgenmesh::cross ( REAL *  v1,
REAL *  v2,
REAL *  n 
)
inline
3371 {
3372  n[0] = v1[1] * v2[2] - v2[1] * v1[2];
3373  n[1] = -(v1[0] * v2[2] - v2[0] * v1[2]);
3374  n[2] = v1[0] * v2[1] - v2[0] * v1[1];
3375 }
n
const unsigned n
Definition: CG3DPackingUnitTest.cpp:11
v2
Map< RowVectorXf > v2(M2.data(), M2.size())
v1
M1<< 1, 2, 3, 4, 5, 6, 7, 8, 9;Map< RowVectorXf > v1(M1.data(), M1.size())

References n, v1(), and v2().

◆ deallocfaketets()

void tetgenmesh::deallocfaketets ( list *  frontlist)

◆ decidefeaturepointsizes()

void tetgenmesh::decidefeaturepointsizes ( )

◆ decode()

void tetgenmesh::decode ( tetrahedron  ptr,
triface &  t 
)
inline
2457  {
2458  t.loc = (int) ((uintptr_t) (ptr) & (uintptr_t) 3);
2459  t.tet = (tetrahedron *) ((uintptr_t) (ptr) & ~(uintptr_t) 7);
2460 }
int
return int(ret)+1

References int(), and plotPSD::t.

Referenced by stpivot(), sym(), symedge(), symedgeself(), and symself().

◆ delaunizecavity()

bool tetgenmesh::delaunizecavity ( arraypool *  ,
arraypool *  ,
arraypool *  ,
arraypool *  ,
arraypool *  ,
arraypool *   
)

◆ delaunizecavvertices()

bool tetgenmesh::delaunizecavvertices ( triface *  ,
list *  ,
list *  ,
list *  ,
queue *   
)

◆ delaunizesegments2()

void tetgenmesh::delaunizesegments2 ( )

◆ delaunizevertices()

long tetgenmesh::delaunizevertices ( )

◆ dequeuebadtet()

void tetgenmesh::dequeuebadtet ( )

◆ dequeueencsub()

badface* tetgenmesh::dequeueencsub ( int *  quenumber)

◆ dest()

tetgenmesh::point tetgenmesh::dest ( triface &  t)
inline
2501  {
2502  return (point) t.tet[locver2dest[t.loc][t.ver] + 4];
2503 }
tetgenmesh::locver2dest
static int locver2dest[4][6]
Definition: tetgen.h:1192

References locver2dest, and plotPSD::t.

Referenced by isfacehaspoint().

◆ detachauxsubfaces()

void tetgenmesh::detachauxsubfaces ( list *  newtetlist)

◆ detectinterfaces()

void tetgenmesh::detectinterfaces ( )

◆ dissolve()

void tetgenmesh::dissolve ( triface &  t)
inline
2490  {
2491  t.tet[t.loc] = (tetrahedron) dummytet;
2492 }

References dummytet, and plotPSD::t.

◆ distance()

REAL tetgenmesh::distance ( REAL *  p1,
REAL *  p2 
)
inline
3379 {
3380  return sqrt((p2[0] - p1[0]) * (p2[0] - p1[0]) +
3381  (p2[1] - p1[1]) * (p2[1] - p1[1]) +
3382  (p2[2] - p1[2]) * (p2[2] - p1[2]));
3383 }
sqrt
AnnoyingScalar sqrt(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:134
p1
Vector3f p1
Definition: MatrixBase_all.cpp:2

References p1, and sqrt().

◆ distance2()

REAL tetgenmesh::distance2 ( tetrahedron *  tetptr,
point  p 
)

◆ dot()

REAL tetgenmesh::dot ( REAL *  v1,
REAL *  v2 
)
inline
3364 {
3365  return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
3366 }

References v1(), and v2().

◆ dummyinit()

void tetgenmesh::dummyinit ( int  ,
int   
)

◆ duplicatebgmesh()

void tetgenmesh::duplicatebgmesh ( )

◆ edge_edge_cop_inter()

enum interresult tetgenmesh::edge_edge_cop_inter ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *   
)

◆ edge_vert_col_inter()

enum interresult tetgenmesh::edge_vert_col_inter ( REAL *  ,
REAL *  ,
REAL *   
)

◆ edgemarked()

bool tetgenmesh::edgemarked ( triface &  t)
inline
2847  {
2848  return (((int *) (t.tet))[elemmarkerindex] &
2849  (int) (64<<locver2edge[(t).loc][(t).ver])) != 0;
2850 }
tetgenmesh::elemmarkerindex
int elemmarkerindex
Definition: tetgen.h:2128
tetgenmesh::locver2edge
static int locver2edge[4][6]
Definition: tetgen.h:1204

References elemmarkerindex, locver2edge, and plotPSD::t.

◆ edgeorthonormal()

void tetgenmesh::edgeorthonormal ( REAL *  e1,
REAL *  e2,
REAL *  op,
REAL *  n 
)

◆ elemattribute()

REAL tetgenmesh::elemattribute ( tetrahedron *  ptr,
int  attnum 
)
inline
2749  {
2750  return ((REAL *) (ptr))[elemattribindex + attnum];
2751 }

References elemattribindex, and REAL.

◆ encode()

tetgenmesh::tetrahedron tetgenmesh::encode ( triface &  t)
inline
2462  {
2463  return (tetrahedron) ((uintptr_t) t.tet | (uintptr_t) t.loc);
2464 }

References plotPSD::t.

Referenced by bond(), and tsbond().

◆ enext()

void tetgenmesh::enext ( triface &  t1,
triface &  t2 
)
inline
2548  {
2549  t2.tet = t1.tet;
2550  t2.loc = t1.loc;
2551  t2.ver = ve[t1.ver];
2552 }
tetgenmesh::ve
static int ve[6]
Definition: tetgen.h:1184

References tetgenmesh::triface::loc, tetgenmesh::triface::tet, ve, and tetgenmesh::triface::ver.

Referenced by enextfnext().

◆ enext2()

void tetgenmesh::enext2 ( triface &  t1,
triface &  t2 
)
inline
2560  {
2561  t2.tet = t1.tet;
2562  t2.loc = t1.loc;
2563  t2.ver = ve[ve[t1.ver]];
2564 }

References tetgenmesh::triface::loc, tetgenmesh::triface::tet, ve, and tetgenmesh::triface::ver.

Referenced by enext2fnext().

◆ enext2fnext()

void tetgenmesh::enext2fnext ( triface &  t1,
triface &  t2 
)
inline
2737  {
2738  enext2(t1, t2);
2739  fnextself(t2);
2740 }
tetgenmesh::fnextself
bool fnextself(triface &t)
Definition: tetgen.h:2605
tetgenmesh::enext2
void enext2(triface &t1, triface &t2)
Definition: tetgen.h:2560

References enext2(), and fnextself().

◆ enext2fnextself()

void tetgenmesh::enext2fnextself ( triface &  t)
inline
2742  {
2743  enext2self(t);
2744  fnextself(t);
2745 }
tetgenmesh::enext2self
void enext2self(triface &t)
Definition: tetgen.h:2566

References enext2self(), fnextself(), and plotPSD::t.

◆ enext2self()

void tetgenmesh::enext2self ( triface &  t)
inline
2566  {
2567  t.ver = ve[ve[t.ver]];
2568 }

References plotPSD::t, and ve.

Referenced by enext2fnextself().

◆ enextfnext()

void tetgenmesh::enextfnext ( triface &  t1,
triface &  t2 
)
inline
2727  {
2728  enext(t1, t2);
2729  fnextself(t2);
2730 }
tetgenmesh::enext
void enext(triface &t1, triface &t2)
Definition: tetgen.h:2548

References enext(), and fnextself().

◆ enextfnextself()

void tetgenmesh::enextfnextself ( triface &  t)
inline
2732  {
2733  enextself(t);
2734  fnextself(t);
2735 }
tetgenmesh::enextself
void enextself(triface &t)
Definition: tetgen.h:2554

References enextself(), fnextself(), and plotPSD::t.

◆ enextself()

void tetgenmesh::enextself ( triface &  t)
inline
2554  {
2555  t.ver = ve[t.ver];
2556 }

References plotPSD::t, and ve.

Referenced by enextfnextself(), fnext(), and fnextself().

◆ enforcequality()

void tetgenmesh::enforcequality ( )

◆ enqueuebadtet()

void tetgenmesh::enqueuebadtet ( triface *  tt,
REAL  key,
REAL *  cent 
)

◆ enqueueencsub()

void tetgenmesh::enqueueencsub ( face *  ss,
point  encpt,
int  quenumber,
REAL *  cent 
)

◆ enqueueflipedge()

void tetgenmesh::enqueueflipedge ( face &  ,
queue *   
)

◆ enqueueflipface()

void tetgenmesh::enqueueflipface ( triface &  ,
queue *   
)

◆ esym()

void tetgenmesh::esym ( triface &  t1,
triface &  t2 
)
inline
2536  {
2537  t2.tet = t1.tet;
2538  t2.loc = t1.loc;
2539  t2.ver = t1.ver + (EdgeRing(t1.ver) ? -1 : 1);
2540 }

References EdgeRing, tetgenmesh::triface::loc, tetgenmesh::triface::tet, and tetgenmesh::triface::ver.

◆ esymself()

void tetgenmesh::esymself ( triface &  t)
inline
2542  {
2543  t.ver += (EdgeRing(t.ver) ? -1 : 1);
2544 }

References EdgeRing, and plotPSD::t.

Referenced by adjustedgering().

◆ facedihedral()

REAL tetgenmesh::facedihedral ( REAL *  pa,
REAL *  pb,
REAL *  pc1,
REAL *  pc2 
)

◆ facemarked()

bool tetgenmesh::facemarked ( triface &  t)
inline
2828  {
2829  return (((int *) (t.tet))[elemmarkerindex] & (int) (4<<(t).loc)) != 0;
2830 }

References elemmarkerindex, and plotPSD::t.

◆ facenormal()

void tetgenmesh::facenormal ( REAL *  pa,
REAL *  pb,
REAL *  pc,
REAL *  n,
REAL *  nlen 
)

◆ facenormal2()

void tetgenmesh::facenormal2 ( point  pa,
point  pb,
point  pc,
REAL *  n,
int  pivot 
)

◆ fillcavity()

bool tetgenmesh::fillcavity ( arraypool *  ,
arraypool *  ,
arraypool *  ,
arraypool *   
)

◆ findcollapseedge()

bool tetgenmesh::findcollapseedge ( point  suppt,
point *  conpt,
list *  oldtetlist,
list *   
)

◆ finddirection()

enum finddirectionresult tetgenmesh::finddirection ( triface *  searchtet,
point  ,
long   
)

◆ finddirection2()

enum interresult tetgenmesh::finddirection2 ( triface *  searchtet,
point   
)

◆ finddirection3()

enum interresult tetgenmesh::finddirection3 ( triface *  searchtet,
point   
)

◆ finddirectionsub()

enum finddirectionresult tetgenmesh::finddirectionsub ( face *  searchsh,
point  tend 
)

◆ findedge() [1/2]

void tetgenmesh::findedge ( face *  s,
point  eorg,
point  edest 
)

◆ findedge() [2/2]

void tetgenmesh::findedge ( triface *  t,
point  eorg,
point  edest 
)

◆ findorg() [1/2]

bool tetgenmesh::findorg ( face *  s,
point  dorg 
)

◆ findorg() [2/2]

bool tetgenmesh::findorg ( triface *  t,
point  dorg 
)

◆ findrelocatepoint2()

bool tetgenmesh::findrelocatepoint2 ( point  sp,
point  np,
REAL *  n,
list *  ,
list *   
)

◆ flip22()

void tetgenmesh::flip22 ( triface *  ,
queue *   
)

◆ flip22sub()

void tetgenmesh::flip22sub ( face *  ,
queue *   
)

◆ flip23()

void tetgenmesh::flip23 ( triface *  ,
queue *   
)

◆ flip32()

void tetgenmesh::flip32 ( triface *  ,
queue *   
)

◆ flipedgerecursive()

void tetgenmesh::flipedgerecursive ( face *  flipedge,
queue *  flipqueue 
)

◆ fnext()

bool tetgenmesh::fnext ( triface &  t1,
triface &  t2 
)
inline
2575 {
2576  // Get the next face.
2577  t2.loc = locver2nextf[t1.loc][t1.ver][0];
2578  // Is the next face in the same tet?
2579  if (t2.loc != -1) {
2580  // It's in the same tet. Get the edge version.
2581  t2.ver = locver2nextf[t1.loc][t1.ver][1];
2582  t2.tet = t1.tet;
2583  } else {
2584  // The next face is in the neigbhour of 't1'.
2585  sym(t1, t2);
2586  if (t2.tet != dummytet) {
2587  // Find the corresponding edge in t2.
2588  point torg;
2589  int tloc, tver, i;
2590  t2.ver = 0;
2591  torg = org(t1);
2592  for (i = 0; (i < 3) && (org(t2) != torg); i++) {
2593  enextself(t2);
2594  }
2595  // Go to the next face in t2.
2596  tloc = t2.loc;
2597  tver = t2.ver;
2598  t2.loc = locver2nextf[tloc][tver][0];
2599  t2.ver = locver2nextf[tloc][tver][1];
2600  }
2601  }
2602  return t2.tet != dummytet;
2603 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
tetgenmesh::locver2nextf
static int locver2nextf[4][6][2]
Definition: tetgen.h:1201
tetgenmesh::sym
void sym(triface &t1, triface &t2)
Definition: tetgen.h:2468
tetgenmesh::org
point org(triface &t)
Definition: tetgen.h:2497

References dummytet, enextself(), i, tetgenmesh::triface::loc, locver2nextf, org(), sym(), tetgenmesh::triface::tet, and tetgenmesh::triface::ver.

◆ fnextself()

bool tetgenmesh::fnextself ( triface &  t)
inline
2606 {
2607  triface t2;
2608 
2609  // Get the next face.
2610  t2.loc = locver2nextf[t1.loc][t1.ver][0];
2611  // Is the next face in the same tet?
2612  if (t2.loc != -1) {
2613  // It's in the same tet. Get the edge version.
2614  t2.ver = locver2nextf[t1.loc][t1.ver][1];
2615  t1.loc = t2.loc;
2616  t1.ver = t2.ver;
2617  } else {
2618  // The next face is in the neigbhour of 't1'.
2619  sym(t1, t2);
2620  if (t2.tet != dummytet) {
2621  // Find the corresponding edge in t2.
2622  point torg;
2623  int i;
2624  t2.ver = 0;
2625  torg = org(t1);
2626  for (i = 0; (i < 3) && (org(t2) != torg); i++) {
2627  enextself(t2);
2628  }
2629  t1.loc = locver2nextf[t2.loc][t2.ver][0];
2630  t1.ver = locver2nextf[t2.loc][t2.ver][1];
2631  t1.tet = t2.tet;
2632  }
2633  }
2634  return t2.tet != dummytet;
2635 }

References dummytet, enextself(), i, tetgenmesh::triface::loc, locver2nextf, org(), sym(), tetgenmesh::triface::tet, and tetgenmesh::triface::ver.

Referenced by enext2fnext(), enext2fnextself(), enextfnext(), and enextfnextself().

◆ formbowatcavity()

void tetgenmesh::formbowatcavity ( point  bp,
face *  bpseg,
face *  bpsh,
int *  n,
int *  nmax,
list **  sublists,
list **  subceillists,
list **  tetlists,
list **  ceillists 
)

◆ formbowatcavityquad()

void tetgenmesh::formbowatcavityquad ( point  ,
list *  ,
list *   
)

◆ formbowatcavitysegquad()

void tetgenmesh::formbowatcavitysegquad ( point  ,
list *  ,
list *   
)

◆ formbowatcavitysub()

void tetgenmesh::formbowatcavitysub ( point  ,
face *  ,
list *  ,
list *   
)

◆ formcavity()

void tetgenmesh::formcavity ( face *  ,
arraypool *  ,
arraypool *  ,
arraypool *  ,
arraypool *  ,
arraypool *  ,
arraypool *  ,
arraypool *   
)

◆ formskeleton()

void tetgenmesh::formskeleton ( clock_t &  )

◆ formstarpolygon()

void tetgenmesh::formstarpolygon ( point  pt,
list *  trilist,
list *  verlist 
)

◆ formstarpolyhedron()

void tetgenmesh::formstarpolyhedron ( point  pt,
list *  tetlist,
list *  verlist,
bool   
)

◆ getelemmarker()

int tetgenmesh::getelemmarker ( tetrahedron *  ptr)
inline
2770  {
2771  return ((int *) (ptr))[elemmarkerindex];
2772 }

References elemmarkerindex.

◆ getfacetabovepoint()

void tetgenmesh::getfacetabovepoint ( face *  facetsh)

◆ getnextsface()

void tetgenmesh::getnextsface ( face *  ,
face *   
)

Referenced by sfnext(), and sfnextself().

◆ getonextseg()

void tetgenmesh::getonextseg ( face *  s,
face *  lseg 
)

◆ getseghasorg()

void tetgenmesh::getseghasorg ( face *  sseg,
point  dorg 
)

◆ getsegmentsplitpoint2()

void tetgenmesh::getsegmentsplitpoint2 ( face *  sseg,
point  refpt,
REAL *  vt 
)

◆ getsegmentsplitpoint3()

void tetgenmesh::getsegmentsplitpoint3 ( face *  sseg,
point  refpt,
REAL *  vt 
)

◆ getsplitpoint()

void tetgenmesh::getsplitpoint ( point  e1,
point  e2,
point  refpt,
point  newpt 
)

◆ getsubsegfardest()

point tetgenmesh::getsubsegfardest ( face *  sseg)

◆ getsubsegfarorg()

point tetgenmesh::getsubsegfarorg ( face *  sseg)

◆ gluefronts()

void tetgenmesh::gluefronts ( triface *  front,
triface *  front1,
list *  gluetetlist,
list *  glueshlist 
)

◆ highorder()

void tetgenmesh::highorder ( )

◆ hullwalk()

enum locateresult tetgenmesh::hullwalk ( point  searchpt,
triface *  hulltet 
)

◆ identifyfronts()

bool tetgenmesh::identifyfronts ( list *  frontlist,
list *  misfrontlist,
list *  gluetetlist,
list *  glueshlist 
)

◆ incircle3d()

REAL tetgenmesh::incircle3d ( point  pa,
point  pb,
point  pc,
point  pd 
)

◆ incrflipdelaunay()

bool tetgenmesh::incrflipdelaunay ( triface *  ,
point *  ,
long  ,
bool  ,
bool  ,
REAL  ,
queue *   
)

◆ incrflipdelaunaysub()

bool tetgenmesh::incrflipdelaunaysub ( int  shmark,
REAL  eps,
list *  ,
int  ,
REAL *  ,
queue *   
)

◆ infect()

void tetgenmesh::infect ( triface &  t)
inline
2782  {
2783  ((int *) (t.tet))[elemmarkerindex] |= (int) 1;
2784 }

References elemmarkerindex, and plotPSD::t.

◆ infected()

bool tetgenmesh::infected ( triface &  t)
inline
2792  {
2793  return (((int *) (t.tet))[elemmarkerindex] & (int) 1) != 0;
2794 }

References elemmarkerindex, and plotPSD::t.

◆ infecthull()

void tetgenmesh::infecthull ( memorypool *  viri)

◆ infecthullsub()

void tetgenmesh::infecthullsub ( memorypool *  viri)

◆ initializecavity()

void tetgenmesh::initializecavity ( list *  floorlist,
list *  ceillist,
list *  frontlist,
list *  ptlist,
list *  gluelist 
)

◆ initializepools()

void tetgenmesh::initializepools ( )

◆ inscribedsphere()

void tetgenmesh::inscribedsphere ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *  cent,
REAL *  radius 
)

◆ insertauxsubface()

void tetgenmesh::insertauxsubface ( triface *  front,
triface *  idfront 
)

◆ insertconstrainedpoints()

void tetgenmesh::insertconstrainedpoints ( tetgenio *  addio)

◆ insertsubseg()

void tetgenmesh::insertsubseg ( face *  tri)

◆ insertvertexbw()

enum locateresult tetgenmesh::insertvertexbw ( point  insertpt,
triface *  searchtet,
bool  bwflag,
bool  visflag,
bool  noencsegflag,
bool  noencsubflag 
)

◆ insphere_s()

REAL tetgenmesh::insphere_s ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *   
)

◆ interecursive()

void tetgenmesh::interecursive ( shellface **  subfacearray,
int  arraysize,
int  axis,
REAL  bxmin,
REAL  bxmax,
REAL  bymin,
REAL  bymax,
REAL  bzmin,
REAL  bzmax,
int *  internum 
)

◆ interiorangle()

REAL tetgenmesh::interiorangle ( REAL *  o,
REAL *  p1,
REAL *  p2,
REAL *  n 
)

◆ interpolatesizemap()

void tetgenmesh::interpolatesizemap ( )

◆ iscollinear()

bool tetgenmesh::iscollinear ( REAL *  ,
REAL *  ,
REAL *  ,
REAL  eps 
)

◆ iscoplanar()

bool tetgenmesh::iscoplanar ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL  vol6,
REAL  eps 
)

◆ iscospheric()

bool tetgenmesh::iscospheric ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL  vol24,
REAL  eps 
)

◆ isdead() [1/2]

bool tetgenmesh::isdead ( face *  s)
inline
3327  {
3328  if (s->sh == (shellface *) NULL) return true;
3329  else return s->sh[3] == (shellface) NULL;
3330 }

References s.

◆ isdead() [2/2]

bool tetgenmesh::isdead ( triface *  t)
inline
3322  {
3323  if (t->tet == (tetrahedron *) NULL) return true;
3324  else return t->tet[4] == (tetrahedron) NULL;
3325 }

References plotPSD::t.

◆ isfacehasedge()

bool tetgenmesh::isfacehasedge ( face *  s,
point  tend1,
point  tend2 
)
inline
3349  {
3350  return (isfacehaspoint(s, tend1) && isfacehaspoint(s, tend2));
3351 }
tetgenmesh::isfacehaspoint
bool isfacehaspoint(triface *t, point testpoint)
Definition: tetgen.h:3335

References isfacehaspoint(), and s.

◆ isfacehaspoint() [1/2]

bool tetgenmesh::isfacehaspoint ( face *  t,
point  testpoint 
)
inline
3340  {
3341  return (s->sh[3] == (shellface) testpoint) ||
3342  (s->sh[4] == (shellface) testpoint) ||
3343  (s->sh[5] == (shellface) testpoint);
3344 }

References s.

◆ isfacehaspoint() [2/2]

bool tetgenmesh::isfacehaspoint ( triface *  t,
point  testpoint 
)
inline
3335  {
3336  return ((org(*t) == testpoint) || (dest(*t) == testpoint) ||
3337  (apex(*t) == testpoint));
3338 }
tetgenmesh::apex
point apex(triface &t)
Definition: tetgen.h:2505
tetgenmesh::dest
point dest(triface &t)
Definition: tetgen.h:2501

References apex(), dest(), org(), and plotPSD::t.

Referenced by isfacehasedge().

◆ issymexist()

bool tetgenmesh::issymexist ( triface *  t)
inline
3355  {
3356  tetrahedron *ptr = (tetrahedron *)
3357  ((unsigned long)(t->tet[t->loc]) & ~(unsigned long)7l);
3358  return ptr != dummytet;
3359 }

References dummytet, and plotPSD::t.

◆ jettisonnodes()

void tetgenmesh::jettisonnodes ( )

◆ lawson()

long tetgenmesh::lawson ( queue *  flipqueue)

◆ lawson3d()

long tetgenmesh::lawson3d ( queue *  flipqueue)

◆ locate()

enum locateresult tetgenmesh::locate ( point  searchpt,
triface *  searchtet 
)

◆ locate2()

enum locateresult tetgenmesh::locate2 ( point  searchpt,
triface *  searchtet,
arraypool *   
)

◆ locateseg()

enum locateresult tetgenmesh::locateseg ( point  searchpt,
face *  searchseg 
)

◆ locatesub()

enum locateresult tetgenmesh::locatesub ( point  searchpt,
face *  searchsh,
int  ,
REAL   
)

◆ lu_decmp()

bool tetgenmesh::lu_decmp ( REAL  lu[4][4],
int  n,
int *  ps,
REAL *  d,
int  N 
)

◆ lu_solve()

void tetgenmesh::lu_solve ( REAL  lu[4][4],
int  n,
int *  ps,
REAL *  b,
int  N 
)

◆ makeindex2pointmap()

void tetgenmesh::makeindex2pointmap ( point *&  )

◆ makepoint()

void tetgenmesh::makepoint ( point *  )

◆ makepoint2segmap()

void tetgenmesh::makepoint2segmap ( )

◆ makepoint2tetmap()

void tetgenmesh::makepoint2tetmap ( )

◆ makesegmentmap()

void tetgenmesh::makesegmentmap ( int *&  ,
shellface **&   
)

◆ makeshellface()

void tetgenmesh::makeshellface ( memorypool *  ,
face *   
)

◆ makesubfacemap()

void tetgenmesh::makesubfacemap ( int *&  ,
shellface **&   
)

◆ maketetrahedron()

void tetgenmesh::maketetrahedron ( triface *  )

◆ maketetrahedronmap()

void tetgenmesh::maketetrahedronmap ( int *&  ,
tetrahedron **&   
)

◆ markacutevertices()

void tetgenmesh::markacutevertices ( REAL  acuteangle)

◆ markedge()

void tetgenmesh::markedge ( triface &  t)
inline
2837  {
2838  ((int *) (t.tet))[elemmarkerindex] |=
2839  (int) (64<<locver2edge[(t).loc][(t).ver]);
2840 }

References elemmarkerindex, locver2edge, and plotPSD::t.

◆ markface()

void tetgenmesh::markface ( triface &  t)
inline
2820  {
2821  ((int *) (t.tet))[elemmarkerindex] |= (int) (4<<(t).loc);
2822 }

References elemmarkerindex, and plotPSD::t.

◆ marksharpsegments()

void tetgenmesh::marksharpsegments ( REAL  sharpangle)

◆ marktest()

void tetgenmesh::marktest ( triface &  t)
inline
2802  {
2803  ((int *) (t.tet))[elemmarkerindex] |= (int) 2;
2804 }

References elemmarkerindex, and plotPSD::t.

◆ marktested()

bool tetgenmesh::marktested ( triface &  t)
inline
2810  {
2811  return (((int *) (t.tet))[elemmarkerindex] & (int) 2) != 0;
2812 }

References elemmarkerindex, and plotPSD::t.

◆ mergefacets()

void tetgenmesh::mergefacets ( queue *  flipqueue)

◆ meshsurface()

long tetgenmesh::meshsurface ( )

◆ numberedges()

void tetgenmesh::numberedges ( )

◆ oppo()

tetgenmesh::point tetgenmesh::oppo ( triface &  t)
inline
2509  {
2510  return (point) t.tet[loc2oppo[t.loc] + 4];
2511 }
tetgenmesh::loc2oppo
static int loc2oppo[4]
Definition: tetgen.h:1196

References loc2oppo, and plotPSD::t.

◆ optimizemesh2()

void tetgenmesh::optimizemesh2 ( bool  optflag)

◆ ordervertices()

void tetgenmesh::ordervertices ( point *  vertexarray,
int  arraysize 
)

◆ org()

tetgenmesh::point tetgenmesh::org ( triface &  t)
inline
2497  {
2498  return (point) t.tet[locver2org[t.loc][t.ver] + 4];
2499 }
tetgenmesh::locver2org
static int locver2org[4][6]
Definition: tetgen.h:1191

References locver2org, and plotPSD::t.

Referenced by fnext(), fnextself(), and isfacehaspoint().

◆ orientnewsubs()

void tetgenmesh::orientnewsubs ( list *  newshlist,
face *  orientsh,
REAL *  norm 
)

◆ outedges()

void tetgenmesh::outedges ( tetgenio *  )

◆ outelements()

void tetgenmesh::outelements ( tetgenio *  )

◆ outfaces()

void tetgenmesh::outfaces ( tetgenio *  )

◆ outhullfaces()

void tetgenmesh::outhullfaces ( tetgenio *  )

◆ outmesh2gid()

void tetgenmesh::outmesh2gid ( char *  )

◆ outmesh2medit()

void tetgenmesh::outmesh2medit ( char *  )

◆ outmesh2off()

void tetgenmesh::outmesh2off ( char *  )

◆ outmesh2vtk()

void tetgenmesh::outmesh2vtk ( char *  )

◆ outmetrics()

void tetgenmesh::outmetrics ( tetgenio *  )

◆ outneighbors()

void tetgenmesh::outneighbors ( tetgenio *  )

◆ outnodes()

void tetgenmesh::outnodes ( tetgenio *  )

◆ outsmesh()

void tetgenmesh::outsmesh ( char *  )

◆ outsubfaces()

void tetgenmesh::outsubfaces ( tetgenio *  )

◆ outsubsegments()

void tetgenmesh::outsubsegments ( tetgenio *  )

◆ outvoronoi()

void tetgenmesh::outvoronoi ( tetgenio *  )

◆ p1interpolatebgm()

bool tetgenmesh::p1interpolatebgm ( point  pt,
triface *  bgmtet,
long *  scount 
)

◆ pinfect()

void tetgenmesh::pinfect ( point  pt)
inline
3231  {
3232  ((int *) (pt))[pointmarkindex + 1] |= (int) 1;
3233 }

References pointmarkindex.

◆ pinfected()

bool tetgenmesh::pinfected ( point  pt)
inline
3239  {
3240  return (((int *) (pt))[pointmarkindex + 1] & (int) 1) != 0;
3241 }

References pointmarkindex.

◆ plague()

void tetgenmesh::plague ( memorypool *  viri)

◆ plaguesub()

void tetgenmesh::plaguesub ( memorypool *  viri)

◆ planelineint()

void tetgenmesh::planelineint ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *   
)

◆ point2bgmtet()

tetgenmesh::tetrahedron tetgenmesh::point2bgmtet ( point  pt)
inline
3278  {
3279  return ((tetrahedron *) (pt))[point2simindex + 4];
3280 }

References point2simindex.

◆ point2pbcpt()

tetgenmesh::point tetgenmesh::point2pbcpt ( point  pt)
inline
3288  {
3289  return (point) ((tetrahedron *) (pt))[point2pbcptindex];
3290 }

References point2pbcptindex.

◆ point2ppt()

tetgenmesh::point tetgenmesh::point2ppt ( point  pt)
inline
3270  {
3271  return (point) ((tetrahedron *) (pt))[point2simindex + 3];
3272 }

References point2simindex.

◆ point2seg()

tetgenmesh::shellface tetgenmesh::point2seg ( point  pt)
inline
3262  {
3263  return (shellface) ((tetrahedron *) (pt))[point2simindex + 2];
3264 }

References point2simindex.

◆ point2segorg()

void tetgenmesh::point2segorg ( point  ,
face &   
)

◆ point2sh()

tetgenmesh::shellface tetgenmesh::point2sh ( point  pt)
inline
3254  {
3255  return (shellface) ((tetrahedron *) (pt))[point2simindex + 1];
3256 }

References point2simindex.

◆ point2shorg()

void tetgenmesh::point2shorg ( point  ,
face &   
)

◆ point2tet()

tetgenmesh::tetrahedron tetgenmesh::point2tet ( point  pt)
inline
3246  {
3247  return ((tetrahedron *) (pt))[point2simindex];
3248 }

References point2simindex.

◆ point2tetorg()

void tetgenmesh::point2tetorg ( point  ,
triface &   
)

◆ pointdealloc()

void tetgenmesh::pointdealloc ( point  )

◆ pointmark()

int tetgenmesh::pointmark ( point  pt)
inline
3208  {
3209  return ((int *) (pt))[pointmarkindex];
3210 }

References pointmarkindex.

◆ pointtraverse()

point tetgenmesh::pointtraverse ( )

◆ pointtype()

enum tetgenmesh::verttype tetgenmesh::pointtype ( point  pt)
inline
3219  {
3220  return (enum verttype) (((int *) (pt))[pointmarkindex + 1] >> (int) 1);
3221 }
tetgenmesh::verttype
verttype
Definition: tetgen.h:829

References pointmarkindex, and Eigen::value.

◆ preciselocate()

enum locateresult tetgenmesh::preciselocate ( point  searchpt,
triface *  searchtet,
long   
)

◆ printsh()

void tetgenmesh::printsh ( face *  )

◆ printtet()

void tetgenmesh::printtet ( triface *  )

◆ projpt2edge()

void tetgenmesh::projpt2edge ( REAL *  p,
REAL *  e1,
REAL *  e2,
REAL *  prj 
)

◆ projpt2face()

void tetgenmesh::projpt2face ( REAL *  p,
REAL *  f1,
REAL *  f2,
REAL *  f3,
REAL *  prj 
)

◆ puninfect()

void tetgenmesh::puninfect ( point  pt)
inline
3235  {
3236  ((int *) (pt))[pointmarkindex + 1] &= ~(int) 1;
3237 }

References pointmarkindex.

◆ qualitystatistics()

void tetgenmesh::qualitystatistics ( )

◆ randomnation()

unsigned long tetgenmesh::randomnation ( unsigned int  choices)

◆ randomsample()

void tetgenmesh::randomsample ( point  searchpt,
triface *  searchtet 
)

◆ reconstructmesh()

long tetgenmesh::reconstructmesh ( )

◆ recoveredgebyflips()

bool tetgenmesh::recoveredgebyflips ( triface *  searchtet,
point  pb,
int *   
)

◆ recoverfacebyflips()

bool tetgenmesh::recoverfacebyflips ( triface *  front,
int *   
)

◆ recoversegment()

void tetgenmesh::recoversegment ( point  tstart,
point  tend,
queue *  flipqueue 
)

◆ recoversubfacebyflips()

void tetgenmesh::recoversubfacebyflips ( face *  pssub,
triface *  crossface,
arraypool *   
)

◆ regionplague()

void tetgenmesh::regionplague ( memorypool *  viri,
REAL  attribute,
REAL  volume 
)

◆ registerelemflip()

bool tetgenmesh::registerelemflip ( enum fliptype  ft,
point  pa1,
point  pb1,
point  pc1,
point  pa2,
point  pb2,
point  pc2 
)

◆ releasebowatcavity()

void tetgenmesh::releasebowatcavity ( face *  ,
int  ,
list **  ,
list **  ,
list **  ,
list **   
)

◆ relocatepoint()

bool tetgenmesh::relocatepoint ( point  steinpt,
triface *  oldtet,
list *  ,
list *  ,
queue *   
)

◆ removeedge()

bool tetgenmesh::removeedge ( badface *  remedge,
bool  optflag 
)

◆ removeedgebycombNM()

bool tetgenmesh::removeedgebycombNM ( REAL *  ,
int  ,
triface *  ,
int *  ,
triface *  ,
triface *  ,
queue *   
)

◆ removeedgebyflip22()

bool tetgenmesh::removeedgebyflip22 ( REAL *  key,
int  ,
triface *  ,
queue *   
)

◆ removeedgebyflip32()

bool tetgenmesh::removeedgebyflip32 ( REAL *  key,
triface *  ,
triface *  ,
queue *   
)

◆ removeedgebyflips()

bool tetgenmesh::removeedgebyflips ( triface *  remedge,
int *   
)

◆ removeedgebytranNM()

bool tetgenmesh::removeedgebytranNM ( REAL *  ,
int  ,
triface *  ,
triface *  ,
point  ,
point  ,
queue *   
)

◆ removefacebyflip23()

bool tetgenmesh::removefacebyflip23 ( REAL *  key,
triface *  ,
triface *  ,
queue *   
)

◆ removefacebyflips()

bool tetgenmesh::removefacebyflips ( triface *  remface,
int *   
)

◆ removeholetets()

void tetgenmesh::removeholetets ( memorypool *  viri)

◆ removesteiners2()

void tetgenmesh::removesteiners2 ( )

◆ removetetbypeeloff()

bool tetgenmesh::removetetbypeeloff ( triface *  striptet,
triface *   
)

◆ repairbadtets()

void tetgenmesh::repairbadtets ( )

◆ repairencsegs()

void tetgenmesh::repairencsegs ( bool  chkencsub,
bool  chkbadtet 
)

◆ repairencsubs()

void tetgenmesh::repairencsubs ( bool  chkbadtet)

◆ replacepolygonsubs()

void tetgenmesh::replacepolygonsubs ( list *  oldshlist,
list *  newshlist 
)

◆ restorecavity()

void tetgenmesh::restorecavity ( arraypool *  ,
arraypool *  ,
arraypool *   
)

◆ restorepolyhedron()

void tetgenmesh::restorepolyhedron ( list *  oldtetlist)

◆ retrievenewsubs()

void tetgenmesh::retrievenewsubs ( list *  newshlist,
bool  removeseg 
)

◆ retrievenewtets()

void tetgenmesh::retrievenewtets ( list *  newtetlist)

◆ rotatepoint()

void tetgenmesh::rotatepoint ( REAL *  p,
REAL  rotangle,
REAL *  p1,
REAL *  p2 
)

◆ sapex()

tetgenmesh::point tetgenmesh::sapex ( face &  s)
inline
2923  {
2924  return (point) s.sh[3 + va[s.shver]];
2925 }
tetgenmesh::va
static int va[6]
Definition: tetgen.h:1187

References s, and va.

◆ sbond()

void tetgenmesh::sbond ( face &  s1,
face &  s2 
)
inline
2893  {
2894  s1.sh[Orient(s1.shver)] = sencode(s2);
2895  s2.sh[Orient(s2.shver)] = sencode(s1);
2896 }
tetgenmesh::sencode
shellface sencode(face &s)
Definition: tetgen.h:2873
Orient
#define Orient(V)
Definition: tetgen.h:2438

References Orient, sencode(), tetgenmesh::face::sh, and tetgenmesh::face::shver.

◆ sbond1()

void tetgenmesh::sbond1 ( face &  s1,
face &  s2 
)
inline
2901  {
2902  s1.sh[Orient(s1.shver)] = sencode(s2);
2903 }

References Orient, sencode(), tetgenmesh::face::sh, and tetgenmesh::face::shver.

◆ scoutcrosstet()

enum interresult tetgenmesh::scoutcrosstet ( face *  ssub,
triface *  searchtet,
arraypool *   
)

◆ scoutfront()

bool tetgenmesh::scoutfront ( triface *  front,
triface *  idfront 
)

◆ scoutsegment2()

enum interresult tetgenmesh::scoutsegment2 ( face *  ,
triface *  ,
point *   
)

◆ scoutsegmentsub()

bool tetgenmesh::scoutsegmentsub ( face *  searchsh,
point  tend 
)

◆ scoutsubface()

enum interresult tetgenmesh::scoutsubface ( face *  ssub,
triface *  searchtet,
int   
)

◆ sdecode()

void tetgenmesh::sdecode ( shellface  sptr,
face &  s 
)
inline
2868  {
2869  s.shver = (int) ((uintptr_t) (sptr) & (uintptr_t) 7);
2870  s.sh = (shellface *) ((uintptr_t) (sptr) & ~ (uintptr_t) 7);
2871 }

References int(), and s.

Referenced by spivot(), spivotself(), sspivot(), tspivot(), and tsspivot1().

◆ sdest()

tetgenmesh::point tetgenmesh::sdest ( face &  s)
inline
2919  {
2920  return (point) s.sh[3 + vd[s.shver]];
2921 }
tetgenmesh::vd
static int vd[6]
Definition: tetgen.h:1187

References s, and vd.

◆ sdissolve()

void tetgenmesh::sdissolve ( face &  s)
inline
2908  {
2909  s.sh[Orient(s.shver)] = (shellface) dummysh;
2910 }

References dummysh, Orient, and s.

◆ sencode()

tetgenmesh::shellface tetgenmesh::sencode ( face &  s)
inline
2873  {
2874  return (shellface) ((uintptr_t) s.sh | (uintptr_t) s.shver);
2875 }

References s.

Referenced by sbond(), sbond1(), ssbond(), tsbond(), and tssbond1().

◆ senext()

void tetgenmesh::senext ( face &  s1,
face &  s2 
)
inline
2951  {
2952  s2.sh = s1.sh;
2953  s2.shver = ve[s1.shver];
2954 }

References tetgenmesh::face::sh, tetgenmesh::face::shver, and ve.

◆ senext2()

void tetgenmesh::senext2 ( face &  s1,
face &  s2 
)
inline
2960  {
2961  s2.sh = s1.sh;
2962  s2.shver = ve[ve[s1.shver]];
2963 }

References tetgenmesh::face::sh, tetgenmesh::face::shver, and ve.

◆ senext2self()

void tetgenmesh::senext2self ( face &  s)
inline
2965  {
2966  s.shver = ve[ve[s.shver]];
2967 }

References s, and ve.

◆ senextself()

void tetgenmesh::senextself ( face &  s)
inline
2956  {
2957  s.shver = ve[s.shver];
2958 }

References s, and ve.

◆ sesym()

void tetgenmesh::sesym ( face &  s1,
face &  s2 
)
inline
2942  {
2943  s2.sh = s1.sh;
2944  s2.shver = s1.shver + (EdgeRing(s1.shver) ? -1 : 1);
2945 }

References EdgeRing, tetgenmesh::face::sh, and tetgenmesh::face::shver.

◆ sesymself()

void tetgenmesh::sesymself ( face &  s)
inline
2947  {
2948  s.shver += (EdgeRing(s.shver) ? -1 : 1);
2949 }

References EdgeRing, and s.

Referenced by adjustedgering().

◆ setapex()

void tetgenmesh::setapex ( triface &  t,
point  pointptr 
)
inline
2521  {
2522  t.tet[locver2apex[t.loc][t.ver] + 4] = (tetrahedron) pointptr;
2523 }

References locver2apex, and plotPSD::t.

◆ setareabound()

void tetgenmesh::setareabound ( face &  s,
REAL  value 
)
inline
2996  {
2997  ((REAL *) (s.sh))[areaboundindex] = value;
2998 }
Eigen::value
squared absolute value
Definition: GlobalFunctions.h:87

References areaboundindex, REAL, s, and Eigen::value.

◆ setdest()

void tetgenmesh::setdest ( triface &  t,
point  pointptr 
)
inline
2517  {
2518  t.tet[locver2dest[t.loc][t.ver] + 4] = (tetrahedron) pointptr;
2519 }

References locver2dest, and plotPSD::t.

◆ setelemattribute()

void tetgenmesh::setelemattribute ( tetrahedron *  ptr,
int  attnum,
REAL  value 
)
inline
2754  {
2755  ((REAL *) (ptr))[elemattribindex + attnum] = value;
2756 }

References elemattribindex, REAL, and Eigen::value.

◆ setelemmarker()

void tetgenmesh::setelemmarker ( tetrahedron *  ptr,
int  value 
)
inline
2774  {
2775  ((int *) (ptr))[elemmarkerindex] = value;
2776 }

References elemmarkerindex, and Eigen::value.

◆ setnewpointsize()

void tetgenmesh::setnewpointsize ( point  newpt,
point  e1,
point  e2 
)

◆ setoppo()

void tetgenmesh::setoppo ( triface &  t,
point  pointptr 
)
inline
2525  {
2526  t.tet[loc2oppo[t.loc] + 4] = (tetrahedron) pointptr;
2527 }

References loc2oppo, and plotPSD::t.

◆ setorg()

void tetgenmesh::setorg ( triface &  t,
point  pointptr 
)
inline
2513  {
2514  t.tet[locver2org[t.loc][t.ver] + 4] = (tetrahedron) pointptr;
2515 }

References locver2org, and plotPSD::t.

◆ setpoint2bgmtet()

void tetgenmesh::setpoint2bgmtet ( point  pt,
tetrahedron  value 
)
inline
3282  {
3283  ((tetrahedron *) (pt))[point2simindex + 4] = value;
3284 }

References point2simindex, and Eigen::value.

◆ setpoint2pbcpt()

void tetgenmesh::setpoint2pbcpt ( point  pt,
point  value 
)
inline
3292  {
3293  ((tetrahedron *) (pt))[point2pbcptindex] = (tetrahedron) value;
3294 }

References point2pbcptindex, and Eigen::value.

◆ setpoint2ppt()

void tetgenmesh::setpoint2ppt ( point  pt,
point  value 
)
inline
3274  {
3275  ((tetrahedron *) (pt))[point2simindex + 3] = (tetrahedron) value;
3276 }

References point2simindex, and Eigen::value.

◆ setpoint2seg()

void tetgenmesh::setpoint2seg ( point  pt,
shellface  value 
)
inline
3266  {
3267  ((tetrahedron *) (pt))[point2simindex + 2] = (tetrahedron) value;
3268 }

References point2simindex, and Eigen::value.

◆ setpoint2sh()

void tetgenmesh::setpoint2sh ( point  pt,
shellface  value 
)
inline
3258  {
3259  ((tetrahedron *) (pt))[point2simindex + 1] = (tetrahedron) value;
3260 }

References point2simindex, and Eigen::value.

◆ setpoint2tet()

void tetgenmesh::setpoint2tet ( point  pt,
tetrahedron  value 
)
inline
3250  {
3251  ((tetrahedron *) (pt))[point2simindex] = value;
3252 }

References point2simindex, and Eigen::value.

◆ setpointmark()

void tetgenmesh::setpointmark ( point  pt,
int  value 
)
inline
3212  {
3213  ((int *) (pt))[pointmarkindex] = value;
3214 }

◆ setpointtype()

void tetgenmesh::setpointtype ( point  pt,
enum verttype  value 
)
inline
3223  {
3224  ((int *) (pt))[pointmarkindex + 1] =
3225  ((int) value << 1) + (((int *) (pt))[pointmarkindex + 1] & (int) 1);
3226 }

References int(), pointmarkindex, and Eigen::value.

◆ setsapex()

void tetgenmesh::setsapex ( face &  s,
point  pointptr 
)
inline
2935  {
2936  s.sh[3 + va[s.shver]] = (shellface) pointptr;
2937 }

References s, and va.

◆ setsdest()

void tetgenmesh::setsdest ( face &  s,
point  pointptr 
)
inline
2931  {
2932  s.sh[3 + vd[s.shver]] = (shellface) pointptr;
2933 }

References s, and vd.

◆ setshell2badface()

void tetgenmesh::setshell2badface ( face &  s,
badface *  value 
)
inline
2986  {
2987  s.sh[11] = (shellface) value;
2988 }

References s, and Eigen::value.

◆ setshellmark()

void tetgenmesh::setshellmark ( face &  s,
int  value 
)
inline
3010  {
3011  ((int *) ((s).sh))[shmarkindex] = (value << (int) 2) +
3012  ((((int *) ((s).sh))[shmarkindex]) & (int) 3);
3013  // ((int *) (s.sh))[shmarkindex] = value;
3014 }

References int(), s, shmarkindex, and Eigen::value.

◆ setshellpbcgroup()

void tetgenmesh::setshellpbcgroup ( face &  s,
int  value 
)
inline
3032  {
3033  ((int *) (s.sh))[shmarkindex + 2] = value;
3034 }

References s, shmarkindex, and Eigen::value.

◆ setshelltype()

void tetgenmesh::setshelltype ( face &  s,
enum shestype  value 
)
inline
3022  {
3023  ((int *) (s.sh))[shmarkindex + 1] = (int) value;
3024 }

References s, shmarkindex, and Eigen::value.

◆ setsorg()

void tetgenmesh::setsorg ( face &  s,
point  pointptr 
)
inline
2927  {
2928  s.sh[3 + vo[s.shver]] = (shellface) pointptr;
2929 }
tetgenmesh::vo
static int vo[6]
Definition: tetgen.h:1187

References s, and vo.

◆ setvolumebound()

void tetgenmesh::setvolumebound ( tetrahedron *  ptr,
REAL  value 
)
inline
2764  {
2765  ((REAL *) (ptr))[volumeboundindex] = value;
2766 }

References REAL, Eigen::value, and volumeboundindex.

◆ sfnext()

void tetgenmesh::sfnext ( face &  s1,
face &  s2 
)
inline
2971  {
2972  getnextsface(&s1, &s2);
2973 }
tetgenmesh::getnextsface
void getnextsface(face *, face *)

References getnextsface().

◆ sfnextself()

void tetgenmesh::sfnextself ( face &  s)
inline
2975  {
2976  getnextsface(&s, NULL);
2977 }

References getnextsface(), and s.

◆ shell2badface()

tetgenmesh::badface * tetgenmesh::shell2badface ( face &  s)
inline
2982  {
2983  return (badface*) s.sh[11];
2984 }

References s.

◆ shellfacedealloc()

void tetgenmesh::shellfacedealloc ( memorypool *  ,
shellface *   
)

◆ shellfacetraverse()

shellface* tetgenmesh::shellfacetraverse ( memorypool *  )

◆ shellmark()

int tetgenmesh::shellmark ( face &  s)
inline
3005  {
3006  return (((int *) ((s).sh))[shmarkindex]) >> (int) 2;
3007  // return ((int *) (s.sh))[shmarkindex];
3008 }

References int(), s, and shmarkindex.

◆ shellpbcgroup()

int tetgenmesh::shellpbcgroup ( face &  s)
inline
3028  {
3029  return ((int *) (s.sh))[shmarkindex + 2];
3030 }

References s, and shmarkindex.

◆ shelltype()

enum tetgenmesh::shestype tetgenmesh::shelltype ( face &  s)
inline
3018  {
3019  return (enum shestype) ((int *) (s.sh))[shmarkindex + 1];
3020 }
tetgenmesh::shestype
shestype
Definition: tetgen.h:833

◆ shortdistance() [1/2]

REAL tetgenmesh::shortdistance ( REAL *  p,
REAL *  e1,
REAL *  e2 
)

◆ shortdistance() [2/2]

REAL tetgenmesh::shortdistance ( REAL *  p,
REAL *  e1,
REAL *  e2,
REAL *  e3 
)

◆ sinfect()

void tetgenmesh::sinfect ( face &  s)
inline
3039  {
3040  ((int *) ((s).sh))[shmarkindex] =
3041  (((int *) ((s).sh))[shmarkindex] | (int) 1);
3042  // s.sh[6] = (shellface) ((unsigned long) s.sh[6] | (unsigned long) 4l);
3043 }

References int(), s, and shmarkindex.

◆ sinfected()

bool tetgenmesh::sinfected ( face &  s)
inline
3053  {
3054  return (((int *) ((s).sh))[shmarkindex] & (int) 1) != 0;
3055 }

References s, and shmarkindex.

◆ sinsertvertex()

enum locateresult tetgenmesh::sinsertvertex ( point  insertpt,
face *  splitsh,
face *  splitseg,
bool  bwflag,
bool  cflag 
)

◆ smoothpoint()

bool tetgenmesh::smoothpoint ( point  smthpt,
point  ,
point  ,
list *  ,
bool  ,
REAL *   
)

◆ smoothsliver()

bool tetgenmesh::smoothsliver ( badface *  remedge,
list *  starlist 
)

◆ sorg()

tetgenmesh::point tetgenmesh::sorg ( face &  s)
inline
2915  {
2916  return (point) s.sh[3 + vo[s.shver]];
2917 }

References s, and vo.

◆ spivot()

void tetgenmesh::spivot ( face &  s1,
face &  s2 
)
inline
2880  {
2881  shellface sptr = s1.sh[Orient(s1.shver)];
2882  sdecode(sptr, s2);
2883 }
tetgenmesh::sdecode
void sdecode(shellface sptr, face &s)
Definition: tetgen.h:2868

References Orient, sdecode(), tetgenmesh::face::sh, and tetgenmesh::face::shver.

◆ spivotself()

void tetgenmesh::spivotself ( face &  s)
inline
2885  {
2886  shellface sptr = s.sh[Orient(s.shver)];
2887  sdecode(sptr, s);
2888 }

References Orient, s, and sdecode().

◆ splitencseg()

bool tetgenmesh::splitencseg ( point  ,
face *  ,
list *  ,
list *  ,
list *  ,
queue *  ,
bool  ,
bool  ,
bool   
)

◆ splitsliver()

bool tetgenmesh::splitsliver ( badface *  remedge,
list *  tetlist,
list *  ceillist 
)

◆ splitsubedge() [1/2]

void tetgenmesh::splitsubedge ( point  ,
face *  ,
arraypool *  ,
arraypool *   
)

◆ splitsubedge() [2/2]

void tetgenmesh::splitsubedge ( point  ,
face *  ,
queue *   
)

◆ splitsubface()

void tetgenmesh::splitsubface ( point  ,
face *  ,
queue *   
)

◆ splittetedge()

bool tetgenmesh::splittetedge ( point  ,
triface *  ,
queue *   
)

◆ splittetface()

void tetgenmesh::splittetface ( point  ,
triface *  ,
queue *   
)

◆ splittetrahedron()

void tetgenmesh::splittetrahedron ( point  ,
triface *  ,
queue *   
)

◆ ssbond()

void tetgenmesh::ssbond ( face &  s,
face &  edge 
)
inline
3144  {
3145  s.sh[8 + Orient(s.shver)] = sencode(edge);
3146  edge.sh[0] = sencode(s);
3147 }

References Orient, s, sencode(), and tetgenmesh::face::sh.

◆ ssdissolve()

void tetgenmesh::ssdissolve ( face &  s)
inline
3151  {
3152  s.sh[8 + Orient(s.shver)] = (shellface) dummysh;
3153 }

References dummysh, Orient, and s.

◆ sspivot()

void tetgenmesh::sspivot ( face &  s,
face &  edge 
)
inline
3137  {
3138  shellface sptr = (shellface) s.sh[8 + Orient(s.shver)];
3139  sdecode(sptr, edge);
3140 }

References Orient, s, and sdecode().

◆ sstpivot()

void tetgenmesh::sstpivot ( face *  ,
triface *   
)

◆ statistics()

void tetgenmesh::statistics ( )

◆ stdissolve()

void tetgenmesh::stdissolve ( face &  s)
inline
3123  {
3124  s.sh[6 + EdgeRing(s.shver)] = (shellface) dummytet;
3125 }

References dummytet, EdgeRing, and s.

◆ stpivot()

void tetgenmesh::stpivot ( face &  s,
triface &  t 
)
inline
3090  {
3091  tetrahedron ptr = (tetrahedron) s.sh[6 + EdgeRing(s.shver)];
3092  decode(ptr, t);
3093 }
tetgenmesh::decode
void decode(tetrahedron ptr, triface &t)
Definition: tetgen.h:2457

References decode(), EdgeRing, s, and plotPSD::t.

◆ suninfect()

void tetgenmesh::suninfect ( face &  s)
inline
3045  {
3046  ((int *) ((s).sh))[shmarkindex] =
3047  (((int *) ((s).sh))[shmarkindex] & ~(int) 1);
3048  // s.sh[6] = (shellface)((unsigned long) s.sh[6] & ~(unsigned long) 4l);
3049 }

References int(), s, and shmarkindex.

◆ suppressfacetpoint()

bool tetgenmesh::suppressfacetpoint ( face *  supsh,
list *  frontlist,
list *  misfrontlist,
list *  ptlist,
list *  conlist,
memorypool *  viri,
queue *  flipque,
bool  noreloc,
bool  optflag 
)

◆ suppresssegpoint()

bool tetgenmesh::suppresssegpoint ( face *  supseg,
list *  spinshlist,
list *  newsegshlist,
list *  frontlist,
list *  misfrontlist,
list *  ptlist,
list *  conlist,
memorypool *  viri,
queue *  flipque,
bool  noreloc,
bool  optflag 
)

◆ suppressvolpoint()

bool tetgenmesh::suppressvolpoint ( triface *  suptet,
list *  frontlist,
list *  misfrontlist,
list *  ptlist,
queue *  flipque,
bool  optflag 
)

◆ sym()

void tetgenmesh::sym ( triface &  t1,
triface &  t2 
)
inline
2468  {
2469  tetrahedron ptr = t1.tet[t1.loc];
2470  decode(ptr, t2);
2471 }

References decode(), tetgenmesh::triface::loc, and tetgenmesh::triface::tet.

Referenced by fnext(), and fnextself().

◆ symedge()

void tetgenmesh::symedge ( triface &  t1,
triface &  t2 
)
inline
2643 {
2644  decode(t1.tet[t1.loc], t2);
2645  if (t2.tet != dummytet) {
2646  // Search the edge of t1 in t2.
2647  point tapex = apex(t1);
2648  if ((point) (t2.tet[locver2apex[t2.loc][0] + 4]) == tapex) {
2649  t2.ver = 0;
2650  } else if ((point) (t2.tet[locver2apex[t2.loc][2] + 4]) == tapex) {
2651  t2.ver = 2;
2652  } else {
2653  assert((point) (t2.tet[locver2apex[t2.loc][4] + 4]) == tapex);
2654  t2.ver = 4;
2655  }
2656  }
2657 }
assert
#define assert(e,...)
Definition: Logger.h:744

References apex(), assert, decode(), dummytet, tetgenmesh::triface::loc, locver2apex, tetgenmesh::triface::tet, and tetgenmesh::triface::ver.

Referenced by tfnext().

◆ symedgeself()

void tetgenmesh::symedgeself ( triface &  t)
inline
2660 {
2661  tetrahedron ptr;
2662  point tapex;
2663 
2664  ptr = t.tet[t.loc];
2665  tapex = apex(t);
2666 
2667  decode(ptr, t);
2668  if (t.tet != dummytet) {
2669  // Search the edge of t1 in t2.
2670  if ((point) (t.tet[locver2apex[t.loc][0] + 4]) == tapex) {
2671  t.ver = 0;
2672  } else if ((point) (t.tet[locver2apex[t.loc][2] + 4]) == tapex) {
2673  t.ver = 2;
2674  } else {
2675  assert((point) (t.tet[locver2apex[t.loc][4] + 4]) == tapex);
2676  t.ver = 4;
2677  }
2678  }
2679 }

References apex(), assert, decode(), dummytet, locver2apex, and plotPSD::t.

Referenced by tfnext(), and tfnextself().

◆ symself()

void tetgenmesh::symself ( triface &  t)
inline
2473  {
2474  tetrahedron ptr = t.tet[t.loc];
2475  decode(ptr, t);
2476 }

References decode(), and plotPSD::t.

◆ tallbadtetrahedrons()

void tetgenmesh::tallbadtetrahedrons ( )

◆ tallencsegs()

bool tetgenmesh::tallencsegs ( point  testpt,
int  n,
list **  ceillists 
)

◆ tallencsubs()

bool tetgenmesh::tallencsubs ( point  testpt,
int  n,
list **  ceillists 
)

◆ tallslivers()

void tetgenmesh::tallslivers ( bool  optflag)

◆ tetalldihedral()

void tetgenmesh::tetalldihedral ( point  ,
point  ,
point  ,
point  ,
REAL *  ,
REAL *  ,
REAL *   
)

◆ tetallnormal()

void tetgenmesh::tetallnormal ( point  ,
point  ,
point  ,
point  ,
REAL  N[4][3],
REAL *  volume 
)

◆ tetaspectratio()

REAL tetgenmesh::tetaspectratio ( point  ,
point  ,
point  ,
point   
)

◆ tetrahedrondealloc()

void tetgenmesh::tetrahedrondealloc ( tetrahedron *  )

◆ tetrahedrontraverse()

tetrahedron* tetgenmesh::tetrahedrontraverse ( )

◆ tfnext()

void tetgenmesh::tfnext ( triface &  t1,
triface &  t2 
)
inline
2686 {
2687  int *iptr;
2688 
2689  if ((t1.ver & 1) == 0) {
2690  t2.tet = t1.tet;
2691  iptr = locver2nextf[t1.loc][t1.ver];
2692  t2.loc = iptr[0];
2693  t2.ver = iptr[1];
2694  symedgeself(t2); // t2.tet may be dummytet.
2695  } else {
2696  symedge(t1, t2);
2697  if (t2.tet != dummytet) {
2698  iptr = locver2nextf[t2.loc][t2.ver];
2699  t2.loc = iptr[0];
2700  t2.ver = iptr[1];
2701  }
2702  }
2703 }
tetgenmesh::symedge
void symedge(triface &t1, triface &t2)
Definition: tetgen.h:2642
tetgenmesh::symedgeself
void symedgeself(triface &t)
Definition: tetgen.h:2659

References dummytet, tetgenmesh::triface::loc, locver2nextf, symedge(), symedgeself(), tetgenmesh::triface::tet, and tetgenmesh::triface::ver.

◆ tfnextself()

void tetgenmesh::tfnextself ( triface &  t)
inline
2706 {
2707  int *iptr;
2708 
2709  if ((t.ver & 1) == 0) {
2710  iptr = locver2nextf[t.loc][t.ver];
2711  t.loc = iptr[0];
2712  t.ver = iptr[1];
2713  symedgeself(t); // t.tet may be dummytet.
2714  } else {
2715  symedgeself(t);
2716  if (t.tet != dummytet) {
2717  iptr = locver2nextf[t.loc][t.ver];
2718  t.loc = iptr[0];
2719  t.ver = iptr[1];
2720  }
2721  }
2722 }

References dummytet, locver2nextf, symedgeself(), and plotPSD::t.

◆ topbadtetra()

badface* tetgenmesh::topbadtetra ( )

◆ transfernodes()

void tetgenmesh::transfernodes ( )

◆ tri_edge_2d()

int tetgenmesh::tri_edge_2d ( point  ,
point  ,
point  ,
point  ,
point  ,
point  ,
int  ,
int *  ,
int *   
)

◆ tri_edge_cop_inter()

enum interresult tetgenmesh::tri_edge_cop_inter ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *   
)

◆ tri_edge_inter()

enum interresult tetgenmesh::tri_edge_inter ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *   
)

◆ tri_edge_inter_tail()

enum interresult tetgenmesh::tri_edge_inter_tail ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL  ,
REAL   
)

◆ tri_edge_test()

int tetgenmesh::tri_edge_test ( point  ,
point  ,
point  ,
point  ,
point  ,
point  ,
int  ,
int *  ,
int *   
)

◆ tri_tri_inter()

enum interresult tetgenmesh::tri_tri_inter ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *   
)

◆ tri_vert_cop_inter()

enum interresult tetgenmesh::tri_vert_cop_inter ( REAL *  ,
REAL *  ,
REAL *  ,
REAL *  ,
REAL *   
)

◆ triangulate()

void tetgenmesh::triangulate ( int  shmark,
REAL  eps,
list *  ptlist,
list *  conlist,
int  holes,
REAL *  holelist,
memorypool *  viri,
queue *   
)

◆ trimbowatcavity()

bool tetgenmesh::trimbowatcavity ( point  bp,
face *  bpseg,
int  n,
list **  sublists,
list **  subceillists,
list **  tetlists,
list **  ceillists,
REAL  maxcosd 
)

◆ tsbond()

void tetgenmesh::tsbond ( triface &  t,
face &  s 
)
inline
3097  {
3098  if ((t).tet[9] == NULL) {
3099  // Allocate space for this tet.
3100  (t).tet[9] = (tetrahedron) tet2subpool->alloc();
3101  // NULL all fields in this space.
3102  for (int i = 0; i < 4; i++) {
3103  ((shellface *) (t).tet[9])[i] = (shellface) dummysh;
3104  }
3105  }
3106  // Bond t <==> s.
3107  ((shellface *) (t).tet[9])[(t).loc] = sencode(s);
3108  //t.tet[8 + t.loc] = (tetrahedron) sencode(s);
3109  s.sh[6 + EdgeRing(s.shver)] = (shellface) encode(t);
3110 }

References tetgenmesh::memorypool::alloc(), dummysh, EdgeRing, encode(), i, s, sencode(), plotPSD::t, and tet2subpool.

◆ tsdissolve()

void tetgenmesh::tsdissolve ( triface &  t)
inline
3114  {
3115  if ((t).tet[9] != NULL) {
3116  ((shellface *) (t).tet[9])[(t).loc] = (shellface) dummysh;
3117  }
3118  // t.tet[8 + t.loc] = (tetrahedron) dummysh;
3119 }

References dummysh, and plotPSD::t.

◆ tspivot()

void tetgenmesh::tspivot ( triface &  t,
face &  s 
)
inline
3078  {
3079  if ((t).tet[9] != NULL) {
3080  sdecode(((shellface *) (t).tet[9])[(t).loc], s);
3081  } else {
3082  (s).sh = dummysh;
3083  }
3084  //shellface sptr = (shellface) t.tet[8 + t.loc];
3085  //sdecode(sptr, s);
3086 }

References dummysh, s, sdecode(), and plotPSD::t.

◆ tssbond1()

void tetgenmesh::tssbond1 ( triface &  t,
face &  seg 
)
inline
3177 {
3178  if ((t).tet[8] == NULL) {
3179  // Allocate space for this tet.
3180  (t).tet[8] = (tetrahedron) tet2segpool->alloc();
3181  // NULL all fields in this space.
3182  for (int i = 0; i < 6; i++) {
3183  ((shellface *) (t).tet[8])[i] = (shellface) dummysh;
3184  }
3185  }
3186  // Bond the segment.
3187  ((shellface *) (t).tet[8])[locver2edge[(t).loc][(t).ver]] = sencode((s));
3188  // t.tet[8 + locver2edge[t.loc][t.ver]] = (tetrahedron) sencode(seg);
3189 }

References tetgenmesh::memorypool::alloc(), dummysh, i, locver2edge, s, sencode(), plotPSD::t, and tet2segpool.

◆ tssdissolve1()

void tetgenmesh::tssdissolve1 ( triface &  t)
inline
3192 {
3193  if ((t).tet[8] != NULL) {
3194  ((shellface *) (t).tet[8])[locver2edge[(t).loc][(t).ver]]
3195  = (shellface) dummysh;
3196  }
3197  // t.tet[8 + locver2edge[t.loc][t.ver]] = (tetrahedron) dummysh;
3198 }

References dummysh, locver2edge, and plotPSD::t.

◆ tsspivot()

void tetgenmesh::tsspivot ( triface *  ,
face *   
)

◆ tsspivot1()

void tetgenmesh::tsspivot1 ( triface &  t,
face &  seg 
)
inline
3164 {
3165  if ((t).tet[8] != NULL) {
3166  sdecode(((shellface *) (t).tet[8])[locver2edge[(t).loc][(t).ver]], s);
3167  } else {
3168  (s).sh = dummysh;
3169  }
3170  // shellface sptr = (shellface) t.tet[8 + locver2edge[t.loc][t.ver]];
3171  // sdecode(sptr, seg);
3172 }

References dummysh, locver2edge, s, sdecode(), and plotPSD::t.

◆ unifypoint()

bool tetgenmesh::unifypoint ( point  testpt,
triface *  ,
enum  locateresult,
REAL   
)

◆ unifysegments()

void tetgenmesh::unifysegments ( )

◆ uninfect()

void tetgenmesh::uninfect ( triface &  t)
inline
2786  {
2787  ((int *) (t.tet))[elemmarkerindex] &= ~(int) 1;
2788 }

References elemmarkerindex, and plotPSD::t.

◆ unmarkedge()

void tetgenmesh::unmarkedge ( triface &  t)
inline
2842  {
2843  ((int *) (t.tet))[elemmarkerindex] &=
2844  ~(int) (64<<locver2edge[(t).loc][(t).ver]);
2845 }

References elemmarkerindex, locver2edge, and plotPSD::t.

◆ unmarkface()

void tetgenmesh::unmarkface ( triface &  t)
inline
2824  {
2825  ((int *) (t.tet))[elemmarkerindex] &= ~(int) (4<<(t).loc);
2826 }

References elemmarkerindex, and plotPSD::t.

◆ unmarktest()

void tetgenmesh::unmarktest ( triface &  t)
inline
2806  {
2807  ((int *) (t.tet))[elemmarkerindex] &= ~(int) 2;
2808 }

References elemmarkerindex, and plotPSD::t.

◆ updatebowatcavityquad()

void tetgenmesh::updatebowatcavityquad ( list *  tetlist,
list *  ceillist 
)

◆ updatebowatcavitysub()

void tetgenmesh::updatebowatcavitysub ( list *  sublist,
list *  subceillist,
int *  cutcount 
)

◆ validatebowatcavityquad()

bool tetgenmesh::validatebowatcavityquad ( point  bp,
list *  ceillist,
REAL  maxcosd 
)

◆ volumebound()

REAL tetgenmesh::volumebound ( tetrahedron *  ptr)
inline
2760  {
2761  return ((REAL *) (ptr))[volumeboundindex];
2762 }

References REAL, and volumeboundindex.

Member Data Documentation

◆ abovecount

long tetgenmesh::abovecount

Referenced by tetgenmesh().

◆ abovepoint

point tetgenmesh::abovepoint

Referenced by tetgenmesh().

◆ across_edge_count

long tetgenmesh::across_edge_count

Referenced by tetgenmesh().

◆ across_face_count

long tetgenmesh::across_face_count

Referenced by tetgenmesh().

◆ across_max_count

long tetgenmesh::across_max_count

Referenced by tetgenmesh().

◆ areaboundindex

int tetgenmesh::areaboundindex

Referenced by areabound(), setareabound(), and tetgenmesh().

◆ b

tetgenbehavior* tetgenmesh::b

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ b_steinerflag

bool tetgenmesh::b_steinerflag

Referenced by tetgenmesh().

◆ badsubfaces

memorypool* tetgenmesh::badsubfaces

Referenced by tetgenmesh().

◆ badsubsegs

memorypool* tetgenmesh::badsubsegs

Referenced by tetgenmesh().

◆ badtetrahedrons

memorypool* tetgenmesh::badtetrahedrons

Referenced by tetgenmesh().

◆ bgm

tetgenmesh* tetgenmesh::bgm

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ bowatsegcount

long tetgenmesh::bowatsegcount

Referenced by tetgenmesh().

◆ bowatsubcount

long tetgenmesh::bowatsubcount

Referenced by tetgenmesh().

◆ bowatvolcount

long tetgenmesh::bowatvolcount

Referenced by tetgenmesh().

◆ btreenode_list

arraypool* tetgenmesh::btreenode_list

Referenced by tetgenmesh().

◆ cavebdrylist

arraypool * tetgenmesh::cavebdrylist

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ caveoldtetlist

arraypool * tetgenmesh::caveoldtetlist

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ caveshbdlist

arraypool * tetgenmesh::caveshbdlist

Referenced by tetgenmesh().

◆ caveshlist

arraypool* tetgenmesh::caveshlist

Referenced by tetgenmesh().

◆ cavetetlist

arraypool* tetgenmesh::cavetetlist

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ cavityexpcount

long tetgenmesh::cavityexpcount

Referenced by tetgenmesh().

◆ cdtenforcesegpts

long tetgenmesh::cdtenforcesegpts

Referenced by tetgenmesh().

◆ checkpbcs

int tetgenmesh::checkpbcs

Referenced by tetgenmesh().

◆ checksubfaces

int tetgenmesh::checksubfaces

Referenced by tetgenmesh().

◆ checksubsegs

int tetgenmesh::checksubsegs

Referenced by tetgenmesh().

◆ collapverts

int tetgenmesh::collapverts

Referenced by tetgenmesh().

◆ cosmaxdihed

REAL tetgenmesh::cosmaxdihed

◆ cosmindihed

REAL tetgenmesh::cosmindihed

◆ dummypoint

point tetgenmesh::dummypoint

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ dummysh

shellface* tetgenmesh::dummysh

Referenced by sdissolve(), ssdissolve(), tetgenmesh(), tsbond(), tsdissolve(), tspivot(), tssbond1(), tssdissolve1(), and tsspivot1().

◆ dummyshbase

shellface* tetgenmesh::dummyshbase

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ dummytet

tetrahedron* tetgenmesh::dummytet

Referenced by dissolve(), fnext(), fnextself(), issymexist(), stdissolve(), symedge(), symedgeself(), tetgenmesh(), tfnext(), and tfnextself().

◆ dummytetbase

tetrahedron* tetgenmesh::dummytetbase

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ dupverts

int tetgenmesh::dupverts

Referenced by tetgenmesh().

◆ edge2locver

int tetgenmesh::edge2locver[6][2]
static

◆ elemattribindex

int tetgenmesh::elemattribindex

Referenced by elemattribute(), setelemattribute(), and tetgenmesh().

◆ elemfliplist

arraypool* tetgenmesh::elemfliplist

Referenced by tetgenmesh().

◆ elemmarkerindex

int tetgenmesh::elemmarkerindex

Referenced by edgemarked(), facemarked(), getelemmarker(), infect(), infected(), markedge(), markface(), marktest(), marktested(), setelemmarker(), uninfect(), unmarkedge(), unmarkface(), and unmarktest().

◆ facetabovepointarray

point* tetgenmesh::facetabovepointarray

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ failsegcount

long tetgenmesh::failsegcount

Referenced by tetgenmesh().

◆ failsubcount

long tetgenmesh::failsubcount

Referenced by tetgenmesh().

◆ failvolcount

long tetgenmesh::failvolcount

Referenced by tetgenmesh().

◆ firstbotface

triface tetgenmesh::firstbotface

◆ firstnonemptyq

int tetgenmesh::firstnonemptyq

◆ firsttopface

triface tetgenmesh::firsttopface

◆ fixededgelist

arraypool* tetgenmesh::fixededgelist

Referenced by tetgenmesh().

◆ flip14count

long tetgenmesh::flip14count

Referenced by tetgenmesh().

◆ flip22count

long tetgenmesh::flip22count

Referenced by tetgenmesh().

◆ flip22s

long tetgenmesh::flip22s

Referenced by tetgenmesh().

◆ flip23s

long tetgenmesh::flip23s

Referenced by tetgenmesh().

◆ flip26count

long tetgenmesh::flip26count

Referenced by tetgenmesh().

◆ flip32s

long tetgenmesh::flip32s

Referenced by tetgenmesh().

◆ flip44s

long tetgenmesh::flip44s

Referenced by tetgenmesh().

◆ flipn2ncount

long tetgenmesh::flipn2ncount

Referenced by tetgenmesh().

◆ highorderindex

int tetgenmesh::highorderindex

Referenced by tetgenmesh().

◆ highordertable

point* tetgenmesh::highordertable

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ hullsize

long tetgenmesh::hullsize

Referenced by tetgenmesh().

◆ idx2segpglist

int* tetgenmesh::idx2segpglist

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ in

tetgenio* tetgenmesh::in

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ insegments

long tetgenmesh::insegments

Referenced by tetgenmesh().

◆ inserthullcount

long tetgenmesh::inserthullcount

Referenced by tetgenmesh().

◆ insphere_sos_count

long tetgenmesh::insphere_sos_count

Referenced by tetgenmesh().

◆ inspherecount

long tetgenmesh::inspherecount

Referenced by tetgenmesh().

◆ jettisoninverts

int tetgenmesh::jettisoninverts

Referenced by tetgenmesh().

◆ lengthlimit

REAL tetgenmesh::lengthlimit

◆ loc2oppo

int tetgenmesh::loc2oppo[4]
static

Referenced by oppo(), and setoppo().

◆ locpivot

int tetgenmesh::locpivot[4][3]
static

◆ locver2apex

int tetgenmesh::locver2apex[4][6]
static

Referenced by apex(), setapex(), symedge(), and symedgeself().

◆ locver2dest

int tetgenmesh::locver2dest[4][6]
static

Referenced by dest(), and setdest().

◆ locver2edge

int tetgenmesh::locver2edge[4][6]
static

Referenced by edgemarked(), markedge(), tssbond1(), tssdissolve1(), tsspivot1(), and unmarkedge().

◆ locver2nextf

int tetgenmesh::locver2nextf[4][6][2]
static

Referenced by fnext(), fnextself(), tfnext(), and tfnextself().

◆ locver2org

int tetgenmesh::locver2org[4][6]
static

Referenced by org(), and setorg().

◆ locverpivot

int tetgenmesh::locverpivot[4][6][2]
static

◆ longest

REAL tetgenmesh::longest

Referenced by tetgenmesh().

◆ macheps

REAL tetgenmesh::macheps

Referenced by tetgenmesh().

◆ max_btree_depth

int tetgenmesh::max_btree_depth

◆ max_btreenode_size

int tetgenmesh::max_btreenode_size

◆ maxbowatcavsize

long tetgenmesh::maxbowatcavsize

Referenced by tetgenmesh().

◆ maxcavfaces

int tetgenmesh::maxcavfaces

Referenced by tetgenmesh().

◆ maxcavsize

long tetgenmesh::maxcavsize

Referenced by tetgenmesh().

◆ maxcavverts

int tetgenmesh::maxcavverts

Referenced by tetgenmesh().

◆ maxregionsize

long tetgenmesh::maxregionsize

Referenced by tetgenmesh().

◆ meshedges

long tetgenmesh::meshedges

Referenced by tetgenmesh().

◆ minfaceang

REAL tetgenmesh::minfaceang

Referenced by tetgenmesh().

◆ minfacetdihed

REAL tetgenmesh::minfacetdihed

Referenced by tetgenmesh().

◆ minus1mod3

int tetgenmesh::minus1mod3[3]
static

◆ ndelaunayedgecount

long tetgenmesh::ndelaunayedgecount

Referenced by tetgenmesh().

◆ nextnonemptyq

int tetgenmesh::nextnonemptyq[64]

◆ nonconvex

int tetgenmesh::nonconvex

Referenced by tetgenmesh().

◆ opt_edge_flips

long tetgenmesh::opt_edge_flips

Referenced by tetgenmesh().

◆ opt_face_flips

long tetgenmesh::opt_face_flips

Referenced by tetgenmesh().

◆ opt_tet_peels

long tetgenmesh::opt_tet_peels

Referenced by tetgenmesh().

◆ optcount

long tetgenmesh::optcount[10]

◆ orient3dcount

long tetgenmesh::orient3dcount

Referenced by tetgenmesh().

◆ outbowatcircumcount

long tetgenmesh::outbowatcircumcount

Referenced by tetgenmesh().

◆ PI

REAL tetgenmesh::PI
static

Referenced by tetgenmesh().

◆ plus1mod3

int tetgenmesh::plus1mod3[3]
static

◆ point2pbcptindex

int tetgenmesh::point2pbcptindex

Referenced by point2pbcpt(), setpoint2pbcpt(), and tetgenmesh().

◆ point2simindex

int tetgenmesh::point2simindex

Referenced by point2bgmtet(), point2ppt(), point2seg(), point2sh(), point2tet(), setpoint2bgmtet(), setpoint2ppt(), setpoint2seg(), setpoint2sh(), setpoint2tet(), and tetgenmesh().

◆ pointmarkindex

int tetgenmesh::pointmarkindex

Referenced by pinfect(), pinfected(), pointmark(), pointtype(), puninfect(), setpointtype(), and tetgenmesh().

◆ pointmtrindex

int tetgenmesh::pointmtrindex

Referenced by tetgenmesh().

◆ points

memorypool* tetgenmesh::points

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ ptloc_count

long tetgenmesh::ptloc_count

Referenced by tetgenmesh().

◆ ptloc_max_count

long tetgenmesh::ptloc_max_count

Referenced by tetgenmesh().

◆ r1count

long tetgenmesh::r1count

Referenced by tetgenmesh().

◆ r2count

long tetgenmesh::r2count

Referenced by tetgenmesh().

◆ r3count

long tetgenmesh::r3count

Referenced by tetgenmesh().

◆ randomseed

unsigned long tetgenmesh::randomseed

Referenced by tetgenmesh().

◆ recentq

int tetgenmesh::recentq

◆ recenttet

triface tetgenmesh::recenttet

◆ rejsegpts

long tetgenmesh::rejsegpts

Referenced by tetgenmesh().

◆ rejsubpts

long tetgenmesh::rejsubpts

Referenced by tetgenmesh().

◆ rejtetpts

long tetgenmesh::rejtetpts

Referenced by tetgenmesh().

◆ relverts

int tetgenmesh::relverts

Referenced by tetgenmesh().

◆ samples

long tetgenmesh::samples

Referenced by tetgenmesh().

◆ segpbcgrouptable

list* tetgenmesh::segpbcgrouptable

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ segpglist

int * tetgenmesh::segpglist

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ shmarkindex

int tetgenmesh::shmarkindex

Referenced by setshellmark(), setshellpbcgroup(), setshelltype(), shellmark(), shellpbcgroup(), sinfect(), sinfected(), suninfect(), and tetgenmesh().

◆ sizeoftensor

int tetgenmesh::sizeoftensor

◆ smoothsegverts

int tetgenmesh::smoothsegverts

◆ steinerleft

int tetgenmesh::steinerleft

◆ subfaces

memorypool* tetgenmesh::subfaces

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ subfacstack

arraypool * tetgenmesh::subfacstack

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ subpbcgrouptable

pbcdata* tetgenmesh::subpbcgrouptable

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ subquefront

badface* tetgenmesh::subquefront[3]

◆ subquetail

badface ** tetgenmesh::subquetail[3]

◆ subsegs

memorypool* tetgenmesh::subsegs

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ subsegstack

arraypool* tetgenmesh::subsegstack

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ suprelverts

int tetgenmesh::suprelverts

Referenced by tetgenmesh().

◆ tet2segpool

memorypool* tetgenmesh::tet2segpool

Referenced by tetgenmesh(), tssbond1(), and ~tetgenmesh().

◆ tet2subpool

memorypool * tetgenmesh::tet2subpool

Referenced by tetgenmesh(), tsbond(), and ~tetgenmesh().

◆ tetquefront

badface* tetgenmesh::tetquefront[64]

◆ tetquetail

badface * tetgenmesh::tetquetail[64]

◆ tetrahedrons

memorypool* tetgenmesh::tetrahedrons

Referenced by tetgenmesh(), and ~tetgenmesh().

◆ totalbowatcavsize

long tetgenmesh::totalbowatcavsize

Referenced by tetgenmesh().

◆ totaldeadtets

long tetgenmesh::totaldeadtets

Referenced by tetgenmesh().

◆ unsupverts

int tetgenmesh::unsupverts

Referenced by tetgenmesh().

◆ unuverts

int tetgenmesh::unuverts

Referenced by tetgenmesh().

◆ updsegcount

long tetgenmesh::updsegcount

Referenced by tetgenmesh().

◆ updsubcount

long tetgenmesh::updsubcount

Referenced by tetgenmesh().

◆ updvolcount

long tetgenmesh::updvolcount

Referenced by tetgenmesh().

◆ va

int tetgenmesh::va[6]
static

Referenced by sapex(), and setsapex().

◆ varconstraint

int tetgenmesh::varconstraint

Referenced by tetgenmesh().

◆ vd

int tetgenmesh::vd[6]
static

Referenced by sdest(), and setsdest().

◆ ve

int tetgenmesh::ve[6]
static

Referenced by enext(), enext2(), enext2self(), enextself(), senext(), senext2(), senext2self(), and senextself().

◆ vo

int tetgenmesh::vo[6]
static

Referenced by setsorg(), and sorg().

◆ volumeboundindex

int tetgenmesh::volumeboundindex

Referenced by setvolumebound(), tetgenmesh(), and volumebound().

◆ xmax

REAL tetgenmesh::xmax

Referenced by tetgenmesh().

◆ xmin

REAL tetgenmesh::xmin

Referenced by tetgenmesh().

◆ ymax

REAL tetgenmesh::ymax

Referenced by tetgenmesh().

◆ ymin

REAL tetgenmesh::ymin

Referenced by tetgenmesh().

◆ zmax

REAL tetgenmesh::zmax

Referenced by tetgenmesh().

◆ zmin

REAL tetgenmesh::zmin

Referenced by tetgenmesh().

The documentation for this class was generated from the following file: