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
// unclear to you.
//
// Support: https://www.geom.at/contact/
// Project: https://www.geom.at/fade2d/html/
 
 
#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 ZoneShooter2; // FWD
class ConstraintSegment2; // FWD
class Fade_2D; // FWD
 
enum OptimizationMode
{
    OPTMODE_STANDARD, 
    OPTMODE_BETTER, 
    OPTMODE_BEST 
};
 
 
 
enum SegmentSelectionType
{
    SST_CONSTRAINT, 
    SST_INCIRCLE, 
    SST_IN_OR_ONCIRCLE 
};
 
 
 
class Progress; // FWD
class Dt2; // Fwd
class ConstraintGraph2; // Fwd
class Triangle2; // Fwd
class Point2; // Fwd
class Visualizer2; // Fwd
class Visualizer3; // Fwd
 
 
 
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);
 
 
    double getMedianEdgeLength2D();
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    double getMedianEdgeLength25D();
#endif
 
    bool hasOnBoundary(const Point2& p);
 
    Triangle2* locate(const Point2& p);
 
    ConstraintSegment2* getNearbyBoundaryConstraint(Point2& p, double tolerance);
    bool shiftToZone(const Point2& q, 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) const;
 
    Zone2* createOffsetZone(Fade_2D* pFade,double offset,double mergeAngleDeg=10,double angleStep=20.0) const;
 
 
 
    Zone2* morphOpen(Fade_2D* pFade,double offset,double mergeAngleDeg=10.0,double angleStep=20.0) const;
 
 
    Zone2* morphClose(Fade_2D* pFade,double offset,double mergeAngleDeg=10.0,double angleStep=20.0) const;
 
 
    void subscribe(MsgType msgType,MsgBase* pMsg);
 
 
    void unsubscribe(MsgType msgType,MsgBase* pMsg);
 
    ZoneLocation getZoneLocation() const;
 
 
    Zone2* convertToBoundedZone();
 
 
    void show(const char* filename,const Colorname& zoneFillColor=CTRANSPARENT,const Colorname& zoneEdgeColor=CBLACK,const Colorname& nonZoneFillColor=CTRANSPARENT,const Colorname& nonZoneEdgeColor=CTRANSPARENT,const Colorname& constraintEdgeColor=CTRANSPARENT) const;
 
    void show(Visualizer2* pVisualizer,const Colorname& zoneFillColor=CTRANSPARENT,const Colorname& zoneEdgeColor=CBLACK,const Colorname& nonZoneFillColor=CTRANSPARENT,const Colorname& nonZoneEdgeColor=CTRANSPARENT,const Colorname& constraintEdgeColor=CTRANSPARENT) const;
 
 
    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="");
 
    double getVerticalWalls(double aboveAngleDegree,std::vector<Triangle2*>& vVerticalWalls);
 
    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* filename) 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
 
 
    void getReplicationData(    SegmentSelectionType segmentSelectionType,
                                std::vector<Point2>& vPoints,
                                std::vector<Segment2>& vInnerSegments,
                                std::vector<Segment2>& vBoundarySegments
                               ) const;
 
 
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;
    ZoneShooter2* 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* zoneDifference(Zone2* pZone0,Zone2* pZone1);
 
CLASS_DECLSPEC
Zone2* zoneIntersection(Zone2* pZone0,Zone2* pZone1);
 
 
CLASS_DECLSPEC
Zone2* zoneSymmetricDifference(Zone2* pZone0,Zone2* pZone1);
 
 
CLASS_DECLSPEC
Zone2* zoneUnion(Zone2* pZone0,Zone2* pZone1);
 
 
 
 
 
 
} // (namespace)