HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
GU_PolyDelaunay.h
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * NAME: GU_PolyDelaunay.h
7  *
8  */
9 
10 #ifndef __GU_PolyDelaunay_h__
11 #define __GU_PolyDelaunay_h__
12 
13 #include "GU_API.h"
14 #include <UT/UT_FastRandom.h>
16 #include <UT/UT_StringStream.h>
17 
18 #include <GEO/GEO_HedgeInterface.h>
19 
20 #define DELAUNAY_TINY_AREA_TOLERANCE (std::numeric_limits<fpreal>::min())
21 
22 class GU_Detail;
23 class GA_EdgeGroup;
24 class GA_PrimitiveGroup;
25 class GA_PointGroup;
26 
27 
28 /// Delaunay triangulation (and refinement) of a set of 2D points.
29 ///
30 /// The Delaunay triangulation algorithm used is the randomized incremental
31 /// algorithm, as presented in
32 /// de Berg, van Kreveld, Overmars and Schwarzkopf.
33 /// "Computational Geometry", 2nd edition, 1999,
34 /// in turn adapated from:
35 /// Guibas, Knuth and Sharir. "Randomized incremental construction of
36 /// Delaunay and Voronoi diagrams." Algorithmica, 7:381-413, 1992.
37 ///
38 /// Most ideas are present in the earlier paper:
39 /// Guibas and Stolfi. "Primitives for the Manipulation of General
40 /// Subdivisions and the Computation of Voronoi Diagrams", ACM Transactions
41 /// on Graphics, 4(2):74-123, April 1985.
42 /// except for the point location DAG.
43 ///
44 /// Constraint enforcement is done through removal of edges that intersect
45 /// constraints and retriangulating the resulting poligons. The code closely
46 /// follows the appraoch of Shewchuk in his Triangle package.
47 ///
48 /// After triangulation is complete, an optional Delaunay refinement
49 /// process is applied. This follows
50 /// Shewchuk. "Delaunay Refinement Algorithms for Triangular Mesh
51 /// Generation". Computational Geometry: Theory and Applications
52 /// 22(1-3):21-74, May 2002.
53 /// http://www.cs.berkeley.edu/~jrs/papers/2dj.ps
54 ///
55 /// A good resource for quick lookup is Shewchuk's presentation slides on
56 /// this subject:
57 /// http://www.cs.berkeley.edu/~jrs/papers/imrtalk.pdf
58 ///
59 
61 {
62 public:
63 
64  /// Some local typedefs for our helper classes to avoid having to fully
65  /// qualify the names everywhere.
66 
67  explicit GU_PolyDelaunay(GU_Detail *gdp,
68  uint32 rand_seed = 5678U);
69 
70  virtual ~GU_PolyDelaunay();
71 
72  /// Set the plane where triangulation happens.
73  void setPlane(const UT_Vector3 &normal, fpreal distance);
74 
75  /// Fit a plane to the input points. Returns true if it succeeded.
76  bool fitPlane(const GA_PointGroup *ptgrp = 0,
77  UT_Vector3 *out_normal = 0,
78  fpreal *out_distance = 0,
79  UT_Vector3 *out_center = 0);
80 
82  { myRemoveDuplicatePoints = value; }
83 
84  /// This one is mostly here for debugging - if enabled, we don't
85  /// delete the bounding triangle that's added during construction.
87  { myKeepBoundingTriangle = value; }
88 
90  {
91  REMOVE_NONE = 0,
93  REMOVE_IF_OUT_BUT_NOT_IN
94  };
95 
97  { myRemoveFromConvexHull = value; }
98 
99  /// If enabled, delete all edges that are outside the constrained
100  /// edges.
101  void setRemoveOutside(bool value,
102  bool skip_if_also_inside = false);
103 
104 
105  /// Allow new points - e.g., constraint edges are split to maintain
106  /// the Delaunay property.
108  { myCanSplitConstraints = enabled; }
109 
110  // if the new point group is set by setConstraintNewPointGroup, then
111  // setting the group name is ignored
113  { myConstraintNewPointGroupName.harden(name); }
114 
116  { myConstraintNewPointGroup = new_pt_grp; }
117 
118  /// Allow refinement.
120  { myDoRefinement = enabled; }
121 
122  /// Cap the maximum allowed number of new ponts
123  void setMaxNewPoints(int maxNewPoints)
124  { myMaxNewPoints = maxNewPoints; }
125 
126  /// Whether to keep the triangulation on the projection plane or
127  /// backproject it back to the original point positions
129  { myRestorePositions = val; }
130 
131  /// Set refinement maximum area criterion. Any triangle with larger area
132  /// than this is subdivided. To disable, set to <= 0.0.
133  void setMaxArea(fpreal max_area);
134 
135  /// Set refinement minmum angle. Any triangle with an angle less than
136  /// this is subdivided (modulo satisfying Miller-Pav-Walkington rule)
137  /// The argument angle is in radians. To disable this test, set to <= 0.0.
138  ///
139  /// IMPORTANT: Large minimum angle values drive the refinement to infinity,
140  /// or until the maximum allowed number of points is reached. If minimum
141  /// required angle is <= 21 degrees, the algorithm provably terminates.
142  /// In practice, the algorithm almost always terminates for minimum
143  /// angles of up to about 33 degrees. Beyond that, the algorithm almost
144  /// surely goes on for ever or until it hits the set limit.
145  void setMinAngle(fpreal min_angle);
146  void setMinEdgeLength(fpreal min_edge_length);
147 
148  /// Perform the triangulation
149  void triangulate(const GA_PointGroup *point_group,
150  const GA_PrimitiveGroup *constraint_prims,
151  const GA_EdgeGroup *constraint_edges);
152 
153  void copyTriangles(bool updatePointNormals = true,
154  GA_PrimitiveGroup *out_grp = NULL);
155 
157  { return myWarningMessage.str().toStdString(); }
158 
159  void getBoundingSquareCorners(UT_Vector3 *corners);
160  bool setPositionAttribute(const char *attrib);
161 
162  void getProjectedConstrainedEdges(
163  UT_Array<UT_Vector3> &endpoints);
164 
165  void getEnforcedEdges(GA_EdgeGroup &edge_group);
166 
167  /// Query whether or not the triangulation consolidated some duplicate
168  /// points.
170  { return myDuplicateMap.size() != 0; }
171 
172  /// Query how the triangulation consolidated duplicate points.
173  void getDuplicatePointMapForInput(
174  UT_Map<GA_Offset, GA_Offset> &map) const;
175 
176 private:
177 
178  typedef UT_Array<GEO_Hedge> GEO_HedgeArray;
179 
180  bool verifyMarks();
181 
182  template <class T>
183  struct MultiQueue
184  {
185  MultiQueue(int num_queues = 1, int rand_seed = -1, int init_size = -1);
186  void append(const T &t, int queue_idx = 0);
187  T pick();
188  int entries() { return myEntries; }
189  public:
190  typedef UT_Array<T> SingleQueue;
191 
192  int myPickQueueIdx;
193  int myEntries;
194  bool myShuffle;
195  UT_Array<SingleQueue> myQueues;
196  UT_FastRandom myRand;
197  };
198 
199  struct PinnedEdge
200  {
201  PinnedEdge(GEO_Hedge e, GA_Offset src, GA_Offset dst) :
202  myHedge(e), mySrc(src), myDst(dst) {}
203  GEO_Hedge myHedge;
204  GA_Offset mySrc;
205  GA_Offset myDst;
206  };
207 
208  PinnedEdge pinEdge(GEO_Hedge e);
209  bool isPresent(PinnedEdge &se);
210 
211  struct PinnedFace
212  {
213  PinnedFace(GA_Offset face, GA_Offset p0, GA_Offset p1, GA_Offset p2) :
214  myFace(face), myP0(p0), myP1(p1), myP2(p2) {}
215 
216  GA_Offset myFace;
217  GA_Offset myP0;
218  GA_Offset myP1;
219  GA_Offset myP2;
220 
221  bool operator==(const PinnedFace &other)
222  {
223  return myFace == other.myFace &&
224  ((myP0 == other.myP0 && myP1 == other.myP1 &&
225  myP2 == other.myP2) ||
226  (myP0 == other.myP1 && myP1 == other.myP2 &&
227  myP2 == other.myP0) ||
228  (myP0 == other.myP2 && myP1 == other.myP0 &&
229  myP2 == other.myP1));
230  }
231  };
232 
233  PinnedFace pinFace(GA_Offset face);
234  bool isPresent(PinnedFace &sf);
235 
236  typedef MultiQueue<PinnedEdge> EdgeQueue;
237  typedef MultiQueue<PinnedFace> FaceQueue;
238 
239  // Container class used for the set of constrained edges
240  // Each element is a pair of point offsets (possibly with an optional
241  // primitive (used for removing holes) if it is a boundary edge
242  struct Constraint
243  {
244  Constraint(const GA_Edge &e, bool h) { edge = e; is_boundary = h; }
245 
246  GA_Edge edge;
247  bool is_boundary;
248  };
249 
250  struct LocatorNode
251  {
252  enum
253  {
254  NSUCCESSORS = 3
255  };
256  // associated mesh face; 0 for sinks and deleted faces.
257  GA_Offset myFaceOffset;
258  GA_Offset myPointOffset[3]; // 3 points of the covered triangle
259  int myRefCount; // number of nodes pointing to this
260  int mySuccessors[NSUCCESSORS]; // non-NULLs at the start
261  int myParent; // one of immediate ancestors
262  };
263 
264 
265  // Methods to manipulate the Point Location DAG:
266  int newLocatorNode();
267  void freeLocatorNode(int idx);
268  void attachLocatorNodeToFace(int idx, GA_Offset faceoff);
269  void detachLocatorNodeFromFace(int idx);
270  void setLocatorNodeSuccessors(int idx, int s1, int s2,
271  int s3);
272 
273  void splitLocatorNode(int idx, GA_Offset f0, GA_Offset f1,
275 
276  UT_Vector3 signedDistance(const UT_Vector2 &pos, int node_idx);
277 
278  inline UT_Vector2 barycentricCoordinates(const UT_Vector2 &x,
279  UT_Vector2 &a, UT_Vector2 &b);
280 
281  inline UT_Vector3 barycentricCoordinates(const UT_Vector2 &x,
282  GA_Offset faceoff, GA_Offset &aoff,
283  GA_Offset &boff, GA_Offset &coff);
284 
285  GA_Offset resolveDuplicate(GA_Offset ptoff);
286  GA_Edge resolveDuplicate(GA_Edge edge);
287  void mapDuplicate(GA_Offset frompt, GA_Offset topt);
288 
289  /// Project 3D point onto plane.
290  UT_Vector2 make2D(const UT_Vector3 &pos) const;
291  UT_Vector3 make3D(const UT_Vector2 &pos) const;
292 
293  inline GA_Offset getConcentricShellCenter(GA_Offset p);
294  inline void setConcentricShellCenter(GA_Offset p, GA_Offset c);
295 
296  inline int getLocatorNodeIndex(GA_Offset faceoff);
297 
298  /// Find a leaf node with a triangle that encloses the given point.
299  /// Returns the node, and if the point falls on an edge or a vertex of the
300  /// triangle, returns those as well.
301 
302  GA_Offset locateUsingLocatorDAG(const UT_Vector2 &pos,
303  GEO_Hedge &on_edge, GA_Offset &on_point);
304 
305  int locateInSuccessors(int dnode_idx,
306  const UT_Vector2 &pos, UT_Vector3 &sd);
307 
308  GA_Offset locateByWalking(const UT_Vector2 &searchpoint,
309  GA_Offset searchface, GEO_Hedge &on_edge,
310  GA_Offset &on_point);
311 
312 
313  inline fpreal counterclockwise(const UT_Vector2 &a,
314  const UT_Vector2 &b, const UT_Vector2 &c)
315  { return UT_GeometryPredicate::orient2d(b, a, c); }
316 
317  inline fpreal counterclockwise( GA_Offset pa, GA_Offset pb,
318  GA_Offset pc);
319 
320  inline fpreal incircle(GA_Offset pa, GA_Offset pb, GA_Offset pc,
321  GA_Offset pd);
322 
323  fpreal exactDot(const UT_Vector2 &u, const UT_Vector2 &v);
324 
325  UT_Vector2 circumcenter(GA_Offset pa, GA_Offset pb, GA_Offset pc);
326 
327 
328  GA_Offset appendPoint();
329  void deletePoint(GA_Offset pt,
330  bool from_input_only = false);
331 
332  void removeFace(GA_Offset faceoff);
333 
334  // Subdivide an edge by inserting a new point along it and dividing
335  // the triangles on its two sides. The effect on input edge and the
336  // the returned edge are as in divideEdge(). If a valid ptoff is
337  // supplied the new point will have that offset and the corresponding
338  // index in myPointList. The faces to the left and right of e before
339  // splitting stay those the left and right of it afterwards.
340  GEO_Hedge splitEdge(GEO_Hedge e, fpreal bias,
341  GA_Offset ptoff = GA_INVALID_OFFSET);
342 
343  void collapseEdge(GEO_Hedge e);
344  GEO_Hedge findEdge(GA_Offset p0, GA_Offset p1);
345 
346  /// A journal of events during a point insertion. It is used to allow
347  /// the point insertion to be undone.
348  struct Journal
349  {
350  Journal() : myOldFace(GA_INVALID_OFFSET),
351  myOldEdge(GEO_INVALID_HEDGE), myNewEdge(GEO_INVALID_HEDGE),
352  myNewPoint(GA_INVALID_OFFSET), myRecording(false) {}
353 
354  void reset()
355  {
356  myOldFace = GA_INVALID_OFFSET;
357  myOldEdge = GEO_INVALID_HEDGE;
358  myNewEdge = GEO_INVALID_HEDGE;
359  myNewPoint = GA_INVALID_OFFSET;
360  myFlippedEdges.entries(0);
361  }
362 
363  void startRecording() { myRecording = true; }
364  void stopRecording() { myRecording = false; }
365  bool isRecording() { return myRecording; }
366 
367  GEO_HedgeArray myFlippedEdges;
368  GA_Offset myOldFace;
369  GEO_Hedge myOldEdge;
370  GEO_Hedge myNewEdge;
371  GA_Offset myNewPoint;
372  bool myRecording;
373  };
374 
375  bool maxNewPointsReached();
376 
377  GA_Offset inputDetailPoint(GA_Offset ptoff) const;
378  GA_Offset workDetailPoint(GA_Offset ptoff) const;
379 
380  GA_Offset importInputDetailPoint(GA_Offset inptoff);
381  GA_Offset exportWorkDetailPoint(GA_Offset ptoff);
382 
383  void importInputPoints(const GA_PointGroup *pts);
384  void importInputConstraints(const GA_PrimitiveGroup *prims,
385  const GA_EdgeGroup *constraint_edges);
386 
387  void insertInputPoints(const GA_PointGroup *point_group,
388  GA_PointGroup *duplicate_grp);
389 
390  void cleanUp(GA_PointGroup *duplicate_grp,
391  const GA_PrimitiveGroup *constraint_prims);
392 
393  /// Set up the bounding triangle, myGqd, and the locating DAG.
394  void setup();
395  void retireLocatorDAG();
396 
397  /// Set up my*Transform member variables from the plane
398  /// normal/distance.
399  void calcTransforms(const UT_Vector3 &normal,
400  fpreal distance);
401 
402  enum InsertStatus
403  {
404  INSERTED_IN_FACE, INSERTED_ON_EDGE, DUPLICATE, OUTSIDE
405  };
406 
407  GEO_Hedge insertOnEdge(GA_Offset pt, GEO_Hedge e);
408  void insertInFace(GA_Offset pt, GA_Offset f);
409 
410  /// Insert a new point into the existing triangulation.
411  InsertStatus insertPoint(GA_Offset ptoff,
412  GEO_Hedge on_edge = GEO_INVALID_HEDGE,
413  bool delaunize = true,
414  GEO_Hedge *out_edge = NULL,
415  GA_Offset walk_from_face = GA_INVALID_OFFSET);
416 
417  /// Undo an insertion.
418  void undoInsertPoint();
419 
420  /// Flip a single edge. Does not update the point location data structure.
421  void flipEdge(GEO_Hedge edge);
422  void unflipEdge(GEO_Hedge edge);
423 
424  void delaunizePointLink(GA_Offset pt);
425 
426  /// Part of the core triangulation algorithm. Parameter point has just
427  /// been inserted, and edge is being tested to see if it's legal
428  /// according to the Delaunay criterion; if not, the edge is flipped
429  /// and we recurse.
430  void delaunizeEdge(GA_Offset point, GEO_Hedge edge);
431 
432  enum ConstraintStatus
433  {
434  ENFORCED, PENDING, BLOCKED
435  };
436 
437  void intersectConstraints(GEO_Hedge &esplit, GA_Offset p1);
438  int turnToFace(GEO_Hedge &esearch, GA_Offset p);
439  ConstraintStatus trackConstraint(GEO_Hedge &esearch, GA_Offset p1,
440  bool is_boundary);
441 
442  void delaunayFixup(GEO_Hedge efixup, bool leftside);
443  ConstraintStatus enforceConstraint(GEO_Hedge estart, GA_Offset p1,
444  bool is_boundary);
445 
446  void enforceInputConstraints();
447 
448  /// Remove the bounding triangle
449  void removeBoundingTriangle();
450  /// Remove outside edges that aren't in the given group.
451  void removeOutside();
452  /// Remove edges that are inside holes.
453  void removeHoles();
454 
455  void propagateGroup(GA_PrimitiveGroup *grp, GA_Offset face);
456  void propagateRemoved(GA_Offset face, bool is_seed = false);
457 
458  /// Insert new points to satisfy refinement criteria.
459  void refine();
460 
461  /// Test if a given face is "bad" - i.e., excessive area, or too small
462  /// an angle and add it to the bad triangles pile if so.
463  void testTriangle(GA_Offset face);
464 
465  // Test if a given edge is encroached and add it to the encroached edges
466  // pile if so.
467  void testEdge(GEO_Hedge edge, bool on_left_only = false);
468 
469  /// Test if the given edge is "encroached" - i.e., if a triangles on
470  /// some side has an obtuse angle opposite to the edge.
471  bool isEncroached(GEO_Hedge edge,
472  bool on_left_only = false);
473 
474  /// Insert a point to split an non/existing edge at the given fraction
475  /// along its length. Returns the edge along the old edge with origin
476  /// equal to its midpoint.
477  GEO_Hedge insertSplitPoint(GEO_Hedge on_edge, fpreal bias,
478  bool delaunize = true);
479 
480  /// Split an existing edge at somewhere-near-the-midpoint.
481  GEO_Hedge concentricShellSplit(GEO_Hedge edge);
482 
483  void splitEncroachedEdges(bool check_for_bad_faces);
484  void testLinkEdges(GA_Offset pt);
485  void testIncidentTriangles(GA_Offset pt);
486 
487  void markEnforced(GEO_Hedge edge, bool enforced = true);
488  bool isEnforced(GEO_Hedge edge);
489  void markBoundary(GEO_Hedge edge, bool boundary = true);
490  bool isBoundary(const GEO_Hedge edge);
491 
492  bool isBoundingTrianglePoint(GA_Offset ptoff);
493  bool isBoundingTriangleHedge(GEO_Hedge edge);
494 
495  void remove(GA_Offset primoff);
496  bool isRemoved(GA_Offset primoff);
497 
498  void markInputPoint(GA_Offset ptoff);
499  bool isInputPoint(GA_Offset ptoff);
500  void markFirstSplit(GA_Offset ptoff);
501  bool isFirstSplit(GA_Offset ptoff);
502 
503  // Some notation simplification
504 
505  inline GA_Offset src(GEO_Hedge e) const
506  { return myHi->srcPoint(e); }
507 
508  inline GA_Offset dst(GEO_Hedge e) const
509  { return myHi->dstPoint(e); }
510 
511  inline GA_Offset apx(GEO_Hedge e) const
512  { return myHi->preSrcPoint(e); }
513 
514  inline GEO_Hedge sym(GEO_Hedge e) const
515  { return myHi->nextEquivalentHedge(e); }
516 
517  inline GEO_Hedge lnext(GEO_Hedge e) const
518  { return myHi->lnext(e); }
519 
520  inline GEO_Hedge onext(GEO_Hedge e) const
521  { return myHi->onext(e); }
522 
523  inline GEO_Hedge lprev(GEO_Hedge e) const
524  { return myHi->lprev(e); }
525 
526  inline GEO_Hedge oprev(GEO_Hedge e) const
527  { return myHi->oprev(e); }
528 
529  inline UT_Vector2 getPos2(GA_Offset ptoff) const
530  { return myPos2.get(ptoff); }
531 
532  inline bool isValid(GEO_Hedge e) const
533  { return myHi->isValidHedge(e); }
534 
535  inline bool isPrimary(GEO_Hedge e) const
536  { return myHi->isPrimary(e); }
537 
539  GA_Offset right(GEO_Hedge e);
540  GEO_Hedge hedge(GA_Offset faceoff);
541 
542 
543  typedef UT_Array<Constraint> ConstraintArray;
544  typedef UT_Map<GA_Offset, GA_Offset> OffsetMap;
545 
546  // Locator DAG
547  typedef UT_Array<LocatorNode> LocatorNodeArray;
548 
549  LocatorNodeArray myLocatorNodes;
550  UT_IntArray myLocatorNodesFreeIndices;
551  int myLocatorRootIndex;
552 
553  // Transform matrices between 2d and 3d
554  UT_Matrix4 my3to2Transform;
555  UT_Matrix4 my2to3Transform;
556 
557  // Flags
558  bool myHasClosedConstraints: 1;
559  bool myHasConflictingConstraints: 1;
560  bool myCanSplitConstraints: 1;
561  bool myRestorePositions: 1;
562  bool myDoRefinement: 1;
563  bool myRemoveDuplicatePoints: 1;
564  bool myKeepBoundingTriangle: 1;
565  bool myMapDuplicates: 1;
566  bool myWrangleAttributes: 1;
567 
568 
569  bool myRemoveFromConvexHull;
570  RemoveOutsidePolicy myRemoveOutsidePolicy;
571 
572  int myMaxNewPoints;
573  int myNumNewPoints;
574  fpreal myMinEdgeLengthSqr;
575  fpreal myMaxArea, myMaxAngleCosSqr;
576 
577 
578  UT_String myConstraintNewPointGroupName;
579 
580  GU_Detail *mySrcGdp;
581  GU_Detail *myGdp;
582  GEO_HedgeInterface *myHi;
583  GA_PointWrangler *myWrangler;
584 
585  bool myUsePos2Attrib;
586  UT_String myPos2AttribName;
587  GA_RWHandleV2 myPos2;
588 
589  ConstraintArray myInputConstraints;
590  OffsetMap myDuplicateMap;
591 
592  // Points and hedges of the bounding triangle
593  GA_Offset myBoundingTrianglePoints[3];
594  GEO_Hedge myBoundingTriangleHedges[3];
595 
596  // 3d positions of the bounding square (to help draw guide)
597  UT_Vector3 myBoundingSquareCorners[4];
598 
599  // Point group accumulating constraint split points
600  GA_PointGroup *myConstraintNewPointGroup;
601 
602  // Journal for tracking changes during the last insertion to allow undo
603  Journal myJournal;
604 
605  EdgeQueue myEncroachedEdges;
606  FaceQueue myBadTriangles;
607 
608  int myRandSeed;
609 
610  UT_StringStream myWarningMessage;
611 
612  fpreal myTollerance;
613 
614  GA_VertexGroup *myEnforcedHedges;
615  GA_VertexGroup *myBoundaryHedges;
616 
617  GA_PrimitiveGroup *myRemovedFaces;
618 
619  GA_PointGroup *myInputPoints;
620  GA_PointGroup *myFirstSplitPoints;
621 
622  GA_RWHandleI myShellCenter;
623  GA_RWHandleI myLocatorIndex;
624  GA_RWHandleI myInputDetailPoint;
625  GA_RWHandleI myWorkDetailPoint;
626 };
627 
628 #endif
png_voidp s1
Definition: png.h:2193
GLint left
Definition: glcorearb.h:2004
void setKeepBoundingTriangle(bool value)
const GLdouble * v
Definition: glcorearb.h:836
GLsizei const GLchar *const * string
Definition: glcorearb.h:813
GLboolean GLboolean GLboolean GLboolean a
Definition: glcorearb.h:1221
void setRestorePositions(bool val)
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glcorearb.h:2538
#define GEO_INVALID_HEDGE
An invalid hedge is sometimes returned if an operation is unsuccessful.
Definition: GEO_Hedge.h:32
#define GA_INVALID_OFFSET
Definition: GA_Types.h:654
void setRemoveFromConvexHull(bool value)
GA_Size GA_Offset
Definition: GA_Types.h:617
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
GLfloat f
Definition: glcorearb.h:1925
T distance(const UT_Vector4T< T > &v1, const UT_Vector4T< T > &v2)
Definition: UT_Vector4.h:634
GEO_Hedge encapsulates a half-edge (hedge) which is the restriction of.
Definition: GEO_Hedge.h:47
void enableRefinement(bool enabled)
Allow refinement.
An bi-directional stream object that owns its own string buffer storage.
void setRemoveDuplicatePoints(bool value)
bool hasNonEmptyDuplicatePointMap() const
#define GU_API
Definition: GU_API.h:11
GLuint const GLchar * name
Definition: glcorearb.h:785
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:1221
void setMaxNewPoints(int maxNewPoints)
Cap the maximum allowed number of new ponts.
GLfloat GLfloat GLfloat GLfloat h
Definition: glcorearb.h:2001
GLenum GLenum dst
Definition: glcorearb.h:1792
GLsizei const GLfloat * value
Definition: glcorearb.h:823
double fpreal
Definition: SYS_Types.h:263
png_voidp png_voidp s2
Definition: png.h:2193
png_infop png_sPLT_tpp entries
Definition: png.h:2481
SYS_FORCE_INLINE REAL incircle(const REAL pa[2], const REAL pb[2], const REAL pc[2], const REAL pd[2])
GLint GLenum GLint x
Definition: glcorearb.h:408
GLuint GLfloat * val
Definition: glcorearb.h:1607
void allowConstraintSplit(bool enabled)
void setConstraintSplitPointGroupName(const UT_String &name)
void setConstraintSplitPointGroup(GA_PointGroup *new_pt_grp)
SYS_FORCE_INLINE REAL orient2d(const REAL pa[2], const REAL pb[2], const REAL pc[2])
const std::string getWarningMessage()
GLenum src
Definition: glcorearb.h:1792
unsigned int uint32
Definition: SYS_Types.h:29