triangle.c | 116 ++++++++++++++++++++++++++----------------------------------- triangle.h | 29 +++++++++------- 2 files changed, 66 insertions(+), 79 deletions(-) diff --git a/triangle.c b/triangle.c index f7a5700..084902e 100644 --- a/triangle.c +++ b/triangle.c @@ -194,27 +194,8 @@ /* */ /*****************************************************************************/ -/* For single precision (which will save some memory and reduce paging), */ -/* define the symbol SINGLE by using the -DSINGLE compiler switch or by */ -/* writing "#define SINGLE" below. */ -/* */ -/* For double precision (which will allow you to refine meshes to a smaller */ -/* edge length), leave SINGLE undefined. */ -/* */ -/* Double precision uses more memory, but improves the resolution of the */ -/* meshes you can generate with Triangle. It also reduces the likelihood */ -/* of a floating exception due to overflow. Finally, it is much faster */ -/* than single precision on 64-bit architectures like the DEC Alpha. I */ -/* recommend double precision unless you want to generate a mesh for which */ -/* you do not have enough memory. */ - -/* #define SINGLE */ - -#ifdef SINGLE -#define REAL float -#else /* not SINGLE */ #define REAL double -#endif /* not SINGLE */ +#define VOID void /* If yours is not a Unix system, define the NO_TIMER compiler switch to */ /* remove the Unix-specific timing code. */ @@ -308,12 +289,6 @@ #define DEADVERTEX -32768 #define UNDEADVERTEX -32767 -/* The next line is used to outsmart some very stupid compilers. If your */ -/* compiler is smarter, feel free to replace the "int" with "void". */ -/* Not that it matters. */ - -#define VOID int - /* Two constants for algorithms based on random sampling. Both constants */ /* have been chosen empirically to optimize their respective algorithms. */ @@ -340,6 +315,7 @@ #define ONETHIRD 0.333333333333333333333333333333333333333333333333333333333333 +#include #include #include #include @@ -938,16 +914,16 @@ int minus1mod3[3] = {2, 0, 1}; /* extracted from the two least significant bits of the pointer. */ #define decode(ptr, otri) \ - (otri).orient = (int) ((unsigned long) (ptr) & (unsigned long) 3l); \ + (otri).orient = (int) ((uintptr_t) (ptr) & (uintptr_t) 3l); \ (otri).tri = (triangle *) \ - ((unsigned long) (ptr) ^ (unsigned long) (otri).orient) + ((uintptr_t) (ptr) ^ (uintptr_t) (otri).orient) /* encode() compresses an oriented triangle into a single pointer. It */ /* relies on the assumption that all triangles are aligned to four-byte */ /* boundaries, so the two least significant bits of (otri).tri are zero. */ #define encode(otri) \ - (triangle) ((unsigned long) (otri).tri | (unsigned long) (otri).orient) + (triangle) ((uintptr_t) (otri).tri | (uintptr_t) (otri).orient) /* The following handle manipulation primitives are all described by Guibas */ /* and Stolfi. However, Guibas and Stolfi use an edge-based data */ @@ -1111,16 +1087,16 @@ int minus1mod3[3] = {2, 0, 1}; #define infect(otri) \ (otri).tri[6] = (triangle) \ - ((unsigned long) (otri).tri[6] | (unsigned long) 2l) + ((uintptr_t) (otri).tri[6] | (uintptr_t) 2l) #define uninfect(otri) \ (otri).tri[6] = (triangle) \ - ((unsigned long) (otri).tri[6] & ~ (unsigned long) 2l) + ((uintptr_t) (otri).tri[6] & ~ (uintptr_t) 2l) /* Test a triangle for viral infection. */ #define infected(otri) \ - (((unsigned long) (otri).tri[6] & (unsigned long) 2l) != 0l) + (((uintptr_t) (otri).tri[6] & (uintptr_t) 2l) != 0l) /* Check or set a triangle's attributes. */ @@ -1158,16 +1134,16 @@ int minus1mod3[3] = {2, 0, 1}; /* are masked out to produce the real pointer. */ #define sdecode(sptr, osub) \ - (osub).ssorient = (int) ((unsigned long) (sptr) & (unsigned long) 1l); \ + (osub).ssorient = (int) ((uintptr_t) (sptr) & (uintptr_t) 1l); \ (osub).ss = (subseg *) \ - ((unsigned long) (sptr) & ~ (unsigned long) 3l) + ((uintptr_t) (sptr) & ~ (uintptr_t) 3l) /* sencode() compresses an oriented subsegment into a single pointer. It */ /* relies on the assumption that all subsegments are aligned to two-byte */ /* boundaries, so the least significant bit of (osub).ss is zero. */ #define sencode(osub) \ - (subseg) ((unsigned long) (osub).ss | (unsigned long) (osub).ssorient) + (subseg) ((uintptr_t) (osub).ss | (uintptr_t) (osub).ssorient) /* ssym() toggles the orientation of a subsegment. */ @@ -3891,7 +3867,7 @@ struct memorypool *pool; #endif /* not ANSI_DECLARATORS */ { - unsigned long alignptr; + uintptr_t alignptr = 0; pool->items = 0; pool->maxitems = 0; @@ -3899,11 +3875,11 @@ struct memorypool *pool; /* Set the currently active block. */ pool->nowblock = pool->firstblock; /* Find the first item in the pool. Increment by the size of (VOID *). */ - alignptr = (unsigned long) (pool->nowblock + 1); + alignptr = (uintptr_t) (pool->nowblock + 1); /* Align the item on an `alignbytes'-byte boundary. */ pool->nextitem = (VOID *) - (alignptr + (unsigned long) pool->alignbytes - - (alignptr % (unsigned long) pool->alignbytes)); + (alignptr + (uintptr_t) pool->alignbytes - + (alignptr % (uintptr_t) pool->alignbytes)); /* There are lots of unallocated items left in this block. */ pool->unallocateditems = pool->itemsfirstblock; /* The stack of deallocated items is empty. */ @@ -4008,7 +3984,7 @@ struct memorypool *pool; { VOID *newitem; VOID **newblock; - unsigned long alignptr; + uintptr_t alignptr = 0; /* First check the linked list of dead items. If the list is not */ /* empty, allocate an item from the list rather than a fresh one. */ @@ -4033,11 +4009,11 @@ struct memorypool *pool; pool->nowblock = (VOID **) *(pool->nowblock); /* Find the first item in the block. */ /* Increment by the size of (VOID *). */ - alignptr = (unsigned long) (pool->nowblock + 1); + alignptr = (uintptr_t) (pool->nowblock + 1); /* Align the item on an `alignbytes'-byte boundary. */ pool->nextitem = (VOID *) - (alignptr + (unsigned long) pool->alignbytes - - (alignptr % (unsigned long) pool->alignbytes)); + (alignptr + (uintptr_t) pool->alignbytes - + (alignptr % (uintptr_t) pool->alignbytes)); /* There are lots of unallocated items left in this block. */ pool->unallocateditems = pool->itemsperblock; } @@ -4092,16 +4068,16 @@ struct memorypool *pool; #endif /* not ANSI_DECLARATORS */ { - unsigned long alignptr; + uintptr_t alignptr = 0; /* Begin the traversal in the first block. */ pool->pathblock = pool->firstblock; /* Find the first item in the block. Increment by the size of (VOID *). */ - alignptr = (unsigned long) (pool->pathblock + 1); + alignptr = (uintptr_t) (pool->pathblock + 1); /* Align with item on an `alignbytes'-byte boundary. */ pool->pathitem = (VOID *) - (alignptr + (unsigned long) pool->alignbytes - - (alignptr % (unsigned long) pool->alignbytes)); + (alignptr + (uintptr_t) pool->alignbytes - + (alignptr % (uintptr_t) pool->alignbytes)); /* Set the number of items left in the current block. */ pool->pathitemsleft = pool->itemsfirstblock; } @@ -4129,7 +4105,7 @@ struct memorypool *pool; { VOID *newitem; - unsigned long alignptr; + uintptr_t alignptr = 0; /* Stop upon exhausting the list of items. */ if (pool->pathitem == pool->nextitem) { @@ -4141,11 +4117,11 @@ struct memorypool *pool; /* Find the next block. */ pool->pathblock = (VOID **) *(pool->pathblock); /* Find the first item in the block. Increment by the size of (VOID *). */ - alignptr = (unsigned long) (pool->pathblock + 1); + alignptr = (uintptr_t) (pool->pathblock + 1); /* Align with item on an `alignbytes'-byte boundary. */ pool->pathitem = (VOID *) - (alignptr + (unsigned long) pool->alignbytes - - (alignptr % (unsigned long) pool->alignbytes)); + (alignptr + (uintptr_t) pool->alignbytes - + (alignptr % (uintptr_t) pool->alignbytes)); /* Set the number of items left in the current block. */ pool->pathitemsleft = pool->itemsperblock; } @@ -4197,16 +4173,16 @@ int subsegbytes; #endif /* not ANSI_DECLARATORS */ { - unsigned long alignptr; + uintptr_t alignptr = 0; /* Set up `dummytri', the `triangle' that occupies "outer space." */ m->dummytribase = (triangle *) trimalloc(trianglebytes + m->triangles.alignbytes); /* Align `dummytri' on a `triangles.alignbytes'-byte boundary. */ - alignptr = (unsigned long) m->dummytribase; + alignptr = (uintptr_t) m->dummytribase; m->dummytri = (triangle *) - (alignptr + (unsigned long) m->triangles.alignbytes - - (alignptr % (unsigned long) m->triangles.alignbytes)); + (alignptr + (uintptr_t) m->triangles.alignbytes - + (alignptr % (uintptr_t) m->triangles.alignbytes)); /* Initialize the three adjoining triangles to be "outer space." These */ /* will eventually be changed by various bonding operations, but their */ /* values don't really matter, as long as they can legally be */ @@ -4226,10 +4202,10 @@ int subsegbytes; m->dummysubbase = (subseg *) trimalloc(subsegbytes + m->subsegs.alignbytes); /* Align `dummysub' on a `subsegs.alignbytes'-byte boundary. */ - alignptr = (unsigned long) m->dummysubbase; + alignptr = (uintptr_t) m->dummysubbase; m->dummysub = (subseg *) - (alignptr + (unsigned long) m->subsegs.alignbytes - - (alignptr % (unsigned long) m->subsegs.alignbytes)); + (alignptr + (uintptr_t) m->subsegs.alignbytes - + (alignptr % (uintptr_t) m->subsegs.alignbytes)); /* Initialize the two adjoining subsegments to be the omnipresent */ /* subsegment. These will eventually be changed by various bonding */ /* operations, but their values don't really matter, as long as they */ @@ -4586,7 +4562,7 @@ int number; { VOID **getblock; char *foundvertex; - unsigned long alignptr; + uintptr_t alignptr = 0; int current; getblock = m->vertices.firstblock; @@ -4603,9 +4579,9 @@ int number; } /* Now find the right vertex. */ - alignptr = (unsigned long) (getblock + 1); - foundvertex = (char *) (alignptr + (unsigned long) m->vertices.alignbytes - - (alignptr % (unsigned long) m->vertices.alignbytes)); + alignptr = (uintptr_t) (getblock + 1); + foundvertex = (char *) (alignptr + (uintptr_t) m->vertices.alignbytes - + (alignptr % (uintptr_t) m->vertices.alignbytes)); return (vertex) (foundvertex + m->vertices.itembytes * (number - current)); } @@ -4883,6 +4859,7 @@ struct osub *newsubseg; /* */ /*****************************************************************************/ +static void exactinit() { REAL half; @@ -4956,6 +4933,7 @@ void exactinit() /* */ /*****************************************************************************/ +static #ifdef ANSI_DECLARATORS int fast_expansion_sum_zeroelim(int elen, REAL *e, int flen, REAL *f, REAL *h) #else /* not ANSI_DECLARATORS */ @@ -5050,6 +5028,7 @@ REAL *h; /* */ /*****************************************************************************/ +static #ifdef ANSI_DECLARATORS int scale_expansion_zeroelim(int elen, REAL *e, REAL b, REAL *h) #else /* not ANSI_DECLARATORS */ @@ -5106,6 +5085,7 @@ REAL *h; /* */ /*****************************************************************************/ +static #ifdef ANSI_DECLARATORS REAL estimate(int elen, REAL *e) #else /* not ANSI_DECLARATORS */ @@ -5303,6 +5283,7 @@ vertex pc; /* */ /*****************************************************************************/ +static #ifdef ANSI_DECLARATORS REAL incircleadapt(vertex pa, vertex pb, vertex pc, vertex pd, REAL permanent) #else /* not ANSI_DECLARATORS */ @@ -5882,6 +5863,7 @@ REAL permanent; return finnow[finlength - 1]; } +static #ifdef ANSI_DECLARATORS REAL incircle(struct mesh *m, struct behavior *b, vertex pa, vertex pb, vertex pc, vertex pd) @@ -5964,6 +5946,7 @@ vertex pd; /* */ /*****************************************************************************/ +static #ifdef ANSI_DECLARATORS REAL orient3dadapt(vertex pa, vertex pb, vertex pc, vertex pd, REAL aheight, REAL bheight, REAL cheight, REAL dheight, @@ -6389,6 +6372,7 @@ REAL permanent; return finnow[finlength - 1]; } +static #ifdef ANSI_DECLARATORS REAL orient3d(struct mesh *m, struct behavior *b, vertex pa, vertex pb, vertex pc, vertex pd, @@ -7649,7 +7633,7 @@ struct otri *searchtri; char *firsttri; struct otri sampletri; vertex torg, tdest; - unsigned long alignptr; + uintptr_t alignptr = 0; REAL searchdist, dist; REAL ahead; long samplesperblock, totalsamplesleft, samplesleft; @@ -7721,11 +7705,11 @@ struct otri *searchtri; population = totalpopulation; } /* Find a pointer to the first triangle in the block. */ - alignptr = (unsigned long) (sampleblock + 1); + alignptr = (uintptr_t) (sampleblock + 1); firsttri = (char *) (alignptr + - (unsigned long) m->triangles.alignbytes - + (uintptr_t) m->triangles.alignbytes - (alignptr % - (unsigned long) m->triangles.alignbytes)); + (uintptr_t) m->triangles.alignbytes)); /* Choose `samplesleft' randomly sampled triangles in this block. */ do { diff --git a/triangle.h b/triangle.h index 9df1f39..8d9c754 100644 --- a/triangle.h +++ b/triangle.h @@ -248,16 +248,20 @@ /* */ /*****************************************************************************/ +#ifdef __cplusplus +extern "C" { +#endif + struct triangulateio { - REAL *pointlist; /* In / out */ - REAL *pointattributelist; /* In / out */ + double *pointlist; /* In / out */ + double *pointattributelist; /* In / out */ int *pointmarkerlist; /* In / out */ int numberofpoints; /* In / out */ int numberofpointattributes; /* In / out */ int *trianglelist; /* In / out */ - REAL *triangleattributelist; /* In / out */ - REAL *trianglearealist; /* In only */ + double *triangleattributelist; /* In / out */ + double *trianglearealist; /* In only */ int *neighborlist; /* Out only */ int numberoftriangles; /* In / out */ int numberofcorners; /* In / out */ @@ -267,23 +271,22 @@ struct triangulateio { int *segmentmarkerlist; /* In / out */ int numberofsegments; /* In / out */ - REAL *holelist; /* In / pointer to array copied out */ + double *holelist; /* In / pointer to array copied out */ int numberofholes; /* In / copied out */ - REAL *regionlist; /* In / pointer to array copied out */ + double *regionlist; /* In / pointer to array copied out */ int numberofregions; /* In / copied out */ int *edgelist; /* Out only */ int *edgemarkerlist; /* Not used with Voronoi diagram; out only */ - REAL *normlist; /* Used only with Voronoi diagram; out only */ + double *normlist; /* Used only with Voronoi diagram; out only */ int numberofedges; /* Out only */ }; -#ifdef ANSI_DECLARATORS void triangulate(char *, struct triangulateio *, struct triangulateio *, struct triangulateio *); -void trifree(VOID *memptr); -#else /* not ANSI_DECLARATORS */ -void triangulate(); -void trifree(); -#endif /* not ANSI_DECLARATORS */ +void trifree(void *memptr); + +#ifdef __cplusplus +} +#endif \ No newline at end of file