Zone2.h

Go to the documentation of this file.

// Copyright (C) Geom Software e.U, Bernhard Kornberger, Graz/Austria
//
// This file is part of the Fade2D library. The student license is free
// of charge and covers personal non-commercial research. Licensees
// holding a commercial license may use this file in accordance with
// the Commercial License Agreement.
//
// This software is provided AS IS with NO WARRANTY OF ANY KIND,
// INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE.
//
// Please contact the author if any conditions of this licensing are
// not clear to you.
//
// Author: Bernhard Kornberger, bkorn (at) geom.at
// http://www.geom.at
 
 
#pragma once
 
#include "common.h"
#include "freeFunctions.h"
#include "FadeExport.h"
#include "Bbox2.h"
#include "Edge2.h"
#include "Segment2.h"
#include "UserPredicates.h"
#include "MsgBase.h"
#include "VtkWriter.h"
#include "CompPolygon.h"
#include "PolygonClipper.h"
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    namespace GEOM_FADE25D {
#elif GEOM_PSEUDO3D==GEOM_FALSE
    namespace GEOM_FADE2D {
#else
    #error GEOM_PSEUDO3D is not defined
#endif
 
class ZoneShooter; // FWD
class ConstraintSegment2; // FWD
 
enum OptimizationMode
{
    OPTMODE_STANDARD, 
    OPTMODE_BETTER, 
    OPTMODE_BEST 
};
 
class Progress; // FWD
class Dt2; // Fwd
class ConstraintGraph2; // Fwd
class Triangle2; // Fwd
class Point2; // Fwd
class Visualizer2; // Fwd
class Visualizer3; // Fwd
 
//
// *
// * The CompPolygon struct holds a connected component of triangles.
// * Thereby two triangles count as connected if they share a common
// * edge. It also holds an ordered vector of polygon edges and
// * ordered vectors of hole edges.
// *
// * @remark An edge is represented by a triangle and an opposite
// * index. Its orientation is always counterclockwise (CCW) around
// * the triangle. Thus outer polygon edges are counterclockwise
// * while hole polygons (if any) are clockwise (CW) oriented.
// */
//struct CLASS_DECLSPEC CompPolygon
//{
//  CompPolygon();
//  CompPolygon(const CompPolygon& other);
//  CompPolygon& operator=(const CompPolygon& other);
//  ~CompPolygon();
//  // Data
//  std::vector<Triangle2*>* pvCC; ///< Connected component of triangles (connection along edges, not just vertices)
//  std::vector<Edge2>* pvOuterPolygon; ///< Ordered outer polygon
//  std::vector<std::vector<Edge2> >* pvvHolePolygons; ///< Ordered hole polygons
//};
 
class CLASS_DECLSPEC Zone2
{
public:
    Zone2(Dt2* pDt_,ZoneLocation zoneLoc_);
    Zone2(Dt2* pDt_,ZoneLocation zoneLoc_,ConstraintGraph2* pConstraintGraph_);
    Zone2(Dt2* pDt_,ZoneLocation zoneLoc_,const std::vector<ConstraintGraph2*>& vConstraintGraphs_);
    Zone2(Dt2* pDt_,const std::vector<ConstraintGraph2*>& vConstraintGraphs_,ZoneLocation zoneLoc_,std::vector<Point2>& vStartPoints);
    ~Zone2();
 
    bool hasOn(const Point2& p);
 
    bool hasOnBoundary(const Point2& p);
 
    Triangle2* locate(const Point2& p);
 
    ConstraintSegment2* getNearbyBoundaryConstraint(Point2& p, double tolerance);
    bool shiftToZone(const Point2& from, double tolerance, Point2& result);
 
 
    bool save(const char* filename);
 
    bool save(std::ostream& stream);
 
 
    void exportZone(FadeExport& fadeExport,bool bWithCustomIndices) const;
 
    void getOffsetBoundary(double offset,std::vector<Segment2>& vOffsetBoundary,double mergeAngleDeg=10.0,double angleStepDeg=20.0);
 
    void subscribe(MsgType msgType,MsgBase* pMsg);
    void unsubscribe(MsgType msgType,MsgBase* pMsg);
    ZoneLocation getZoneLocation() const;
 
    Zone2* convertToBoundedZone();
 
    void show(const char* filename,bool bShowFull,bool bWithConstraints) const;
 
    void show(Visualizer2* pVisualizer,bool bShowFull,bool bWithConstraints) const;
 
 
 
    void showVtk(const char* filename,VtkColor zoneColor,VtkColor nonZoneColor=VTK_TRANSPARENT,VtkColor constraintColor=VTK_TRANSPARENT) const;
 
 
    void showVtk(VtkWriter* pVtk,VtkColor zoneColor,VtkColor nonZoneColor=VTK_TRANSPARENT,VtkColor constraintColor=VTK_TRANSPARENT) const;
 
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    void showGeomview(const char* filename,const char* color) const;
    void showGeomview(Visualizer3* pVis,const char* color) const;
 
    void analyzeAngles(const char* name="");
 
    void smoothing(int numIterations=2,bool bWithXY=true);
 
    void smoothing2(int numIterations,bool bWithXY,bool bWithConstraintZ);
 
    void slopeValleyRidgeOptimization(OptimizationMode om=OPTMODE_BETTER);
 
    /*
     * This function is deprecated but kept for backwards compatibility.
     * Better use slopeValleyRidgeOptimization() (see above)
     *
     * Optimize Valleys and Ridges
     *
     * A Delaunay triangulation is not unique when when 2 or more triangles
     * share a common circumcircle. As a consequence the four corners of
     * a rectangle can be triangulated in two different ways: Either the
     * diagonal proceeds from the lower left to the upper right corner
     * or it connects the other two corners. Both solutions are valid and
     * an arbitrary one is applied when points are triangulated. To improve
     * the repeatability and for reasons of visual appearance this method
     * unifies such diagonals such that they point from the lower left to
     * the upper right corner (or in horizontal direction).\n
     *
     * Moreover a Delaunay triangulation does not take the z-value into
     * account and thus valleys and ridges may be disturbed. The present
     * method flips diagonals such that they point from the lower left to
     * the upper right corner of a quad. And if the 2.5D lengths of the
     * diagonals are significantly different, then the shorter one is
     * applied.
     *
     * @param tolerance2D is 0 when only exact cases of more than 3 points
     * on a common circumcircle shall be changed. But in practice input
     * data can be disturbed by noise and tiny rounding errors such that
     * grid points are not exactly on a grid. The numeric error is computed
     * as \f$error=\frac{abs(diagonalA-diagonalB)}{max(diagonalA,diagonalB)}\f$.
     * and \p tolerance2D is an upper threshold to allow modification despite
     * such tiny inaccuracies.
     * @param lowerThreshold25D is used to take also the heights of the
     * involved points into account. For example, the points\n
     * \n
     * Point_2 a(0,0,0);\n
     * Point_2 b(10,0,0);\n
     * Point_2 c(10,10,0);\n
     * Point_2 d(0,10,1000);\n
     * \n
     * can form the triangles (a,b,c) and (a,c,d) or the triangles (a,b,d)
     * and (d,b,c) but (a,c) is obviousy the better diagonal because the
     * points a,b,c share the same elevation while d is at z=1000.
     * Technically spoken, the diagonal with the smaller 2.5D-length is
     * applied if the both, the 2D error is below \p tolerance2D and the
     * 2.5D error is above \p lowerThreshold25D. The 2.5D
     * criterion has priority over the 2D criterion.
     *
     */
    void optimizeValleysAndRidges(double tolerance2D,double lowerThreshold25D);
#endif
 
    void unifyGrid(double tolerance);
 
    bool assignDt2(Dt2* pDt_);
 
    void getTriangles(std::vector<Triangle2*>& vTriangles_) const;
 
    void getVertices(std::vector<Point2*>& vVertices_) const;
 
 
    void statistics(const char* s) const;
 
 
    ConstraintGraph2* getConstraintGraph() const;
 
    size_t getNumberOfTriangles() const;
 
 
    void getConstraintGraphs(std::vector<ConstraintGraph2*>& vConstraintGraphs_) const;
 
    Dt2* getDelaunayTriangulation() const;
 
    size_t numberOfConstraintGraphs() const;
 
    void debug(const char* name="");
 
    Bbox2 getBoundingBox() const;
 
    // Deprecated, replaced by getBorderEdges() but kept for
    // backwards-compatibility.
    void getBoundaryEdges(std::vector<Edge2>& vEdges) const;
 
    void getComponentPolygons(std::vector<CompPolygon>& vCompPolygons) const;
 
    void getBoundarySegments(std::vector<Segment2>& vSegments) const;
 
    double getArea2D() const;
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    double getArea25D() const;
#endif
 
    void getBorderEdges(std::vector<Edge2>& vBorderEdgesOut) const;
 
    void writeObj(const char* outFilename) const;
 
#ifndef SKIPTHREADS
#if GEOM_PSEUDO3D==GEOM_TRUE
    bool writePly(const char*  filename,bool bASCII=false) const;
    bool writePly(std::ostream& os,bool bASCII=false) const;
#endif
#endif
 
 
 
protected:
    Zone2& operator=(const Zone2&);
    // Optimization techniques
    void optMode_standard_sub(std::vector<Triangle2*>& vT,std::vector<Triangle2*>& vChangedT);
    void optMode_standard();
    double optMode_prioq(double noEdgeBelowDih,bool bWithProgress);
    void getEdgesForOptimization(double noEdgeBelowDegree,std::vector<Edge2>& vEdges);
    void optMode_simulatedAnnealing();
    void optMode_simulatedAnnealing_sub(std::vector<Edge2>& vUniqueEdges,double temperature);
    void removeConstraintEdges(std::vector<Edge2>& vEdges) const;
    Zone2(const Zone2&);
    void getTriangles_RESULT(std::vector<Triangle2*>& vTriangles) const;
    void initWorkspace(bool bInside,std::set<std::pair<Point2*,Point2*> >& sNoGrowEdges,std::vector<Triangle2*>& vWorkspace) const;
    void bfsFromWorkspace(std::vector<Triangle2*>& vWorkspace,std::set<std::pair<Point2*,Point2*> >& sNoGrowEdges,std::vector<Triangle2*>& vTriangles) const;
    Zone2* ctbz_treatCC(std::vector<Triangle2*>& vOneCC);
    // Data
    Dt2* pDt;
    Progress* pZoneProgress;
    ZoneShooter* pZoneShooter;
    ZoneLocation zoneLoc;
    CLASS_DECLSPEC
    friend Zone2* zoneUnion(Zone2* pZone0,Zone2* pZone1);
    CLASS_DECLSPEC
    friend Zone2* zoneIntersection(Zone2* pZone0,Zone2* pZone1);
    CLASS_DECLSPEC
    friend Zone2* zoneDifference(Zone2* pZone0,Zone2* pZone1);
    CLASS_DECLSPEC
    friend Zone2* zoneSymmetricDifference(Zone2* pZone0,Zone2* pZone1);
 
    CLASS_DECLSPEC
    friend Zone2* peelOffIf(Zone2* pZone, UserPredicateT* pPredicate,bool bVerbose); // Depricated!
 
    CLASS_DECLSPEC
    friend Zone2* peelOffIf(Zone2* pZone, bool bAvoidSplit,PeelPredicateTS* pPredicate);
 
 
 
private:
#ifndef __MINGW32__
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable:4251)
#endif
#endif
    std::vector<ConstraintGraph2*> vConstraintGraphs;
    std::vector<Point2> vStartPoints;
    std::vector<Zone2*> vInputZones;
 
#ifndef __MINGW32__
#ifdef _WIN32
#pragma warning(pop)
#endif
#endif
};
 
// Free functions
CLASS_DECLSPEC
Zone2* zoneUnion(Zone2* pZone0,Zone2* pZone1);
 
 
CLASS_DECLSPEC
Zone2* zoneIntersection(Zone2* pZone0,Zone2* pZone1);
 
CLASS_DECLSPEC
Zone2* zoneDifference(Zone2* pZone0,Zone2* pZone1);
 
CLASS_DECLSPEC
Zone2* zoneSymmetricDifference(Zone2* pZone0,Zone2* pZone1);
 
 
 
 
} // (namespace)