Hauptseite | Liste aller Namensbereiche | Klassenhierarchie | Auflistung der Klassen | Verzeichnisse | Auflistung der Dateien | Klassen-Elemente | Datei-Elemente

triangle.cpp-Dateireferenz

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <sys/time.h>

Include-Abhängigkeitsdiagramm für triangle.cpp:


Klassen

struct  otri
struct  osub
struct  badsubseg
struct  badtriang
struct  flipstacker
struct  event
struct  splaynode
struct  memorypool
struct  mesh
struct  behavior

Makrodefinitionen

#define REAL   double
#define INEXACT
#define FILENAMESIZE   512
#define INPUTLINESIZE   512
#define TRIPERBLOCK   4092
#define SUBSEGPERBLOCK   508
#define VERTEXPERBLOCK   4092
#define VIRUSPERBLOCK   1020
#define BADSUBSEGPERBLOCK   252
#define BADTRIPERBLOCK   4092
#define FLIPSTACKERPERBLOCK   252
#define SPLAYNODEPERBLOCK   508
#define INPUTVERTEX   0
#define SEGMENTVERTEX   1
#define FREEVERTEX   2
#define DEADVERTEX   -32768
#define UNDEADVERTEX   -32767
#define VOID   void
#define SAMPLEFACTOR   11
#define SAMPLERATE   10
#define PI   3.141592653589793238462643383279502884197169399375105820974944592308
#define SQUAREROOTTWO   1.4142135623730950488016887242096980785696718753769480732
#define ONETHIRD   0.333333333333333333333333333333333333333333333333333333333333
#define decode(ptr, otri)
#define encode(otri)   (triangle) ((unsigned long) (otri).tri | (unsigned long) (otri).orient)
#define sym(otri1, otri2)
#define symself(otri)
#define lnext(otri1, otri2)
#define lnextself(otri)   (otri).orient = plus1mod3[(otri).orient]
#define lprev(otri1, otri2)
#define lprevself(otri)   (otri).orient = minus1mod3[(otri).orient]
#define onext(otri1, otri2)
#define onextself(otri)
#define oprev(otri1, otri2)
#define oprevself(otri)
#define dnext(otri1, otri2)
#define dnextself(otri)
#define dprev(otri1, otri2)
#define dprevself(otri)
#define rnext(otri1, otri2)
#define rnextself(otri)
#define rprev(otri1, otri2)
#define rprevself(otri)
#define org(otri, vertexptr)   vertexptr = (vertex) (otri).tri[plus1mod3[(otri).orient] + 3]
#define dest(otri, vertexptr)   vertexptr = (vertex) (otri).tri[minus1mod3[(otri).orient] + 3]
#define apex(otri, vertexptr)   vertexptr = (vertex) (otri).tri[(otri).orient + 3]
#define setorg(otri, vertexptr)   (otri).tri[plus1mod3[(otri).orient] + 3] = (triangle) vertexptr
#define setdest(otri, vertexptr)   (otri).tri[minus1mod3[(otri).orient] + 3] = (triangle) vertexptr
#define setapex(otri, vertexptr)   (otri).tri[(otri).orient + 3] = (triangle) vertexptr
#define bond(otri1, otri2)
#define dissolve(otri)   (otri).tri[(otri).orient] = (triangle) m->dummytri
#define otricopy(otri1, otri2)
#define otriequal(otri1, otri2)
#define infect(otri)
#define uninfect(otri)
#define infected(otri)   (((unsigned long) (otri).tri[6] & (unsigned long) 2l) != 0l)
#define elemattribute(otri, attnum)   ((REAL *) (otri).tri)[m->elemattribindex + (attnum)]
#define setelemattribute(otri, attnum, value)   ((REAL *) (otri).tri)[m->elemattribindex + (attnum)] = value
#define areabound(otri)   ((REAL *) (otri).tri)[m->areaboundindex]
#define setareabound(otri, value)   ((REAL *) (otri).tri)[m->areaboundindex] = value
#define deadtri(tria)   ((tria)[1] == (triangle) NULL)
#define killtri(tria)
#define sdecode(sptr, osub)
#define sencode(osub)   (subseg) ((unsigned long) (osub).ss | (unsigned long) (osub).ssorient)
#define ssym(osub1, osub2)
#define ssymself(osub)   (osub).ssorient = 1 - (osub).ssorient
#define spivot(osub1, osub2)
#define spivotself(osub)
#define snext(osub1, osub2)
#define snextself(osub)
#define sorg(osub, vertexptr)   vertexptr = (vertex) (osub).ss[2 + (osub).ssorient]
#define sdest(osub, vertexptr)   vertexptr = (vertex) (osub).ss[3 - (osub).ssorient]
#define setsorg(osub, vertexptr)   (osub).ss[2 + (osub).ssorient] = (subseg) vertexptr
#define setsdest(osub, vertexptr)   (osub).ss[3 - (osub).ssorient] = (subseg) vertexptr
#define mark(osub)   (* (int *) ((osub).ss + 6))
#define setmark(osub, value)   * (int *) ((osub).ss + 6) = value
#define sbond(osub1, osub2)
#define sdissolve(osub)   (osub).ss[(osub).ssorient] = (subseg) m->dummysub
#define subsegcopy(osub1, osub2)
#define subsegequal(osub1, osub2)
#define deadsubseg(sub)   ((sub)[1] == (subseg) NULL)
#define killsubseg(sub)
#define tspivot(otri, osub)
#define stpivot(osub, otri)
#define tsbond(otri, osub)
#define tsdissolve(otri)   (otri).tri[6 + (otri).orient] = (triangle) m->dummysub
#define stdissolve(osub)   (osub).ss[4 + (osub).ssorient] = (subseg) m->dummytri
#define vertexmark(vx)   ((int *) (vx))[m->vertexmarkindex]
#define setvertexmark(vx, value)   ((int *) (vx))[m->vertexmarkindex] = value
#define vertextype(vx)   ((int *) (vx))[m->vertexmarkindex + 1]
#define setvertextype(vx, value)   ((int *) (vx))[m->vertexmarkindex + 1] = value
#define vertex2tri(vx)   ((triangle *) (vx))[m->vertex2triindex]
#define setvertex2tri(vx, value)   ((triangle *) (vx))[m->vertex2triindex] = value
#define STARTINDEX   1
#define Absolute(a)   ((a) >= 0.0 ? (a) : -(a))
#define Fast_Two_Sum_Tail(a, b, x, y)
#define Fast_Two_Sum(a, b, x, y)
#define Two_Sum_Tail(a, b, x, y)
#define Two_Sum(a, b, x, y)
#define Two_Diff_Tail(a, b, x, y)
#define Two_Diff(a, b, x, y)
#define Split(a, ahi, alo)
#define Two_Product_Tail(a, b, x, y)
#define Two_Product(a, b, x, y)
#define Two_Product_Presplit(a, b, bhi, blo, x, y)
#define Square_Tail(a, x, y)
#define Square(a, x, y)
#define Two_One_Sum(a1, a0, b, x2, x1, x0)
#define Two_One_Diff(a1, a0, b, x2, x1, x0)
#define Two_Two_Sum(a1, a0, b1, b0, x3, x2, x1, x0)
#define Two_Two_Diff(a1, a0, b1, b0, x3, x2, x1, x0)
#define Two_One_Product(a1, a0, b, x3, x2, x1, x0)

Typdefinitionen

typedef REAL ** triangle
typedef REAL ** subseg
typedef REAL * vertex

Aufzählungen

enum  wordtype { POINTER, FLOATINGPOINT }
enum  locateresult { INTRIANGLE, ONEDGE, ONVERTEX, OUTSIDE }
enum  insertvertexresult { SUCCESSFULVERTEX, ENCROACHINGVERTEX, VIOLATINGVERTEX, DUPLICATEVERTEX }
enum  finddirectionresult { WITHIN, LEFTCOLLINEAR, RIGHTCOLLINEAR }

Funktionen

char * readline ()
char * findfield ()
int triunsuitable (triorg, tridest, triapex, area) vertex triorg

Variablen

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
int plus1mod3 [3] = {1, 2, 0}
int minus1mod3 [3] = {2, 0, 1}
vertex tridest
vertex triapex
REAL area
char ** argv
behaviorb
otrit
osubs
int bytecount
int itemcount
enum wordtype wtype
int alignment
VOID * dyingitem
int trianglewords
int subsegwords
triangledyingtriangle
subsegdyingsubseg
vertex dyingvertex
badsubsegdyingseg
int number
otrinewotri
osubnewsubseg
REAL * e
int flen
REAL * f
REAL * h
vertex pb
vertex pc
REAL detsum
vertex pa
vertex pd
REAL permanent
REAL aheight
REAL bheight
REAL cheight
REAL dheight
vertex torg
vertex tdest
vertex tapex
vertex circumcenter
REAL * xi
REAL * eta
REAL * minedge
badtriangbadtri
otrienqtri
REAL angle
vertex enqapex
vertex enqorg
vertex enqdest
osubtestsubseg
REAL iradius
otritesttri
vertex searchpoint
otrisearchtri
int stopatsubsegment
otritri
int subsegmark
otriflipedge
vertex newvertex
osubsplitseg
int segmentflaws
int triflaws
otrifirstedge
otrilastedge
int edgecount
int doflip
otrideltri
int arraysize
int median
int axis
otrifarleft
otriinnerleft
otriinnerright
otrifarright
vertexsortarray
int vertices
otristartghost
int heapsize
eventnewevent
int eventnum
event *** eventheap
event ** events
event ** freeevents
otrifronttri
vertex newsite
REAL ccwabc
splaynodesplaytree
splaynodesplayroot
otrinewkey
REAL topy
otribottommost
vertex searchvertex
char * elefilename
char * areafilename
char * polyfilename
FILE * polyfile
otrisplittri
osubsplitsubseg
vertex endpoint2
int newmark
vertex endpoint1
otrifixuptri
int leftside
otristarttri
REAL attribute
REAL * holelist
int holes
REAL * regionlist
int regions
FILE * infile
char * infilename
char * nodefilename
REAL ** hlist
REAL ** rlist
int argc
char * edgefilename
char * vnodefilename
char * vedgefilename
char * neighborfilename
char * offfilename

Makro-Dokumentation

#define Absolute  )     ((a) >= 0.0 ? (a) : -(a))
 

#define apex otri,
vertexptr   )     vertexptr = (vertex) (otri).tri[(otri).orient + 3]
 

#define areabound otri   )     ((REAL *) (otri).tri)[m->areaboundindex]
 

#define BADSUBSEGPERBLOCK   252
 

#define BADTRIPERBLOCK   4092
 

#define bond otri1,
otri2   ) 
 

Wert:

(otri1).tri[(otri1).orient] = encode(otri2);                                \
  (otri2).tri[(otri2).orient] = encode(otri1)

#define deadsubseg sub   )     ((sub)[1] == (subseg) NULL)
 

#define deadtri tria   )     ((tria)[1] == (triangle) NULL)
 

#define DEADVERTEX   -32768
 

#define decode ptr,
otri   ) 
 

Wert:

(otri).orient = (int) ((unsigned long) (ptr) & (unsigned long) 3l);         \
  (otri).tri = (triangle *)                                                   \
                  ((unsigned long) (ptr) ^ (unsigned long) (otri).orient)

#define dest otri,
vertexptr   )     vertexptr = (vertex) (otri).tri[minus1mod3[(otri).orient] + 3]
 

#define dissolve otri   )     (otri).tri[(otri).orient] = (triangle) m->dummytri
 

#define dnext otri1,
otri2   ) 
 

Wert:

sym(otri1, otri2);                                                          \
  lprevself(otri2);

#define dnextself otri   ) 
 

Wert:

#define dprev otri1,
otri2   ) 
 

Wert:

lnext(otri1, otri2);                                                        \
  symself(otri2);

#define dprevself otri   ) 
 

Wert:

#define elemattribute otri,
attnum   )     ((REAL *) (otri).tri)[m->elemattribindex + (attnum)]
 

#define encode otri   )     (triangle) ((unsigned long) (otri).tri | (unsigned long) (otri).orient)
 

#define Fast_Two_Sum a,
b,
x,
 ) 
 

Wert:

x = (REAL) (a + b); \
  Fast_Two_Sum_Tail(a, b, x, y)

#define Fast_Two_Sum_Tail a,
b,
x,
 ) 
 

Wert:

bvirt = x - a; \
  y = b - bvirt

#define FILENAMESIZE   512
 

#define FLIPSTACKERPERBLOCK   252
 

#define FREEVERTEX   2
 

#define INEXACT
 

#define infect otri   ) 
 

Wert:

(otri).tri[6] = (triangle)                                                  \
                    ((unsigned long) (otri).tri[6] | (unsigned long) 2l)

#define infected otri   )     (((unsigned long) (otri).tri[6] & (unsigned long) 2l) != 0l)
 

#define INPUTLINESIZE   512
 

#define INPUTVERTEX   0
 

#define killsubseg sub   ) 
 

Wert:

(sub)[1] = (subseg) NULL;                                                   \
  (sub)[2] = (subseg) NULL

#define killtri tria   ) 
 

Wert:

(tria)[1] = (triangle) NULL;                                                \
  (tria)[3] = (triangle) NULL

#define lnext otri1,
otri2   ) 
 

Wert:

(otri2).tri = (otri1).tri;                                                  \
  (otri2).orient = plus1mod3[(otri1).orient]

#define lnextself otri   )     (otri).orient = plus1mod3[(otri).orient]
 

#define lprev otri1,
otri2   ) 
 

Wert:

(otri2).tri = (otri1).tri;                                                  \
  (otri2).orient = minus1mod3[(otri1).orient]

#define lprevself otri   )     (otri).orient = minus1mod3[(otri).orient]
 

#define mark osub   )     (* (int *) ((osub).ss + 6))
 

#define ONETHIRD   0.333333333333333333333333333333333333333333333333333333333333
 

#define onext otri1,
otri2   ) 
 

Wert:

lprev(otri1, otri2);                                                        \
  symself(otri2);

#define onextself otri   ) 
 

Wert:

#define oprev otri1,
otri2   ) 
 

Wert:

sym(otri1, otri2);                                                          \
  lnextself(otri2);

#define oprevself otri   ) 
 

Wert:

#define org otri,
vertexptr   )     vertexptr = (vertex) (otri).tri[plus1mod3[(otri).orient] + 3]
 

#define otricopy otri1,
otri2   ) 
 

Wert:

(otri2).tri = (otri1).tri;                                                  \
  (otri2).orient = (otri1).orient

#define otriequal otri1,
otri2   ) 
 

Wert:

(((otri1).tri == (otri2).tri) &&                                            \
   ((otri1).orient == (otri2).orient))

#define PI   3.141592653589793238462643383279502884197169399375105820974944592308
 

#define REAL   double
 

#define rnext otri1,
otri2   ) 
 

Wert:

sym(otri1, otri2);                                                          \
  lnextself(otri2);                                                           \
  symself(otri2);

#define rnextself otri   ) 
 

Wert:

#define rprev otri1,
otri2   ) 
 

Wert:

sym(otri1, otri2);                                                          \
  lprevself(otri2);                                                           \
  symself(otri2);

#define rprevself otri   ) 
 

Wert:

#define SAMPLEFACTOR   11
 

#define SAMPLERATE   10
 

#define sbond osub1,
osub2   ) 
 

Wert:

(osub1).ss[(osub1).ssorient] = sencode(osub2);                              \
  (osub2).ss[(osub2).ssorient] = sencode(osub1)

#define sdecode sptr,
osub   ) 
 

Wert:

(osub).ssorient = (int) ((unsigned long) (sptr) & (unsigned long) 1l);      \
  (osub).ss = (subseg *)                                                      \
              ((unsigned long) (sptr) & ~ (unsigned long) 3l)

#define sdest osub,
vertexptr   )     vertexptr = (vertex) (osub).ss[3 - (osub).ssorient]
 

#define sdissolve osub   )     (osub).ss[(osub).ssorient] = (subseg) m->dummysub
 

#define SEGMENTVERTEX   1
 

#define sencode osub   )     (subseg) ((unsigned long) (osub).ss | (unsigned long) (osub).ssorient)
 

#define setapex otri,
vertexptr   )     (otri).tri[(otri).orient + 3] = (triangle) vertexptr
 

#define setareabound otri,
value   )     ((REAL *) (otri).tri)[m->areaboundindex] = value
 

#define setdest otri,
vertexptr   )     (otri).tri[minus1mod3[(otri).orient] + 3] = (triangle) vertexptr
 

#define setelemattribute otri,
attnum,
value   )     ((REAL *) (otri).tri)[m->elemattribindex + (attnum)] = value
 

#define setmark osub,
value   )     * (int *) ((osub).ss + 6) = value
 

#define setorg otri,
vertexptr   )     (otri).tri[plus1mod3[(otri).orient] + 3] = (triangle) vertexptr
 

#define setsdest osub,
vertexptr   )     (osub).ss[3 - (osub).ssorient] = (subseg) vertexptr
 

#define setsorg osub,
vertexptr   )     (osub).ss[2 + (osub).ssorient] = (subseg) vertexptr
 

#define setvertex2tri vx,
value   )     ((triangle *) (vx))[m->vertex2triindex] = value
 

#define setvertexmark vx,
value   )     ((int *) (vx))[m->vertexmarkindex] = value
 

#define setvertextype vx,
value   )     ((int *) (vx))[m->vertexmarkindex + 1] = value
 

#define snext osub1,
osub2   ) 
 

Wert:

sptr = (osub1).ss[1 - (osub1).ssorient];                                    \
  sdecode(sptr, osub2)

#define snextself osub   ) 
 

Wert:

sptr = (osub).ss[1 - (osub).ssorient];                                      \
  sdecode(sptr, osub)

#define sorg osub,
vertexptr   )     vertexptr = (vertex) (osub).ss[2 + (osub).ssorient]
 

#define spivot osub1,
osub2   ) 
 

Wert:

sptr = (osub1).ss[(osub1).ssorient];                                        \
  sdecode(sptr, osub2)

#define spivotself osub   ) 
 

Wert:

sptr = (osub).ss[(osub).ssorient];                                          \
  sdecode(sptr, osub)

#define SPLAYNODEPERBLOCK   508
 

#define Split a,
ahi,
alo   ) 
 

Wert:

c = (REAL) (splitter * a); \
  abig = (REAL) (c - a); \
  ahi = c - abig; \
  alo = a - ahi

#define Square a,
x,
 ) 
 

Wert:

x = (REAL) (a * a); \
  Square_Tail(a, x, y)

#define Square_Tail a,
x,
 ) 
 

Wert:

Split(a, ahi, alo); \
  err1 = x - (ahi * ahi); \
  err3 = err1 - ((ahi + ahi) * alo); \
  y = (alo * alo) - err3

#define SQUAREROOTTWO   1.4142135623730950488016887242096980785696718753769480732
 

#define ssym osub1,
osub2   ) 
 

Wert:

(osub2).ss = (osub1).ss;                                                    \
  (osub2).ssorient = 1 - (osub1).ssorient

#define ssymself osub   )     (osub).ssorient = 1 - (osub).ssorient
 

#define STARTINDEX   1
 

#define stdissolve osub   )     (osub).ss[4 + (osub).ssorient] = (subseg) m->dummytri
 

#define stpivot osub,
otri   ) 
 

Wert:

ptr = (triangle) (osub).ss[4 + (osub).ssorient];                            \
  decode(ptr, otri)

#define subsegcopy osub1,
osub2   ) 
 

Wert:

(osub2).ss = (osub1).ss;                                                    \
  (osub2).ssorient = (osub1).ssorient

#define subsegequal osub1,
osub2   ) 
 

Wert:

(((osub1).ss == (osub2).ss) &&                                              \
   ((osub1).ssorient == (osub2).ssorient))

#define SUBSEGPERBLOCK   508
 

#define sym otri1,
otri2   ) 
 

Wert:

ptr = (otri1).tri[(otri1).orient];                                          \
  decode(ptr, otri2);

#define symself otri   ) 
 

Wert:

ptr = (otri).tri[(otri).orient];                                            \
  decode(ptr, otri);

#define TRIPERBLOCK   4092
 

#define tsbond otri,
osub   ) 
 

Wert:

(otri).tri[6 + (otri).orient] = (triangle) sencode(osub);                   \
  (osub).ss[4 + (osub).ssorient] = (subseg) encode(otri)

#define tsdissolve otri   )     (otri).tri[6 + (otri).orient] = (triangle) m->dummysub
 

#define tspivot otri,
osub   ) 
 

Wert:

sptr = (subseg) (otri).tri[6 + (otri).orient];                              \
  sdecode(sptr, osub)

#define Two_Diff a,
b,
x,
 ) 
 

Wert:

x = (REAL) (a - b); \
  Two_Diff_Tail(a, b, x, y)

#define Two_Diff_Tail a,
b,
x,
 ) 
 

Wert:

bvirt = (REAL) (a - x); \
  avirt = x + bvirt; \
  bround = bvirt - b; \
  around = a - avirt; \
  y = around + bround

#define Two_One_Diff a1,
a0,
b,
x2,
x1,
x0   ) 
 

Wert:

Two_Diff(a0, b , _i, x0); \
  Two_Sum( a1, _i, x2, x1)

#define Two_One_Product a1,
a0,
b,
x3,
x2,
x1,
x0   ) 
 

Wert:

Split(b, bhi, blo); \
  Two_Product_Presplit(a0, b, bhi, blo, _i, x0); \
  Two_Product_Presplit(a1, b, bhi, blo, _j, _0); \
  Two_Sum(_i, _0, _k, x1); \
  Fast_Two_Sum(_j, _k, x3, x2)

#define Two_One_Sum a1,
a0,
b,
x2,
x1,
x0   ) 
 

Wert:

Two_Sum(a0, b , _i, x0); \
  Two_Sum(a1, _i, x2, x1)

#define Two_Product a,
b,
x,
 ) 
 

Wert:

x = (REAL) (a * b); \
  Two_Product_Tail(a, b, x, y)

#define Two_Product_Presplit a,
b,
bhi,
blo,
x,
 ) 
 

Wert:

x = (REAL) (a * b); \
  Split(a, ahi, alo); \
  err1 = x - (ahi * bhi); \
  err2 = err1 - (alo * bhi); \
  err3 = err2 - (ahi * blo); \
  y = (alo * blo) - err3

#define Two_Product_Tail a,
b,
x,
 ) 
 

Wert:

Split(a, ahi, alo); \
  Split(b, bhi, blo); \
  err1 = x - (ahi * bhi); \
  err2 = err1 - (alo * bhi); \
  err3 = err2 - (ahi * blo); \
  y = (alo * blo) - err3

#define Two_Sum a,
b,
x,
 ) 
 

Wert:

x = (REAL) (a + b); \
  Two_Sum_Tail(a, b, x, y)

#define Two_Sum_Tail a,
b,
x,
 ) 
 

Wert:

bvirt = (REAL) (x - a); \
  avirt = x - bvirt; \
  bround = b - bvirt; \
  around = a - avirt; \
  y = around + bround

#define Two_Two_Diff a1,
a0,
b1,
b0,
x3,
x2,
x1,
x0   ) 
 

Wert:

Two_One_Diff(a1, a0, b0, _j, _0, x0); \
  Two_One_Diff(_j, _0, b1, x3, x2, x1)

#define Two_Two_Sum a1,
a0,
b1,
b0,
x3,
x2,
x1,
x0   ) 
 

Wert:

Two_One_Sum(a1, a0, b0, _j, _0, x0); \
  Two_One_Sum(_j, _0, b1, x3, x2, x1)

#define UNDEADVERTEX   -32767
 

#define uninfect otri   ) 
 

Wert:

(otri).tri[6] = (triangle)                                                  \
                    ((unsigned long) (otri).tri[6] & ~ (unsigned long) 2l)

#define vertex2tri vx   )     ((triangle *) (vx))[m->vertex2triindex]
 

#define vertexmark vx   )     ((int *) (vx))[m->vertexmarkindex]
 

#define VERTEXPERBLOCK   4092
 

#define vertextype vx   )     ((int *) (vx))[m->vertexmarkindex + 1]
 

#define VIRUSPERBLOCK   1020
 

#define VOID   void
 


Dokumentation der benutzerdefinierten Typen

typedef REAL** subseg
 

typedef REAL** triangle
 

typedef REAL* vertex
 


Dokumentation der Aufzählungstypen

enum finddirectionresult
 

Aufzählungswerte:
WITHIN 
LEFTCOLLINEAR 
RIGHTCOLLINEAR 

enum insertvertexresult
 

Aufzählungswerte:
SUCCESSFULVERTEX 
ENCROACHINGVERTEX 
VIOLATINGVERTEX 
DUPLICATEVERTEX 

enum locateresult
 

Aufzählungswerte:
INTRIANGLE 
ONEDGE 
ONVERTEX 
OUTSIDE 

enum wordtype
 

Aufzählungswerte:
POINTER 
FLOATINGPOINT 


Dokumentation der Funktionen

char* findfield  ) 
 

char* readline  ) 
 

int triunsuitable triorg  ,
tridest  ,
triapex  ,
area 
 


Variablen-Dokumentation

REAL aheight
 

int alignment
 

REAL angle
 

REAL area
 

char* areafilename
 

int argc
 

char ** argv
 

int arraysize
 

REAL attribute
 

int axis
 

struct behavior * b
 

struct badtriang * badtri
 

REAL bheight
 

struct otri* bottommost
 

int bytecount
 

REAL ccwabc
 

REAL ccwerrboundA
 

REAL ccwerrboundB
 

REAL ccwerrboundC
 

REAL cheight
 

vertex circumcenter
 

struct otri* deltri
 

REAL detsum
 

REAL dheight
 

int doflip
 

VOID* dyingitem
 

struct badsubseg* dyingseg
 

subseg* dyingsubseg
 

triangle* dyingtriangle
 

vertex dyingvertex
 

REAL * e
 

int edgecount
 

char* edgefilename
 

char * elefilename
 

vertex endpoint1
 

vertex endpoint2
 

vertex enqapex
 

vertex enqdest
 

vertex enqorg
 

struct otri* enqtri
 

REAL epsilon
 

REAL* eta
 

struct event ** eventheap
 

int eventnum
 

struct event** events
 

REAL* f
 

struct otri * farleft
 

int * farright
 

struct otri* firstedge
 

struct otri* fixuptri
 

int flen
 

struct otri * flipedge
 

struct event ** freeevents
 

struct otri* fronttri
 

REAL * h
 

int * heapsize
 

REAL** hlist
 

REAL * holelist
 

int holes
 

REAL iccerrboundA
 

REAL iccerrboundB
 

REAL iccerrboundC
 

FILE* infile
 

char* infilename
 

struct otri* innerleft
 

struct otri* innerright
 

REAL iradius
 

int itemcount
 

struct otri* lastedge
 

int leftside
 

int median
 

REAL* minedge
 

int minus1mod3[3] = {2, 0, 1}
 

char* neighborfilename
 

struct event* newevent
 

struct otri * newkey
 

int newmark
 

struct otri* newotri
 

vertex newsite
 

struct osub* newsubseg
 

vertex newvertex
 

char * nodefilename
 

int number
 

REAL o3derrboundA
 

REAL o3derrboundB
 

REAL o3derrboundC
 

char* offfilename
 

vertex pa
 

vertex pb
 

vertex pc
 

vertex pd
 

REAL permanent
 

int plus1mod3[3] = {1, 2, 0}
 

FILE * polyfile
 

char * polyfilename
 

unsigned long randomseed
 

REAL * regionlist
 

int regions
 

REAL resulterrbound
 

REAL** rlist
 

struct osub* s
 

vertex searchpoint
 

struct otri * searchtri
 

vertex searchvertex
 

int segmentflaws
 

vertex* sortarray
 

struct splaynode * splayroot
 

struct splaynode* splaytree
 

struct osub* splitseg
 

struct osub* splitsubseg
 

REAL splitter
 

struct otri* splittri
 

struct otri* startghost
 

struct otri* starttri
 

int stopatsubsegment
 

int subsegmark
 

int subsegwords
 

struct otri* t
 

vertex tapex
 

vertex tdest
 

struct osub* testsubseg
 

struct otri* testtri
 

REAL topy
 

vertex torg
 

struct otri* tri
 

int trianglewords
 

vertex triapex
 

vertex tridest
 

int triflaws
 

char* vedgefilename
 

int vertices
 

char* vnodefilename
 

enum wordtype wtype
 

REAL* xi
 


Erzeugt am Wed Apr 19 00:18:33 2006 für Quinview von  doxygen 1.4.4