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 <climits>
#include <functional>
#include <limits>
#include <memory>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsabstractgeometry.h"
#include "qgsfeatureid.h"
#include "qgspoint.h"
#include "qgspointxy.h"
#include "qgsvertexid.h"
 
#include <QDomDocument>
#include <QJsonObject>
#include <QSet>
#include <QString>
#include <QVector>
 
using namespace Qt::StringLiterals;
 
#ifndef SIP_RUN
#include <nlohmann/json_fwd.hpp>
using namespace nlohmann;
#endif
 
class QgsGeometryEngine;
class QgsVectorLayer;
class QgsMapToPixel;
class QPainter;
class QgsPolygon;
class QgsLineString;
class QgsCompoundCurve;
class QgsCurve;
class QgsFeedback;

typedef QVector<QgsPointXY> QgsPolylineXY;

#ifndef SIP_RUN
typedef QgsPointSequence QgsPolyline;
#else
typedef QVector<QgsPoint> QgsPolyline;
#endif

#ifndef SIP_RUN
typedef QVector<QgsPolyline> QgsMultiPolyline;
#else
typedef QVector<QVector< QgsPoint >> QgsMultiPolyline;
#endif

#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 QgsGeometryParameters
{
  public:
    double gridSize() const { return mGridSize; }

    void setGridSize( double size ) { mGridSize = size; }
 
  private:
    double mGridSize = -1;
};

class CORE_EXPORT QgsGeometry
{
    Q_GADGET
    Q_PROPERTY( bool isNull READ isNull )
    Q_PROPERTY( Qgis::GeometryType type READ type )
 
  public:
    QgsGeometry() SIP_HOLDGIL;

    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;
 
    virtual ~QgsGeometry();

    const QgsAbstractGeometry *constGet() const SIP_HOLDGIL;

    QgsAbstractGeometry *get();

    void set( QgsAbstractGeometry *geometry SIP_TRANSFER ) SIP_DEPRECATED;

    bool isNull() const SIP_HOLDGIL;

    Q_INVOKABLE static QgsGeometry fromWkt( const QString &wkt );
    static QgsGeometry fromPointXY( const QgsPointXY &point ) SIP_HOLDGIL;

    static QgsGeometry fromPoint( const QgsPoint &point ) SIP_HOLDGIL;

    static QgsGeometry fromMultiPointXY( const QgsMultiPointXY &multipoint );

    static QgsGeometry fromPolylineXY( const QgsPolylineXY &polyline );

    static QgsGeometry fromPolyline( const QgsPolyline &polyline );

    static QgsGeometry fromMultiPolylineXY( const QgsMultiPolylineXY &multiline );
 
#ifndef SIP_RUN

#else

#endif
    static QgsGeometry fromPolygonXY( const QgsPolygonXY &polygon );

    static QgsGeometry fromMultiPolygonXY( const QgsMultiPolygonXY &multipoly );

    static QgsGeometry fromRect( const QgsRectangle &rect ) SIP_HOLDGIL;

    static QgsGeometry fromBox3D( const QgsBox3D &box ) SIP_HOLDGIL;
 

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

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

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

    static QgsGeometry createWedgeBufferFromAngles( const QgsPoint &center, double startAngle, double endAngle, double outerRadius, double innerRadius = 0 );

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

    void fromWkb( const QByteArray &wkb );

    Qgis::WkbType wkbType() const SIP_HOLDGIL;

    Qgis::GeometryType type() const SIP_HOLDGIL;

    bool isEmpty() const SIP_HOLDGIL;

    bool isMultipart() const SIP_HOLDGIL;

    bool equals( const QgsGeometry &geometry ) const;

    bool isGeosEqual( const QgsGeometry & ) const;

    bool isGeosValid( Qgis::GeometryValidityFlags flags = Qgis::GeometryValidityFlags() ) const;

    bool isSimple() const;

    bool isAxisParallelRectangle( double maximumDeviation, bool simpleRectanglesOnly = false ) const;

    double area() const;

    double area3D() const SIP_THROW( QgsInvalidArgumentException );

    double length() const;

    double distance( const QgsGeometry &geom ) const;
 
#ifndef SIP_RUN
 
    // TODO QGIS 5: consider renaming vertices_begin, vertices_end, parts_begin, parts_end, etc
    // to camelCase

    QgsAbstractGeometry::vertex_iterator vertices_begin() const;

    QgsAbstractGeometry::vertex_iterator vertices_end() const;
#endif

    QgsVertexIterator vertices() const;
 
#ifndef SIP_RUN

    QgsAbstractGeometry::part_iterator parts_begin();

    QgsAbstractGeometry::part_iterator parts_end();

    QgsAbstractGeometry::const_part_iterator const_parts_begin() const;

    QgsAbstractGeometry::const_part_iterator const_parts_end() const;
#endif

    QgsGeometryPartIterator parts();

    QgsGeometryConstPartIterator constParts() const;

    double hausdorffDistance( const QgsGeometry &geom ) const;

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

    double frechetDistance( const QgsGeometry &geom ) const SIP_THROW( QgsNotSupportedException );

    double frechetDistanceDensify( const QgsGeometry &geom, double densifyFraction ) const SIP_THROW( QgsNotSupportedException );

    QgsPointXY closestVertex( const QgsPointXY &point, int &closestVertexIndex SIP_OUT, int &previousVertexIndex SIP_OUT, int &nextVertexIndex 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 addTopologicalPoint( const QgsPoint &point, double snappingTolerance = 1e-8, double segmentSearchEpsilon = 1e-12 );

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

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

    bool deleteVertex( int atVertex );

    bool toggleCircularAtVertex( 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 &nextVertexIndex SIP_OUT, int *leftOrRightOfSegment SIP_OUT = nullptr, double epsilon = Qgis::DEFAULT_SEGMENT_EPSILON ) const;

    Qgis::GeometryOperationResult addRing( const QVector<QgsPointXY> &ring );

    Qgis::GeometryOperationResult addRing( QgsCurve *ring SIP_TRANSFER );

    Q_DECL_DEPRECATED Qgis::GeometryOperationResult addPart( const QVector<QgsPointXY> &points, Qgis::GeometryType geomType = Qgis::GeometryType::Unknown ) SIP_PYNAME( addPointsXY ) SIP_DEPRECATED;

    Qgis::GeometryOperationResult addPartV2( const QVector<QgsPointXY> &points, Qgis::WkbType wkbType = Qgis::WkbType::Unknown ) SIP_PYNAME( addPointsXYV2 );

    Q_DECL_DEPRECATED Qgis::GeometryOperationResult addPart( const QgsPointSequence &points, Qgis::GeometryType geomType = Qgis::GeometryType::Unknown ) SIP_PYNAME( addPoints ) SIP_DEPRECATED;

    Qgis::GeometryOperationResult addPartV2( const QgsPointSequence &points, Qgis::WkbType wkbType = Qgis::WkbType::Unknown ) SIP_PYNAME( addPointsV2 );

    Q_DECL_DEPRECATED Qgis::GeometryOperationResult addPart( QgsAbstractGeometry *part SIP_TRANSFER, Qgis::GeometryType geomType = Qgis::GeometryType::Unknown ) SIP_DEPRECATED;

    Qgis::GeometryOperationResult addPartV2( QgsAbstractGeometry *part SIP_TRANSFER, Qgis::WkbType wkbType = Qgis::WkbType::Unknown );

    Qgis::GeometryOperationResult addPart( const QgsGeometry &newPart ) SIP_PYNAME( addPartGeometry );

    QgsGeometry removeInteriorRings( double minimumAllowedArea = -1 ) const;

    Qgis::GeometryOperationResult translate( double dx, double dy, double dz = 0.0, double dm = 0.0 );

    Qgis::GeometryOperationResult transform( const QgsCoordinateTransform &ct, Qgis::TransformDirection direction = Qgis::TransformDirection::Forward, bool transformZ = false ) SIP_THROW( QgsCsException );

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

    Qgis::GeometryOperationResult rotate( double rotation, const QgsPointXY &center );

    Q_DECL_DEPRECATED Qgis::GeometryOperationResult splitGeometry( const QVector<QgsPointXY> &splitLine, QVector<QgsGeometry> &newGeometries, bool topological, QVector<QgsPointXY> &topologyTestPoints, bool splitFeature = true ) SIP_SKIP;

    Qgis::GeometryOperationResult splitGeometry( const QgsPointSequence &splitLine, QVector<QgsGeometry> &newGeometries SIP_OUT, bool topological, QgsPointSequence &topologyTestPoints SIP_OUT, bool splitFeature = true, bool skipIntersectionTest SIP_PYARGREMOVE = false ) SIP_SKIP;
 
 
    /*
     This SIP code is to support overloaded methods of splitGeometry.
     When the deprecated method is removed in QGIS 5.0 this code can be dropped
     TODO QGIS 5 remove MethodCode
    */
#ifdef SIP_RUN

    SIP_PYOBJECT splitGeometry( SIP_PYOBJECT splitLine SIP_TYPEHINT( List[Union[QgsPoint, QgsPointXY]] ), bool topological, bool splitFeature = true ) SIP_TYPEHINT( Tuple[Qgis.GeometryOperationResult, Union[List[QgsPoint], List[QgsPointXY]], Union[List[QgsPoint], List[QgsPointXY]]] );
    % MethodCode
    {
      int sipIsErr = 0;
      int state;
 
      if ( PyList_Check( a0 ) && PyList_GET_SIZE( a0 ) )
      {
        PyObject *p0 = PyList_GetItem( a0, 0 );
        if ( sipCanConvertToType( p0, sipType_QgsPointXY, SIP_NOT_NONE ) && sipCanConvertToType( a0, sipType_QVector_0100QgsPointXY, SIP_NOT_NONE ) )
        {
          QVector<QgsGeometry> newGeometries;
          QVector<QgsPointXY> topologyTestPoints;
 
          QVector<QgsPointXY> *splitLine = reinterpret_cast<QVector<QgsPointXY> *>( sipConvertToType( a0, sipType_QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
          if ( !sipIsErr )
          {
            Qgis::GeometryOperationResult result = sipCpp->splitGeometry( *splitLine, newGeometries, a1, topologyTestPoints, a2 );
 
            PyObject *o0 = sipConvertFromEnum( static_cast<int>( result ), sipType_Qgis_GeometryOperationResult );
            PyObject *o1 = sipConvertFromType( &newGeometries, sipType_QVector_0100QgsGeometry, Py_None );
            PyObject *o2 = sipConvertFromType( &topologyTestPoints, sipType_QVector_0100QgsPointXY, Py_None );
 
            sipRes = PyTuple_New( 3 );
            PyTuple_SET_ITEM( sipRes, 0, o0 );
            PyTuple_SET_ITEM( sipRes, 1, o1 );
            PyTuple_SET_ITEM( sipRes, 2, o2 );
          }
          sipReleaseType( splitLine, sipType_QVector_0100QgsPointXY, state );
        }
 
        else if ( sipCanConvertToType( p0, sipType_QgsPoint, SIP_NOT_NONE ) && sipCanConvertToType( a0, sipType_QVector_0100QgsPoint, SIP_NOT_NONE ) )
        {
          QVector<QgsGeometry> newGeometries;
          QVector<QgsPoint> topologyTestPoints;
 
          QVector<QgsPoint> *splitLine = reinterpret_cast<QVector<QgsPoint> *>( sipConvertToType( a0, sipType_QVector_0100QgsPoint, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
          if ( !sipIsErr )
          {
            Qgis::GeometryOperationResult result = sipCpp->splitGeometry( *splitLine, newGeometries, a1, topologyTestPoints, a2 );
 
            PyObject *o0 = sipConvertFromEnum( static_cast<int>( result ), sipType_Qgis_GeometryOperationResult );
            PyObject *o1 = sipConvertFromType( &newGeometries, sipType_QVector_0100QgsGeometry, Py_None );
            PyObject *o2 = sipConvertFromType( &topologyTestPoints, sipType_QVector_0100QgsPoint, Py_None );
 
            sipRes = PyTuple_New( 3 );
            PyTuple_SET_ITEM( sipRes, 0, o0 );
            PyTuple_SET_ITEM( sipRes, 1, o1 );
            PyTuple_SET_ITEM( sipRes, 2, o2 );
          }
          sipReleaseType( splitLine, sipType_QVector_0100QgsPoint, state );
        }
        else
        {
          sipIsErr = 1;
          PyErr_SetString( PyExc_TypeError, u"Could not convert first argument to a list of QgsPoint or QgsPointXY."_s.toUtf8().constData() );
        }
      }
      else
      {
        sipIsErr = 1;
        PyErr_SetString( PyExc_TypeError, u"First argument is not a list of points or is empty."_s.toUtf8().constData() );
      }
    }
    % End
#endif

    Qgis::GeometryOperationResult splitGeometry( const QgsCurve *curve, QVector<QgsGeometry> &newGeometries SIP_OUT, bool preserveCircular, bool topological, QgsPointSequence &topologyTestPoints SIP_OUT, bool splitFeature = true );

    Qgis::GeometryOperationResult reshapeGeometry( const QgsLineString &reshapeLineString );

    int makeDifferenceInPlace( const QgsGeometry &other ) SIP_SKIP;

    QgsGeometry makeDifference( const QgsGeometry &other ) const;

    QgsRectangle boundingBox() const;

    QgsBox3D boundingBox3D() 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 triangularWaves( double wavelength, double amplitude, bool strictWavelength = false ) const;

    QgsGeometry triangularWavesRandomized( double minimumWavelength, double maximumWavelength, double minimumAmplitude, double maximumAmplitude, unsigned long seed = 0 ) const;

    QgsGeometry squareWaves( double wavelength, double amplitude, bool strictWavelength = false ) const;

    QgsGeometry squareWavesRandomized( double minimumWavelength, double maximumWavelength, double minimumAmplitude, double maximumAmplitude, unsigned long seed = 0 ) const;

    QgsGeometry roundWaves( double wavelength, double amplitude, bool strictWavelength = false ) const;

    QgsGeometry roundWavesRandomized( double minimumWavelength, double maximumWavelength, double minimumAmplitude, double maximumAmplitude, unsigned long seed = 0 ) const;

    QgsGeometry applyDashPattern( const QVector< double > &pattern, Qgis::DashPatternLineEndingRule startRule = Qgis::DashPatternLineEndingRule::NoRule, Qgis::DashPatternLineEndingRule endRule = Qgis::DashPatternLineEndingRule::NoRule, Qgis::DashPatternSizeAdjustment adjustment = Qgis::DashPatternSizeAdjustment::ScaleBothDashAndGap, double patternOffset = 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( double x, double y ) 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;

    QgsGeometry buffer( double distance, int segments ) const;

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

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

    QgsGeometry singleSidedBuffer( double distance, int segments, Qgis::BufferSide side, Qgis::JoinStyle joinStyle = Qgis::JoinStyle::Round, 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 convertToCurves( double distanceTolerance = 1e-8, double angleTolerance = 1e-8 ) const;

    QgsGeometry centroid() const;

    QgsGeometry pointOnSurface() const;

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

    QgsGeometry largestEmptyCircle( double tolerance, const QgsGeometry &boundary = QgsGeometry() ) const SIP_THROW( QgsNotSupportedException );

    QgsGeometry minimumWidth() const SIP_THROW( QgsNotSupportedException );

    double minimumClearance() const SIP_THROW( QgsNotSupportedException );

    QgsGeometry minimumClearanceLine() const SIP_THROW( QgsNotSupportedException );

    QgsGeometry convexHull() const;

    QgsGeometry concaveHull( double targetPercent, bool allowHoles = false ) const SIP_THROW( QgsNotSupportedException );

    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 constrainedDelaunayTriangulation() const SIP_THROW( QgsNotSupportedException );

    Qgis::CoverageValidityResult validateCoverage( double gapWidth, QgsGeometry *invalidEdges SIP_OUT = nullptr ) const SIP_THROW( QgsNotSupportedException );

    QgsGeometry simplifyCoverageVW( double tolerance, bool preserveBoundary ) const SIP_THROW( QgsNotSupportedException );

    QgsGeometry unionCoverage() const;

    QgsGeometry node() const;

    QgsGeometry sharedPaths( const QgsGeometry &other ) const;

    QgsGeometry subdivide( int maxNodes = 256, const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;

    QgsGeometry interpolate( double distance ) const;

    double lineLocatePoint( const QgsGeometry &point ) const;

    double interpolateAngle( double distance ) const;

    QgsGeometry intersection( const QgsGeometry &geometry, const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;

    QgsGeometry clipped( const QgsRectangle &rectangle );

    QgsGeometry combine( const QgsGeometry &geometry, const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;

    QgsGeometry mergeLines( const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;

    QgsGeometry difference( const QgsGeometry &geometry, const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;

    QgsGeometry symDifference( const QgsGeometry &geometry, const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;

    QgsGeometry extrude( double x, double y );
 
#ifndef SIP_RUN

    QVector< QgsPointXY > randomPointsInPolygon( int count, const std::function< bool( const QgsPointXY & ) > &acceptPoint, unsigned long seed = 0, QgsFeedback *feedback = nullptr, int maxTriesPerPoint = 0 ) const;

    QVector< QgsPointXY > randomPointsInPolygon( int count, unsigned long seed = 0, QgsFeedback *feedback = nullptr ) const;
#else

    SIP_PYOBJECT randomPointsInPolygon( int count, unsigned long seed = 0 ) const SIP_TYPEHINT( QgsPolylineXY );
    % MethodCode
    const Qgis::GeometryType type = sipCpp->type();
    if ( sipCpp->isNull() )
    {
      PyErr_SetString( PyExc_ValueError, u"Cannot generate points inside a null geometry."_s.toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( type != Qgis::GeometryType::Polygon )
    {
      PyErr_SetString( PyExc_TypeError, u"Cannot generate points inside a %1 geometry. Only Polygon types are permitted."_s.arg( QgsWkbTypes::displayString( sipCpp->wkbType() ) ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else
    {
      const sipTypeDef *qvector_type = sipFindType( "QVector<QgsPointXY>" );
      sipRes = sipConvertFromNewType( new QVector< QgsPointXY >( sipCpp->randomPointsInPolygon( a0, a1 ) ), qvector_type, Py_None );
    }
    % End
 
 
#endif

    int wkbSize( QgsAbstractGeometry::WkbFlags flags = QgsAbstractGeometry::WkbFlags() ) const;

    QByteArray asWkb( QgsAbstractGeometry::WkbFlags flags = QgsAbstractGeometry::WkbFlags() ) const;

    Q_INVOKABLE QString asWkt( int precision = 17 ) const;
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str;
    if ( sipCpp->isNull() )
      str = u"<QgsGeometry: null>"_s;
    else
    {
      QString wkt = sipCpp->asWkt();
      if ( wkt.length() > 1000 )
        wkt = wkt.left( 1000 ) + u"..."_s;
      str = u"<QgsGeometry: %1>"_s.arg( wkt );
    }
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif

    QString asJson( int precision = 17 ) const;

    virtual json asJsonObject( int precision = 17 ) const SIP_SKIP;

    QVector< QgsGeometry > coerceToType( Qgis::WkbType type, double defaultZ = 0, double defaultM = 0, bool avoidDuplicates = true ) const;

    QgsGeometry convertToType( Qgis::GeometryType destType, bool destMultipart = false ) const;
 
    /* Accessor functions for getting geometry data */
 
#ifndef SIP_RUN

    QgsPointXY asPoint() const;
#else

    SIP_PYOBJECT asPoint() const SIP_TYPEHINT( QgsPointXY );
    % MethodCode
    if ( sipCpp->isNull() )
    {
      PyErr_SetString( PyExc_ValueError, u"Null geometry cannot be converted to a point."_s.toUtf8().constData() );
      sipIsErr = 1;
    }
    else
    {
      const QgsAbstractGeometry *geom = sipCpp->constGet();
      if ( QgsWkbTypes::flatType( geom->simplifiedTypeRef()->wkbType() ) != Qgis::WkbType::Point )
      {
        PyErr_SetString( PyExc_TypeError, u"%1 geometry cannot be converted to a point. Only Point types are permitted."_s.arg( QgsWkbTypes::displayString( geom->wkbType() ) ).toUtf8().constData() );
        sipIsErr = 1;
      }
      else
      {
        sipRes = sipConvertFromNewType( new QgsPointXY( sipCpp->asPoint() ), sipType_QgsPointXY, Py_None );
      }
    }
    % End
#endif
 
#ifndef SIP_RUN

    QgsPolylineXY asPolyline() const;
#else

    SIP_PYOBJECT asPolyline() const SIP_TYPEHINT( QgsPolylineXY );
    % MethodCode
    const Qgis::WkbType type = sipCpp->wkbType();
    if ( sipCpp->isNull() )
    {
      PyErr_SetString( PyExc_ValueError, u"Null geometry cannot be converted to a polyline."_s.toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( QgsWkbTypes::geometryType( type ) != Qgis::GeometryType::Line || QgsWkbTypes::isMultiType( type ) )
    {
      PyErr_SetString( PyExc_TypeError, u"%1 geometry cannot be converted to a polyline. Only single line or curve types are permitted."_s.arg( QgsWkbTypes::displayString( type ) ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else
    {
      const sipTypeDef *qvector_type = sipFindType( "QVector< QgsPointXY >" );
      sipRes = sipConvertFromNewType( new QgsPolylineXY( sipCpp->asPolyline() ), qvector_type, Py_None );
    }
    % End
#endif
 
#ifndef SIP_RUN

    QgsPolygonXY asPolygon() const;
#else

    SIP_PYOBJECT asPolygon() const SIP_TYPEHINT( QgsPolygonXY );
    % MethodCode
    const Qgis::WkbType type = sipCpp->wkbType();
    if ( sipCpp->isNull() )
    {
      PyErr_SetString( PyExc_ValueError, u"Null geometry cannot be converted to a polygon."_s.toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( QgsWkbTypes::geometryType( type ) != Qgis::GeometryType::Polygon || QgsWkbTypes::isMultiType( type ) )
    {
      PyErr_SetString( PyExc_TypeError, u"%1 geometry cannot be converted to a polygon. Only single polygon or curve polygon types are permitted."_s.arg( QgsWkbTypes::displayString( type ) ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else
    {
      const sipTypeDef *qvector_type = sipFindType( "QVector<QVector<QgsPointXY>>" );
      sipRes = sipConvertFromNewType( new QgsPolygonXY( sipCpp->asPolygon() ), qvector_type, Py_None );
    }
    % End
#endif
 
#ifndef SIP_RUN

    QgsMultiPointXY asMultiPoint() const;
#else

    SIP_PYOBJECT asMultiPoint() const SIP_TYPEHINT( QgsMultiPointXY );
    % MethodCode
    const Qgis::WkbType type = sipCpp->wkbType();
    if ( sipCpp->isNull() )
    {
      PyErr_SetString( PyExc_ValueError, u"Null geometry cannot be converted to a multipoint."_s.toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( QgsWkbTypes::geometryType( type ) != Qgis::GeometryType::Point || !QgsWkbTypes::isMultiType( type ) )
    {
      PyErr_SetString( PyExc_TypeError, u"%1 geometry cannot be converted to a multipoint. Only multipoint types are permitted."_s.arg( QgsWkbTypes::displayString( type ) ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else
    {
      const sipTypeDef *qvector_type = sipFindType( "QVector< QgsPointXY >" );
      sipRes = sipConvertFromNewType( new QgsPolylineXY( sipCpp->asMultiPoint() ), qvector_type, Py_None );
    }
    % End
#endif
 
#ifndef SIP_RUN

    QgsMultiPolylineXY asMultiPolyline() const;
#else

    SIP_PYOBJECT asMultiPolyline() const SIP_TYPEHINT( QgsMultiPolylineXY );
    % MethodCode
    const Qgis::WkbType type = sipCpp->wkbType();
    if ( sipCpp->isNull() )
    {
      PyErr_SetString( PyExc_ValueError, u"Null geometry cannot be converted to a multilinestring."_s.toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( QgsWkbTypes::geometryType( type ) != Qgis::GeometryType::Line || !QgsWkbTypes::isMultiType( type ) )
    {
      PyErr_SetString( PyExc_TypeError, u"%1 geometry cannot be converted to a multilinestring. Only multi linestring or curves are permitted."_s.arg( QgsWkbTypes::displayString( type ) ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else
    {
      const sipTypeDef *qvector_type = sipFindType( "QVector<QVector<QgsPointXY>>" );
      sipRes = sipConvertFromNewType( new QgsMultiPolylineXY( sipCpp->asMultiPolyline() ), qvector_type, Py_None );
    }
    % End
#endif
 
#ifndef SIP_RUN

    QgsMultiPolygonXY asMultiPolygon() const;
#else

    SIP_PYOBJECT asMultiPolygon() const SIP_TYPEHINT( QgsMultiPolygonXY );
    % MethodCode
    const Qgis::WkbType type = sipCpp->wkbType();
    if ( sipCpp->isNull() )
    {
      PyErr_SetString( PyExc_ValueError, u"Null geometry cannot be converted to a multipolygon."_s.toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( QgsWkbTypes::geometryType( type ) != Qgis::GeometryType::Polygon || !QgsWkbTypes::isMultiType( type ) )
    {
      PyErr_SetString( PyExc_TypeError, u"%1 geometry cannot be converted to a multipolygon. Only multi polygon or curves are permitted."_s.arg( QgsWkbTypes::displayString( type ) ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else
    {
      const sipTypeDef *qvector_type = sipFindType( "QVector<QVector<QVector<QgsPointXY>>>" );
      sipRes = sipConvertFromNewType( new QgsMultiPolygonXY( sipCpp->asMultiPolygon() ), qvector_type, Py_None );
    }
    % End
#endif

    QVector<QgsGeometry> asGeometryCollection() const;

    QPointF asQPointF() const SIP_HOLDGIL;

    QPolygonF asQPolygonF() const SIP_HOLDGIL;

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

    bool deletePart( int partNum );

    bool convertToMultiType();

    bool convertToCurvedMultiType();

    bool convertToSingleType();

    bool convertGeometryCollectionToSubclass( Qgis::GeometryType geomType );

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

    Qgis::GeometryOperationResult avoidIntersectionsV2( const QList<QgsVectorLayer *> &avoidIntersectionsLayers, const QHash<QgsVectorLayer *, QSet<QgsFeatureId> > &ignoreFeatures SIP_PYARGREMOVE = ( QHash<QgsVectorLayer *, QSet<QgsFeatureId> >() ) );

    QgsGeometry makeValid( Qgis::MakeValidMethod method = Qgis::MakeValidMethod::Linework, bool keepCollapsed = false ) const SIP_THROW( QgsNotSupportedException );

    Qgis::AngularDirection polygonOrientation() const;

    bool isPolygonCounterClockwise() const { return polygonOrientation() == Qgis::AngularDirection::CounterClockwise; }

    bool isPolygonClockwise() const { return polygonOrientation() == Qgis::AngularDirection::Clockwise; }
 

    QgsGeometry forceRHR() const;

    QgsGeometry forcePolygonClockwise() const;

    QgsGeometry forcePolygonCounterClockwise() const;

    class CORE_EXPORT Error
    {
      public:
        Error()
          : mMessage( u"none"_s )
        {}
 
        explicit Error( const QString &m )
          : mMessage( m )
        {}
 
        Error( const QString &m, const QgsPointXY &p )
          : mMessage( m )
          , mLocation( p )
          , mHasLocation( true ) {}

        QString what() const;

        QgsPointXY where() const;

        bool hasWhere() const;
 
#ifdef SIP_RUN
        SIP_PYOBJECT __repr__();
        % MethodCode
        QString str = u"<QgsGeometry.Error: %1>"_s.arg( sipCpp->what() );
        sipRes = PyUnicode_FromString( str.toUtf8().data() );
        % End
#endif
 
        // TODO c++20 - replace with = default
        bool operator==( const QgsGeometry::Error &other ) const
        {
          return other.mMessage == mMessage && other.mHasLocation == mHasLocation && other.mLocation == mLocation;
        }
 
      private:
        QString mMessage;
        QgsPointXY mLocation;
        bool mHasLocation = false;
    };

    void validateGeometry( QVector<QgsGeometry::Error> &errors SIP_OUT, Qgis::GeometryValidationEngine method = Qgis::GeometryValidationEngine::QgisInternal, Qgis::GeometryValidityFlags flags = Qgis::GeometryValidityFlags() ) const;

    void normalize();

    static QgsGeometry unaryUnion( const QVector<QgsGeometry> &geometries, const QgsGeometryParameters &parameters = QgsGeometryParameters() );

    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 SIP_HOLDGIL;

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

    void transformVertices( const std::function< QgsPoint( const QgsPoint & ) > &transform ) SIP_SKIP;

    static QgsGeometry fromQPointF( QPointF point ) SIP_HOLDGIL;

    static QgsGeometry fromQPolygonF( const QPolygonF &polygon );

    Q_DECL_DEPRECATED static QgsPolylineXY createPolylineFromQPolygonF( const QPolygonF &polygon ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED static QgsPolygonXY createPolygonFromQPolygonF( const QPolygonF &polygon ) SIP_DEPRECATED;
 
#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 )
            {
              sipRes = QgsGeometry::compare( *p0, *p1, a2 );
            }
            sipReleaseType( p0, sipType_QVector_0100QgsPointXY, state0 );
            sipReleaseType( p1, sipType_QVector_0100QgsPointXY, state1 );
          }
          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 )
                {
                  sipRes = QgsGeometry::compare( *p0, *p1, a2 );
                }
                sipReleaseType( p0, sipType_QVector_0600QVector_0100QgsPointXY, state0 );
                sipReleaseType( p1, sipType_QVector_0600QVector_0100QgsPointXY, state1 );
              }
              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 )
                    {
                      sipRes = QgsGeometry::compare( *p0, *p1, a2 );
                    }
                    sipReleaseType( p0, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, state0 );
                    sipReleaseType( p1, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, state1 );
                  }
                }
              }
            }
          }
        }
      }
    }
    % 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, double precision = 0.0, Qgis::GeosCreationFlags flags = Qgis::GeosCreationFlag::SkipEmptyInteriorRings ) 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 );
    }

    enum class ChamferFilletOperationType : int SIP_SKIP
    {
      Chamfer = 1,
      Fillet,
    };
#ifndef SIP_RUN
    Q_ENUM( ChamferFilletOperationType )
#endif

    QgsGeometry fillet( int vertexIndex, double radius, int segments = 8 ) const;

    static QgsGeometry fillet( const QgsPoint &segment1Start, const QgsPoint &segment1End, const QgsPoint &segment2Start, const QgsPoint &segment2End, double radius, int segments = 8 ) SIP_THROW( QgsInvalidArgumentException );

    QgsGeometry chamfer( int vertexIndex, double distance1, double distance2 = -1.0 ) const;

    static QgsGeometry chamfer( const QgsPoint &segment1Start, const QgsPoint &segment1End, const QgsPoint &segment2Start, const QgsPoint &segment2End, double distance1, double distance2 = -1.0 ) SIP_THROW( QgsInvalidArgumentException );
 
 
  private:
    QgsGeometryPrivate *d; //implicitly shared data pointer

    mutable QString mLastError;

    void detach();

    void reset( std::unique_ptr< QgsAbstractGeometry > newGeometry );
 
    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;
 
    QgsGeometry doChamferFillet( ChamferFilletOperationType op, int vertexIndex, double distance1, double distance2, int segments ) 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