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 );
    int addPoint( Point3D* p );
    virtual void performConsistencyTest();
    virtual bool calcNormal( double x, double y, Vector3D* result );
    virtual bool calcPoint( double x, double y, Point3D* result );
    //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;
    int getOppositePoint( int p1, int p2 );

    virtual bool getTriangle( double x, double y, Point3D* p1, int* n1, Point3D* p2, int* n2, Point3D* p3, int* n3 );
    virtual bool getTriangle( double x, double y, Point3D* p1, Point3D* p2, Point3D* p3 );
    QList<int>* getSurroundingTriangles( int pointno );
    virtual double getXMax() const;
    virtual double getXMin() const;
    virtual double getYMax() const;
    virtual double getYMin() const;
    virtual int getNumberOfPoints() const;
    void removeLine( int i );
    void removePoint( int i );
    virtual void setForcedCrossBehaviour( Triangulation::forcedCrossBehaviour b );
    virtual void setEdgeColor( int r, int g, int b );
    virtual void setForcedEdgeColor( int r, int g, int b );
    virtual void setBreakEdgeColor( int r, int g, int b );
    void setTriangleInterpolator( TriangleInterpolator* interpolator );
    void eliminateHorizontalTriangles();
    virtual void ruppertRefinement();
    bool pointInside( double x, double y );
    //bool readFromTAFF(QString fileName);
    //bool saveToTAFF(QString fileName) const;
    virtual bool swapEdge( double x, double y );
    virtual QList<int>* getPointsAroundEdge( double x, double y );
    virtual bool saveAsShapefile( const QString& fileName ) const;

  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( 0 ), mForcedCrossBehaviour( Triangulation::DELETE_FIRST ), mEdgeColor( 0, 255, 0 ), mForcedEdgeColor( 0, 0, 255 ), mBreakEdgeColor( 100, 100, 0 ), mDecorator( this )
{
  mPointVector.reserve( mDefaultStorageForPoints );
  mHalfEdge.reserve( mDefaultStorageForHalfEdges );
}

inline DualEdgeTriangulation::DualEdgeTriangulation( int nop, Triangulation* decorator ): xMax( 0 ), xMin( 0 ), yMax( 0 ), yMin( 0 ), mTriangleInterpolator( 0 ), mForcedCrossBehaviour( Triangulation::DELETE_FIRST ), mEdgeColor( 0, 255, 0 ), mForcedEdgeColor( 0, 0, 255 ), mBreakEdgeColor( 100, 100, 0 ), mDecorator( decorator )
{
  mPointVector.reserve( nop );
  mHalfEdge.reserve( nop );
  if ( !mDecorator )
  {
    mDecorator = this;
  }
}

inline double DualEdgeTriangulation::getXMax() const
{
  return xMax;
}

inline double DualEdgeTriangulation::getXMin() const
{
  return xMin;
}

inline double DualEdgeTriangulation::getYMax() const
{
  return yMax;
}

inline double DualEdgeTriangulation::getYMin() const
{
  return yMin;
}

inline int DualEdgeTriangulation::getNumberOfPoints() const
{
  return (( int )( 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