qgsgeometry.h

Go to the documentation of this file.

/***************************************************************************
  qgsgeometry.h - Geometry (stored as Open Geospatial Consortium WKB)
  -------------------------------------------------------------------
Date                 : 02 May 2005
Copyright            : (C) 2005 by Brendan Morley
email                : morb at ozemail dot com dot au
 ***************************************************************************
 *                                                                         *
 *   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 QGSGEOMETRY_H
#define QGSGEOMETRY_H

#include <QDomDocument>
#include <QSet>
#include <QString>
#include <QVector>

#include <climits>
#include <limits>
#include <memory>

#include "qgis_core.h"
#include "qgis.h"

#include "qgsabstractgeometry.h"
#include "qgsfeature.h"
#include "qgspointxy.h"
#include "qgspoint.h"


class QgsGeometryEngine;
class QgsVectorLayer;
class QgsMapToPixel;
class QPainter;
class QgsPolygon;
class QgsLineString;

typedef QVector<QgsPointXY> QgsPolylineXY;

typedef QVector<QgsPoint> QgsPolyline;

#ifndef SIP_RUN
typedef QVector<QgsPolylineXY> QgsPolygonXY;
#else
typedef QVector<QVector<QgsPointXY>> QgsPolygonXY;
#endif

typedef QVector<QgsPointXY> QgsMultiPointXY;

#ifndef SIP_RUN
typedef QVector<QgsPolylineXY> QgsMultiPolylineXY;
#else
typedef QVector<QVector<QgsPointXY>> QgsMultiPolylineXY;
#endif

#ifndef SIP_RUN
typedef QVector<QgsPolygonXY> QgsMultiPolygonXY;
#else
typedef QVector<QVector<QVector<QgsPointXY>>> QgsMultiPolygonXY;
#endif

class QgsRectangle;

class QgsConstWkbPtr;

struct QgsGeometryPrivate;

class CORE_EXPORT QgsGeometry
{
    Q_GADGET
  public:

    enum OperationResult
    {
      Success = 0, 
      NothingHappened = 1000, 
      InvalidBaseGeometry, 
      InvalidInputGeometryType, 
      SelectionIsEmpty, 
      SelectionIsGreaterThanOne, 
      GeometryEngineError, 
      LayerNotEditable, 
      /* Add part issues */
      AddPartSelectedGeometryNotFound, 
      AddPartNotMultiGeometry, 
      /* Add ring issues*/
      AddRingNotClosed, 
      AddRingNotValid, 
      AddRingCrossesExistingRings, 
      AddRingNotInExistingFeature, 
      /* Split features */
      SplitCannotSplitPoint, 
    };

    QgsGeometry();

    QgsGeometry( const QgsGeometry & );

    QgsGeometry &operator=( QgsGeometry const &rhs ) SIP_SKIP;

    explicit QgsGeometry( QgsAbstractGeometry *geom SIP_TRANSFER );

    explicit QgsGeometry( std::unique_ptr< QgsAbstractGeometry > geom ) SIP_SKIP;

    ~QgsGeometry();

    const QgsAbstractGeometry *constGet() const;

    QgsAbstractGeometry *get();

    void set( QgsAbstractGeometry *geometry SIP_TRANSFER );

    bool isNull() const;

    static QgsGeometry fromWkt( const QString &wkt );
    static QgsGeometry fromPointXY( const QgsPointXY &point );
    static QgsGeometry fromMultiPointXY( const QgsMultiPointXY &multipoint );

    static QgsGeometry fromPolylineXY( const QgsPolylineXY &polyline );

    static QgsGeometry fromPolyline( const QgsPolyline &polyline );

    static QgsGeometry fromMultiPolylineXY( const QgsMultiPolylineXY &multiline );
    static QgsGeometry fromPolygonXY( const QgsPolygonXY &polygon );
    static QgsGeometry fromMultiPolygonXY( const QgsMultiPolygonXY &multipoly );
    static QgsGeometry fromRect( const QgsRectangle &rect );
    static QgsGeometry collectGeometry( const QVector<QgsGeometry> &geometries );

    static QgsGeometry createWedgeBuffer( const QgsPoint &center, double azimuth, double angularWidth,
                                          double outerRadius, double innerRadius = 0 );

    void fromWkb( unsigned char *wkb, int length ) SIP_SKIP;

    void fromWkb( const QByteArray &wkb );

    QgsWkbTypes::Type wkbType() const;

    QgsWkbTypes::GeometryType type() const;

    bool isEmpty() const;

    bool isMultipart() const;

    bool equals( const QgsGeometry &geometry ) const;

    bool isGeosEqual( const QgsGeometry & ) const;

    bool isGeosValid() const;

    bool isSimple() const;

    double area() const;

    double length() const;

    double distance( const QgsGeometry &geom ) const;

#ifndef SIP_RUN

    QgsAbstractGeometry::vertex_iterator vertices_begin() const;

    QgsAbstractGeometry::vertex_iterator vertices_end() const;
#endif

    QgsVertexIterator vertices() const;

    double hausdorffDistance( const QgsGeometry &geom ) const;

    double hausdorffDistanceDensify( const QgsGeometry &geom, double densifyFraction ) const;

    //TODO QGIS 3.0 - rename beforeVertex to previousVertex, afterVertex to nextVertex
    QgsPointXY closestVertex( const QgsPointXY &point, int &atVertex SIP_OUT, int &beforeVertex SIP_OUT, int &afterVertex SIP_OUT, double &sqrDist SIP_OUT ) const;

    double distanceToVertex( int vertex ) const;

    double angleAtVertex( int vertex ) const;

    void adjacentVertices( int atVertex, int &beforeVertex SIP_OUT, int &afterVertex SIP_OUT ) const;

    bool insertVertex( double x, double y, int beforeVertex );

    bool insertVertex( const QgsPoint &point, int beforeVertex );

    bool moveVertex( double x, double y, int atVertex );

    bool moveVertex( const QgsPoint &p, int atVertex );

    bool deleteVertex( int atVertex );

    QgsPoint vertexAt( int atVertex ) const;

    double sqrDistToVertexAt( QgsPointXY &point SIP_IN, int atVertex ) const;

    QgsGeometry nearestPoint( const QgsGeometry &other ) const;

    QgsGeometry shortestLine( const QgsGeometry &other ) const;

    double closestVertexWithContext( const QgsPointXY &point, int &atVertex SIP_OUT ) const;

    double closestSegmentWithContext( const QgsPointXY &point, QgsPointXY &minDistPoint SIP_OUT, int &afterVertex SIP_OUT, int *leftOf SIP_OUT = nullptr, double epsilon = DEFAULT_SEGMENT_EPSILON ) const;

    OperationResult addRing( const QVector<QgsPointXY> &ring );

    OperationResult addRing( QgsCurve *ring SIP_TRANSFER );

    OperationResult addPart( const QVector<QgsPointXY> &points, QgsWkbTypes::GeometryType geomType = QgsWkbTypes::UnknownGeometry ) SIP_PYNAME( addPointsXY );

    OperationResult addPart( const QgsPointSequence &points, QgsWkbTypes::GeometryType geomType = QgsWkbTypes::UnknownGeometry ) SIP_PYNAME( addPoints );

    OperationResult addPart( QgsAbstractGeometry *part SIP_TRANSFER, QgsWkbTypes::GeometryType geomType = QgsWkbTypes::UnknownGeometry );

    OperationResult addPart( const QgsGeometry &newPart ) SIP_PYNAME( addPartGeometry );

    QgsGeometry removeInteriorRings( double minimumAllowedArea = -1 ) const;

    OperationResult translate( double dx, double dy, double dz = 0.0, double dm = 0.0 );

    OperationResult transform( const QgsCoordinateTransform &ct, QgsCoordinateTransform::TransformDirection direction = QgsCoordinateTransform::ForwardTransform, bool transformZ = false ) SIP_THROW( QgsCsException );

    OperationResult transform( const QTransform &t, double zTranslate = 0.0, double zScale = 1.0, double mTranslate = 0.0, double mScale = 1.0 );

    OperationResult rotate( double rotation, const QgsPointXY &center );

    OperationResult splitGeometry( const QVector<QgsPointXY> &splitLine, QVector<QgsGeometry> &newGeometries SIP_OUT, bool topological, QVector<QgsPointXY> &topologyTestPoints SIP_OUT );

    OperationResult reshapeGeometry( const QgsLineString &reshapeLineString );

    int makeDifferenceInPlace( const QgsGeometry &other ) SIP_SKIP;

    QgsGeometry makeDifference( const QgsGeometry &other ) const;

    QgsRectangle boundingBox() const;

    QgsGeometry orientedMinimumBoundingBox( double &area SIP_OUT, double &angle SIP_OUT, double &width SIP_OUT, double &height SIP_OUT ) const;

    QgsGeometry orientedMinimumBoundingBox() const SIP_SKIP;

    QgsGeometry minimalEnclosingCircle( QgsPointXY &center SIP_OUT, double &radius SIP_OUT, unsigned int segments = 36 ) const;

    QgsGeometry minimalEnclosingCircle( unsigned int segments = 36 ) const SIP_SKIP;

    QgsGeometry orthogonalize( double tolerance = 1.0E-8, int maxIterations = 1000, double angleThreshold = 15.0 ) const;

    QgsGeometry snappedToGrid( double hSpacing, double vSpacing, double dSpacing = 0, double mSpacing = 0 ) const;

    bool removeDuplicateNodes( double epsilon = 4 * std::numeric_limits<double>::epsilon(), bool useZValues = false );

    bool intersects( const QgsRectangle &rectangle ) const;

    bool intersects( const QgsGeometry &geometry ) const;

    bool boundingBoxIntersects( const QgsRectangle &rectangle ) const;

    bool boundingBoxIntersects( const QgsGeometry &geometry ) const;

    bool contains( const QgsPointXY *p ) const;

    bool contains( const QgsGeometry &geometry ) const;

    bool disjoint( const QgsGeometry &geometry ) const;

    bool touches( const QgsGeometry &geometry ) const;

    bool overlaps( const QgsGeometry &geometry ) const;

    bool within( const QgsGeometry &geometry ) const;

    bool crosses( const QgsGeometry &geometry ) const;

    enum BufferSide
    {
      SideLeft = 0, 
      SideRight, 
    };
    Q_ENUM( BufferSide )

    
    enum EndCapStyle
    {
      CapRound = 1, 
      CapFlat, 
      CapSquare, 
    };
    Q_ENUM( EndCapStyle )

    
    enum JoinStyle
    {
      JoinStyleRound = 1, 
      JoinStyleMiter, 
      JoinStyleBevel, 
    };
    Q_ENUM( JoinStyle )

    
    QgsGeometry buffer( double distance, int segments ) const;

    QgsGeometry buffer( double distance, int segments, EndCapStyle endCapStyle, JoinStyle joinStyle, double miterLimit ) const;

    QgsGeometry offsetCurve( double distance, int segments, JoinStyle joinStyle, double miterLimit ) const;

    QgsGeometry singleSidedBuffer( double distance, int segments, BufferSide side,
                                   JoinStyle joinStyle = JoinStyleRound,
                                   double miterLimit = 2.0 ) const;

    QgsGeometry taperedBuffer( double startWidth, double endWidth, int segments ) const;

    QgsGeometry variableWidthBufferByM( int segments ) const;

    QgsGeometry extendLine( double startDistance, double endDistance ) const;

    QgsGeometry simplify( double tolerance ) const;

    QgsGeometry densifyByCount( int extraNodesPerSegment ) const;

    QgsGeometry densifyByDistance( double distance ) const;

    QgsGeometry centroid() const;

    QgsGeometry pointOnSurface() const;

    QgsGeometry poleOfInaccessibility( double precision, double *distanceToBoundary SIP_OUT = nullptr ) const;

    QgsGeometry convexHull() const;

    QgsGeometry voronoiDiagram( const QgsGeometry &extent = QgsGeometry(), double tolerance = 0.0, bool edgesOnly = false ) const;

    QgsGeometry delaunayTriangulation( double tolerance = 0.0, bool edgesOnly = false ) const;

    QgsGeometry subdivide( int maxNodes = 256 ) const;

    QgsGeometry interpolate( double distance ) const;

    double lineLocatePoint( const QgsGeometry &point ) const;

    double interpolateAngle( double distance ) const;

    QgsGeometry intersection( const QgsGeometry &geometry ) const;

    QgsGeometry clipped( const QgsRectangle &rectangle );

    QgsGeometry combine( const QgsGeometry &geometry ) const;

    QgsGeometry mergeLines() const;

    QgsGeometry difference( const QgsGeometry &geometry ) const;

    QgsGeometry symDifference( const QgsGeometry &geometry ) const;

    QgsGeometry extrude( double x, double y );

    QByteArray asWkb() const;

    QString asWkt( int precision = 17 ) const;

#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsGeometry: %1>" ).arg( sipCpp->asWkt() );
    sipRes = PyUnicode_FromString( str.toUtf8().data() );
    % End
#endif

    QString asJson( int precision = 17 ) const;

    QgsGeometry convertToType( QgsWkbTypes::GeometryType destType, bool destMultipart = false ) const SIP_FACTORY;

    /* Accessor functions for getting geometry data */

    QgsPointXY asPoint() const;

    QgsPolylineXY asPolyline() const;

    QgsPolygonXY asPolygon() const;

    QgsMultiPointXY asMultiPoint() const;

    QgsMultiPolylineXY asMultiPolyline() const;

    QgsMultiPolygonXY asMultiPolygon() const;

    QVector<QgsGeometry> asGeometryCollection() const;

    QPointF asQPointF() const;

    QPolygonF asQPolygonF() const;

    bool deleteRing( int ringNum, int partNum = 0 );

    bool deletePart( int partNum );

    bool convertToMultiType();

    bool convertToSingleType();

    bool convertGeometryCollectionToSubclass( QgsWkbTypes::GeometryType geomType );

    int avoidIntersections( const QList<QgsVectorLayer *> &avoidIntersectionsLayers,
                            const QHash<QgsVectorLayer *, QSet<QgsFeatureId> > &ignoreFeatures SIP_PYARGREMOVE = ( QHash<QgsVectorLayer *, QSet<QgsFeatureId> >() ) );

    QgsGeometry makeValid() const;

    class CORE_EXPORT Error
    {
        QString message;
        QgsPointXY location;
        bool hasLocation = false;

      public:
        Error()
          : message( QStringLiteral( "none" ) )
        {}

        explicit Error( const QString &m )
          : message( m )
        {}

        Error( const QString &m, const QgsPointXY &p )
          : message( m )
          , location( p )
          , hasLocation( true ) {}

        QString what() { return message; }
        QgsPointXY where() { return location; }
        bool hasWhere() { return hasLocation; }
    };

    enum ValidationMethod
    {
      ValidatorQgisInternal, 
      ValidatorGeos, 
    };

    void validateGeometry( QVector<QgsGeometry::Error> &errors SIP_OUT, ValidationMethod method = ValidatorQgisInternal ) const;

    static QgsGeometry unaryUnion( const QVector<QgsGeometry> &geometries );

    static QgsGeometry polygonize( const QVector<QgsGeometry> &geometries );

    void convertToStraightSegment( double tolerance = M_PI / 180., QgsAbstractGeometry::SegmentationToleranceType toleranceType = QgsAbstractGeometry::MaximumAngle );

    bool requiresConversionToStraightSegments() const;

    void mapToPixel( const QgsMapToPixel &mtp );

    void draw( QPainter &p ) const;

    bool vertexIdFromVertexNr( int number, QgsVertexId &id SIP_OUT ) const;

    int vertexNrFromVertexId( QgsVertexId id ) const;

    QString lastError() const;

    void filterVertices( const std::function< bool( const QgsPoint & ) > &filter ) SIP_SKIP;

    static QgsGeometry fromQPointF( QPointF point );

    static QgsGeometry fromQPolygonF( const QPolygonF &polygon );

    static QgsPolylineXY createPolylineFromQPolygonF( const QPolygonF &polygon ) SIP_FACTORY;

    static QgsPolygonXY createPolygonFromQPolygonF( const QPolygonF &polygon ) SIP_FACTORY;

#ifndef SIP_RUN

    static bool compare( const QgsPolylineXY &p1, const QgsPolylineXY &p2,
                         double epsilon = 4 * std::numeric_limits<double>::epsilon() );

    static bool compare( const QgsPolygonXY &p1, const QgsPolygonXY &p2,
                         double epsilon = 4 * std::numeric_limits<double>::epsilon() );

    static bool compare( const QgsMultiPolygonXY &p1, const QgsMultiPolygonXY &p2,
                         double epsilon = 4 * std::numeric_limits<double>::epsilon() );
#else

    static bool compare( PyObject *obj1, PyObject *obj2, double epsilon = 4 * std::numeric_limits<double>::epsilon() );
    % MethodCode
    {
      sipRes = false;
      int state0;
      int state1;
      int sipIsErr = 0;

      if ( PyList_Check( a0 ) && PyList_Check( a1 ) &&
           PyList_GET_SIZE( a0 ) && PyList_GET_SIZE( a1 ) )
      {
        PyObject *o0 = PyList_GetItem( a0, 0 );
        PyObject *o1 = PyList_GetItem( a1, 0 );
        if ( o0 && o1 )
        {
          // compare polyline - polyline
          if ( sipCanConvertToType( o0, sipType_QgsPointXY, SIP_NOT_NONE ) &&
               sipCanConvertToType( o1, sipType_QgsPointXY, SIP_NOT_NONE ) &&
               sipCanConvertToType( a0, sipType_QVector_0100QgsPointXY, SIP_NOT_NONE ) &&
               sipCanConvertToType( a1, sipType_QVector_0100QgsPointXY, SIP_NOT_NONE ) )
          {
            QgsPolylineXY *p0;
            QgsPolylineXY *p1;
            p0 = reinterpret_cast<QgsPolylineXY *>( sipConvertToType( a0, sipType_QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state0, &sipIsErr ) );
            p1 = reinterpret_cast<QgsPolylineXY *>( sipConvertToType( a1, sipType_QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state1, &sipIsErr ) );
            if ( sipIsErr )
            {
              sipReleaseType( p0, sipType_QVector_0100QgsPointXY, state0 );
              sipReleaseType( p1, sipType_QVector_0100QgsPointXY, state1 );
            }
            else
            {
              sipRes = QgsGeometry::compare( *p0, *p1, a2 );
            }
          }
          else if ( PyList_Check( o0 ) && PyList_Check( o1 ) &&
                    PyList_GET_SIZE( o0 ) && PyList_GET_SIZE( o1 ) )
          {
            PyObject *oo0 = PyList_GetItem( o0, 0 );
            PyObject *oo1 = PyList_GetItem( o1, 0 );
            if ( oo0 && oo1 )
            {
              // compare polygon - polygon
              if ( sipCanConvertToType( oo0, sipType_QgsPointXY, SIP_NOT_NONE ) &&
                   sipCanConvertToType( oo1, sipType_QgsPointXY, SIP_NOT_NONE ) &&
                   sipCanConvertToType( a0, sipType_QVector_0600QVector_0100QgsPointXY, SIP_NOT_NONE ) &&
                   sipCanConvertToType( a1, sipType_QVector_0600QVector_0100QgsPointXY, SIP_NOT_NONE ) )
              {
                QgsPolygonXY *p0;
                QgsPolygonXY *p1;
                p0 = reinterpret_cast<QgsPolygonXY *>( sipConvertToType( a0, sipType_QVector_0600QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state0, &sipIsErr ) );
                p1 = reinterpret_cast<QgsPolygonXY *>( sipConvertToType( a1, sipType_QVector_0600QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state1, &sipIsErr ) );
                if ( sipIsErr )
                {
                  sipReleaseType( p0, sipType_QVector_0600QVector_0100QgsPointXY, state0 );
                  sipReleaseType( p1, sipType_QVector_0600QVector_0100QgsPointXY, state1 );
                }
                else
                {
                  sipRes = QgsGeometry::compare( *p0, *p1, a2 );
                }
              }
              else if ( PyList_Check( oo0 ) && PyList_Check( oo1 ) &&
                        PyList_GET_SIZE( oo0 ) && PyList_GET_SIZE( oo1 ) )
              {
                PyObject *ooo0 = PyList_GetItem( oo0, 0 );
                PyObject *ooo1 = PyList_GetItem( oo1, 0 );
                if ( ooo0 && ooo1 )
                {
                  // compare multipolygon - multipolygon
                  if ( sipCanConvertToType( ooo0, sipType_QgsPointXY, SIP_NOT_NONE ) &&
                       sipCanConvertToType( ooo1, sipType_QgsPointXY, SIP_NOT_NONE ) &&
                       sipCanConvertToType( a0, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, SIP_NOT_NONE ) &&
                       sipCanConvertToType( a1, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, SIP_NOT_NONE ) )
                  {
                    QgsMultiPolygonXY *p0;
                    QgsMultiPolygonXY *p1;
                    p0 = reinterpret_cast<QgsMultiPolygonXY *>( sipConvertToType( a0, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state0, &sipIsErr ) );
                    p1 = reinterpret_cast<QgsMultiPolygonXY *>( sipConvertToType( a1, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state1, &sipIsErr ) );
                    if ( sipIsErr )
                    {
                      sipReleaseType( p0, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, state0 );
                      sipReleaseType( p1, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, state1 );
                    }
                    else
                    {
                      sipRes = QgsGeometry::compare( *p0, *p1, a2 );
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
    % End
#endif

    QgsGeometry smooth( unsigned int iterations = 1, double offset = 0.25,
                        double minimumDistance = -1.0, double maxAngle = 180.0 ) const;

    static QgsGeometryEngine *createGeometryEngine( const QgsAbstractGeometry *geometry ) SIP_FACTORY;

    static void convertPointList( const QVector<QgsPointXY> &input, QgsPointSequence &output );

    static void convertPointList( const QgsPointSequence &input, QVector<QgsPointXY> &output );

    operator QVariant() const
    {
      return QVariant::fromValue( *this );
    }

    operator bool() const;

  private:

    QgsGeometryPrivate *d; //implicitly shared data pointer

    mutable QString mLastError;

    void detach();

    void reset( std::unique_ptr< QgsAbstractGeometry > newGeometry );

    static void convertToPolyline( const QgsPointSequence &input, QgsPolylineXY &output );
    static void convertPolygon( const QgsPolygon &input, QgsPolygonXY &output );

    QgsGeometry convertToPoint( bool destMultipart ) const;
    QgsGeometry convertToLine( bool destMultipart ) const;
    QgsGeometry convertToPolygon( bool destMultipart ) const;

    std::unique_ptr< QgsLineString > smoothLine( const QgsLineString &line, unsigned int iterations = 1, double offset = 0.25,
        double minimumDistance = -1, double maxAngle = 180.0 ) const;

    std::unique_ptr< QgsPolygon > smoothPolygon( const QgsPolygon &polygon, unsigned int iterations = 1, double offset = 0.25,
        double minimumDistance = -1, double maxAngle = 180.0 ) const;


    friend class QgsInternalGeometryEngine;

}; // class QgsGeometry

Q_DECLARE_METATYPE( QgsGeometry )

CORE_EXPORT QDataStream &operator<<( QDataStream &out, const QgsGeometry &geometry );
CORE_EXPORT QDataStream &operator>>( QDataStream &in, QgsGeometry &geometry );

#endif