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 <functional>
 
#include <QDomDocument>
#include <QJsonObject>
#include <QSet>
#include <QString>
#include <QVector>
 
#include <climits>
#include <limits>
#include <memory>
 
#include "qgis_core.h"
#include "qgis_sip.h"
 
#include "qgsabstractgeometry.h"
#include "qgspointxy.h"
#include "qgspoint.h"
#include "qgsfeatureid.h"
#include "qgsvertexid.h"
 
#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 QgsCurve;
class QgsFeedback;
 
typedef QVector<QgsPointXY> QgsPolylineXY;
 
typedef QgsPointSequence 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 QgsGeometryParameters
{
  public:
 
    double gridSize() const { return mGridSize; }
 
    void setGridSize( double size ) { mGridSize = size; }
 
  private:
 
    double mGridSize = -1;
};
class CORE_EXPORT QgsGeometryParameters {…};
 
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 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 length() const;
 
    double distance( const QgsGeometry &geom ) const;
 
#ifndef SIP_RUN
 
    // TODO QGIS 4: 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 4.0 this code can be dropped
     TODO QGIS 4 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, QStringLiteral( "Could not convert first argument to a list of QgsPoint or QgsPointXY." ).toUtf8().constData() );
        }
      }
      else
      {
        sipIsErr = 1;
        PyErr_SetString( PyExc_TypeError, QStringLiteral( "First argument is not a list of points or is empty." ).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, QStringLiteral( "Cannot generate points inside a null geometry." ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( type != Qgis::GeometryType::Polygon )
    {
      PyErr_SetString( PyExc_TypeError, QStringLiteral( "Cannot generate points inside a %1 geometry. Only Polygon types are permitted." ).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 = QStringLiteral( "<QgsGeometry: null>" );
    else
    {
      QString wkt = sipCpp->asWkt();
      if ( wkt.length() > 1000 )
        wkt = wkt.left( 1000 ) + QStringLiteral( "..." );
      str = QStringLiteral( "<QgsGeometry: %1>" ).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, QStringLiteral( "Null geometry cannot be converted to a point." ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else
    {
      const QgsAbstractGeometry *geom = sipCpp->constGet();
      if ( QgsWkbTypes::flatType( geom->simplifiedTypeRef()->wkbType() ) != Qgis::WkbType::Point )
      {
        PyErr_SetString( PyExc_TypeError, QStringLiteral( "%1 geometry cannot be converted to a point. Only Point types are permitted." ).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, QStringLiteral( "Null geometry cannot be converted to a polyline." ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( QgsWkbTypes::geometryType( type ) != Qgis::GeometryType::Line || QgsWkbTypes::isMultiType( type ) )
    {
      PyErr_SetString( PyExc_TypeError, QStringLiteral( "%1 geometry cannot be converted to a polyline. Only single line or curve types are permitted." ).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, QStringLiteral( "Null geometry cannot be converted to a polygon." ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( QgsWkbTypes::geometryType( type ) != Qgis::GeometryType::Polygon || QgsWkbTypes::isMultiType( type ) )
    {
      PyErr_SetString( PyExc_TypeError, QStringLiteral( "%1 geometry cannot be converted to a polygon. Only single polygon or curve polygon types are permitted." ).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, QStringLiteral( "Null geometry cannot be converted to a multipoint." ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( QgsWkbTypes::geometryType( type ) != Qgis::GeometryType::Point || !QgsWkbTypes::isMultiType( type ) )
    {
      PyErr_SetString( PyExc_TypeError, QStringLiteral( "%1 geometry cannot be converted to a multipoint. Only multipoint types are permitted." ).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, QStringLiteral( "Null geometry cannot be converted to a multilinestring." ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( QgsWkbTypes::geometryType( type ) != Qgis::GeometryType::Line || !QgsWkbTypes::isMultiType( type ) )
    {
      PyErr_SetString( PyExc_TypeError, QStringLiteral( "%1 geometry cannot be converted to a multilinestring. Only multi linestring or curves are permitted." ).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, QStringLiteral( "Null geometry cannot be converted to a multipolygon." ).toUtf8().constData() );
      sipIsErr = 1;
    }
    else if ( QgsWkbTypes::geometryType( type ) != Qgis::GeometryType::Polygon || !QgsWkbTypes::isMultiType( type ) )
    {
      PyErr_SetString( PyExc_TypeError, QStringLiteral( "%1 geometry cannot be converted to a multipolygon. Only multi polygon or curves are permitted." ).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( QStringLiteral( "none" ) )
        {}
        Error() {…}
 
        explicit Error( const QString &m )
          : mMessage( m )
        {}
        explicit Error( const QString &m ) {…}
 
        Error( const QString &m, const QgsPointXY &p )
          : mMessage( m )
          , mLocation( p )
          , mHasLocation( true ) {}
        Error( const QString &m, const QgsPointXY &p ) {…}
 
        QString what() const;
 
        QgsPointXY where() const;
 
        bool hasWhere() const;
 
#ifdef SIP_RUN
        SIP_PYOBJECT __repr__();
        % MethodCode
        QString str = QStringLiteral( "<QgsGeometry.Error: %1>" ).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;
        }
        bool operator==( const QgsGeometry::Error &other ) const {…}
 
      private:
        QString mMessage;
        QgsPointXY mLocation;
        bool mHasLocation = false;
    };
    class CORE_EXPORT Error {…};
 
    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 );
    }
    operator QVariant() const {…}
 
  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;
 
 
    friend class QgsInternalGeometryEngine;
 
}; // class QgsGeometry
class CORE_EXPORT QgsGeometry {…};
 
Q_DECLARE_METATYPE( QgsGeometry )
 
 
CORE_EXPORT QDataStream &operator<<( QDataStream &out, const QgsGeometry &geometry );
CORE_EXPORT QDataStream &operator>>( QDataStream &in, QgsGeometry &geometry );
 
#endif