Fade_2D.h

// 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 "Point2.h"
#include "Triangle2.h"
#include "TriangleAroundVertexIterator.h"
#include "Visualizer2.h"
#include "Zone2.h"
#include "ConstraintGraph2.h"
#include "Performance.h"
#include "MeshGenParams.h"
#include "MsgBase.h"
#include "SegmentChecker.h"
#include "testDataGenerators.h"
#include "freeFunctions.h"




#if GEOM_PSEUDO3D==GEOM_TRUE
    #include "IsoContours.h"
    #include "EfficientModel.h"
    #include "CutAndFill.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)
    {
        initFade(numExpectedVertices);
    }


    ~Fade_2D();



    bool checkValidity(bool bCheckEmptyCircleProperty,const std::string& msg) const;

    int setNumCPU(int numCPU);


    void statistics(const std::string& s) const;

    void show(const std::string& postscriptFilename,bool bWithConstraints=true) const;


    void show(Visualizer2* pVis,bool bWithConstraints=true) const;

#if GEOM_PSEUDO3D==GEOM_TRUE

    void showGeomview(const std::string& filename);

    void showGeomview(Visualizer3* pVis);

    // Experimental, will change
    bool save(const char* filenameOut);
    // Experimental, will change
    bool load(const char* filenameIn);

#endif

    void remove(Point2* pVertex);


    void getConvexHull(bool bAllVertices,std::vector<Point2*>& vConvexHullPointsOut);



    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 measureTrianguluationTime(std::vector<Point2>& vPoints);



    Triangle2* locate(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;



Triangle2* getAdjacentTriangle(Point2* p0,Point2* p1) const;

    bool is2D() const;


    ConstraintGraph2* createConstraint(
        std::vector<Segment2>& vSegments,
        ConstraintInsertionStrategy cis,
        bool bOrientedSegments=false
        );






    Zone2* createZone(ConstraintGraph2* pConstraintGraph,ZoneLocation zoneLoc,bool bVerbose=true);


    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*>& vIncidentVertices) const;


    void writeObj(const std::string& filename) const;

    void writeObj(const std::string& 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 std::string& name,const AcceptExperimentalFeature& accept);

    void setName(const std::string& s);

    std::string getName() const;


    Zone2* importTriangles( std::vector<Point2>& vPoints,
                            bool bReorientIfNeeded,
                            bool bCreateExtendedBoundingBox
                        );

    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 enableMultithreading();

    // Development functions, not for public use
    void internal(int au,int fu,std::string s="");
    Dt2* getImpl();
    void setDev(const std::string& s,int ival,double dval);

protected:
    void initFade(unsigned numExpectedVertices);
    Fade_2D(const Fade_2D&); // No copy constructor
    Fade_2D& operator=(const Fade_2D&); // No assignment allowed
    Dt2* pImpl;
};



//                     D E P R E C A T E D                         //

#if GEOM_PSEUDO3D==GEOM_TRUE

CLASS_DECLSPEC
bool reconstruct(const std::string& inFile,std::vector<Point2>& vCornersOut);

CLASS_DECLSPEC
bool reconstruct(const std::string& inFile,const std::string& outFile);
CLASS_DECLSPEC
bool reconstruct(std::vector<Point2>& vInPoints, std::vector<Point2>& vCornersOut);

#endif

} // (namespace)




#ifndef FADE2D_EXPORT
    #include "License.h"
#endif