Fade2D Documentation pages v1.97
Delaunay Features
Zone2.h
Go to the documentation of this file.
1 // Copyright (C) Geom Software e.U, Bernhard Kornberger, Graz/Austria
2 //
3 // This file is part of the Fade2D library. The student license is free
4 // of charge and covers personal non-commercial research. Licensees
5 // holding a commercial license may use this file in accordance with
6 // the Commercial License Agreement.
7 //
8 // This software is provided AS IS with NO WARRANTY OF ANY KIND,
9 // INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS
10 // FOR A PARTICULAR PURPOSE.
11 //
12 // Please contact the author if any conditions of this licensing are
13 // not clear to you.
14 //
15 // Author: Bernhard Kornberger, bkorn (at) geom.at
16 // http://www.geom.at
17 
19 
20 #pragma once
21 
22 #include "common.h"
23 #include "freeFunctions.h"
24 #include "FadeExport.h"
25 #include "Bbox2.h"
26 #include "Edge2.h"
27 #include "Segment2.h"
28 #include "UserPredicates.h"
29 #include "MsgBase.h"
30 
31 
32 
33 #if GEOM_PSEUDO3D==GEOM_TRUE
34  namespace GEOM_FADE25D {
35 #elif GEOM_PSEUDO3D==GEOM_FALSE
36  namespace GEOM_FADE2D {
37 #else
38  #error GEOM_PSEUDO3D is not defined
39 #endif
40 
49 {
53 };
54 
55 class Progress; // FWD
56 class Dt2; // Fwd
57 class ConstraintGraph2; // Fwd
58 class Triangle2; // Fwd
59 class Point2; // Fwd
60 class Visualizer2; // Fwd
61 class Visualizer3; // Fwd
62 
63 
73 struct CLASS_DECLSPEC CompPolygon
74 {
75  CompPolygon();
76  CompPolygon(const CompPolygon& other);
77  CompPolygon& operator=(const CompPolygon& other);
78  ~CompPolygon();
79  // Data
80  std::vector<Triangle2*>* pvCC;
81  std::vector<Edge2>* pvOuterPolygon;
82  std::vector<std::vector<Edge2> >* pvvHolePolygons;
83 };
84 
91 class CLASS_DECLSPEC Zone2
92 {
93 public:
95  Zone2(Dt2* pDt_,ZoneLocation zoneLoc_);
97  Zone2(Dt2* pDt_,ZoneLocation zoneLoc_,ConstraintGraph2* pConstraintGraph_);
99  Zone2(Dt2* pDt_,ZoneLocation zoneLoc_,const std::vector<ConstraintGraph2*>& vConstraintGraphs_);
101  Zone2(Dt2* pDt_,const std::vector<ConstraintGraph2*>& vConstraintGraphs_,ZoneLocation zoneLoc_,std::vector<Point2>& vStartPoints);
103  ~Zone2();
104 
124  bool save(const char* filename);
125 
144  bool save(std::ostream& stream);
145 
146 
153  void exportZone(FadeExport& fadeExport,bool bWithCustomIndices) const;
154 
155 
156 
157 
163  void subscribe(MsgType msgType,MsgBase* pMsg);
169  void unsubscribe(MsgType msgType,MsgBase* pMsg);
180  ZoneLocation getZoneLocation() const;
181 
195 
203  void show(const char* postscriptFilename,bool bShowFull,bool bWithConstraints) const;
204 
212  void show(Visualizer2* pVisualizer,bool bShowFull,bool bWithConstraints) const;
213 
214 
215 
216 
217 
218 #if GEOM_PSEUDO3D==GEOM_TRUE
225  void showGeomview(const char* filename,const char* color) const;
232  void showGeomview(Visualizer3* pVis,const char* color) const;
233 
235  void analyzeAngles(const char* name="");
236 
249  void smoothing(int numIterations=2);
250 
271  void slopeValleyRidgeOptimization(OptimizationMode om=OPTMODE_BETTER);
272 
274  /*
275  * This function is deprecated but kept for backwards compatibility.
276  * Better use slopeValleyRidgeOptimization() (see above)
277  *
278  * Optimize Valleys and Ridges
279  *
280  * A Delaunay triangulation is not unique when when 2 or more triangles
281  * share a common circumcircle. As a consequence the four corners of
282  * a rectangle can be triangulated in two different ways: Either the
283  * diagonal proceeds from the lower left to the upper right corner
284  * or it connects the other two corners. Both solutions are valid and
285  * an arbitrary one is applied when points are triangulated. To improve
286  * the repeatability and for reasons of visual appearance this method
287  * unifies such diagonals such that they point from the lower left to
288  * the upper right corner (or in horizontal direction).\n
289  *
290  * Moreover a Delaunay triangulation does not take the z-value into
291  * account and thus valleys and ridges may be disturbed. The present
292  * method flips diagonals such that they point from the lower left to
293  * the upper right corner of a quad. And if the 2.5D lengths of the
294  * diagonals are significantly different, then the shorter one is
295  * applied.
296  *
297  * @param tolerance2D is 0 when only exact cases of more than 3 points
298  * on a common circumcircle shall be changed. But in practice input
299  * data can be disturbed by noise and tiny rounding errors such that
300  * grid points are not exactly on a grid. The numeric error is computed
301  * as \f$error=\frac{abs(diagonalA-diagonalB)}{max(diagonalA,diagonalB)}\f$.
302  * and \p tolerance2D is an upper threshold to allow modification despite
303  * such tiny inaccuracies.
304  * @param lowerThreshold25D is used to take also the heights of the
305  * involved points into account. For example, the points\n
306  * \n
307  * Point_2 a(0,0,0);\n
308  * Point_2 b(10,0,0);\n
309  * Point_2 c(10,10,0);\n
310  * Point_2 d(0,10,1000);\n
311  * \n
312  * can form the triangles (a,b,c) and (a,c,d) or the triangles (a,b,d)
313  * and (d,b,c) but (a,c) is obviousy the better diagonal because the
314  * points a,b,c share the same elevation while d is at z=1000.
315  * Technically spoken, the diagonal with the smaller 2.5D-length is
316  * applied if the both, the 2D error is below \p tolerance2D and the
317  * 2.5D error is above \p lowerThreshold25D. The 2.5D
318  * criterion has priority over the 2D criterion.
319  *
320  */
321  void optimizeValleysAndRidges(double tolerance2D,double lowerThreshold25D);
322 #endif
323 
346  void unifyGrid(double tolerance);
347 
349  bool assignDt2(Dt2* pDt_);
350 
361  void getTriangles(std::vector<Triangle2*>& vTriangles_) const;
362 
366  void getVertices(std::vector<Point2*>& vVertices_) const;
367 
368 
373  void statistics(const char* s) const;
374 
375 
381 
386  size_t getNumberOfTriangles() const;
387 
388 
392  void getConstraintGraphs(std::vector<ConstraintGraph2*>& vConstraintGraphs_) const;
393 
395  Dt2* getDelaunayTriangulation() const;
396 
401  size_t numberOfConstraintGraphs() const;
402 
405  void debug(const char* name="");
406 
410 
417  void getBoundaryEdges(std::vector<Edge2>& vEdges) const;
418 
429  void getComponentPolygons(std::vector<CompPolygon>& vCompPolygons) const;
430 
436  void getBoundarySegments(std::vector<Segment2>& vSegments) const;
437 
450  double getArea2D() const;
451 
452 
453 #if GEOM_PSEUDO3D==GEOM_TRUE
461  double getArea25D() const;
462 #endif
463 
467  void getBorderEdges(std::vector<Edge2>& vBorderEdgesOut) const;
468 
475  void writeObj(const char* outFilename) const;
476 
477 
478 
479 protected:
480  // Optimization techniques
482  void optMode_standard_sub(std::vector<Triangle2*>& vT,std::vector<Triangle2*>& vChangedT);
484  void optMode_standard();
486  double optMode_prioq(double noEdgeBelowDih,bool bWithProgress);
488  void getEdgesForOptimization(double noEdgeBelowDegree,std::vector<Edge2>& vEdges);
490  void optMode_simulatedAnnealing();
492  void optMode_simulatedAnnealing_sub(std::vector<Edge2>& vUniqueEdges,double temperature);
493 
494 
496  Zone2(const Zone2&);
498  void getTriangles_RESULT(std::vector<Triangle2*>& vTriangles) const;
500  void initWorkspace(bool bInside,std::vector<Triangle2*>& vWorkspace) const;
502  void bfsFromWorkspace(std::vector<Triangle2*>& vWorkspace,std::vector<Triangle2*>& vTriangles) const;
504  Zone2* ctbz_treatCC(std::vector<Triangle2*>& vOneCC);
505  // Data
507  Dt2* pDt;
509  Progress* pZoneProgress;
511  ZoneLocation zoneLoc;
512  CLASS_DECLSPEC
513  friend Zone2* zoneUnion(Zone2* pZone0,Zone2* pZone1);
514  CLASS_DECLSPEC
515  friend Zone2* zoneIntersection(Zone2* pZone0,Zone2* pZone1);
516  CLASS_DECLSPEC
517  friend Zone2* zoneDifference(Zone2* pZone0,Zone2* pZone1);
518  CLASS_DECLSPEC
519  friend Zone2* zoneSymmetricDifference(Zone2* pZone0,Zone2* pZone1);
520  // This version is deprecated (but still valid) in favor of the
521  // version that takes a PeelPredicateTS.
538  CLASS_DECLSPEC
539  friend Zone2* peelOffIf(Zone2* pZone, UserPredicateT* pPredicate,bool bVerbose);
553  CLASS_DECLSPEC
554  friend Zone2* peelOffIf(Zone2* pZone, bool bAvoidSplit,PeelPredicateTS* pPredicate);
555 
556 
557 
558 private:
559 #ifdef _WIN32
560 #pragma warning(push)
561 #pragma warning(disable:4251)
562 #endif
563  std::vector<ConstraintGraph2*> vConstraintGraphs;
564  std::vector<Point2> vStartPoints;
565  std::vector<Zone2*> vInputZones;
566 #ifdef _WIN32
567 #pragma warning(pop)
568 #endif
569 
570 };
571 
572 // Free functions
573 
578 CLASS_DECLSPEC
579 Zone2* zoneUnion(Zone2* pZone0,Zone2* pZone1);
584 CLASS_DECLSPEC
585 Zone2* zoneIntersection(Zone2* pZone0,Zone2* pZone1);
590 CLASS_DECLSPEC
591 Zone2* zoneDifference(Zone2* pZone0,Zone2* pZone1);
597 CLASS_DECLSPEC
599 
600 
601 
602 
603 } // (namespace)
Zone2 * zoneSymmetricDifference(Zone2 *pZone0, Zone2 *pZone1)
Compute the symmetric difference of two zones.
Zone2 * zoneDifference(Zone2 *pZone0, Zone2 *pZone1)
Compute the difference of two zones.
Zone2 * zoneUnion(Zone2 *pZone0, Zone2 *pZone1)
Compute the union of two zones.
Zone2 * zoneIntersection(Zone2 *pZone0, Zone2 *pZone1)
Compute the intersection of two zones.
OptimizationMode
Definition: Zone2.h:49
@ OPTMODE_STANDARD
Fastest optimization mode.
Definition: Zone2.h:50
@ OPTMODE_BEST
Best quality but quite time consuming.
Definition: Zone2.h:52
@ OPTMODE_BETTER
Considerably better quality and still fast.
Definition: Zone2.h:51
Bbox2 is an axis aligned 2D bounding box.
Definition: Bbox2.h:37
ConstraintGraph2 is a set of Constraint Edges (ConstraintSegment2)
Definition: ConstraintGraph2.h:52
MsgBase, a base class for message subscriber classes.
Definition: MsgBase.h:47
User-defined peel predicate.
Definition: UserPredicates.h:60
User-defined predicate (deprecated)
Definition: UserPredicates.h:39
Visualizer2 is a general Postscript writer. It draws the objects Point2, Segment2,...
Definition: Visualizer2.h:56
Zone2 is a certain defined area of a triangulation.
Definition: Zone2.h:92
friend Zone2 * peelOffIf(Zone2 *pZone, UserPredicateT *pPredicate, bool bVerbose)
Peel off border triangles (deprecated)
ConstraintGraph2 * getConstraintGraph() const
Get the associated constraint.
void show(const char *postscriptFilename, bool bShowFull, bool bWithConstraints) const
Postscript visualization.
bool save(std::ostream &stream)
Save the zone.
Bbox2 getBoundingBox() const
Compute the bounding box.
void getBoundaryEdges(std::vector< Edge2 > &vEdges) const
Compute the boundary edges.
double getArea2D() const
Get 2D Area.
void writeObj(const char *outFilename) const
Write the zone to *.obj Writes the triangles of the present Zone2 to an *.obj file (The *....
size_t numberOfConstraintGraphs() const
Get a the number of ConstraintGraph2 objects.
friend Zone2 * zoneIntersection(Zone2 *pZone0, Zone2 *pZone1)
Compute the intersection of two zones.
void getTriangles(std::vector< Triangle2 * > &vTriangles_) const
Get the triangles of the zone.
void getComponentPolygons(std::vector< CompPolygon > &vCompPolygons) const
Get connected components and their boundary polygons.
void show(Visualizer2 *pVisualizer, bool bShowFull, bool bWithConstraints) const
Postscript visualization.
void subscribe(MsgType msgType, MsgBase *pMsg)
Register a message receiver.
void getBoundarySegments(std::vector< Segment2 > &vSegments) const
Compute the boundary segments.
void getConstraintGraphs(std::vector< ConstraintGraph2 * > &vConstraintGraphs_) const
Get the associated constraint graphs.
friend Zone2 * zoneSymmetricDifference(Zone2 *pZone0, Zone2 *pZone1)
Compute the symmetric difference of two zones.
ZoneLocation getZoneLocation() const
Get the zone location.
void getVertices(std::vector< Point2 * > &vVertices_) const
Get the vertices of the zone.
void exportZone(FadeExport &fadeExport, bool bWithCustomIndices) const
Export triangles from a zone.
friend Zone2 * zoneUnion(Zone2 *pZone0, Zone2 *pZone1)
Compute the union of two zones.
void unsubscribe(MsgType msgType, MsgBase *pMsg)
Unregister a message receiver.
void debug(const char *name="")
Development function.
size_t getNumberOfTriangles() const
Get the number of triangles.
friend Zone2 * peelOffIf(Zone2 *pZone, bool bAvoidSplit, PeelPredicateTS *pPredicate)
Peel off border triangles.
bool save(const char *filename)
Save the zone.
Zone2 * convertToBoundedZone()
Convert a zone to a bounded zone.
void unifyGrid(double tolerance)
void statistics(const char *s) const
void getBorderEdges(std::vector< Edge2 > &vBorderEdgesOut) const
Get border edges.
friend Zone2 * zoneDifference(Zone2 *pZone0, Zone2 *pZone1)
Compute the difference of two zones.
Connected component with boundary- and hole polygons.
Definition: Zone2.h:74
std::vector< std::vector< Edge2 > > * pvvHolePolygons
Sorted hole polygons.
Definition: Zone2.h:82
std::vector< Edge2 > * pvOuterPolygon
Sorted outer polygon.
Definition: Zone2.h:81
std::vector< Triangle2 * > * pvCC
One connected component of triangles (connection is meant along edges, not just vertices)
Definition: Zone2.h:80
FadeExport is a simple struct to export triangulation data.
Definition: FadeExport.h:43