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