DualEdgeTriangulation.h

Go to the documentation of this file.

/***************************************************************************
                          DualEdgeTriangulation.h  -  description
                             -------------------
    copyright            : (C) 2004 by Marco Hugentobler
    email                : [email protected]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef DUALEDGETRIANGULATION_H
#define DUALEDGETRIANGULATION_H

#include "Triangulation.h"
#include "HalfEdge.h"
#include <QVector>
#include <QList>
#include <QSet>
#include "MathUtils.h"
#include "TriangleInterpolator.h"
#include <QColor>
#include <QFile>
#include <QTextStream>
#include <QMessageBox>
#include <cfloat>
#include <QBuffer>
#include <QStringList>
#include <QProgressDialog>
#include <QCursor>

class ANALYSIS_EXPORT DualEdgeTriangulation: public Triangulation
{
  public:
    DualEdgeTriangulation();
    DualEdgeTriangulation( int nop, Triangulation* decorator );
    virtual ~DualEdgeTriangulation();
    void setDecorator( Triangulation* d ) {mDecorator = d;}
    void addLine( Line3D* line, bool breakline ) override;
    int addPoint( Point3D* p ) override;
    virtual void performConsistencyTest() override;
    virtual bool calcNormal( double x, double y, Vector3D* result ) override;
    virtual bool calcPoint( double x, double y, Point3D* result ) override;
    //virtual void draw(QPainter* p, double xlowleft, double ylowleft, double xupright, double yupright, double width, double height) const;
    virtual Point3D* getPoint( unsigned int i ) const override;
    int getOppositePoint( int p1, int p2 ) override;
    virtual bool getTriangle( double x, double y, Point3D* p1, int* n1, Point3D* p2, int* n2, Point3D* p3, int* n3 ) override;
    virtual bool getTriangle( double x, double y, Point3D* p1, Point3D* p2, Point3D* p3 ) override;
    QList<int>* getSurroundingTriangles( int pointno ) override;
    virtual double getXMax() const override { return xMax; }
    virtual double getXMin() const override { return xMin; }
    virtual double getYMax() const override { return yMax; }
    virtual double getYMin() const override { return yMin; }
    virtual int getNumberOfPoints() const override;
    virtual void setForcedCrossBehaviour( Triangulation::forcedCrossBehaviour b ) override;
    virtual void setEdgeColor( int r, int g, int b ) override;
    virtual void setForcedEdgeColor( int r, int g, int b ) override;
    virtual void setBreakEdgeColor( int r, int g, int b ) override;
    void setTriangleInterpolator( TriangleInterpolator* interpolator ) override;
    void eliminateHorizontalTriangles() override;
    virtual void ruppertRefinement() override;
    bool pointInside( double x, double y ) override;
    //bool readFromTAFF(QString fileName);
    //bool saveToTAFF(QString fileName) const;
    virtual bool swapEdge( double x, double y ) override;
    virtual QList<int>* getPointsAroundEdge( double x, double y ) override;
    virtual bool saveAsShapefile( const QString& fileName ) const override;

  protected:
    double xMax;
    double xMin;
    double yMax;
    double yMin;
    const static unsigned int mDefaultStorageForPoints = 100000;
    QVector<Point3D*> mPointVector;
    const static unsigned int mDefaultStorageForHalfEdges = 300006;
    QVector<HalfEdge*> mHalfEdge;
    TriangleInterpolator* mTriangleInterpolator;
    Triangulation::forcedCrossBehaviour mForcedCrossBehaviour;
    QColor mEdgeColor;
    QColor mForcedEdgeColor;
    QColor mBreakEdgeColor;
    Triangulation* mDecorator;
    unsigned int insertEdge( int dual, int next, int point, bool mbreak, bool forced );
    int insertForcedSegment( int p1, int p2, bool breakline );
    //const static double leftOfTresh=0.00001;
    const static int nBaseOfRuns = 300000;
    int baseEdgeOfPoint( int point );
    int baseEdgeOfTriangle( Point3D* point );
    bool checkSwap( unsigned int edge, unsigned int recursiveDeep );
    void doSwap( unsigned int edge, unsigned int recursiveDeep );
    void doOnlySwap( unsigned int edge );
    unsigned int mEdgeInside;
    unsigned int mEdgeOutside;
    unsigned int mEdgeWithPoint;
    unsigned int mUnstableEdge;
    int mTwiceInsPoint;
    bool swapPossible( unsigned int edge );
    void triangulatePolygon( QList<int>* poly, QList<int>* free, int mainedge );
    bool halfEdgeBBoxTest( int edge, double xlowleft, double ylowleft, double xupright, double yupright ) const;
    double swapMinAngle( int edge ) const;
    int splitHalfEdge( int edge, float position );
    bool edgeOnConvexHull( int edge );
    void evaluateInfluenceRegion( Point3D* point, int edge, QSet<int> &set );
};

inline DualEdgeTriangulation::DualEdgeTriangulation()
    : xMax( 0 )
    , xMin( 0 )
    , yMax( 0 )
    , yMin( 0 )
    , mTriangleInterpolator( nullptr )
    , mForcedCrossBehaviour( Triangulation::DELETE_FIRST )
    , mEdgeColor( 0, 255, 0 )
    , mForcedEdgeColor( 0, 0, 255 )
    , mBreakEdgeColor( 100, 100, 0 )
    , mDecorator( this )
    , mEdgeInside( 0 )
    , mEdgeOutside( 0 )
    , mEdgeWithPoint( 0 )
    , mUnstableEdge( 0 )
    , mTwiceInsPoint( 0 )
{
  mPointVector.reserve( mDefaultStorageForPoints );
  mHalfEdge.reserve( mDefaultStorageForHalfEdges );
}

inline DualEdgeTriangulation::DualEdgeTriangulation( int nop, Triangulation* decorator )
    : xMax( 0 )
    , xMin( 0 )
    , yMax( 0 )
    , yMin( 0 )
    , mTriangleInterpolator( nullptr )
    , mForcedCrossBehaviour( Triangulation::DELETE_FIRST )
    , mEdgeColor( 0, 255, 0 )
    , mForcedEdgeColor( 0, 0, 255 )
    , mBreakEdgeColor( 100, 100, 0 )
    , mDecorator( decorator ? decorator : this )
    , mEdgeInside( 0 )
    , mEdgeOutside( 0 )
    , mEdgeWithPoint( 0 )
    , mUnstableEdge( 0 )
    , mTwiceInsPoint( 0 )
{
  mPointVector.reserve( nop );
  mHalfEdge.reserve( nop );
}

inline int DualEdgeTriangulation::getNumberOfPoints() const
{
  return mPointVector.count();
}

inline Point3D* DualEdgeTriangulation::getPoint( unsigned int i ) const
{
  return mPointVector.at( i );
}

inline bool DualEdgeTriangulation::halfEdgeBBoxTest( int edge, double xlowleft, double ylowleft, double xupright, double yupright ) const
{
  return (
           ( getPoint( mHalfEdge[edge]->getPoint() )->getX() >= xlowleft &&
             getPoint( mHalfEdge[edge]->getPoint() )->getX() <= xupright &&
             getPoint( mHalfEdge[edge]->getPoint() )->getY() >= ylowleft &&
             getPoint( mHalfEdge[edge]->getPoint() )->getY() <= yupright ) ||
           ( getPoint( mHalfEdge[mHalfEdge[edge]->getDual()]->getPoint() )->getX() >= xlowleft &&
             getPoint( mHalfEdge[mHalfEdge[edge]->getDual()]->getPoint() )->getX() <= xupright &&
             getPoint( mHalfEdge[mHalfEdge[edge]->getDual()]->getPoint() )->getY() >= ylowleft &&
             getPoint( mHalfEdge[mHalfEdge[edge]->getDual()]->getPoint() )->getY() <= yupright )
         );
}

#endif