qgsabstractgeometry.h

Go to the documentation of this file.

/***************************************************************************
                        qgsabstractgeometry.h
  -------------------------------------------------------------------
Date                 : 04 Sept 2014
Copyright            : (C) 2014 by Marco Hugentobler
email                : marco.hugentobler at sourcepole dot com
 ***************************************************************************
 *                                                                         *
 *   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 QGSABSTRACTGEOMETRYV2
#define QGSABSTRACTGEOMETRYV2
 
#include <array>
#include <functional>
#include <type_traits>
#include <QString>
 
#include "qgis_core.h"
#include "qgscoordinatetransform.h"
#include "qgswkbtypes.h"
#include "qgswkbptr.h"
 
#ifndef SIP_RUN
#include "json_fwd.hpp"
using namespace nlohmann;
#endif
 
class QgsMapToPixel;
class QgsCurve;
class QgsMultiCurve;
class QgsMultiPoint;
 
struct QgsVertexId;
class QgsVertexIterator;
class QPainter;
class QDomDocument;
class QDomElement;
class QgsGeometryPartIterator;
class QgsGeometryConstPartIterator;
class QgsConstWkbPtr;
class QPainterPath;
class QgsAbstractGeometryTransformer;
class QgsFeedback;
 
typedef QVector< QgsPoint > QgsPointSequence;
#ifndef SIP_RUN
typedef QVector< QgsPointSequence > QgsRingSequence;
typedef QVector< QgsRingSequence > QgsCoordinateSequence;
#else
typedef QVector< QVector< QgsPoint > > QgsRingSequence;
typedef QVector< QVector< QVector< QgsPoint > > > QgsCoordinateSequence;
#endif
 
 
class CORE_EXPORT QgsAbstractGeometry
{
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( qgsgeometry_cast<QgsPoint *>( sipCpp ) != nullptr )
      sipType = sipType_QgsPoint;
    else if ( qgsgeometry_cast<QgsLineString *>( sipCpp ) != nullptr )
      sipType = sipType_QgsLineString;
    else if ( qgsgeometry_cast<QgsCircularString *>( sipCpp ) != nullptr )
      sipType = sipType_QgsCircularString;
    else if ( qgsgeometry_cast<QgsCompoundCurve *>( sipCpp ) != nullptr )
      sipType = sipType_QgsCompoundCurve;
    else if ( qgsgeometry_cast<QgsTriangle *>( sipCpp ) != nullptr )
      sipType = sipType_QgsTriangle;
    else if ( qgsgeometry_cast<QgsPolygon *>( sipCpp ) != nullptr )
      sipType = sipType_QgsPolygon;
    else if ( qgsgeometry_cast<QgsCurvePolygon *>( sipCpp ) != nullptr )
      sipType = sipType_QgsCurvePolygon;
    else if ( qgsgeometry_cast<QgsMultiPoint *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMultiPoint;
    else if ( qgsgeometry_cast<QgsMultiLineString *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMultiLineString;
    else if ( qgsgeometry_cast<QgsMultiPolygon *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMultiPolygon;
    else if ( qgsgeometry_cast<QgsMultiSurface *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMultiSurface;
    else if ( qgsgeometry_cast<QgsMultiCurve *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMultiCurve;
    else if ( qgsgeometry_cast<QgsGeometryCollection *>( sipCpp ) != nullptr )
      sipType = sipType_QgsGeometryCollection;
    else
      sipType = 0;
    SIP_END
#endif
 
    Q_GADGET
 
  public:
 
    enum SegmentationToleranceType
    {
 
      MaximumAngle = 0,
 
      MaximumDifference
    };
    Q_ENUM( SegmentationToleranceType )
 
    
    enum AxisOrder
    {
 
      XY = 0,
 
      YX
    };
    Q_ENUM( QgsAbstractGeometry::AxisOrder )
 
    
    QgsAbstractGeometry() = default;
    virtual ~QgsAbstractGeometry() = default;
    QgsAbstractGeometry( const QgsAbstractGeometry &geom );
    QgsAbstractGeometry &operator=( const QgsAbstractGeometry &geom );
 
    virtual bool operator==( const QgsAbstractGeometry &other ) const = 0;
    virtual bool operator!=( const QgsAbstractGeometry &other ) const = 0;
 
    virtual QgsAbstractGeometry *clone() const = 0 SIP_FACTORY;
 
    virtual int compareTo( const QgsAbstractGeometry *other ) const;
 
    virtual void clear() = 0;
 
    virtual QgsRectangle boundingBox() const = 0;
 
    //mm-sql interface
 
    virtual int dimension() const = 0;
 
    virtual QString geometryType() const = 0;
 
    inline QgsWkbTypes::Type wkbType() const SIP_HOLDGIL { return mWkbType; }
 
    QString wktTypeStr() const;
 
    bool is3D() const SIP_HOLDGIL
    {
      return QgsWkbTypes::hasZ( mWkbType );
    }
 
    bool isMeasure() const SIP_HOLDGIL
    {
      return QgsWkbTypes::hasM( mWkbType );
    }
 
    virtual QgsAbstractGeometry *boundary() const = 0 SIP_FACTORY;
 
    virtual void normalize() = 0;
 
    //import
 
    virtual bool fromWkb( QgsConstWkbPtr &wkb ) = 0;
 
    virtual bool fromWkt( const QString &wkt ) = 0;
 
    //export
 
    enum WkbFlag
    {
      FlagExportTrianglesAsPolygons = 1 << 0, 
    };
    Q_DECLARE_FLAGS( WkbFlags, WkbFlag )
 
    
    virtual int wkbSize( QgsAbstractGeometry::WkbFlags flags = QgsAbstractGeometry::WkbFlags() ) const = 0;
 
    virtual QByteArray asWkb( WkbFlags flags = QgsAbstractGeometry::WkbFlags() ) const = 0;
 
    virtual QString asWkt( int precision = 17 ) const = 0;
 
    virtual QDomElement asGml2( QDomDocument &doc, int precision = 17, const QString &ns = "gml", AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const = 0;
 
    virtual QDomElement asGml3( QDomDocument &doc, int precision = 17, const QString &ns = "gml", AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const = 0;
 
    QString asJson( int precision = 17 );
 
    virtual json asJsonObject( int precision = 17 ) SIP_SKIP const;
 
    virtual QString asKml( int precision = 17 ) const = 0;
 
 
    //render pipeline
 
    virtual void transform( const QgsCoordinateTransform &ct, QgsCoordinateTransform::TransformDirection d = QgsCoordinateTransform::ForwardTransform, bool transformZ = false ) SIP_THROW( QgsCsException ) = 0;
 
    virtual void transform( const QTransform &t, double zTranslate = 0.0, double zScale = 1.0,
                            double mTranslate = 0.0, double mScale = 1.0 ) = 0;
 
    virtual void draw( QPainter &p ) const = 0;
 
    virtual QPainterPath asQPainterPath() const = 0;
 
    virtual int vertexNumberFromVertexId( QgsVertexId id ) const = 0;
 
    virtual bool nextVertex( QgsVertexId &id, QgsPoint &vertex SIP_OUT ) const = 0;
 
    virtual void adjacentVertices( QgsVertexId vertex, QgsVertexId &previousVertex SIP_OUT, QgsVertexId &nextVertex SIP_OUT ) const = 0;
 
    virtual QgsCoordinateSequence coordinateSequence() const = 0;
 
    virtual int nCoordinates() const;
 
    virtual QgsPoint vertexAt( QgsVertexId id ) const = 0;
 
    virtual double closestSegment( const QgsPoint &pt, QgsPoint &segmentPt SIP_OUT,
                                   QgsVertexId &vertexAfter SIP_OUT,
                                   int *leftOf SIP_OUT = nullptr, double epsilon = 4 * std::numeric_limits<double>::epsilon() ) const = 0;
 
    //low-level editing
 
    virtual bool insertVertex( QgsVertexId position, const QgsPoint &vertex ) = 0;
 
    virtual bool moveVertex( QgsVertexId position, const QgsPoint &newPos ) = 0;
 
    virtual bool deleteVertex( QgsVertexId position ) = 0;
 
    virtual double length() const;
 
    virtual double perimeter() const;
 
    virtual double area() const;
 
    virtual double segmentLength( QgsVertexId startVertex ) const = 0;
 
    virtual QgsPoint centroid() const;
 
    virtual bool isEmpty() const;
 
    virtual bool hasCurvedSegments() const;
 
    virtual bool boundingBoxIntersects( const QgsRectangle &rectangle ) const SIP_HOLDGIL;
 
    virtual QgsAbstractGeometry *segmentize( double tolerance = M_PI / 180., SegmentationToleranceType toleranceType = MaximumAngle ) const SIP_FACTORY;
 
    virtual QgsAbstractGeometry *toCurveType() const = 0 SIP_FACTORY;
 
    virtual QgsAbstractGeometry *snappedToGrid( double hSpacing, double vSpacing, double dSpacing = 0, double mSpacing = 0 ) const = 0 SIP_FACTORY;
 
    virtual bool removeDuplicateNodes( double epsilon = 4 * std::numeric_limits<double>::epsilon(), bool useZValues = false ) = 0;
 
    virtual double vertexAngle( QgsVertexId vertex ) const = 0;
 
    virtual int vertexCount( int part = 0, int ring = 0 ) const = 0;
 
    virtual int ringCount( int part = 0 ) const = 0;
 
    virtual int partCount() const = 0;
 
    virtual bool addZValue( double zValue = 0 ) = 0;
 
    virtual bool addMValue( double mValue = 0 ) = 0;
 
    virtual bool dropZValue() = 0;
 
    virtual bool dropMValue() = 0;
 
    virtual void swapXy() = 0;
 
    virtual bool convertTo( QgsWkbTypes::Type type );
 
    virtual const QgsAbstractGeometry *simplifiedTypeRef() const SIP_HOLDGIL;
 
    virtual bool isValid( QString &error SIP_OUT, int flags = 0 ) const = 0;
 
    virtual bool transform( QgsAbstractGeometryTransformer *transformer, QgsFeedback *feedback = nullptr ) = 0;
 
#ifndef SIP_RUN
 
    virtual void filterVertices( const std::function< bool( const QgsPoint & ) > &filter );
 
    virtual void transformVertices( const std::function< QgsPoint( const QgsPoint & ) > &transform );
 
    class CORE_EXPORT part_iterator
    {
      private:
 
        int mIndex = 0; 
        QgsAbstractGeometry *mGeometry = nullptr;
 
      public:
        part_iterator() = default;
 
        part_iterator( QgsAbstractGeometry *g, int index );
 
        part_iterator &operator++();
 
        part_iterator operator++( int );
 
        QgsAbstractGeometry *operator*() const;
 
        int partNumber() const;
 
        bool operator==( part_iterator other ) const;
        bool operator!=( part_iterator other ) const { return !( *this == other ); }
    };
 
    part_iterator parts_begin()
    {
      return part_iterator( this, 0 );
    }
 
    part_iterator parts_end();
 
    QgsGeometryConstPartIterator parts() const;
 
    class CORE_EXPORT const_part_iterator
    {
      private:
 
        int mIndex = 0; 
        const QgsAbstractGeometry *mGeometry = nullptr;
 
      public:
        const_part_iterator() = default;
 
        const_part_iterator( const QgsAbstractGeometry *g, int index );
 
        const_part_iterator &operator++();
 
        const_part_iterator operator++( int );
 
        const QgsAbstractGeometry *operator*() const;
 
        int partNumber() const;
 
        bool operator==( const_part_iterator other ) const;
        bool operator!=( const_part_iterator other ) const { return !( *this == other ); }
    };
 
    const_part_iterator const_parts_begin() const
    {
      return const_part_iterator( this, 0 );
    }
 
    const_part_iterator const_parts_end() const;
 
 
    class CORE_EXPORT vertex_iterator
    {
      private:
 
        struct Level
        {
          const QgsAbstractGeometry *g = nullptr;  
          int index = 0;               
 
          bool operator==( const Level &other ) const;
        };
 
        std::array<Level, 3> levels;  
        int depth = -1;               
 
        void digDown();   
 
      public:
        vertex_iterator() = default;
 
        vertex_iterator( const QgsAbstractGeometry *g, int index );
 
        vertex_iterator &operator++();
 
        vertex_iterator operator++( int );
 
        QgsPoint operator*() const;
 
        QgsVertexId vertexId() const;
 
        bool operator==( const vertex_iterator &other ) const;
        bool operator!=( const vertex_iterator &other ) const { return !( *this == other ); }
    };
 
    vertex_iterator vertices_begin() const
    {
      return vertex_iterator( this, 0 );
    }
 
    vertex_iterator vertices_end() const
    {
      return vertex_iterator( this, childCount() );
    }
#endif
 
    QgsGeometryPartIterator parts();
 
 
    QgsVertexIterator vertices() const;
 
    virtual QgsAbstractGeometry *createEmptyWithSameType() const = 0 SIP_FACTORY;
 
  protected:
 
    int sortIndex() const;
 
    virtual int compareToSameClass( const QgsAbstractGeometry *other ) const = 0;
 
    virtual bool hasChildGeometries() const;
 
    virtual int childCount() const { return 0; }
 
    virtual QgsAbstractGeometry *childGeometry( int index ) const { Q_UNUSED( index ) return nullptr; }
 
    virtual QgsPoint childPoint( int index ) const;
 
  protected:
    QgsWkbTypes::Type mWkbType = QgsWkbTypes::Unknown;
 
    void setZMTypeFromSubGeometry( const QgsAbstractGeometry *subggeom, QgsWkbTypes::Type baseGeomType );
 
    virtual QgsRectangle calculateBoundingBox() const;
 
    virtual void clearCache() const;
 
    friend class TestQgsGeometry;
};
 
 
struct CORE_EXPORT QgsVertexId
{
 
  enum VertexType
  {
    SegmentVertex = 1, 
    CurveVertex, 
  };
 
  explicit QgsVertexId( int _part = -1, int _ring = -1, int _vertex = -1, VertexType _type = SegmentVertex ) SIP_HOLDGIL
: part( _part )
  , ring( _ring )
  , vertex( _vertex )
  , type( _type )
  {}
 
  bool isValid() const  SIP_HOLDGIL { return part >= 0 && ring >= 0 && vertex >= 0; }
 
  bool operator==( QgsVertexId other ) const SIP_HOLDGIL
  {
    return part == other.part && ring == other.ring && vertex == other.vertex;
  }
  bool operator!=( QgsVertexId other ) const SIP_HOLDGIL
  {
    return part != other.part || ring != other.ring || vertex != other.vertex;
  }
 
  bool partEqual( QgsVertexId o ) const SIP_HOLDGIL
  {
    return part >= 0 && o.part == part;
  }
 
  bool ringEqual( QgsVertexId o ) const SIP_HOLDGIL
  {
    return partEqual( o ) && ( ring >= 0 && o.ring == ring );
  }
 
  bool vertexEqual( QgsVertexId o ) const SIP_HOLDGIL
  {
    return ringEqual( o ) && ( vertex >= 0 && o.ring == ring );
  }
 
  bool isValid( const QgsAbstractGeometry *geom ) const SIP_HOLDGIL
  {
    return ( part >= 0 && part < geom->partCount() ) &&
           ( ring < geom->ringCount( part ) ) &&
           ( vertex < 0 || vertex < geom->vertexCount( part, ring ) );
  }
 
  int part = -1;
 
  int ring = -1;
 
  int vertex = -1;
 
  VertexType type = SegmentVertex;
 
#ifdef SIP_RUN
  SIP_PYOBJECT __repr__();
  % MethodCode
  QString str = QStringLiteral( "<QgsVertexId: %1,%2,%3%4>" ).arg( sipCpp->part ).arg( sipCpp->ring ).arg( sipCpp->vertex ).arg( sipCpp->type == QgsVertexId::CurveVertex ? QStringLiteral( " CurveVertex" ) : QString() );
  sipRes = PyUnicode_FromString( str.toUtf8().data() );
  % End
#endif
 
};
 
#ifndef SIP_RUN
 
template <class T>
inline T qgsgeometry_cast( const QgsAbstractGeometry *geom )
{
  return const_cast<T>( std::remove_pointer<T>::type::cast( geom ) );
}
 
#endif
 
// clazy:excludeall=qstring-allocations
 
class CORE_EXPORT QgsVertexIterator
{
  public:
    QgsVertexIterator() = default;
 
    QgsVertexIterator( const QgsAbstractGeometry *geometry )
      : g( geometry )
      , i( g->vertices_begin() )
      , n( g->vertices_end() )
    {
    }
 
    bool hasNext() const
    {
      return g && g->vertices_end() != i;
    }
 
    QgsPoint next();
 
#ifdef SIP_RUN
    QgsVertexIterator *__iter__();
    % MethodCode
    sipRes = sipCpp;
    % End
 
    SIP_PYOBJECT __next__() SIP_TYPEHINT( QgsPoint );
    % MethodCode
    if ( sipCpp->hasNext() )
      sipRes = sipConvertFromType( new QgsPoint( sipCpp->next() ), sipType_QgsPoint, Py_None );
    else
      PyErr_SetString( PyExc_StopIteration, "" );
    % End
#endif
 
  private:
    const QgsAbstractGeometry *g = nullptr;
    QgsAbstractGeometry::vertex_iterator i, n;
 
};
 
class CORE_EXPORT QgsGeometryPartIterator
{
  public:
    QgsGeometryPartIterator() = default;
 
    QgsGeometryPartIterator( QgsAbstractGeometry *geometry )
      : g( geometry )
      , i( g->parts_begin() )
      , n( g->parts_end() )
    {
    }
 
    bool hasNext() const SIP_HOLDGIL
    {
      return g && g->parts_end() != i;
    }
 
    QgsAbstractGeometry *next();
 
#ifdef SIP_RUN
    QgsGeometryPartIterator *__iter__();
    % MethodCode
    sipRes = sipCpp;
    % End
 
    SIP_PYOBJECT __next__() SIP_TYPEHINT( QgsAbstractGeometry );
    % MethodCode
    if ( sipCpp->hasNext() )
      sipRes = sipConvertFromType( sipCpp->next(), sipType_QgsAbstractGeometry, NULL );
    else
      PyErr_SetString( PyExc_StopIteration, "" );
    % End
#endif
 
  private:
    QgsAbstractGeometry *g = nullptr;
    QgsAbstractGeometry::part_iterator i, n;
 
};
 
 
class CORE_EXPORT QgsGeometryConstPartIterator
{
  public:
    QgsGeometryConstPartIterator() = default;
 
    QgsGeometryConstPartIterator( const QgsAbstractGeometry *geometry )
      : g( geometry )
      , i( g->const_parts_begin() )
      , n( g->const_parts_end() )
    {
    }
 
    bool hasNext() const SIP_HOLDGIL
    {
      return g && g->const_parts_end() != i;
    }
 
    const QgsAbstractGeometry *next();
 
#ifdef SIP_RUN
    QgsGeometryConstPartIterator *__iter__();
    % MethodCode
    sipRes = sipCpp;
    % End
 
    SIP_PYOBJECT __next__() SIP_TYPEHINT( QgsAbstractGeometry );
    % MethodCode
    if ( sipCpp->hasNext() )
      sipRes = sipConvertFromType( const_cast< QgsAbstractGeometry * >( sipCpp->next() ), sipType_QgsAbstractGeometry, NULL );
    else
      PyErr_SetString( PyExc_StopIteration, "" );
    % End
#endif
 
  private:
    const QgsAbstractGeometry *g = nullptr;
    QgsAbstractGeometry::const_part_iterator i, n;
 
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsAbstractGeometry::WkbFlags )
 
#endif //QGSABSTRACTGEOMETRYV2