source: trunk/anuga_core/source/anuga/mesh_engine/triangle.h @ 7985

Last change on this file since 7985 was 2141, checked in by duncan, 18 years ago

compiling triangle using setup.

File size: 21.4 KB
Line 
1/*****************************************************************************/
2/*                                                                           */
3/*  (triangle.h)                                                             */
4/*                                                                           */
5/*  Include file for programs that call Triangle.                            */
6/*                                                                           */
7/*  Accompanies Triangle Version 1.6                                         */
8/*  July 28, 2005                                                            */
9/*                                                                           */
10/*  Copyright 1996, 2005                                                     */
11/*  Jonathan Richard Shewchuk                                                */
12/*  2360 Woolsey #H                                                          */
13/*  Berkeley, California  94705-1927                                         */
14/*  jrs@cs.berkeley.edu                                                      */
15/*                                                                           */
16/*****************************************************************************/
17
18/*****************************************************************************/
19/*                                                                           */
20/*  How to call Triangle from another program                                */
21/*                                                                           */
22/*                                                                           */
23/*  If you haven't read Triangle's instructions (run "triangle -h" to read   */
24/*  them), you won't understand what follows.                                */
25/*                                                                           */
26/*  Triangle must be compiled into an object file (triangle.o) with the      */
27/*  TRILIBRARY symbol defined (generally by using the -DTRILIBRARY compiler  */
28/*  switch).  The makefile included with Triangle will do this for you if    */
29/*  you run "make trilibrary".  The resulting object file can be called via  */
30/*  the procedure triangulate().                                             */
31/*                                                                           */
32/*  If the size of the object file is important to you, you may wish to      */
33/*  generate a reduced version of triangle.o.  The REDUCED symbol gets rid   */
34/*  of all features that are primarily of research interest.  Specifically,  */
35/*  the -DREDUCED switch eliminates Triangle's -i, -F, -s, and -C switches.  */
36/*  The CDT_ONLY symbol gets rid of all meshing algorithms above and beyond  */
37/*  constrained Delaunay triangulation.  Specifically, the -DCDT_ONLY switch */
38/*  eliminates Triangle's -r, -q, -a, -u, -D, -Y, -S, and -s switches.       */
39/*                                                                           */
40/*  IMPORTANT:  These definitions (TRILIBRARY, REDUCED, CDT_ONLY) must be    */
41/*  made in the makefile or in triangle.c itself.  Putting these definitions */
42/*  in this file (triangle.h) will not create the desired effect.            */
43/*                                                                           */
44/*                                                                           */
45/*  The calling convention for triangulate() follows.                        */
46/*                                                                           */
47/*      void triangulate(triswitches, in, out, vorout)                       */
48/*      char *triswitches;                                                   */
49/*      struct triangulateio *in;                                            */
50/*      struct triangulateio *out;                                           */
51/*      struct triangulateio *vorout;                                        */
52/*                                                                           */
53/*  `triswitches' is a string containing the command line switches you wish  */
54/*  to invoke.  No initial dash is required.  Some suggestions:              */
55/*                                                                           */
56/*  - You'll probably find it convenient to use the `z' switch so that       */
57/*    points (and other items) are numbered from zero.  This simplifies      */
58/*    indexing, because the first item of any type always starts at index    */
59/*    [0] of the corresponding array, whether that item's number is zero or  */
60/*    one.                                                                   */
61/*  - You'll probably want to use the `Q' (quiet) switch in your final code, */
62/*    but you can take advantage of Triangle's printed output (including the */
63/*    `V' switch) while debugging.                                           */
64/*  - If you are not using the `q', `a', `u', `D', `j', or `s' switches,     */
65/*    then the output points will be identical to the input points, except   */
66/*    possibly for the boundary markers.  If you don't need the boundary     */
67/*    markers, you should use the `N' (no nodes output) switch to save       */
68/*    memory.  (If you do need boundary markers, but need to save memory, a  */
69/*    good nasty trick is to set out->pointlist equal to in->pointlist       */
70/*    before calling triangulate(), so that Triangle overwrites the input    */
71/*    points with identical copies.)                                         */
72/*  - The `I' (no iteration numbers) and `g' (.off file output) switches     */
73/*    have no effect when Triangle is compiled with TRILIBRARY defined.      */
74/*                                                                           */
75/*  `in', `out', and `vorout' are descriptions of the input, the output,     */
76/*  and the Voronoi output.  If the `v' (Voronoi output) switch is not used, */
77/*  `vorout' may be NULL.  `in' and `out' may never be NULL.                 */
78/*                                                                           */
79/*  Certain fields of the input and output structures must be initialized,   */
80/*  as described below.                                                      */
81/*                                                                           */
82/*****************************************************************************/
83
84/*****************************************************************************/
85/*                                                                           */
86/*  The `triangulateio' structure.                                           */
87/*                                                                           */
88/*  Used to pass data into and out of the triangulate() procedure.           */
89/*                                                                           */
90/*                                                                           */
91/*  Arrays are used to store points, triangles, markers, and so forth.  In   */
92/*  all cases, the first item in any array is stored starting at index [0].  */
93/*  However, that item is item number `1' unless the `z' switch is used, in  */
94/*  which case it is item number `0'.  Hence, you may find it easier to      */
95/*  index points (and triangles in the neighbor list) if you use the `z'     */
96/*  switch.  Unless, of course, you're calling Triangle from a Fortran       */
97/*  program.                                                                 */
98/*                                                                           */
99/*  Description of fields (except the `numberof' fields, which are obvious): */
100/*                                                                           */
101/*  `pointlist':  An array of point coordinates.  The first point's x        */
102/*    coordinate is at index [0] and its y coordinate at index [1], followed */
103/*    by the coordinates of the remaining points.  Each point occupies two   */
104/*    REALs.                                                                 */
105/*  `pointattributelist':  An array of point attributes.  Each point's       */
106/*    attributes occupy `numberofpointattributes' REALs.                     */
107/*  `pointmarkerlist':  An array of point markers; one int per point.        */
108/*                                                                           */
109/*  `trianglelist':  An array of triangle corners.  The first triangle's     */
110/*    first corner is at index [0], followed by its other two corners in     */
111/*    counterclockwise order, followed by any other nodes if the triangle    */
112/*    represents a nonlinear element.  Each triangle occupies                */
113/*    `numberofcorners' ints.                                                */
114/*  `triangleattributelist':  An array of triangle attributes.  Each         */
115/*    triangle's attributes occupy `numberoftriangleattributes' REALs.       */
116/*  `trianglearealist':  An array of triangle area constraints; one REAL per */
117/*    triangle.  Input only.                                                 */
118/*  `neighborlist':  An array of triangle neighbors; three ints per          */
119/*    triangle.  Output only.                                                */
120/*                                                                           */
121/*  `segmentlist':  An array of segment endpoints.  The first segment's      */
122/*    endpoints are at indices [0] and [1], followed by the remaining        */
123/*    segments.  Two ints per segment.                                       */
124/*  `segmentmarkerlist':  An array of segment markers; one int per segment.  */
125/*                                                                           */
126/*  `holelist':  An array of holes.  The first hole's x and y coordinates    */
127/*    are at indices [0] and [1], followed by the remaining holes.  Two      */
128/*    REALs per hole.  Input only, although the pointer is copied to the     */
129/*    output structure for your convenience.                                 */
130/*                                                                           */
131/*  `regionlist':  An array of regional attributes and area constraints.     */
132/*    The first constraint's x and y coordinates are at indices [0] and [1], */
133/*    followed by the regional attribute at index [2], followed by the       */
134/*    maximum area at index [3], followed by the remaining area constraints. */
135/*    Four REALs per area constraint.  Note that each regional attribute is  */
136/*    used only if you select the `A' switch, and each area constraint is    */
137/*    used only if you select the `a' switch (with no number following), but */
138/*    omitting one of these switches does not change the memory layout.      */
139/*    Input only, although the pointer is copied to the output structure for */
140/*    your convenience.                                                      */
141/*                                                                           */
142/*  `edgelist':  An array of edge endpoints.  The first edge's endpoints are */
143/*    at indices [0] and [1], followed by the remaining edges.  Two ints per */
144/*    edge.  Output only.                                                    */
145/*  `edgemarkerlist':  An array of edge markers; one int per edge.  Output   */
146/*    only.                                                                  */
147/*  `normlist':  An array of normal vectors, used for infinite rays in       */
148/*    Voronoi diagrams.  The first normal vector's x and y magnitudes are    */
149/*    at indices [0] and [1], followed by the remaining vectors.  For each   */
150/*    finite edge in a Voronoi diagram, the normal vector written is the     */
151/*    zero vector.  Two REALs per edge.  Output only.                        */
152/*                                                                           */
153/*                                                                           */
154/*  Any input fields that Triangle will examine must be initialized.         */
155/*  Furthermore, for each output array that Triangle will write to, you      */
156/*  must either provide space by setting the appropriate pointer to point    */
157/*  to the space you want the data written to, or you must initialize the    */
158/*  pointer to NULL, which tells Triangle to allocate space for the results. */
159/*  The latter option is preferable, because Triangle always knows exactly   */
160/*  how much space to allocate.  The former option is provided mainly for    */
161/*  people who need to call Triangle from Fortran code, though it also makes */
162/*  possible some nasty space-saving tricks, like writing the output to the  */
163/*  same arrays as the input.                                                */
164/*                                                                           */
165/*  Triangle will not free() any input or output arrays, including those it  */
166/*  allocates itself; that's up to you.  You should free arrays allocated by */
167/*  Triangle by calling the trifree() procedure defined below.  (By default, */
168/*  trifree() just calls the standard free() library procedure, but          */
169/*  applications that call triangulate() may replace trimalloc() and         */
170/*  trifree() in triangle.c to use specialized memory allocators.)           */
171/*                                                                           */
172/*  Here's a guide to help you decide which fields you must initialize       */
173/*  before you call triangulate().                                           */
174/*                                                                           */
175/*  `in':                                                                    */
176/*                                                                           */
177/*    - `pointlist' must always point to a list of points; `numberofpoints'  */
178/*      and `numberofpointattributes' must be properly set.                  */
179/*      `pointmarkerlist' must either be set to NULL (in which case all      */
180/*      markers default to zero), or must point to a list of markers.  If    */
181/*      `numberofpointattributes' is not zero, `pointattributelist' must     */
182/*      point to a list of point attributes.                                 */
183/*    - If the `r' switch is used, `trianglelist' must point to a list of    */
184/*      triangles, and `numberoftriangles', `numberofcorners', and           */
185/*      `numberoftriangleattributes' must be properly set.  If               */
186/*      `numberoftriangleattributes' is not zero, `triangleattributelist'    */
187/*      must point to a list of triangle attributes.  If the `a' switch is   */
188/*      used (with no number following), `trianglearealist' must point to a  */
189/*      list of triangle area constraints.  `neighborlist' may be ignored.   */
190/*    - If the `p' switch is used, `segmentlist' must point to a list of     */
191/*      segments, `numberofsegments' must be properly set, and               */
192/*      `segmentmarkerlist' must either be set to NULL (in which case all    */
193/*      markers default to zero), or must point to a list of markers.        */
194/*    - If the `p' switch is used without the `r' switch, then               */
195/*      `numberofholes' and `numberofregions' must be properly set.  If      */
196/*      `numberofholes' is not zero, `holelist' must point to a list of      */
197/*      holes.  If `numberofregions' is not zero, `regionlist' must point to */
198/*      a list of region constraints.                                        */
199/*    - If the `p' switch is used, `holelist', `numberofholes',              */
200/*      `regionlist', and `numberofregions' is copied to `out'.  (You can    */
201/*      nonetheless get away with not initializing them if the `r' switch is */
202/*      used.)                                                               */
203/*    - `edgelist', `edgemarkerlist', `normlist', and `numberofedges' may be */
204/*      ignored.                                                             */
205/*                                                                           */
206/*  `out':                                                                   */
207/*                                                                           */
208/*    - `pointlist' must be initialized (NULL or pointing to memory) unless  */
209/*      the `N' switch is used.  `pointmarkerlist' must be initialized       */
210/*      unless the `N' or `B' switch is used.  If `N' is not used and        */
211/*      `in->numberofpointattributes' is not zero, `pointattributelist' must */
212/*      be initialized.                                                      */
213/*    - `trianglelist' must be initialized unless the `E' switch is used.    */
214/*      `neighborlist' must be initialized if the `n' switch is used.  If    */
215/*      the `E' switch is not used and (`in->numberofelementattributes' is   */
216/*      not zero or the `A' switch is used), `elementattributelist' must be  */
217/*      initialized.  `trianglearealist' may be ignored.                     */
218/*    - `segmentlist' must be initialized if the `p' or `c' switch is used,  */
219/*      and the `P' switch is not used.  `segmentmarkerlist' must also be    */
220/*      initialized under these circumstances unless the `B' switch is used. */
221/*    - `edgelist' must be initialized if the `e' switch is used.            */
222/*      `edgemarkerlist' must be initialized if the `e' switch is used and   */
223/*      the `B' switch is not.                                               */
224/*    - `holelist', `regionlist', `normlist', and all scalars may be ignored.*/
225/*                                                                           */
226/*  `vorout' (only needed if `v' switch is used):                            */
227/*                                                                           */
228/*    - `pointlist' must be initialized.  If `in->numberofpointattributes'   */
229/*      is not zero, `pointattributelist' must be initialized.               */
230/*      `pointmarkerlist' may be ignored.                                    */
231/*    - `edgelist' and `normlist' must both be initialized.                  */
232/*      `edgemarkerlist' may be ignored.                                     */
233/*    - Everything else may be ignored.                                      */
234/*                                                                           */
235/*  After a call to triangulate(), the valid fields of `out' and `vorout'    */
236/*  will depend, in an obvious way, on the choice of switches used.  Note    */
237/*  that when the `p' switch is used, the pointers `holelist' and            */
238/*  `regionlist' are copied from `in' to `out', but no new space is          */
239/*  allocated; be careful that you don't free() the same array twice.  On    */
240/*  the other hand, Triangle will never copy the `pointlist' pointer (or any */
241/*  others); new space is allocated for `out->pointlist', or if the `N'      */
242/*  switch is used, `out->pointlist' remains uninitialized.                  */
243/*                                                                           */
244/*  All of the meaningful `numberof' fields will be properly set; for        */
245/*  instance, `numberofedges' will represent the number of edges in the      */
246/*  triangulation whether or not the edges were written.  If segments are    */
247/*  not used, `numberofsegments' will indicate the number of boundary edges. */
248/*                                                                           */
249/*****************************************************************************/
250
251struct triangulateio {
252  REAL *pointlist;                                               /* In / out */
253  REAL *pointattributelist;                                      /* In / out */
254  int *pointmarkerlist;                                          /* In / out */
255  int numberofpoints;                                            /* In / out */
256  int numberofpointattributes;                                   /* In / out */
257
258  int *trianglelist;                                             /* In / out */
259  REAL *triangleattributelist;                                   /* In / out */
260  REAL *trianglearealist;                                         /* In only */
261  int *neighborlist;                                             /* Out only */
262  int numberoftriangles;                                         /* In / out */
263  int numberofcorners;                                           /* In / out */
264  int numberoftriangleattributes;                                /* In / out */
265
266  int *segmentlist;                                              /* In / out */
267  int *segmentmarkerlist;                                        /* In / out */
268  int numberofsegments;                                          /* In / out */
269
270  REAL *holelist;                        /* In / pointer to array copied out */
271  int numberofholes;                                      /* In / copied out */
272
273  REAL *regionlist;                      /* In / pointer to array copied out */
274  int numberofregions;                                    /* In / copied out */
275
276  int *edgelist;                                                 /* Out only */
277  int *edgemarkerlist;            /* Not used with Voronoi diagram; out only */
278  REAL *normlist;                /* Used only with Voronoi diagram; out only */
279  int numberofedges;                                             /* Out only */
280};
281
282#ifdef ANSI_DECLARATORS
283void triangulate(char *, struct triangulateio *, struct triangulateio *,
284                 struct triangulateio *);
285void trifree(VOID *memptr);
286#else /* not ANSI_DECLARATORS */
287void triangulate();
288void trifree();
289#endif /* not ANSI_DECLARATORS */
Note: See TracBrowser for help on using the repository browser.