Fade_2D.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"
#ifndef FADE2D_EXPORT
    #include "License.h"
#endif
#include "Point2.h"
#include "Triangle2.h"
#include "TriangleAroundVertexIterator.h"
#include "Visualizer2.h"
#include "VtkWriter.h"
#include "Zone2.h"
#include "ConstraintGraph2.h"
#include "Performance.h"
#include "MeshGenParams.h"
#include "MsgBase.h"
#include "SegmentChecker.h"
#include "testDataGenerators.h"
#include "FadeExport.h"
#include "Voronoi2.h"
#include "PolygonClipper.h"
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    #include "IsoContours.h"
    #include "EfficientModel.h"
    #include "CutAndFill.h"
    #include "Visualizer3.h"
    #include "CloudPrepare.h"
#endif
 
 
 
#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 Dt2; // Forward
class Visualizer3; // Forward
 
 
class CLASS_DECLSPEC Fade_2D
{
public:
    explicit Fade_2D(unsigned numExpectedVertices=3);
 
Fade_2D(Fade_2D& other,std::vector<Zone2*> vZoneIn=std::vector<Zone2*>(),std::vector<Zone2*> vZoneOut=std::vector<Zone2*>());
 
    ~Fade_2D();
 
    bool saveTriangulation(const char* filename,std::vector<Zone2*>& vSaveZones);
 
 
    bool saveTriangulation(std::ostream& stream,std::vector<Zone2*>& vSaveZones);
 
    bool saveZones(const char* filename,std::vector<Zone2*>& vSaveZones);
 
 
    bool saveZones(std::ostream& stream,std::vector<Zone2*>& vSaveZones);
 
 
 
    bool load(const char* filename,std::vector<Zone2*>& vZones);
 
 
    bool load(std::istream& stream,std::vector<Zone2*>& vZones);
 
 
    void exportTriangulation(FadeExport& fadeExport,bool bWithCustomIndices,bool bClear);
 
    bool checkValidity(bool bCheckEmptyCircleProperty,const char* msg) const;
 
 
    int setNumCPU(int numCPU);
 
 
    Voronoi2* getVoronoiDiagram();
 
 
    void setFastMode(bool bFast);
 
 
    void statistics(const char*  s) const;
 
    void show(const char* filename,bool bWithConstraints=true) const;
 
 
    void show(Visualizer2* pVis,bool bWithConstraints=true) const;
 
 
    void showVtk(const char* filename,VtkColor color,VtkColor constraintColor=VTK_TRANSPARENT) const;
 
    void showVtk(VtkWriter* pVtkWriter,VtkColor color,VtkColor constraintColor=VTK_TRANSPARENT) const;
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    void showGeomview(const  char* filename, const char* color="1 1 1 0.5") const;
 
    void showGeomview(Visualizer3* pVis, const char* color="1 1 1 0.5") const;
#endif
 
 void remove(Point2* pVertex);
 
    void remove(std::vector<Point2*>& vPoints);
 
 
    void reset();
 
    void getConvexHull(bool bAllVertices,std::vector<Point2*>& vConvexHullPointsOut);
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    void insert(CloudPrepare* pCloudPrepare,bool bClear=true);
#endif
 
 
    Point2* insert(const Point2& p);
 
    void insert(const std::vector<Point2>& vInputPoints);
 
 
 
    void insert(const std::vector<Point2>& vInputPoints,std::vector<Point2*>& vHandles);
 
#if GEOM_PSEUDO3D==GEOM_TRUE
#else
#endif
    void insert(int numPoints,double * aCoordinates,Point2 ** aHandles);
 
 
 
    double measureTriangulationTime(const std::vector<Point2>& vPoints);
 
 
 
 
    Triangle2* locate(const Point2& p);
 
 
Point2* getNearestNeighbor(const Point2& p);
 
#if GEOM_PSEUDO3D==GEOM_TRUE
 
    bool getHeight(double x,double y,double& heightOut,Triangle2* pApproxT=NULL,double tolerance=0) const;
#endif
 
    void refine(    Zone2* pZone,
                    double minAngleDegree,
                    double minEdgeLength,
                    double maxEdgeLength,
                    bool bAllowConstraintSplitting
                    );
 
    void refineAdvanced(MeshGenParams* pParameters);
 
 
 
 
 
 
    size_t numberOfPoints() const;
 
    size_t numberOfTriangles() const;
 
 
    void getTrianglePointers(std::vector<Triangle2*>& vAllTriangles) const;
 
void getVertexPointers(std::vector<Point2*>& vAllPoints) const;
 
Point2* getVertexPointer(const Point2& p);
 
Triangle2* getAdjacentTriangle(Point2* p0,Point2* p1) const;
 
 
    bool hasArea() const;
 
    bool is2D() const;
 
    double getMedianEdgeLength2D();
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    double getMedianEdgeLength25D();
#endif
 
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    ConstraintGraph2* createConstraint(
        std::vector<Segment2>& vSegments,
        ConstraintInsertionStrategy cis=CIS_CONSTRAINED_DELAUNAY,
        bool bOrientedSegments=false,
        bool bUseHeightOfLatest=false
        );
#else
    ConstraintGraph2* createConstraint(
        std::vector<Segment2>& vSegments,
        ConstraintInsertionStrategy cis,
        bool bOrientedSegments=false
        );
#endif
 
 
 
 
 
    Zone2* createZone(ConstraintGraph2* pConstraintGraph,ZoneLocation zoneLoc,bool bVerbose=true);
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    Zone2* getPeeledZone(double angleThreshold,bool bAvoidSplit);
#endif
 
 
    Zone2* createZone(const std::vector<ConstraintGraph2*>& vConstraintGraphs,ZoneLocation zoneLoc,const Point2& startPoint,bool bVerbose=true);
 
 
    Zone2* createZone(ConstraintGraph2* pConstraintGraph,ZoneLocation zoneLoc,const Point2& startPoint,bool bVerbose=true);
 
 
    Zone2* createZone( std::vector<Triangle2*>& vTriangles,bool bVerbose=true );
 
 
 
    void deleteZone(Zone2* pZone);
 
 
    void applyConstraintsAndZones();
 
    Bbox2 computeBoundingBox() const;
 
 
    bool isConstraint(Triangle2* pT,int ith) const;
 
void getAliveConstraintSegments(std::vector<ConstraintSegment2*>& vAliveConstraintSegments) const;
 
    void getAliveAndDeadConstraintSegments(std::vector<ConstraintSegment2*>& vAllConstraintSegments) const;
 
    ConstraintSegment2* getConstraintSegment(Point2* p0,Point2* p1) const;
 
    void getIncidentTriangles(Point2* pVtx,std::vector<Triangle2*>& vIncidentT) const;
 
 
    void getIncidentVertices(Point2* pVtx,std::vector<Point2*>& vAdjVtx) 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 writeObj(const char*  filename,Zone2* pZone) const;
 
    void writeWebScene(const char* path) const;
 
void writeWebScene(const char* path,Zone2* pZone) const;
 
 
void subscribe(MsgType msgType,MsgBase* pMsg);
 
 
 
void unsubscribe(MsgType msgType,MsgBase* pMsg);
 
    bool isConstraint(Point2* p0,Point2* p1) const;
 
    bool isConstraint(Point2* pVtx) const;
 
    void printLicense() const;
 
    bool checkZoneQuality(Zone2* pZone,double minAngle,const char*  name,const AcceptExperimentalFeature& accept);
    void setName(const char* s);
    std::string getName() const;
 
 
    Zone2* importTriangles( std::vector<Point2>& vPoints,
                            bool bReorientIfNeeded,
                            bool bCreateExtendedBoundingBox
                        );
 
 
    Zone2* importTriangles_robust(std::vector<Point2>& vPoints);
 
#ifndef SKIPTHREADS
#if GEOM_PSEUDO3D==GEOM_TRUE
    Zone2* importTrianglesFromPly(const char* filename);
 
    Zone2* importTrianglesFromPly(std::istream& is);
#endif
#endif
 
Orientation2 getOrientation(const Point2& p0,const Point2& p1,const Point2& p2);
 
    void cutTriangles(  const Point2& knifeStart,
                        const Point2& knifeEnd,
                        bool bTurnEdgesIntoConstraints);
 
    void cutTriangles(  std::vector<Segment2>& vSegments,
                        bool bTurnEdgesIntoConstraints);
 
 
Zone2* createZone_cookieCutter(std::vector<Segment2>& vSegments,bool bProtectEdges);
    void getZones(std::vector<Zone2*>& vZones) const;
 
 
    Zone2* createZone_cookieCutter( std::vector<Segment2>& vSegments,
                                    bool bProtectEdges,
                                    ConstraintGraph2*& pProtectedEdgesCG,
                                    ConstraintGraph2*& pBoundaryCG);
 
 
    Zone2* createZone_cookieCutter2( std::vector<Segment2>& vSegments,
                                    bool bProtectEdges,
                                    ConstraintGraph2*& pProtectedEdgesCG,
                                    ConstraintGraph2*& pBoundaryCG);
    Zone2* createZone_cookieCutter2( std::vector<Segment2>& vSegments,
                                     bool bProtectEdges);
 
#if GEOM_PSEUDO3D==GEOM_TRUE
    bool drape( std::vector<Segment2>& vSegmentsIn,
                std::vector<Segment2>& vSegmentsOut,
                double zTolerance,
                double offTolerance=0.0,
                bool bKeepOffSegments=false) const;
#else
    bool drape( std::vector<Segment2>& vSegmentsIn,
                std::vector<Segment2>& vSegmentsOut,
                double offTolerance=0.0,
                bool bKeepOffSegments=false) const;
#endif
 
 
 
 
void getDirectedEdges(std::vector<Edge2>& vDirectedEdgesOut) const;
 
void getUndirectedEdges(std::vector<Edge2>& vUndirectedEdgesOut) const;
 
    /* Deprecated: Use setNumCPU() instead. This method is kept for
    * compatibility with existing applications. Internally it calls
    * setNumCPU(0) to automatically determine and use the number of
    * available CPU cores.
    */
    void enableMultithreading();
    // Development functions, not for public use
    void internal(int au,int fu,const char*  s="");
    Dt2* getImpl();
    void setDev(const char* s,int ival,double dval);
 
protected:
    void initFade(unsigned numExpectedVertices);
    Fade_2D& operator=(const Fade_2D&); // No assignment allowed
    Dt2* pImpl;
}; // end of class
 
 
inline void copyFade(Fade_2D& dt0,std::vector<Zone2*>& vZones0,Fade_2D& dt1,std::vector<Zone2*>& vZones1)
{
    std::stringstream ss;
    dt0.saveTriangulation(ss,vZones0);
    dt1.load(ss,vZones1);
}
 
 
 
 
} // (namespace)