|
| char * | readline () |
| char * | findfield () |
| int | triunsuitable () |
| int | triunsuitable (vertex triorg, vertex tridest, vertex triapex, REAL) int triunsuitable(triorg |
| | if (maxlen > 0.05 *(triorg[0] *triorg[0]+triorg[1] *triorg[1])+0.02) |
| void | triexit (int status) void triexit(status) int status |
| VOID * | trimalloc (int size) VOID *trimalloc(size) int size |
| | if (memptr==(VOID *) NULL) |
| | return (memptr) |
| void | trifree (void *memptr) void trifree(memptr) VOID *memptr |
| void | syntax () |
| void | info () |
| void | internalerror () |
| void | parsecommandline (int argc, const char **argv, struct behavior *b) void parsecommandline(argc |
| | for (i=STARTINDEX;i< argc;i++) |
| | if (b->innodefilename[0]=='\0') |
| | if (!strcmp(&b->innodefilename[strlen(b->innodefilename) - 5], ".node")) |
| | if (!strcmp(&b->innodefilename[strlen(b->innodefilename) - 5], ".poly")) |
| | if (!strcmp(&b->innodefilename[strlen(b->innodefilename) - 4], ".ele")) |
| | if (!strcmp(&b->innodefilename[strlen(b->innodefilename) - 5], ".area")) |
| | if (b->goodangle==1.0) |
| b goodangle * | if (b->refine &&b->noiterationnum) |
| | if (!b->refine &&!b->poly) |
| | if (b->refine||!b->poly) |
| | if (b->weighted &&(b->poly||b->quality)) |
| | if (b->jettison &&b->nonodewritten &&!b->quiet) |
| | strcpy (b->inpolyfilename, b->innodefilename) |
| | strcpy (workstring, b->innodefilename) |
| | while (workstring[j] !='\0') |
| | if (increment > 0) |
| else | if (increment==0) |
| | sprintf (b->outnodefilename, workstring, meshnumber+1) |
| | strcat (b->outnodefilename, ".node") |
| | strcat (b->outpolyfilename, ".poly") |
| | strcat (b->outelefilename, ".ele") |
| | strcat (b->edgefilename, ".edge") |
| | strcat (b->vnodefilename, ".v.node") |
| | strcat (b->vedgefilename, ".v.edge") |
| | strcat (b->neighborfilename, ".neigh") |
| | strcat (b->offfilename, ".off") |
| | strcat (b->areafilename, ".area") |
| void | printtriangle (struct mesh *m, struct behavior *b, struct otri *t) void printtriangle(m |
| | printf ("triangle x%lx with orientation %d:\n",(unsigned long) t->tri, t->orient) |
| | decode (t->tri[0], printtri) |
| | if (printtri.tri==m->dummytri) |
| | decode (t->tri[1], printtri) |
| | decode (t->tri[2], printtri) |
| | if (printvertex==(vertex) NULL) printf(" Origin[%d] |
| called is pointed to *void | dummyinit (struct mesh *m, struct behavior *b, int trianglebytes, int subsegbytes) void dummyinit(m |
| void | initializevertexpool (struct mesh *m, struct behavior *b) void initializevertexpool(m |
| poolinit & | m (REAL) |
| void | initializetrisubpools (struct mesh *m, struct behavior *b) void initializetrisubpools(m |
| else | if (m->eextras+b->regionattrib > 0) |
| | if ((b->voronoi||b->neighbors) &&(trisize< int(6 *sizeof(triangle)+sizeof(int)))) |
| poolinit & | m (2 *m->invertices - 2) > TRIPERBLOCK ?(2 *m->invertices - 2) :TRIPERBLOCK, 4 |
| void | triangledealloc (struct mesh *m, triangle *dyingtriangle) void triangledealloc(m |
| pooldealloc & | m (VOID *) dyingtriangle |
| triangle * | triangletraverse (struct mesh *m) triangle *triangletraverse(m) struct mesh *m |
| | if (newtriangle==(triangle *) NULL) |
| | while (deadtri(newtriangle)) |
| void | subsegdealloc (struct mesh *m, subseg *dyingsubseg) void subsegdealloc(m |
| subseg * | subsegtraverse (struct mesh *m) subseg *subsegtraverse(m) struct mesh *m |
| | if (newsubseg==(subseg *) NULL) |
| | while (deadsubseg(newsubseg)) |
| void | vertexdealloc (struct mesh *m, vertex dyingvertex) void vertexdealloc(m |
| vertex | vertextraverse (struct mesh *m) vertex vertextraverse(m) struct mesh *m |
| | if (newvertex==(vertex) NULL) |
| | while (vertextype(newvertex)==DEADVERTEX) |
| void | badsubsegdealloc (struct mesh *m, struct badsubseg *dyingseg) void badsubsegdealloc(m |
| struct badsubseg * | badsubsegtraverse (struct mesh *m) struct badsubseg *badsubsegtraverse(m) struct mesh *m |
| | if (newseg==(struct badsubseg *) NULL) |
| | while (newseg->subsegorg==(vertex) NULL) |
| vertex | getvertex (struct mesh *m, struct behavior *b, int number) vertex getvertex(m |
| | if (current+m->vertices.itemsfirstblock<=number) |
| return | vertex (foundvertex+m->vertices.itembytes *(number - current)) |
| void | triangledeinit (struct mesh *m, struct behavior *b) void triangledeinit(m |
| | trifree ((VOID *) m->dummytribase) |
| void | maketriangle (struct mesh *m, struct behavior *b, struct otri *newotri) void maketriangle(m |
| | for (i=0;i< m->eextras;i++) |
| void | makesubseg (struct mesh *m, struct osub *newsubseg) void makesubseg(m |
| void | exactinit () |
| int | fast_expansion_sum_zeroelim (int elen, REAL *e, int flen, REAL *f, REAL *h) int fast_expansion_sum_zeroelim(elen |
| | if ((fnow > enow)==(fnow > -enow)) |
| | if ((eindex< elen) &&(findex< flen)) |
| | while (eindex< elen) |
| | if ((Q !=0.0)||(hindex==0)) |
| int | scale_expansion_zeroelim (int elen, REAL *e, REAL b, REAL *h) int scale_expansion_zeroelim(elen |
| | Split (b, bhi, blo) |
| | Two_Product_Presplit (e[0], b, bhi, blo, Q, hh) |
| | if (hh !=0) |
| REAL | estimate (int elen, REAL *e) REAL estimate(elen |
| REAL | counterclockwiseadapt (vertex pa, vertex pb, vertex pc, REAL detsum) REAL counterclockwiseadapt(pa |
| | Two_Product (acx, bcy, detleft, detlefttail) |
| | Two_Product (acy, bcx, detright, detrighttail) |
| | Two_Two_Diff (detleft, detlefttail, detright, detrighttail, B3, B[2], B[1], B[0]) |
| | if ((det >=errbound)||(-det >=errbound)) |
| | Two_Diff_Tail (pa[0], pc[0], acx, acxtail) |
| | Two_Diff_Tail (pb[0], pc[0], bcx, bcxtail) |
| | Two_Diff_Tail (pa[1], pc[1], acy, acytail) |
| | Two_Diff_Tail (pb[1], pc[1], bcy, bcytail) |
| | if ((acxtail==0.0) &&(acytail==0.0) &&(bcxtail==0.0) &&(bcytail==0.0)) |
| | Two_Product (acxtail, bcy, s1, s0) |
| | Two_Product (acytail, bcx, t1, t0) |
| | Two_Two_Diff (s1, s0, t1, t0, u3, u[2], u[1], u[0]) |
| | Two_Product (acx, bcytail, s1, s0) |
| | Two_Product (acy, bcxtail, t1, t0) |
| | Two_Product (acxtail, bcytail, s1, s0) |
| | Two_Product (acytail, bcxtail, t1, t0) |
| | return (D[Dlength - 1]) |
| REAL | counterclockwise (struct mesh *m, struct behavior *b, vertex pa, vertex pb, vertex pc) REAL counterclockwise(m |
| | if (detleft > 0.0) |
| else | if (detleft< 0.0) |
| return | counterclockwiseadapt (pa, pb, pc, detsum) |
| REAL | incircleadapt (vertex pa, vertex pb, vertex pc, vertex pd, REAL permanent) REAL incircleadapt(pa |
| | Two_Product (bdx, cdy, bdxcdy1, bdxcdy0) |
| | Two_Product (cdx, bdy, cdxbdy1, cdxbdy0) |
| | Two_Two_Diff (bdxcdy1, bdxcdy0, cdxbdy1, cdxbdy0, bc3, bc[2], bc[1], bc[0]) |
| | Two_Product (cdx, ady, cdxady1, cdxady0) |
| | Two_Product (adx, cdy, adxcdy1, adxcdy0) |
| | Two_Two_Diff (cdxady1, cdxady0, adxcdy1, adxcdy0, ca3, ca[2], ca[1], ca[0]) |
| | Two_Product (adx, bdy, adxbdy1, adxbdy0) |
| | Two_Product (bdx, ady, bdxady1, bdxady0) |
| | Two_Two_Diff (adxbdy1, adxbdy0, bdxady1, bdxady0, ab3, ab[2], ab[1], ab[0]) |
| | Two_Diff_Tail (pa[0], pd[0], adx, adxtail) |
| | Two_Diff_Tail (pa[1], pd[1], ady, adytail) |
| | Two_Diff_Tail (pb[0], pd[0], bdx, bdxtail) |
| | Two_Diff_Tail (pb[1], pd[1], bdy, bdytail) |
| | Two_Diff_Tail (pc[0], pd[0], cdx, cdxtail) |
| | Two_Diff_Tail (pc[1], pd[1], cdy, cdytail) |
| | if ((adxtail==0.0) &&(bdxtail==0.0) &&(cdxtail==0.0) &&(adytail==0.0) &&(bdytail==0.0) &&(cdytail==0.0)) |
| | if ((bdxtail !=0.0)||(bdytail !=0.0)||(cdxtail !=0.0)||(cdytail !=0.0)) |
| | if ((cdxtail !=0.0)||(cdytail !=0.0)||(adxtail !=0.0)||(adytail !=0.0)) |
| | if ((adxtail !=0.0)||(adytail !=0.0)||(bdxtail !=0.0)||(bdytail !=0.0)) |
| | if (adxtail !=0.0) |
| | if (adytail !=0.0) |
| | if (bdxtail !=0.0) |
| | if (bdytail !=0.0) |
| | if (cdxtail !=0.0) |
| | if (cdytail !=0.0) |
| | if ((adxtail !=0.0)||(adytail !=0.0)) |
| | if ((bdxtail !=0.0)||(bdytail !=0.0)) |
| | if ((cdxtail !=0.0)||(cdytail !=0.0)) |
| REAL | incircle (struct mesh *m, struct behavior *b, vertex pa, vertex pb, vertex pc, vertex pd) REAL incircle(m |
| | if ((det > errbound)||(-det > errbound)) |
| return | incircleadapt (pa, pb, pc, pd, permanent) |
| REAL | orient3dadapt (vertex pa, vertex pb, vertex pc, vertex pd, REAL aheight, REAL bheight, REAL cheight, REAL dheight, REAL permanent) REAL orient3dadapt(pa |
| | Two_Diff_Tail (aheight, dheight, adheight, adheighttail) |
| | Two_Diff_Tail (bheight, dheight, bdheight, bdheighttail) |
| | Two_Diff_Tail (cheight, dheight, cdheight, cdheighttail) |
| | if ((adxtail==0.0) &&(bdxtail==0.0) &&(cdxtail==0.0) &&(adytail==0.0) &&(bdytail==0.0) &&(cdytail==0.0) &&(adheighttail==0.0) &&(bdheighttail==0.0) &&(cdheighttail==0.0)) |
| | if (adxtail==0.0) |
| | if (adheighttail !=0.0) |
| | if (bdheighttail !=0.0) |
| | if (cdheighttail !=0.0) |
| REAL | orient3d (struct mesh *m, struct behavior *b, vertex pa, vertex pb, vertex pc, vertex pd, REAL aheight, REAL bheight, REAL cheight, REAL dheight) REAL orient3d(m |
| return | orient3dadapt (pa, pb, pc, pd, aheight, bheight, cheight, dheight, permanent) |
| REAL | nonregular (struct mesh *m, struct behavior *b, vertex pa, vertex pb, vertex pc, vertex pd) REAL nonregular(m |
| | if ((dodist< aodist) &&(dodist< dadist)) |
| void | triangleinit (struct mesh *m) void triangleinit(m) struct mesh *m |
| unsigned long | randomnation (unsigned int choices) unsigned long randomnation(choices) unsigned int choices |
| return | randomseed (714025l/choices+1) |
| void | checkmesh (struct mesh *m, struct behavior *b) void checkmesh(m |
| | if (!b->quiet) |
| | while (triangleloop.tri !=(triangle *) NULL) |
| | if (horrors==0) |
| void | checkdelaunay (struct mesh *m, struct behavior *b) void checkdelaunay(m |
| void | enqueuebadtriang (struct mesh *m, struct behavior *b, struct badtriang *badtri) void enqueuebadtriang(m |
| | if (b->verbose > 2) |
| | if (badtri->key >=1.0) |
| | while (length > 2.0) |
| | if (posexponent) |
| | if (m->queuefront[queuenumber]==(struct badtriang *) NULL) |
| void | enqueuebadtri (struct mesh *m, struct behavior *b, struct otri *enqtri, REAL minedge, vertex enqapex, vertex enqorg, vertex enqdest) void enqueuebadtri(m |
| | enqueuebadtriang (m, b, newbad) |
| struct badtriang * | dequeuebadtriang (struct mesh *m) struct badtriang *dequeuebadtriang(m) struct mesh *m |
| | if (result==m->queuetail[m->firstnonemptyq]) |
| int | checkseg4encroach (struct mesh *m, struct behavior *b, struct osub *testsubseg) int checkseg4encroach(m |
| | if (neighbortri.tri !=m->dummytri) |
| | stpivot (testsym, neighbortri) |
| | if (encroached &&(!b->nobisect||((b->nobisect==1) &&(sides==2)))) |
| void | testtriangle (struct mesh *m, struct behavior *b, struct otri *testtri) void testtriangle(m |
| | if ((apexlen< orglen) &&(apexlen< destlen)) |
| | if (b->vararea||b->fixedarea||b->usertest) |
| | if (angle > b->goodangle) |
| void | makevertexmap (struct mesh *m, struct behavior *b) void makevertexmap(m |
| enum locateresult | preciselocate (struct mesh *m, struct behavior *b, vertex searchpoint, struct otri *searchtri, int stopatsubsegment) enum locateresult preciselocate(m |
| | while (1) |
| enum locateresult | locate (struct mesh *m, struct behavior *b, vertex searchpoint, struct otri *searchtri) enum locateresult locate(m |
| | if (m->recenttri.tri !=(triangle *) NULL) |
| | while (SAMPLEFACTOR *m->samples *m->samples *m->samples< m->triangles.items) |
| | while (totalsamplesleft > 0) |
| | if ((torg[0]==searchpoint[0]) &&(torg[1]==searchpoint[1])) |
| | if ((tdest[0]==searchpoint[0]) &&(tdest[1]==searchpoint[1])) |
| else | if (ahead==0.0) |
| return | preciselocate (m, b, searchpoint, searchtri, 0) |
| void | insertsubseg (struct mesh *m, struct behavior *b, struct otri *tri, int subsegmark) void insertsubseg(m |
| | if (vertexmark(triorg)==0) |
| | if (vertexmark(tridest)==0) |
| | if (newsubseg.ss==m->dummysub) |
| | if (top.tri==m->dummytri) |
| | if (m->checksegments) |
| | apex (top, farvertex) |
| | lprev (top, topleft) |
| | sym (topleft, toplcasing) |
| | lnext (top, topright) |
| | sym (topright, toprcasing) |
| | sym (botleft, botlcasing) |
| | sym (botright, botrcasing) |
| | bond (topleft, botlcasing) |
| | bond (botleft, botrcasing) |
| | bond (botright, toprcasing) |
| | bond (topright, toplcasing) |
| | setorg (top, botvertex) |
| | setdest (top, farvertex) |
| | setapex (top, leftvertex) |
| void | unflip (struct mesh *m, struct behavior *b, struct otri *flipedge) void unflip(m |
| | bond (topleft, toprcasing) |
| | bond (botleft, toplcasing) |
| | bond (botright, botlcasing) |
| | bond (topright, botrcasing) |
| | setorg (top, farvertex) |
| | setdest (top, botvertex) |
| | setapex (top, rightvertex) |
| enum insertvertexresult | insertvertex (struct mesh *m, struct behavior *b, vertex newvertex, struct otri *searchtri, struct osub *splitseg, int segmentflaws, int triflaws) enum insertvertexresult insertvertex(m |
| | if (b->verbose > 1) |
| | if (splitseg==(struct osub *) NULL) |
| | if (intersect==ONVERTEX) |
| | if ((intersect==ONEDGE)||(intersect==OUTSIDE)) |
| | lprev (horiz, botright) |
| | maketriangle (m, b, &newbotleft) |
| | org (horiz, rightvertex) |
| | destT (horiz, leftvertex) |
| | apex (horiz, botvertex) |
| | setorg (newbotleft, leftvertex) |
| | setdest (newbotleft, botvertex) |
| | setapex (newbotleft, newvertex) |
| | setorg (newbotright, botvertex) |
| | setdest (newbotright, rightvertex) |
| | setapex (newbotright, newvertex) |
| | setapex (horiz, newvertex) |
| | bond (newbotleft, botlcasing) |
| | bond (newbotright, botrcasing) |
| | lnextself (newbotleft) |
| | lprevself (newbotright) |
| | bond (newbotleft, newbotright) |
| | bond (botleft, newbotleft) |
| | bond (botright, newbotright) |
| | org (horiz, first) |
| void | triangulatepolygon (struct mesh *m, struct behavior *b, struct otri *firstedge, struct otri *lastedge, int edgecount, int doflip, int triflaws) void triangulatepolygon(m |
| | destT (besttri, bestvertex) |
| | otricopy (besttri, testtri) |
| | if (bestnumber > 1) |
| | if (doflip) |
| | otricopy (besttri, *lastedge) |
| void | deletevertex (struct mesh *m, struct behavior *b, struct otri *deltri) void deletevertex(m |
| | vertexdealloc (m, delvertex) |
| | while (!otriequal(*deltri, countingtri)) |
| | if (edgecount > 3) |
| | sym (lefttri, leftcasing) |
| | oprev (deltriright, righttri) |
| | sym (righttri, rightcasing) |
| | bond (deltriright, rightcasing) |
| | tspivot (lefttri, leftsubseg) |
| | if (leftsubseg.ss !=m->dummysub) |
| | tspivot (righttri, rightsubseg) |
| | if (rightsubseg.ss !=m->dummysub) |
| | org (lefttri, neworg) |
| | triangledealloc (m, lefttri.tri) |
| | triangledealloc (m, righttri.tri) |
| void | undovertex (struct mesh *m, struct behavior *b) void undovertex(m |
| | while (m->lastflip !=(struct flipstacker *) NULL) |
| void | vertexsort (vertex *sortarray, int arraysize) void vertexsort(sortarray |
| | if (arraysize==2) |
| | if (left > 1) |
| void | vertexmedian (vertex *sortarray, int arraysize, int median, int axis) void vertexmedian(sortarray |
| | if (left > median) |
| void | alternateaxes (vertex *sortarray, int arraysize, int axis) void alternateaxes(sortarray |
| | if (arraysize<=3) |
| | vertexmedian (sortarray, arraysize, divider, axis) |
| | if (arraysize - divider >=2) |
| void | mergehulls (struct mesh *m, struct behavior *b, struct otri *farleft, struct otri *innerleft, struct otri *innerright, struct otri *farright, int axis) void mergehulls(m |
| | if (b->dwyer &&(axis==1)) |
| | if (counterclockwise(m, b, innerleftdest, innerleftapex, innerrightorg) > 0.0) |
| | if (counterclockwise(m, b, innerrightapex, innerrightorg, innerleftdest) > 0.0) |
| | while (changemade) |
| | bond (baseedge, *innerleft) |
| | lnextself (baseedge) |
| | setorg (baseedge, innerrightorg) |
| | setdest (baseedge, innerleftdest) |
| | if (innerleftdest==farleftpt) |
| | if (innerrightorg==farrightpt) |
| | apex (leftcand, upperleft) |
| | apex (rightcand, upperright) |
| void | divconqrecurse (struct mesh *m, struct behavior *b, vertex *sortarray, int vertices, int axis, struct otri *farleft, struct otri *farright) void divconqrecurse(m |
| | if (vertices==2) |
| | divconqrecurse (m, b, sortarray, divider, 1 - axis, farleft, &innerleft) |
| | divconqrecurse (m, b, &sortarray[divider], vertices - divider, 1 - axis, &innerright, farright) |
| | mergehulls (m, b, farleft, &innerleft, &innerright, farright, axis) |
| long | removeghosts (struct mesh *m, struct behavior *b, struct otri *startghost) long removeghosts(m |
| | symself (searchedge) |
| | lnext (dissolveedge, deadtriangle) |
| | lprevself (dissolveedge) |
| | symself (dissolveedge) |
| | dissolve (dissolveedge) |
| | sym (deadtriangle, dissolveedge) |
| | triangledealloc (m, deadtriangle.tri) |
| | while (!otriequal(dissolveedge, *startghost)) |
| long | divconqdelaunay (struct mesh *m, struct behavior *b) long divconqdelaunay(m |
| | vertexsort (sortarray, m->invertices) |
| | for (j=1;j< m->invertices;j++) |
| | divconqrecurse (m, b, sortarray, i, 0, &hullleft, &hullright) |
| | trifree ((VOID *) sortarray) |
| return | removeghosts (m, b, &hullleft) |
| void | boundingbox (struct mesh *m, struct behavior *b) void boundingbox(m |
| | if (m->ymax - m->ymin > width) |
| | if (width==0.0) |
| | setorg (inftri, m->infvertex1) |
| | setdest (inftri, m->infvertex2) |
| | setapex (inftri, m->infvertex3) |
| long | removebox (struct mesh *m, struct behavior *b) long removebox(m |
| | symself (nextedge) |
| | lprev (nextedge, finaledge) |
| | lnextself (nextedge) |
| | lprev (nextedge, searchedge) |
| | lnext (nextedge, checkedge) |
| | symself (checkedge) |
| | if (checkedge.tri==m->dummytri) |
| | while (!otriequal(nextedge, finaledge)) |
| | triangledealloc (m, finaledge.tri) |
| long | incrementaldelaunay (struct mesh *m, struct behavior *b) long incrementaldelaunay(m |
| | boundingbox (m, b) |
| | while (vertexloop !=(vertex) NULL) |
| return | removebox (m, b) |
| void | eventheapinsert (struct event **heap, int heapsize, struct event *newevent) void eventheapinsert(heap |
| | while (notdone) |
| void | eventheapify (struct event **heap, int heapsize, int eventnum) void eventheapify(heap |
| void | eventheapdelete (struct event **heap, int heapsize, int eventnum) void eventheapdelete(heap |
| | if (eventnum > 0) |
| | eventheapify (heap, heapsize - 1, eventnum) |
| void | createeventheap (struct mesh *m, struct event ***eventheap, struct event **events, struct event **freeevents) void createeventheap(m |
| int | rightofhyperbola (struct mesh *m, struct otri *fronttri, vertex newsite) int rightofhyperbola(m |
| | if ((leftvertex[1]< rightvertex[1])||((leftvertex[1]==rightvertex[1]) &&(leftvertex[0]< rightvertex[0]))) |
| REAL | circletop (struct mesh *m, vertex pa, vertex pb, vertex pc, REAL ccwabc) REAL circletop(m |
| return | pc (xac *bclen2 - xbc *aclen2+sqrt(aclen2 *bclen2 *ablen2))/(2.0 *ccwabc) |
| void | check4deadevent (struct otri *checktri, struct event **freeevents, struct event **eventheap, int *heapsize) void check4deadevent(checktri |
| | if (eventvertex !=(vertex) NULL) |
| struct splaynode * | splay (struct mesh *m, struct splaynode *splaytree, vertex searchpoint, struct otri *searchtri) struct splaynode *splay(m |
| | if (splaytree==(struct splaynode *) NULL) |
| | destT (splaytree->keyedge, checkvertex) |
| | if (checkvertex==splaytree->keydest) |
| | if (lefttree==(struct splaynode *) NULL) |
| else | if (righttree==(struct splaynode *) NULL) |
| else | if (lefttree->rchild==(struct splaynode *) NULL) |
| else | if (righttree->lchild==(struct splaynode *) NULL) |
| | while (leftright->rchild !=(struct splaynode *) NULL) |
| struct splaynode * | splayinsert (struct mesh *m, struct splaynode *splayroot, struct otri *newkey, vertex searchpoint) struct splaynode *splayinsert(m |
| | if (splayroot==(struct splaynode *) NULL) |
| else | if (rightofhyperbola(m, &splayroot->keyedge, searchpoint)) |
| struct splaynode * | circletopinsert (struct mesh *m, struct behavior *b, struct splaynode *splayroot, struct otri *newkey, vertex pa, vertex pb, vertex pc, REAL topy) struct splaynode *circletopinsert(m |
| return | splayinsert (m, splay(m, splayroot,(vertex) searchpoint, &dummytri), newkey,(vertex) searchpoint) |
| struct splaynode * | frontlocate (struct mesh *m, struct splaynode *splayroot, struct otri *bottommost, vertex searchvertex, struct otri *searchtri, int *farright) struct splaynode *frontlocate(m |
| | while (!farrightflag &&rightofhyperbola(m, searchtri, searchvertex)) |
| long | sweeplinedelaunay (struct mesh *m, struct behavior *b) long sweeplinedelaunay(m |
| poolinit & | m (struct splaynode), SPLAYNODEPERBLOCK, SPLAYNODEPERBLOCK, 0 |
| | createeventheap (m, &eventheap, &events, &freeevents) |
| | bond (lefttri, righttri) |
| | lnextself (lefttri) |
| | lprevself (righttri) |
| | eventheapdelete (eventheap, heapsize, 0) |
| | if ((firstvertex[0]==secondvertex[0]) &&(firstvertex[1]==secondvertex[1])) |
| | while ((firstvertex[0]==secondvertex[0]) &&(firstvertex[1]==secondvertex[1])) |
| | setorg (lefttri, firstvertex) |
| | setdest (lefttri, secondvertex) |
| | setorg (righttri, secondvertex) |
| | setdest (righttri, firstvertex) |
| | lprev (lefttri, bottommost) |
| | while (heapsize > 0) |
| | lprevself (bottommost) |
| long | delaunay (struct mesh *m, struct behavior *b) long delaunay(m |
| | initializetrisubpools (m, b) |
| | if (m->triangles.items==0) |
| int | reconstruct (struct mesh *m, struct behavior *b, int *trianglelist, REAL *triangleattriblist, REAL *trianglearealist, int elements, int corners, int attribs, int *segmentlist, int *segmentmarkerlist, int numberofsegments) int reconstruct(m |
| long | reconstruct (struct mesh *m, struct behavior *b, char *elefilename, char *areafilename, char *polyfilename, FILE *polyfile) long reconstruct(m |
| | if (elefile==(FILE *) NULL) |
| | for (elementnumber=1;elementnumber<=m->inelements;elementnumber++) |
| | fclose (elefile) |
| enum finddirectionresult | finddirection (struct mesh *m, struct behavior *b, struct otri *searchtri, vertex searchpoint) enum finddirectionresult finddirection(m |
| | if (leftflag &&rightflag) |
| | while (leftflag) |
| | while (rightflag) |
| | if (leftccw==0.0) |
| else | if (rightccw==0.0) |
| void | segmentintersection (struct mesh *m, struct behavior *b, struct otri *splittri, struct osub *splitsubseg, vertex endpoint2) void segmentintersection(m |
| | if (denom==0.0) |
| | setvertexmark (newvertex, markT(*splitsubseg)) |
| | setvertextype (newvertex, INPUTVERTEX) |
| | if (success !=SUCCESSFULVERTEX) |
| | setvertex2tri (newvertex, encode(*splittri)) |
| | if (m->steinerleft > 0) |
| | sdissolve (opposubseg) |
| | while (splitsubseg->ss !=m->dummysub) |
| | snextself (opposubseg) |
| | while (opposubseg.ss !=m->dummysub) |
| | if ((leftvertex[0]==endpoint1[0]) &&(leftvertex[1]==endpoint1[1])) |
| else | if ((rightvertex[0] !=endpoint1[0])||(rightvertex[1] !=endpoint1[1])) |
| int | scoutsegment (struct mesh *m, struct behavior *b, struct otri *searchtri, vertex endpoint2, int newmark) int scoutsegment(m |
| | if (((leftvertex[0]==endpoint2[0]) &&(leftvertex[1]==endpoint2[1]))||((rightvertex[0]==endpoint2[0]) &&(rightvertex[1]==endpoint2[1]))) |
| else | if (collinear==LEFTCOLLINEAR) |
| | tspivot (crosstri, crosssubseg) |
| | if (crosssubseg.ss==m->dummysub) |
| | otricopy (crosstri, *searchtri) |
| | insertsubseg (m, b, searchtri, newmark) |
| return | scoutsegment (m, b, searchtri, endpoint2, newmark) |
| void | conformingedge (struct mesh *m, struct behavior *b, vertex endpoint1, vertex endpoint2, int newmark) void conformingedge(m |
| | setvertexmark (newvertex, newmark) |
| | setvertextype (newvertex, SEGMENTVERTEX) |
| | if (success==DUPLICATEVERTEX) |
| | finddirection (m, b, &searchtri2, endpoint2) |
| | if (!scoutsegment(m, b, &searchtri1, endpoint1, newmark)) |
| | if (!scoutsegment(m, b, &searchtri2, endpoint2, newmark)) |
| void | delaunayfixup (struct mesh *m, struct behavior *b, struct otri *fixuptri, int leftside) void delaunayfixup(m |
| | sym (neartri, fartri) |
| | if (fartri.tri==m->dummytri) |
| | tspivot (neartri, faredge) |
| | if (faredge.ss !=m->dummysub) |
| | apex (neartri, nearvertex) |
| | org (neartri, leftvertex) |
| | destT (neartri, rightvertex) |
| | apex (fartri, farvertex) |
| | if (leftside) |
| | delaunayfixup (m, b, fixuptri, leftside) |
| | delaunayfixup (m, b, &fartri, leftside) |
| void | constrainededge (struct mesh *m, struct behavior *b, struct otri *starttri, vertex endpoint2, int newmark) void const rainededge(m |
| | flip (m, b, &fixuptri) |
| | if ((farvertex[0]==endpoint2[0]) &&(farvertex[1]==endpoint2[1])) |
| | if (area==0.0) |
| | segmentintersection (m, b, &fixuptri, &crosssubseg, endpoint2) |
| | while (!done) |
| | insertsubseg (m, b, &fixuptri, newmark) |
| | if (collision) |
| void | insertsegment (struct mesh *m, struct behavior *b, vertex endpoint1, vertex endpoint2, int newmark) void insertsegment(m |
| | if (encodedtri !=(triangle) NULL) |
| | if (checkvertex !=endpoint1) |
| | otricopy (searchtri1, m->recenttri) |
| | if (scoutsegment(m, b, &searchtri1, endpoint2, newmark)) |
| | org (searchtri1, endpoint1) |
| | otricopy (searchtri2, m->recenttri) |
| | if (scoutsegment(m, b, &searchtri2, endpoint1, newmark)) |
| | org (searchtri2, endpoint2) |
| void | markhull (struct mesh *m, struct behavior *b) void markhull(m |
| | symself (hulltri) |
| | otricopy (hulltri, starttri) |
| | lnextself (hulltri) |
| | oprev (hulltri, nexttri) |
| | while (nexttri.tri !=m->dummytri) |
| | while (!otriequal(hulltri, starttri)) |
| void | formskeleton (struct mesh *m, struct behavior *b, int *segmentlist, int *segmentmarkerlist, int numberofsegments) void formskeleton(m |
| void | formskeleton (struct mesh *m, struct behavior *b, FILE *polyfile, char *polyfilename) void formskeleton(m |
| | if (b->convex||!b->poly) |
| void | infecthull (struct mesh *m, struct behavior *b) void infecthull(m |
| void | plague (struct mesh *m, struct behavior *b) void plague(m |
| | while (virusloop !=(triangle **) NULL) |
| void | regionplague (struct mesh *m, struct behavior *b, REAL attribute, REAL area) void regionplague(m |
| void | carveholes (struct mesh *m, struct behavior *b, REAL *holelist, int holes, REAL *regionlist, int regions) void carveholes(m |
| | if (!(b->quiet||(b->noholes &&b->convex))) |
| | if (regions > 0) |
| | if (((holes > 0) &&!b->noholes)||!b->convex||(regions > 0)) |
| | if ((holes > 0) &&!b->noholes) |
| | if (m->viri.items > 0) |
| void | tallyencs (struct mesh *m, struct behavior *b) void tallyencs(m |
| | while (subsegloop.ss !=(subseg *) NULL) |
| void | precisionerror () |
| void | splitencsegs (struct mesh *m, struct behavior *b, int triflaws) void splitencsegs(m |
| | while ((m->badsubsegs.items > 0) &&(m->steinerleft !=0)) |
| void | tallyfaces (struct mesh *m, struct behavior *b) void tallyfaces(m |
| void | splittriangle (struct mesh *m, struct behavior *b, struct badtriang *badtri) void splittriangle(m |
| | decode (badtri->poortri, badotri) |
| | org (badotri, borg) |
| | destT (badotri, bdest) |
| | apex (badotri, bapex) |
| | if (!deadtri(badotri.tri) &&(borg==badtri->triangorg) &&(bdest==badtri->triangdest) &&(bapex==badtri->triangapex)) |
| void | enforcequality (struct mesh *m, struct behavior *b) void enforcequality(m |
| poolinit & | m (struct badsubseg), BADSUBSEGPERBLOCK, BADSUBSEGPERBLOCK, 0 |
| | tallyencs (m, b) |
| | if (b->verbose &&(m->badsubsegs.items > 0)) |
| | splitencsegs (m, b, 0) |
| | if ((b->minangle > 0.0)||b->vararea||b->fixedarea||b->usertest) |
| | if (!b->quiet &&b->conformdel &&(m->badsubsegs.items > 0) &&(m->steinerleft==0)) |
| void | highorder (struct mesh *m, struct behavior *b) void highorder(m |
| char * | readline (char *string, FILE *infile, char *infilename) char *readline(string |
| | while ((*result !='\0') &&(*result !='#') &&(*result !='.') &&(*result !='+') &&(*result !='-') &&((*result< '0')||(*result > '9'))) |
| | while ((*result=='#')||(*result=='\0')) |
| char * | findfield (char *string) char *findfield(string) char *string |
| | while ((*result !='\0') &&(*result !='#') &&(*result !=' ') &&(*result !='\t')) |
| void | readnodes (struct mesh *m, struct behavior *b, char *nodefilename, char *polyfilename, FILE **polyfile) void readnodes(m |
| | if (m->mesh_dim !=2) |
| | initializevertexpool (m, b) |
| void | transfernodes (struct mesh *m, struct behavior *b, REAL *pointlist, REAL *pointattriblist, int *pointmarkerlist, int numberofpoints, int numberofpointattribs) void transfernodes(m |
| void | readholes (struct mesh *m, struct behavior *b, FILE *polyfile, char *polyfilename, REAL **hlist, int *holes, REAL **rlist, int *regions) void readholes(m |
| | if ((b->regionattrib||b->vararea) &&!b->refine) |
| | fclose (polyfile) |
| void | finishfile (FILE *outfile, int argc, char **argv) void finishfile(outfile |
| | fprintf (outfile, "# Generated by") |
| | fprintf (outfile, "\n") |
| | fclose (outfile) |
| void | writenodes (struct mesh *m, struct behavior *b, REAL **pointlist, REAL **pointattriblist, int **pointmarkerlist) void writenodes(m |
| void | writenodes (struct mesh *m, struct behavior *b, char *nodefilename, int argc, char **argv) void writenodes(m |
| if * | pointlist (REAL *) NULL |
| | if ((m->nextras > 0) &&(*pointattriblist==(REAL *) NULL)) |
| | if (!b->nobound &&(*pointmarkerlist==(int *) NULL)) |
| | if (outfile==(FILE *) NULL) |
| | fprintf (outfile, "%ld %d %d %d\n", outvertices, m->mesh_dim, m->nextras, 1 - b->nobound) |
| | finishfile (outfile, argc, argv) |
| void | numbernodes (struct mesh *m, struct behavior *b) void numbernodes(m |
| void | writeelements (struct mesh *m, struct behavior *b, int **trianglelist, REAL **triangleattriblist) void writeelements(m |
| void | writeelements (struct mesh *m, struct behavior *b, char *elefilename, int argc, char **argv) void writeelements(m |
| if * | trianglelist (int *) NULL |
| | if ((m->eextras > 0) &&(*triangleattriblist==(REAL *) NULL)) |
| | fprintf (outfile, "%ld %d %d\n", m->triangles.items,(b->order+1) *(b->order+2)/2, m->eextras) |
| void | writepoly (struct mesh *m, struct behavior *b, int **segmentlist, int **segmentmarkerlist) void writepoly(m |
| void | writepoly (struct mesh *m, struct behavior *b, char *polyfilename, REAL *holelist, int holes, REAL *regionlist, int regions, int argc, char **argv) void writepoly(m |
| if * | segmentlist (int *) NULL |
| | fprintf (outfile, "%d %d %d %d\n", 0, m->mesh_dim, m->nextras, 1 - b->nobound) |
| | fprintf (outfile, "%ld %d\n", m->subsegs.items, 1 - b->nobound) |
| | fprintf (outfile, "%d\n", holes) |
| | if (holes > 0) |
| void | writeedges (struct mesh *m, struct behavior *b, int **edgelist, int **edgemarkerlist) void writeedges(m |
| void | writeedges (struct mesh *m, struct behavior *b, char *edgefilename, int argc, char **argv) void writeedges(m |
| if * | edgelist (int *) NULL |
| | fprintf (outfile, "%ld %d\n", m->edges, 1 - b->nobound) |
| void | writevoronoi (struct mesh *m, struct behavior *b, REAL **vpointlist, REAL **vpointattriblist, int **vpointmarkerlist, int **vedgelist, int **vedgemarkerlist, REAL **vnormlist) void writevoronoi(m |
| void | writevoronoi (struct mesh *m, struct behavior *b, char *vnodefilename, char *vedgefilename, int argc, char **argv) void writevoronoi(m |
| if * | vpointlist (REAL *) NULL |
| if * | vpointattriblist (REAL *) NULL |
| | fprintf (outfile, "%ld %d %d %d\n", m->triangles.items, 2, m->nextras, 0) |
| if * | vedgelist (int *) NULL |
| if * | vnormlist (REAL *) NULL |
| | fprintf (outfile, "%ld %d\n", m->edges, 0) |
| void | writeneighbors (struct mesh *m, struct behavior *b, int **neighborlist) void writeneighbors(m |
| void | writeneighbors (struct mesh *m, struct behavior *b, char *neighborfilename, int argc, char **argv) void writeneighbors(m |
| if * | neighborlist (int *) NULL |
| | fprintf (outfile, "%ld %d\n", m->triangles.items, 3) |
| void | writeoff (struct mesh *m, struct behavior *b, char *offfilename, int argc, char **argv) void writeoff(m |
| | fprintf (outfile, "OFF\n%ld %ld %ld\n", outvertices, m->triangles.items, m->edges) |
| void | quality_statistics (struct mesh *m, struct behavior *b) void quality_statistics(m |
| | printf ("Mesh quality statistics:\n\n") |
| smallestarea *biggestarea * | if (smallestangle >=1.0) |
| | if (biggestangle >=1.0) |
| | printf (" Shortest edge: %16.5g | Longest edge: %16.5g\n", shortest, longest) |
| | printf (" Shortest altitude: %12.5g | Largest aspect ratio: %8.5g\n\n", minaltitude, worstaspect) |
| | printf (" Triangle aspect ratio histogram:\n") |
| | printf (" 1.1547 - %-6.6g : %8d | %6.6g - %-6.6g : %8d\n", ratiotable[0], aspecttable[0], ratiotable[7], ratiotable[8], aspecttable[8]) |
| | printf (" %6.6g - %-6.6g : %8d | %6.6g - : %8d\n", ratiotable[6], ratiotable[7], aspecttable[7], ratiotable[14], aspecttable[15]) |
| | printf (" (Aspect ratio is longest edge divided by shortest altitude)\n\n") |
| | printf (" Smallest angle: %15.5g | Largest angle: %15.5g\n\n", smallestangle, biggestangle) |
| | printf (" Angle histogram:\n") |
| | printf ("\n") |
| void | statistics (struct mesh *m, struct behavior *b) void statistics(m |
| | printf (" Input vertices: %d\n", m->invertices) |
| | printf ("\n Mesh vertices: %ld\n", m->vertices.items - m->undeads) |
| | printf (" Mesh triangles: %ld\n", m->triangles.items) |
| | printf (" Mesh edges: %ld\n", m->edges) |
| | printf (" Mesh exterior boundary edges: %ld\n", m->hullsize) |
| | if (b->poly||b->refine) |
| void | triangulate (const char *triswitches, struct triangulateio *in, struct triangulateio *out, struct triangulateio *vorout) void triangulate(triswitches |
| int | main (int argc, char **argv) int main(argc |
| | parsecommandline (1, &triswitches, &b) |
| | parsecommandline (argc, argv, &b) |
| | if (!b.quiet) |
| | if (b.refine) |
| | if (b.poly &&(m.triangles.items > 0)) |
| | if (b.quality &&(m.triangles.items > 0)) |
| | if (b.order > 1) |
| | if (vorout !=(struct triangulateio *) NULL) |
| | if (b.nonodewritten||(b.noiterationnum &&m.readnodefile)) |
| | if (b.poly||b.convex) |
| | if (m.regions > 0) |
|
| REAL | splitter |
| REAL | epsilon |
| REAL | resulterrbound |
| REAL | ccwerrboundA |
| REAL | ccwerrboundB |
| REAL | ccwerrboundC |
| REAL | iccerrboundA |
| REAL | iccerrboundB |
| REAL | iccerrboundC |
| REAL | o3derrboundA |
| REAL | o3derrboundB |
| REAL | o3derrboundC |
| unsigned long | randomseed = 1 |
| int | plus1mod3 [3] = {1, 2, 0} |
| int | minus1mod3 [3] = {2, 0, 1} |
| int | tridest |
| int | triapex |
| int area vertex | triorg |
| REAL | area |
| REAL | dyoa |
| REAL | dyda = tridest[1] - triapex[1] |
| REAL | dyod = triorg[1] - tridest[1] |
| REAL | oalen = dxoa * dxoa + dyoa * dyoa |
| REAL | dalen = dxda * dxda + dyda * dyda |
| REAL | odlen = dxod * dxod + dyod * dyod |
| REAL | maxlen = (dalen > oalen) ? dalen : oalen |
| | dxoa = triorg[0] - triapex[0] |
| | dxda = tridest[0] - triapex[0] |
| | dxod = triorg[0] - tridest[0] |
| | else |
| | memptr = (VOID *) malloc((unsigned int) size) |
| void | argv |
| void b int | argc |
| struct behavior * | b |
| int | meshnumber |
| int | i = 0 |
| int | j = 1 |
| int | k |
| char | workstring [FILENAMESIZE] = 'd' |
| b | poly = b->refine = b->quality = 0 |
| b | vararea = b->fixedarea = b->usertest = 0 |
| b | regionattrib = b->convex = b->weighted = b->jettison = 0 |
| b | firstnumber = 1 |
| b | edgesout = b->voronoi = b->neighbors = b->geomview = 0 |
| b | nobound = b->nopolywritten = b->nonodewritten = b->noelewritten = 0 |
| b | noiterationnum = 0 |
| b | noholes = b->noexact = 0 |
| b | incremental = b->sweepline = 0 |
| b | dwyer = 1 |
| b | splitseg = 0 |
| b | docheck = 0 |
| b | nobisect = 0 |
| b | conformdel = 0 |
| b | steiner = -1 |
| b | order = 1 |
| b | minangle = 0.0 |
| b | maxarea = -1.0 |
| b | quiet = b->verbose = 0 |
| b | innodefilename [0] = '\0' |
| b | usesegments = b->poly || b->refine || b->quality || b->convex |
| b | goodangle = cos(b->minangle * PI / 180.0) |
| | increment = 0 |
| void t struct mesh * | m |
| struct otri * | t |
| struct osub | printsh |
| vertex | printvertex |
| called | dummytri |
| called is pointed to *void | trianglebytes |
| int | subsegbytes |
| m | dummytribase |
| | alignptr = (unsigned long) m->dummytribase |
| m | vertexmarkindex |
| | vertexsize = (m->vertexmarkindex + 2) * sizeof(int) |
| m | highorderindex = 6 + (b->usesegments * 3) |
| | trisize |
| m | elemattribindex = (trisize + sizeof(REAL) - 1) / sizeof(REAL) |
| m | areaboundindex = m->elemattribindex + m->eextras + b->regionattrib |
| triangle * | dyingtriangle |
| | do |
| return | newtriangle |
| subseg * | dyingsubseg |
| return | newsubseg |
| vertex | dyingvertex |
| return | newvertex = (vertex) poolalloc(&m->vertices) |
| struct badsubseg * | dyingseg |
| return | newseg |
| int | number |
| char * | foundvertex |
| int | current = b->firstnumber |
| | getblock = m->vertices.firstblock |
| struct otri * | newotri |
| newotri | tri = (triangle *) poolalloc(&m->triangles) |
| newotri | orient = 0 |
| newsubseg | ss [0] = (subseg) m->dummysub |
| newsubseg | ssorient = 0 |
| int | e |
| int | flen |
| int | f |
| int h int | elen |
| REAL * | h |
| INEXACT REAL | Qnew |
| INEXACT REAL | hh |
| INEXACT REAL | bvirt |
| REAL | avirt |
| REAL | bround |
| REAL | around |
| int | eindex = findex = 0 |
| int | findex |
| int | hindex = 0 |
| REAL | enow = e[0] |
| REAL | fnow = f[0] |
| INEXACT REAL | product1 |
| REAL | product0 |
| INEXACT REAL | c |
| INEXACT REAL | abig |
| REAL | ahi |
| REAL | alo |
| REAL | bhi |
| REAL | blo |
| REAL | err1 |
| REAL | err2 |
| REAL | err3 |
| | Q = e[0] |
| REAL | pb |
| REAL | pc |
| REAL detsum vertex | pa |
| REAL | detsum |
| REAL | acxtail |
| REAL | acytail |
| REAL | bcxtail |
| REAL | bcytail |
| INEXACT REAL | detleft = (pa[0] - pc[0]) * (pb[1] - pc[1]) |
| INEXACT REAL | detright = (pa[1] - pc[1]) * (pb[0] - pc[0]) |
| REAL | detlefttail |
| REAL | detrighttail |
| REAL | det = estimate(4, B) |
| REAL | errbound = ccwerrboundB * detsum |
| REAL | B [4] = B3 |
| REAL | C1 [8] |
| REAL | C2 [12] |
| REAL | D [16] |
| INEXACT REAL | B3 |
| int | C1length = fast_expansion_sum_zeroelim(4, B, 4, u, C1) |
| int | C2length = fast_expansion_sum_zeroelim(C1length, C1, 4, u, C2) |
| int | Dlength = fast_expansion_sum_zeroelim(C2length, C2, 4, u, D) |
| REAL | u [4] = u3 |
| INEXACT REAL | u3 |
| INEXACT REAL | s1 |
| INEXACT REAL | t1 |
| REAL | s0 |
| REAL | t0 |
| INEXACT REAL | _i |
| INEXACT REAL | _j |
| REAL | _0 |
| | acx = (REAL) (pa[0] - pc[0]) |
| | bcx = (REAL) (pb[0] - pc[0]) |
| | acy = (REAL) (pa[1] - pc[1]) |
| | bcy = (REAL) (pb[1] - pc[1]) |
| m | counterclockcount |
| REAL | pd |
| REAL | permanent |
| INEXACT REAL | bdxcdy1 |
| INEXACT REAL | cdxbdy1 |
| INEXACT REAL | cdxady1 |
| INEXACT REAL | adxcdy1 |
| INEXACT REAL | adxbdy1 |
| INEXACT REAL | bdxady1 |
| REAL | bdxcdy0 |
| REAL | cdxbdy0 |
| REAL | cdxady0 |
| REAL | adxcdy0 |
| REAL | adxbdy0 |
| REAL | bdxady0 |
| REAL | bc [4] = bc3 |
| REAL | ca [4] = ca3 |
| REAL | ab [4] = ab3 |
| INEXACT REAL | bc3 |
| INEXACT REAL | ca3 |
| INEXACT REAL | ab3 |
| REAL | axbc [8] |
| REAL | axxbc [16] |
| REAL | aybc [8] |
| REAL | ayybc [16] |
| REAL | adet [32] |
| int | axbclen = scale_expansion_zeroelim(4, bc, adx, axbc) |
| int | axxbclen = scale_expansion_zeroelim(axbclen, axbc, adx, axxbc) |
| int | aybclen = scale_expansion_zeroelim(4, bc, ady, aybc) |
| int | ayybclen = scale_expansion_zeroelim(aybclen, aybc, ady, ayybc) |
| int | alen = fast_expansion_sum_zeroelim(axxbclen, axxbc, ayybclen, ayybc, adet) |
| REAL | bxca [8] |
| REAL | bxxca [16] |
| REAL | byca [8] |
| REAL | byyca [16] |
| REAL | bdet [32] |
| int | bxcalen = scale_expansion_zeroelim(4, ca, bdx, bxca) |
| int | bxxcalen = scale_expansion_zeroelim(bxcalen, bxca, bdx, bxxca) |
| int | bycalen = scale_expansion_zeroelim(4, ca, bdy, byca) |
| int | byycalen = scale_expansion_zeroelim(bycalen, byca, bdy, byyca) |
| int | blen = fast_expansion_sum_zeroelim(bxxcalen, bxxca, byycalen, byyca, bdet) |
| REAL | cxab [8] |
| REAL | cxxab [16] |
| REAL | cyab [8] |
| REAL | cyyab [16] |
| REAL | cdet [32] |
| int | cxablen = scale_expansion_zeroelim(4, ab, cdx, cxab) |
| int | cxxablen = scale_expansion_zeroelim(cxablen, cxab, cdx, cxxab) |
| int | cyablen = scale_expansion_zeroelim(4, ab, cdy, cyab) |
| int | cyyablen = scale_expansion_zeroelim(cyablen, cyab, cdy, cyyab) |
| int | clen = fast_expansion_sum_zeroelim(cxxablen, cxxab, cyyablen, cyyab, cdet) |
| REAL | abdet [64] |
| int | ablen = fast_expansion_sum_zeroelim(alen, adet, blen, bdet, abdet) |
| REAL | fin1 [1152] |
| REAL | fin2 [1152] |
| REAL * | finnow = fin1 |
| REAL * | finother = fin2 |
| REAL * | finswap = finnow |
| int | finlength = fast_expansion_sum_zeroelim(ablen, abdet, clen, cdet, fin1) |
| REAL | adxtail |
| REAL | bdxtail |
| REAL | cdxtail |
| REAL | adytail |
| REAL | bdytail |
| REAL | cdytail |
| INEXACT REAL | adxadx1 |
| INEXACT REAL | adyady1 |
| INEXACT REAL | bdxbdx1 |
| INEXACT REAL | bdybdy1 |
| INEXACT REAL | cdxcdx1 |
| INEXACT REAL | cdycdy1 |
| REAL | adxadx0 |
| REAL | adyady0 |
| REAL | bdxbdx0 |
| REAL | bdybdy0 |
| REAL | cdxcdx0 |
| REAL | cdycdy0 |
| REAL | aa [4] |
| REAL | bb [4] |
| REAL | cc [4] |
| INEXACT REAL | aa3 |
| INEXACT REAL | bb3 |
| INEXACT REAL | cc3 |
| INEXACT REAL | ti1 |
| INEXACT REAL | tj1 |
| REAL | ti0 |
| REAL | tj0 |
| REAL | v [4] |
| INEXACT REAL | v3 |
| REAL | temp8 [8] |
| REAL | temp16a [16] |
| REAL | temp16b [16] |
| REAL | temp16c [16] |
| REAL | temp32a [32] |
| REAL | temp32b [32] |
| REAL | temp48 [48] |
| REAL | temp64 [64] |
| int | temp8len |
| int | temp16alen |
| int | temp16blen |
| int | temp16clen |
| int | temp32alen |
| int | temp32blen |
| int | temp48len |
| int | temp64len |
| REAL | axtbb [8] |
| REAL | axtcc [8] |
| REAL | aytbb [8] |
| REAL | aytcc [8] |
| int | axtbblen |
| int | axtcclen |
| int | aytbblen |
| int | aytcclen |
| REAL | bxtaa [8] |
| REAL | bxtcc [8] |
| REAL | bytaa [8] |
| REAL | bytcc [8] |
| int | bxtaalen |
| int | bxtcclen |
| int | bytaalen |
| int | bytcclen |
| REAL | cxtaa [8] |
| REAL | cxtbb [8] |
| REAL | cytaa [8] |
| REAL | cytbb [8] |
| int | cxtaalen |
| int | cxtbblen |
| int | cytaalen |
| int | cytbblen |
| REAL | axtbc [8] |
| REAL | aytbc [8] |
| REAL | bxtca [8] |
| REAL | bytca [8] |
| REAL | cxtab [8] |
| REAL | cytab [8] |
| int | axtbclen |
| int | aytbclen |
| int | bxtcalen |
| int | bytcalen |
| int | cxtablen |
| int | cytablen |
| REAL | axtbct [16] |
| REAL | aytbct [16] |
| REAL | bxtcat [16] |
| REAL | bytcat [16] |
| REAL | cxtabt [16] |
| REAL | cytabt [16] |
| int | axtbctlen |
| int | aytbctlen |
| int | bxtcatlen |
| int | bytcatlen |
| int | cxtabtlen |
| int | cytabtlen |
| REAL | axtbctt [8] |
| REAL | aytbctt [8] |
| REAL | bxtcatt [8] |
| REAL | bytcatt [8] |
| REAL | cxtabtt [8] |
| REAL | cytabtt [8] |
| int | axtbcttlen |
| int | aytbcttlen |
| int | bxtcattlen |
| int | bytcattlen |
| int | cxtabttlen |
| int | cytabttlen |
| REAL | abt [8] |
| REAL | bct [8] |
| REAL | cat [8] |
| int | abtlen = fast_expansion_sum_zeroelim(at_blen, at_b, bt_alen, bt_a, abt) |
| int | bctlen |
| int | catlen = fast_expansion_sum_zeroelim(ct_alen, ct_a, at_clen, at_c, cat) |
| REAL | abtt [4] |
| REAL | bctt [4] |
| REAL | catt [4] |
| int | abttlen |
| int | bcttlen |
| int | cattlen |
| INEXACT REAL | abtt3 |
| INEXACT REAL | bctt3 |
| INEXACT REAL | catt3 |
| REAL | negate |
| | adx = (REAL) (pa[0] - pd[0]) |
| | bdx = (REAL) (pb[0] - pd[0]) |
| | cdx = (REAL) (pc[0] - pd[0]) |
| | ady = (REAL) (pa[1] - pd[1]) |
| | bdy = (REAL) (pb[1] - pd[1]) |
| | cdy = (REAL) (pc[1] - pd[1]) |
| REAL | bdxcdy |
| REAL | cdxbdy = cdx * bdy |
| REAL | cdxady = cdx * ady |
| REAL | adxcdy = adx * cdy |
| REAL | adxbdy = adx * bdy |
| REAL | bdxady = bdx * ady |
| REAL | alift = adx * adx + ady * ady |
| REAL | blift = bdx * bdx + bdy * bdy |
| REAL | clift = cdx * cdx + cdy * cdy |
| m | incirclecount = m->counterclockcount = m->orient3dcount = 0 |
| REAL | aheight |
| REAL | bheight |
| REAL | cheight |
| REAL | dheight |
| REAL | adheighttail |
| REAL | bdheighttail |
| REAL | cdheighttail |
| INEXACT REAL | at_blarge |
| INEXACT REAL | at_clarge |
| INEXACT REAL | bt_clarge |
| INEXACT REAL | bt_alarge |
| INEXACT REAL | ct_alarge |
| INEXACT REAL | ct_blarge |
| REAL | at_b [4] |
| REAL | at_c [4] |
| REAL | bt_c [4] |
| REAL | bt_a [4] |
| REAL | ct_a [4] |
| REAL | ct_b [4] |
| int | at_blen |
| int | at_clen |
| int | bt_clen |
| int | bt_alen |
| int | ct_alen |
| int | ct_blen |
| INEXACT REAL | bdxt_cdy1 |
| INEXACT REAL | cdxt_bdy1 |
| INEXACT REAL | cdxt_ady1 |
| INEXACT REAL | adxt_cdy1 |
| INEXACT REAL | adxt_bdy1 |
| INEXACT REAL | bdxt_ady1 |
| REAL | bdxt_cdy0 |
| REAL | cdxt_bdy0 |
| REAL | cdxt_ady0 |
| REAL | adxt_cdy0 |
| REAL | adxt_bdy0 |
| REAL | bdxt_ady0 |
| INEXACT REAL | bdyt_cdx1 |
| INEXACT REAL | cdyt_bdx1 |
| INEXACT REAL | cdyt_adx1 |
| INEXACT REAL | adyt_cdx1 |
| INEXACT REAL | adyt_bdx1 |
| INEXACT REAL | bdyt_adx1 |
| REAL | bdyt_cdx0 |
| REAL | cdyt_bdx0 |
| REAL | cdyt_adx0 |
| REAL | adyt_cdx0 |
| REAL | adyt_bdx0 |
| REAL | bdyt_adx0 |
| INEXACT REAL | bdxt_cdyt1 |
| INEXACT REAL | cdxt_bdyt1 |
| INEXACT REAL | cdxt_adyt1 |
| INEXACT REAL | adxt_cdyt1 |
| INEXACT REAL | adxt_bdyt1 |
| INEXACT REAL | bdxt_adyt1 |
| REAL | bdxt_cdyt0 |
| REAL | cdxt_bdyt0 |
| REAL | cdxt_adyt0 |
| REAL | adxt_cdyt0 |
| REAL | adxt_bdyt0 |
| REAL | bdxt_adyt0 |
| REAL | w [16] |
| int | vlength |
| int | wlength = scale_expansion_zeroelim(bctlen, bct, adheight, w) |
| INEXACT REAL | _k |
| | adheight = (REAL) (aheight - dheight) |
| | bdheight = (REAL) (bheight - dheight) |
| | cdheight = (REAL) (cheight - dheight) |
| m | orient3dcount |
| vertex | torg |
| vertex | tdest |
| vertex | tapex |
| vertex | circumcenter = torg[1] + dy |
| REAL * | xi = (yao * dx - xao * dy) * (2.0 * denominator) |
| REAL * | eta = (xdo * dy - ydo * dx) * (2.0 * denominator) |
| int | offcenter |
| REAL | dodist |
| REAL | aodist = xao * xao + yao * yao |
| REAL | dadist |
| REAL | denominator |
| REAL | dx = (yao * dodist - ydo * aodist) * denominator |
| REAL | dy = (xdo * aodist - xao * dodist) * denominator |
| REAL | dxoff |
| REAL | dyoff |
| m | circumcentercount |
| | xdo = tdest[0] - torg[0] |
| | ydo = tdest[1] - torg[1] |
| | xao = tapex[0] - torg[0] |
| | yao = tapex[1] - torg[1] |
| m | undeads = 0 |
| m | samples = 1 |
| m | checksegments = 0 |
| m | checkquality = 0 |
| m | hyperbolacount = m->circletopcount = m->circumcentercount = 0 |
| struct otri oppotri | oppooppotri |
| vertex | oppoorg |
| vertex | oppodest |
| int | horrors = 0 |
| int | saveexact = b->noexact |
| triangle | ptr |
| b | noexact = 0 |
| struct otri | oppotri |
| struct osub | opposubseg |
| vertex | oppoapex |
| int | shouldbedelaunay |
| subseg | sptr |
| struct badtriang * | badtri |
| int | exponent |
| int | expincrement |
| int | queuenumber |
| int | posexponent = 0 |
| m | queuetail [queuenumber] = badtri |
| badtri | nexttriang = (struct badtriang *) NULL |
| void | enqtri |
| void | minedge |
| void | enqapex |
| void | enqorg |
| vertex | enqdest |
| | newbad = (struct badtriang *) poolalloc(&m->badtriangles) |
| newbad | poortri = encode(*enqtri) |
| newbad | key = minedge |
| newbad | triangapex = enqapex |
| newbad | triangorg = enqorg |
| newbad | triangdest = enqdest |
| | result = m->queuefront[m->firstnonemptyq] |
| m | queuefront [m->firstnonemptyq] = result->nexttriang |
| struct osub * | testsubseg |
| struct osub | testsym |
| struct badsubseg * | encroachedseg |
| REAL | dotproduct |
| int | encroached = 0 |
| int | sides = 0 |
| vertex | eorg |
| vertex | edest |
| vertex | eapex |
| struct otri * | testtri |
| struct osub | testsub |
| vertex | base1 = tapex |
| vertex | base2 = torg |
| vertex | org1 |
| vertex | dest1 |
| vertex | org2 |
| vertex | dest2 |
| vertex | joinvertex |
| REAL | dxao = tapex[0] - torg[0] |
| REAL | dyao = tapex[1] - torg[1] |
| REAL | dxod2 = dxod * dxod |
| REAL | dyod2 = dyod * dyod |
| REAL | dxda2 = dxda * dxda |
| REAL | dyda2 = dyda * dyda |
| REAL | dxao2 = dxao * dxao |
| REAL | dyao2 = dyao * dyao |
| REAL | apexlen = dxod2 + dyod2 |
| REAL | orglen = dxda2 + dyda2 |
| REAL | destlen = dxao2 + dyao2 |
| REAL | angle = dxod * dxda + dyod * dyda |
| REAL | dist1 |
| REAL | dist2 |
| enum locateresult | searchpoint = pc[0] - (yac * bclen2 - ybc * aclen2) / (2.0 * ccwabc) |
| enum locateresult | searchtri |
| int | stopatsubsegment |
| struct osub | checkedge |
| vertex | forg |
| vertex | fdest |
| vertex | fapex |
| REAL | orgorient |
| REAL | destorient |
| int | moveleft |
| char * | firsttri |
| struct otri | sampletri |
| REAL | searchdist |
| REAL | dist |
| REAL | ahead = counterclockwise(m, b, torg, tdest, searchpoint) |
| long | samplesperblock = (m->samples * TRIPERBLOCK - 1) / m->triangles.maxitems + 1 |
| long | totalsamplesleft = m->samples |
| long | samplesleft |
| long | population = m->triangles.itemsfirstblock |
| long | totalpopulation = m->triangles.maxitems |
| | sampleblock = m->triangles.firstblock |
| int | subsegmark |
| struct otri * | flipedge |
| struct otri topleft | topright |
| struct otri | top |
| struct otri botlcasing | botrcasing |
| struct otri toplcasing | toprcasing |
| struct osub botlsubseg | botrsubseg |
| struct osub toplsubseg | toprsubseg |
| vertex | leftvertex |
| vertex | rightvertex = first |
| vertex | botvertex |
| vertex | farvertex |
| enum insertvertexresult | segmentflaws |
| int | triflaws |
| struct otri botleft | botright |
| struct otri newbotleft | newbotright |
| struct otri | newtopright |
| struct osub | brokensubseg |
| struct osub | checksubseg |
| struct osub | rightsubseg |
| struct flipstacker * | newflip |
| vertex | first |
| vertex | topvertex |
| vertex | segmentorg |
| vertex | segmentdest |
| REAL | attrib |
| enum insertvertexresult | success = SUCCESSFULVERTEX |
| enum locateresult | intersect = ONEDGE |
| int | doflip |
| int | mirrorflag |
| int | enq |
| void | firstedge |
| void | lastedge |
| void | edgecount = 1 |
| struct otri | besttri |
| struct otri | tempedge |
| vertex | leftbasevertex |
| vertex | rightbasevertex |
| vertex | testvertex |
| vertex | bestvertex |
| int | bestnumber = 1 |
| struct otri * | deltri |
| struct otri | deltriright |
| struct otri lefttri | righttri |
| struct otri leftcasing | rightcasing |
| vertex | delvertex |
| vertex | neworg |
| struct otri | gluetri |
| void arraysize vertex * | sortarray = (vertex *) trimalloc(m->invertices * (int) sizeof(vertex)) |
| int | arraysize |
| int | pivot |
| REAL | pivotx = sortarray[pivot][0] |
| REAL | pivoty = sortarray[pivot][1] |
| vertex | temp |
| | left = -1 |
| | right = arraysize |
| void | median |
| int | axis |
| REAL | pivot1 = sortarray[pivot][axis] |
| REAL | pivot2 = sortarray[pivot][1 - axis] |
| | divider = arraysize >> 1 |
| void | farleft |
| void | innerleft |
| void | innerright |
| void | farright = farrightflag |
| struct otri | baseedge |
| struct otri | nextedge |
| struct otri sidecasing topcasing | outercasing |
| vertex | innerleftdest |
| vertex | innerrightorg |
| vertex | innerleftapex |
| vertex | innerrightapex |
| vertex | farleftpt |
| vertex | farrightpt |
| vertex | farleftapex |
| vertex | farrightapex |
| vertex | lowerleft = innerleftdest |
| vertex | lowerright = innerrightorg |
| vertex | upperleft |
| vertex | upperright |
| vertex | nextapex |
| vertex | checkvertex = (vertex) NULL |
| int | changemade |
| int | badedge |
| int | leftfinished |
| int | rightfinished |
| void | vertices |
| struct otri * | startghost |
| struct otri | dissolveedge |
| struct otri | deadtriangle |
| vertex | markorg |
| long | hullsize = 0 |
| struct otri hullleft | hullright |
| REAL | width |
| m | infvertex1 = (vertex) trimalloc(m->vertices.itembytes) |
| m | infvertex2 = (vertex) trimalloc(m->vertices.itembytes) |
| m | infvertex3 = (vertex) trimalloc(m->vertices.itembytes) |
| struct otri | searchedge |
| vertex | vertexloop |
| void | heapsize = m->invertices |
| void newevent struct event ** | heap = newevent |
| struct event * | newevent |
| int | eventnum |
| int | parent |
| int | notdone = eventnum > 0 |
| | eventx = newevent->xkey |
| | eventy = newevent->ykey |
| newevent | heapposition = eventnum |
| int | leftchild = 2 * eventnum + 1 |
| int | rightchild |
| int | smallest |
| | thisevent = heap[eventnum] |
| | moveevent = heap[heapsize - 1] |
| void | eventheap |
| void | events = (struct event *) trimalloc(maxevents * (int) sizeof(struct event)) |
| struct event ** | freeevents = (struct event *) NULL |
| int | maxevents |
| int | fronttri |
| vertex | newsite |
| REAL | dxa |
| REAL | dya = leftvertex[1] - newsite[1] |
| REAL | dxb = rightvertex[0] - newsite[0] |
| REAL | dyb = rightvertex[1] - newsite[1] |
| REAL | ccwabc = counterclockwise(m, b, pa, pb, pc) |
| REAL | aclen2 |
| REAL | bclen2 = xbc * xbc + ybc * ybc |
| REAL | ablen2 = xab * xab + yab * yab |
| m | circletopcount |
| | xac = pa[0] - pc[0] |
| | yac = pa[1] - pc[1] |
| | xbc = pb[0] - pc[0] |
| | ybc = pb[1] - pc[1] |
| | xab = pa[0] - pb[0] |
| | yab = pa[1] - pb[1] |
| void heapsize struct otri * | checktri |
| vertex | eventvertex |
| struct splaynode | splaytree |
| struct splaynode * | lefttree |
| struct splaynode * | righttree = splay(m, splaytree->rchild, searchpoint, searchtri) |
| struct splaynode * | leftright |
| int | rightofroot |
| int | rightofchild |
| leftright | rchild = righttree |
| struct splaynode | splayroot = splay(m, splayroot, searchvertex, searchtri) |
| struct splaynode | newkey |
| | newsplaynode = (struct splaynode *) poolalloc(&m->splaynodes) |
| splayroot | lchild = (struct splaynode *) NULL |
| REAL | topy |
| struct splaynode | bottommost |
| struct splaynode | searchvertex |
| | farrightflag = 0 |
| struct event * | nextevent |
| struct otri | fliptri |
| struct otri lefttri righttri farlefttri | farrighttri |
| struct otri | inserttri |
| vertex | firstvertex = (vertex) eventheap[0]->eventptr |
| vertex | secondvertex |
| vertex | nextvertex |
| vertex | lastvertex = secondvertex |
| vertex | connectvertex |
| vertex | midvertex |
| REAL | lefttest |
| REAL | righttest |
| int | check4events |
| eventheap[0] | eventptr = (VOID *) freeevents |
| m | eextras = 0 |
| | hulledges = divconqdelaunay(m, b) |
| int | trianglelist |
| int | triangleattriblist |
| int | trianglearealist |
| int | elements |
| int | corners |
| int | attribs |
| int | segmentlist |
| int | segmentmarkerlist |
| int | numberofsegments |
| long | elefilename |
| long | areafilename |
| long | polyfilename |
| FILE * | polyfile = (FILE *) NULL |
| int | attribindex |
| FILE * | elefile = fopen(elefilename, "r") |
| FILE * | areafile |
| char | inputline [INPUTLINESIZE] |
| char * | stringptr = readline(inputline, elefile, elefilename) |
| int | areaelements |
| struct otri | triangleloop |
| struct otri | triangleleft |
| struct otri | checkleft |
| struct otri | checkneighbor |
| struct osub | subsegloop |
| triangle * | vertexarray |
| triangle * | prevlink |
| triangle | nexttri |
| vertex | checkdest |
| vertex | checkapex |
| vertex | shorg |
| vertex | killvertex |
| int | corner [3] |
| int | end [2] |
| int | killvertexindex |
| int | incorners = corners |
| int | segmentmarkers = 0 |
| int | boundmarker |
| int | aroundvertex |
| int | notfound |
| long | elementnumber = b->firstnumber |
| long | segmentnumber |
| m | inelements = elements |
| | vertexindex = 0 |
| vertex | startvertex |
| REAL | leftccw = counterclockwise(m, b, searchpoint, startvertex, leftvertex) |
| REAL | rightccw = counterclockwise(m, b, startvertex, searchpoint, rightvertex) |
| int | leftflag = leftccw > 0.0 |
| int | rightflag = rightccw > 0.0 |
| void | splittri |
| void | splitsubseg |
| vertex | endpoint2 |
| vertex | endpoint1 |
| enum finddirectionresult | collinear = finddirection(m, b, splittri, endpoint1) |
| REAL | ex = endpoint2[0] - endpoint1[0] |
| REAL | ey = endpoint2[1] - endpoint1[1] |
| REAL | tx = tdest[0] - torg[0] |
| REAL | ty = tdest[1] - torg[1] |
| REAL | etx = torg[0] - endpoint2[0] |
| REAL | ety = torg[1] - endpoint2[1] |
| REAL | split = (ey * etx - ex * ety) / denom |
| REAL | denom = ty * ex - tx * ey |
| int | newmark |
| struct osub | crosssubseg |
| vertex | midvertex1 |
| vertex | midvertex2 |
| void | fixuptri |
| int | leftside |
| struct otri | fartri |
| struct osub | faredge |
| vertex | nearvertex |
| void | starttri |
| int | collision = 0 |
| int | done = 0 |
| triangle | encodedtri |
| int | index |
| int | end1 |
| int | end2 |
| struct osub | hullsubseg |
| vertex | horg |
| vertex | hdest |
| struct otri | neighbor |
| triangle ** | virusloop = (triangle **) traverse(&m->viri) |
| struct osub | neighborsubseg |
| vertex | norg |
| vertex | ndest |
| vertex | deadorg |
| vertex | deaddest |
| vertex | deadapex |
| int | killorg |
| void | attribute |
| triangle ** | regiontri |
| vertex | regionorg |
| vertex | regiondest |
| vertex | regionapex |
| void | holelist |
| void | holes = (int) strtol(stringptr, &stringptr, 0) |
| void | regionlist |
| int | regions = 0 |
| struct otri * | regiontris |
| triangle ** | holetri |
| vertex | searchorg |
| vertex | searchdest |
| int | dummy |
| struct osub | testsh |
| struct osub | currentenc |
| struct badsubseg * | encloop |
| REAL | segmentlength |
| REAL | nearestpoweroftwo |
| REAL | multiplier |
| REAL | divisor |
| int | acuteorg |
| int | acuteorg2 |
| int | acutedest |
| int | acutedest2 |
| vertex | borg |
| vertex | bdest |
| vertex | bapex |
| int | errorflag |
| struct osub | checkmark |
| m vertices | deaditemstack = (VOID *) NULL |
| char | infile |
| char infilename char * | string |
| char * | infilename = nodefilename |
| void | nodefilename |
| REAL | x |
| REAL | y |
| int | firstnode |
| int | nodemarkers |
| int | currentmarker |
| m | xminextreme = 10 * m->xmin - 9 * m->xmax |
| void | pointlist |
| void | pointattriblist |
| void | pointmarkerlist |
| void | numberofpoints |
| int | numberofpointattribs |
| int | coordindex = 0 |
| m | invertices = numberofpoints |
| m | mesh_dim = 2 |
| m | nextras = numberofpointattribs |
| m | readnodefile = 0 |
| void | hlist = holelist |
| void | rlist = (REAL *) NULL |
| void argv FILE * | outfile = fopen(nodefilename, "w") |
| REAL * | palist |
| int * | pmlist = *pointmarkerlist |
| long | outvertices |
| int | vertexnumber = b->firstnumber |
| | plist = *pointlist |
| REAL * | talist |
| vertex | p1 |
| vertex | p2 |
| vertex | p3 |
| vertex | mid1 |
| vertex | mid2 |
| vertex | mid3 |
| | tlist = *trianglelist |
| int * | smlist |
| long | holenumber |
| long | regionnumber |
| long | subsegnumber = b->firstnumber |
| | slist = *segmentlist |
| void | edgelist |
| int ** | edgemarkerlist |
| void | edgefilename |
| int * | emlist |
| struct otri triangleloop | trisym |
| long | edgenumber = b->firstnumber |
| | elist = *edgelist |
| void | vpointlist |
| void | vpointattriblist |
| void | vpointmarkerlist = (int *) NULL |
| void | vedgelist |
| void | vedgemarkerlist = (int *) NULL |
| REAL ** | vnormlist |
| void | vnodefilename |
| void | vedgefilename |
| REAL * | normlist = *vnormlist |
| long | vnodenumber = b->firstnumber |
| long | vedgenumber = b->firstnumber |
| int ** | neighborlist |
| void | neighborfilename |
| int | neighbor1 |
| int | neighbor2 |
| int | neighbor3 |
| | nlist = *neighborlist |
| void | offfilename |
| vertex | p [3] |
| REAL | cossquaretable [8] |
| REAL | ratiotable [16] = 1.5 |
| REAL | edgelength [3] |
| REAL | cossquare |
| REAL | triarea |
| REAL | shortest = minaltitude |
| REAL | longest = 0.0 |
| REAL | trilongest2 |
| REAL | smallestarea = minaltitude |
| REAL | biggestarea = 0.0 |
| REAL | triminaltitude2 |
| REAL | minaltitude = m->xmax - m->xmin + m->ymax - m->ymin |
| REAL | triaspect2 |
| REAL | worstaspect = 0.0 |
| REAL | smallestangle = 0.0 |
| REAL | biggestangle = 2.0 |
| REAL | radconst = PI / 18.0 |
| REAL | degconst = 180.0 / PI |
| int | angletable [18] |
| int | aspecttable [16] |
| int | aspectindex |
| int | tendegree |
| int | acutebiggest = 1 |
| int | ii |
| void | in |
| void | out |
| void vorout char * | triswitches |
| struct triangulateio * | vorout |
| REAL * | holearray |
| REAL * | regionarray |
| struct timeval tv0 tv1 tv2 tv3 tv4 tv5 | tv6 |
| struct timezone | tz |
| gettimeofday & | tv0 |
| m | steinerleft = b.steiner |
| m | edges = (3l * m.triangles.items + m.hullsize) / 2l |
| out | numberofpointattributes = m.nextras |
| out | numberoftriangles = m.triangles.items |
| out | numberofcorners = (b.order + 1) * (b.order + 2) / 2 |
| out | numberoftriangleattributes = m.eextras |
| out | numberofedges = m.edges |
| | return |