开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 3D图形编程 > 查看源码
triangle.h
资源名称：triangle.zip　[点击查看]
上传用户：yflamps
上传日期：2010-04-01
资源大小：155k
文件大小：21k
源码类别：

3D图形编程

开发平台：

C/C++

triangle.h：源码内容
  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. /*****************************************************************************/
  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. /*****************************************************************************/
  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. /*****************************************************************************/
  251. struct 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 */
  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 */
  266.   int *segmentlist;                                              /* In / out */
  267.   int *segmentmarkerlist;                                        /* In / out */
  268.   int numberofsegments;                                          /* In / out */
  270.   REAL *holelist;                        /* In / pointer to array copied out */
  271.   int numberofholes;                                      /* In / copied out */
  273.   REAL *regionlist;                      /* In / pointer to array copied out */
  274.   int numberofregions;                                    /* In / copied out */
  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. };
  282. #ifdef ANSI_DECLARATORS
  283. void triangulate(char *, struct triangulateio *, struct triangulateio *,
  284.                  struct triangulateio *);
  285. void trifree(VOID *memptr);
  286. #else /* not ANSI_DECLARATORS */
  287. void triangulate();
  288. void trifree();
  289. #endif /* not ANSI_DECLARATORS */