qgsabstractgeometry.sip.in

/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/geometry/qgsabstractgeometry.h                              *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.py again   *
 ************************************************************************/








typedef QVector< QgsPoint > QgsPointSequence;
typedef QVector< QVector< QgsPoint > > QgsRingSequence;
typedef QVector< QVector< QVector< QgsPoint > > > QgsCoordinateSequence;


class QgsAbstractGeometry
{
%Docstring(signature="appended")
Abstract base class for all geometries.

.. note::

   :py:class:`QgsAbstractGeometry` objects are inherently Cartesian/planar geometries. They have no concept of geodesy, and none
   of the methods or properties exposed from the :py:class:`QgsAbstractGeometry` API (or :py:class:`QgsGeometry` API) utilize
   geodesic calculations. Accordingly, properties like :py:func:`~length` and :py:func:`~area` and spatial operations like :py:func:`~centroid`
   are always calculated using strictly Cartesian mathematics. In contrast, the :py:class:`QgsDistanceArea` class exposes
   methods for working with geodesic calculations and spatial operations on geometries,
   and should be used whenever calculations which account for the curvature of the Earth (or any other celestial body)
   are required.
%End

%TypeHeaderCode
#include "qgsabstractgeometry.h"
%End
%ConvertToSubClassCode
    if ( qgsgeometry_cast<QgsPoint *>( sipCpp ) != nullptr )
      sipType = sipType_QgsPoint;
    else if ( qgsgeometry_cast<QgsLineString *>( sipCpp ) != nullptr )
      sipType = sipType_QgsLineString;
    else if ( qgsgeometry_cast<QgsCircularString *>( sipCpp ) != nullptr )
      sipType = sipType_QgsCircularString;
    else if ( qgsgeometry_cast<QgsCompoundCurve *>( sipCpp ) != nullptr )
      sipType = sipType_QgsCompoundCurve;
    else if ( qgsgeometry_cast<QgsTriangle *>( sipCpp ) != nullptr )
      sipType = sipType_QgsTriangle;
    else if ( qgsgeometry_cast<QgsPolygon *>( sipCpp ) != nullptr )
      sipType = sipType_QgsPolygon;
    else if ( qgsgeometry_cast<QgsCurvePolygon *>( sipCpp ) != nullptr )
      sipType = sipType_QgsCurvePolygon;
    else if ( qgsgeometry_cast<QgsTriangulatedSurface *>( sipCpp ) != nullptr )
      sipType = sipType_QgsTriangulatedSurface;
    else if ( qgsgeometry_cast<QgsPolyhedralSurface *>( sipCpp ) != nullptr )
      sipType = sipType_QgsPolyhedralSurface;
    else if ( qgsgeometry_cast<QgsSurface *>( sipCpp ) != nullptr )
      sipType = sipType_QgsSurface;
    else if ( qgsgeometry_cast<QgsMultiPoint *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMultiPoint;
    else if ( qgsgeometry_cast<QgsMultiLineString *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMultiLineString;
    else if ( qgsgeometry_cast<QgsMultiPolygon *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMultiPolygon;
    else if ( qgsgeometry_cast<QgsMultiSurface *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMultiSurface;
    else if ( qgsgeometry_cast<QgsMultiCurve *>( sipCpp ) != nullptr )
      sipType = sipType_QgsMultiCurve;
    else if ( qgsgeometry_cast<QgsGeometryCollection *>( sipCpp ) != nullptr )
      sipType = sipType_QgsGeometryCollection;
    else
      sipType = 0;
%End
  public:
    static const QMetaObject staticMetaObject;

  public:

    enum SegmentationToleranceType /BaseType=IntEnum/
    {

      MaximumAngle,

      MaximumDifference
    };

    enum AxisOrder /BaseType=IntEnum/
    {

      XY,

      YX
    };

    QgsAbstractGeometry();
    virtual ~QgsAbstractGeometry();
    QgsAbstractGeometry( const QgsAbstractGeometry &geom );

    virtual bool operator==( const QgsAbstractGeometry &other ) const = 0;
    virtual bool operator!=( const QgsAbstractGeometry &other ) const = 0;

    virtual bool fuzzyEqual( const QgsAbstractGeometry &other, double epsilon = 1e-8 ) const = 0;
%Docstring
Performs fuzzy comparison between this geometry and ``other`` using an
``epsilon``.

The comparison is done by examining the specific values (such as x and
y) that define the location of vertices in the geometry.

.. seealso:: :py:func:`fuzzyDistanceEqual`

.. seealso:: :py:func:`QgsGeometryUtilsBase.fuzzyDistanceEqual`

.. versionadded:: 3.36
%End

    virtual bool fuzzyDistanceEqual( const QgsAbstractGeometry &other, double epsilon = 1e-8 ) const = 0;
%Docstring
Performs fuzzy distance comparison between this geometry and ``other``
using an ``epsilon``.

Traditionally, the comparison is done by examining the specific values
(such as x and y) that define the location of vertices in the geometry.
It focuses on the numerical differences or relationships between these
values. On the other hand, comparing distances between points considers
the actual spatial separation or length between the points, regardless
of their coordinate values. This comparison involves measuring the
distance between two points using formulas like the distance formula.
Here, it's the "distance comparison" (fuzzyDistanceEqual).

.. seealso:: :py:func:`fuzzyEqual`

.. seealso:: :py:func:`QgsGeometryUtilsBase.fuzzyEqual`

.. versionadded:: 3.36
%End

    virtual QgsAbstractGeometry *clone() const = 0 /Factory/;
%Docstring
Clones the geometry by performing a deep copy
%End

    virtual int compareTo( const QgsAbstractGeometry *other ) const;
%Docstring
Comparator for sorting of geometry.

.. versionadded:: 3.20
%End

    virtual void clear() = 0;
%Docstring
Clears the geometry, ie reset it to a null geometry
%End

    virtual QgsRectangle boundingBox() const;
%Docstring
Returns the minimal bounding box for the geometry
%End

    virtual QgsBox3D boundingBox3D() const = 0;
%Docstring
Returns the 3D bounding box for the geometry.

.. versionadded:: 3.34
%End


    virtual int dimension() const = 0;
%Docstring
Returns the inherent dimension of the geometry. For example, this is 0
for a point geometry, 1 for a linestring and 2 for a polygon.
%End

    virtual QString geometryType() const = 0;
%Docstring
Returns a unique string representing the geometry type.

.. seealso:: :py:func:`wkbType`

.. seealso:: :py:func:`wktTypeStr`
%End

    Qgis::WkbType wkbType() const /HoldGIL/;
%Docstring
Returns the WKB type of the geometry.

.. seealso:: :py:func:`geometryType`

.. seealso:: :py:func:`wktTypeStr`
%End

    QString wktTypeStr() const;
%Docstring
Returns the WKT type string of the geometry.

.. seealso:: :py:func:`geometryType`

.. seealso:: :py:func:`wkbType`
%End

    bool is3D() const /HoldGIL/;
%Docstring
Returns ``True`` if the geometry is 3D and contains a z-value.

.. seealso:: :py:func:`isMeasure`
%End

    bool isMeasure() const /HoldGIL/;
%Docstring
Returns ``True`` if the geometry contains m values.

.. seealso:: :py:func:`is3D`
%End

    virtual QgsAbstractGeometry *boundary() const = 0 /Factory/;
%Docstring
Returns the closure of the combinatorial boundary of the geometry (ie
the topological boundary of the geometry). For instance, a polygon
geometry will have a boundary consisting of the linestrings for each
ring in the polygon.

:return: boundary for geometry. May be ``None`` for some geometry types.
%End

    virtual void normalize() = 0;
%Docstring
Reorganizes the geometry into a normalized form (or "canonical" form).

Polygon rings will be rearranged so that their starting vertex is the
lower left and ring orientation follows the right hand rule, collections
are ordered by geometry type, and other normalization techniques are
applied. The resultant geometry will be geometrically equivalent to the
original geometry.

.. versionadded:: 3.20
%End


    virtual bool fromWkb( QgsConstWkbPtr &wkb ) = 0;
%Docstring
Sets the geometry from a WKB string. After successful read the wkb
argument will be at the position where the reading has stopped.

.. seealso:: :py:func:`fromWkt`
%End

    virtual bool fromWkt( const QString &wkt ) = 0;
%Docstring
Sets the geometry from a WKT string.

.. seealso:: :py:func:`fromWkb`
%End


    enum WkbFlag /BaseType=IntEnum/
    {
      FlagExportTrianglesAsPolygons,
      FlagExportNanAsDoubleMin,
    };
    typedef QFlags<QgsAbstractGeometry::WkbFlag> WkbFlags;


    virtual int wkbSize( QgsAbstractGeometry::WkbFlags flags = QgsAbstractGeometry::WkbFlags() ) const = 0;
%Docstring
Returns the length of the QByteArray returned by
:py:func:`~QgsAbstractGeometry.asWkb`

The optional ``flags`` argument specifies flags controlling WKB export
behavior

.. versionadded:: 3.16
%End

    virtual QByteArray asWkb( WkbFlags flags = QgsAbstractGeometry::WkbFlags() ) const = 0;
%Docstring
Returns a WKB representation of the geometry.

The optional ``flags`` argument specifies flags controlling WKB export
behavior (since QGIS 3.14).

.. seealso:: :py:func:`asWkt`

.. seealso:: :py:func:`asGml2`

.. seealso:: :py:func:`asGml3`

.. seealso:: :py:func:`asJson`
%End

    virtual QString asWkt( int precision = 17 ) const = 0;
%Docstring
Returns a WKT representation of the geometry.

:param precision: number of decimal places for coordinates

.. seealso:: :py:func:`asWkb`

.. seealso:: :py:func:`asGml2`

.. seealso:: :py:func:`asGml3`

.. seealso:: :py:func:`asJson`
%End

    virtual QDomElement asGml2( QDomDocument &doc, int precision = 17, const QString &ns = "gml", AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const = 0;
%Docstring
Returns a GML2 representation of the geometry.

:param doc: DOM document
:param precision: number of decimal places for coordinates
:param ns: XML namespace
:param axisOrder: Axis order for generated GML

.. seealso:: :py:func:`asWkb`

.. seealso:: :py:func:`asWkt`

.. seealso:: :py:func:`asGml3`

.. seealso:: :py:func:`asJson`
%End

    virtual QDomElement asGml3( QDomDocument &doc, int precision = 17, const QString &ns = "gml", AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const = 0;
%Docstring
Returns a GML3 representation of the geometry.

:param doc: DOM document
:param precision: number of decimal places for coordinates
:param ns: XML namespace
:param axisOrder: Axis order for generated GML

.. seealso:: :py:func:`asWkb`

.. seealso:: :py:func:`asWkt`

.. seealso:: :py:func:`asGml2`

.. seealso:: :py:func:`asJson`
%End

    QString asJson( int precision = 17 );
%Docstring
Returns a GeoJSON representation of the geometry as a string.

:param precision: number of decimal places for coordinates

.. seealso:: :py:func:`asWkb`

.. seealso:: :py:func:`asWkt`

.. seealso:: :py:func:`asGml2`

.. seealso:: :py:func:`asGml3`

.. seealso:: :py:func:`asJsonObject`
%End


    virtual QString asKml( int precision = 17 ) const = 0;
%Docstring
Returns a KML representation of the geometry.

.. versionadded:: 3.12
%End



    virtual void transform( const QgsCoordinateTransform &ct, Qgis::TransformDirection d = Qgis::TransformDirection::Forward, bool transformZ = false )  = 0;
%Docstring
Transforms the geometry using a coordinate transform

:param ct: coordinate transform
:param d: transformation direction
:param transformZ: set to ``True`` to also transform z coordinates. This
                   requires that the z coordinates in the geometry
                   represent height relative to the vertical datum of
                   the source CRS (generally ellipsoidal heights) and
                   are expressed in its vertical units (generally
                   meters). If ``False``, then z coordinates will not be
                   changed by the transform.
%End

    virtual void transform( const QTransform &t, double zTranslate = 0.0, double zScale = 1.0,
                            double mTranslate = 0.0, double mScale = 1.0 ) = 0;
%Docstring
Transforms the x and y components of the geometry using a QTransform
object ``t``.

Optionally, the geometry's z values can be scaled via ``zScale`` and
translated via ``zTranslate``. Similarly, m-values can be scaled via
``mScale`` and translated via ``mTranslate``.
%End

    virtual void draw( QPainter &p ) const = 0;
%Docstring
Draws the geometry using the specified QPainter.

:param p: destination QPainter
%End

    virtual QPainterPath asQPainterPath() const = 0;
%Docstring
Returns the geometry represented as a QPainterPath.

.. warning::

   not all geometry subclasses can be represented by a QPainterPath, e.g.
   points and multipoint geometries will return an empty path.

.. versionadded:: 3.16
%End

    virtual int vertexNumberFromVertexId( QgsVertexId id ) const = 0;
%Docstring
Returns the vertex number corresponding to a vertex ``id``.

The vertex numbers start at 0, so a return value of 0 corresponds to the
first vertex.

Returns -1 if a corresponding vertex could not be found.
%End

    virtual bool nextVertex( QgsVertexId &id, QgsPoint &vertex /Out/ ) const = 0;
%Docstring
Returns next vertex id and coordinates

:param id: initial value should be the starting vertex id. The next
           vertex id will be stored in this variable if found.

:return: - ``False`` if at end
         - vertex: container for found node
%End

    virtual void adjacentVertices( QgsVertexId vertex, QgsVertexId &previousVertex /Out/, QgsVertexId &nextVertex /Out/ ) const = 0;
%Docstring
Returns the vertices adjacent to a specified ``vertex`` within a
geometry.
%End

    virtual QgsCoordinateSequence coordinateSequence() const = 0;
%Docstring
Retrieves the sequence of geometries, rings and nodes.

:return: coordinate sequence
%End

    virtual int nCoordinates() const;
%Docstring
Returns the number of nodes contained in the geometry
%End

    virtual QgsPoint vertexAt( QgsVertexId id ) const = 0;
%Docstring
Returns the point corresponding to a specified vertex id
%End

    virtual double closestSegment( const QgsPoint &pt, QgsPoint &segmentPt /Out/,
                                   QgsVertexId &vertexAfter /Out/,
                                   int *leftOf /Out/ = 0, double epsilon = 4 * DBL_EPSILON ) const = 0;
%Docstring
Searches for the closest segment of the geometry to a given point.

:param pt: specifies the point to find closest segment to
:param epsilon: epsilon for segment snapping

:return: - squared distance to closest segment or negative value on
           error
         - segmentPt: the closest point within the geometry
         - vertexAfter: the ID of the vertex at the end of the closest
           segment
         - leftOf: indicates whether the point lies on the left side of
           the geometry (-1 if point is to the left of the geometry, +1
           if the point is to the right of the geometry, or 0 for cases
           where left/right could not be determined, e.g. point exactly
           on a line) ``False`` if point is to right of segment)
%End


    virtual bool insertVertex( QgsVertexId position, const QgsPoint &vertex ) = 0;
%Docstring
Inserts a vertex into the geometry

:param position: vertex id for position of inserted vertex
:param vertex: vertex to insert

:return: ``True`` if insert was successful

.. seealso:: :py:func:`moveVertex`

.. seealso:: :py:func:`deleteVertex`
%End

    virtual bool moveVertex( QgsVertexId position, const QgsPoint &newPos ) = 0;
%Docstring
Moves a vertex within the geometry

:param position: vertex id for vertex to move
:param newPos: new position of vertex

:return: ``True`` if move was successful

.. seealso:: :py:func:`insertVertex`

.. seealso:: :py:func:`deleteVertex`
%End

    virtual bool deleteVertex( QgsVertexId position ) = 0;
%Docstring
Deletes a vertex within the geometry

:param position: vertex id for vertex to delete

:return: ``True`` if delete was successful

.. seealso:: :py:func:`insertVertex`

.. seealso:: :py:func:`moveVertex`
%End

    virtual bool deleteVertices( const QList<QgsVertexId> &positions ) = 0;
%Docstring
Deletes vertices within the geometry If a vertex cannot be deleted, the
method returns ``False`` and the geometry may be left in a partially
modified and invalid state

:param positions: list of vertex ids for vertices to delete

:return: ``True`` if all requested vertices were deleted, ``False`` if a
         single vertex could not be deleted

.. seealso:: :py:func:`deleteVertex`

.. versionadded:: 4.0
%End

    virtual double length() const;
%Docstring
Returns the planar, 2-dimensional length of the geometry.

.. warning::

   QgsAbstractGeometry objects are inherently Cartesian/planar geometries, and the length
   returned by this method is calculated using strictly Cartesian mathematics. In contrast,
   the :py:class:`QgsDistanceArea` class exposes methods for calculating the lengths of geometries using
   geodesic calculations which account for the curvature of the Earth (or any other
   celestial body).

.. seealso:: :py:func:`area`

.. seealso:: :py:func:`perimeter`
%End

    virtual double perimeter() const;
%Docstring
Returns the planar, 2-dimensional perimeter of the geometry.

.. warning::

   QgsAbstractGeometry objects are inherently Cartesian/planar geometries, and the perimeter
   returned by this method is calculated using strictly Cartesian mathematics. In contrast,
   the :py:class:`QgsDistanceArea` class exposes methods for calculating the perimeters of geometries using
   geodesic calculations which account for the curvature of the Earth (or any other
   celestial body).

.. seealso:: :py:func:`area`

.. seealso:: :py:func:`length`
%End

    virtual double area() const;
%Docstring
Returns the planar, 2-dimensional area of the geometry.

.. warning::

   QgsAbstractGeometry objects are inherently Cartesian/planar geometries, and the area
   returned by this method is calculated using strictly Cartesian mathematics. In contrast,
   the :py:class:`QgsDistanceArea` class exposes methods for calculating the areas of geometries using
   geodesic calculations which account for the curvature of the Earth (or any other
   celestial body).

.. seealso:: :py:func:`length`

.. seealso:: :py:func:`perimeter`

.. seealso:: :py:func:`area`
%End

    virtual double area3D() const;
%Docstring
Returns the 3-dimensional surface area of the geometry.

.. warning::

   QgsAbstractGeometry objects are inherently Cartesian/planar geometries, and the area
   returned by this method is calculated using strictly Cartesian mathematics.

.. seealso:: :py:func:`area`

.. versionadded:: 4.0
%End

    virtual double segmentLength( QgsVertexId startVertex ) const = 0;
%Docstring
Returns the length of the segment of the geometry which begins at
``startVertex``.

.. warning::

   QgsAbstractGeometry objects are inherently Cartesian/planar geometries, and the lengths
   returned by this method are calculated using strictly Cartesian mathematics.
%End

    virtual QgsPoint centroid() const;
%Docstring
Returns the centroid of the geometry
%End

    virtual bool isEmpty() const;
%Docstring
Returns ``True`` if the geometry is empty
%End

    virtual bool hasCurvedSegments() const;
%Docstring
Returns ``True`` if the geometry contains curved segments
%End

    virtual bool boundingBoxIntersects( const QgsRectangle &rectangle ) const /HoldGIL/;
%Docstring
Returns ``True`` if the bounding box of this geometry intersects with a
``rectangle``.

Since this test only considers the bounding box of the geometry, is is
very fast to calculate and handles invalid geometries.

.. versionadded:: 3.20
%End

    virtual bool boundingBoxIntersects( const QgsBox3D &box3d ) const /HoldGIL/;
%Docstring
Returns ``True`` if the bounding box of this geometry intersects with a
``box3d``.

Since this test only considers the bounding box of the geometry, is is
very fast to calculate and handles invalid geometries.

.. versionadded:: 3.34
%End

    virtual QgsAbstractGeometry *segmentize( double tolerance = M_PI / 180., SegmentationToleranceType toleranceType = MaximumAngle ) const /Factory/;
%Docstring
Returns a version of the geometry without curves. Caller takes ownership
of the returned geometry.

:param tolerance: segmentation tolerance
:param toleranceType: maximum segmentation angle or maximum difference
                      between approximation and curve
%End

    virtual QgsAbstractGeometry *toCurveType() const = 0 /Factory/;
%Docstring
Returns the geometry converted to the more generic curve type. E.g.
:py:class:`QgsLineString` -> :py:class:`QgsCompoundCurve`,
:py:class:`QgsPolygon` -> :py:class:`QgsCurvePolygon`,
:py:class:`QgsMultiLineString` -> :py:class:`QgsMultiCurve`,
:py:class:`QgsMultiPolygon` -> :py:class:`QgsMultiSurface`

:return: the converted geometry. Caller takes ownership
%End

    virtual QgsAbstractGeometry *snappedToGrid( double hSpacing, double vSpacing, double dSpacing = 0, double mSpacing = 0, bool removeRedundantPoints = false ) const = 0 /Factory/;
%Docstring
Makes a new geometry with all the points or vertices snapped to the
closest point of the grid. Ownership is transferred to the caller.

If the gridified geometry could not be calculated ``None`` will be
returned. It may generate an invalid geometry (in some corner cases). It
can also be thought as rounding the edges and it may be useful for
removing errors.

Example:

.. code-block:: python

       geometry.snappedToGrid(1, 1)

In this case we use a 2D grid of 1x1 to gridify. In this case, it can be
thought like rounding the x and y of all the points/vertices to full
units (remove all decimals).

:param hSpacing: Horizontal spacing of the grid (x axis). 0 to disable.
:param vSpacing: Vertical spacing of the grid (y axis). 0 to disable.
:param dSpacing: Depth spacing of the grid (z axis). 0 (default) to
                 disable.
:param mSpacing: Custom dimension spacing of the grid (m axis). 0
                 (default) to disable.
:param removeRedundantPoints: if ``True``, then points which are
                              redundant (e.g. they represent mid points
                              on a straight line segment) will be
                              skipped (since QGIS 3.38)
%End

    virtual QgsAbstractGeometry *simplifyByDistance( double tolerance ) const = 0 /Factory/;
%Docstring
Simplifies the geometry by applying the Douglas Peucker simplification
by distance algorithm.

The caller takes ownership of the returned geometry. Curved geometries
will be segmentized prior to simplification.

If a simplified geometry cannot be calculated ``None`` will be returned.

The returned geometry may be invalid and contain self-intersecting
rings.

.. versionadded:: 3.38
%End

    virtual bool removeDuplicateNodes( double epsilon = 4 * DBL_EPSILON, bool useZValues = false ) = 0;
%Docstring
Removes duplicate nodes from the geometry, wherever removing the nodes
does not result in a degenerate geometry.

The ``epsilon`` parameter specifies the tolerance for coordinates when
determining that vertices are identical.

By default, z values are not considered when detecting duplicate nodes.
E.g. two nodes with the same x and y coordinate but different z values
will still be considered duplicate and one will be removed. If
``useZValues`` is ``True``, then the z values are also tested and nodes
with the same x and y but different z will be maintained.

Note that duplicate nodes are not tested between different parts of a
multipart geometry. E.g. a multipoint geometry with overlapping points
will not be changed by this method.

The function will return ``True`` if nodes were removed, or ``False`` if
no duplicate nodes were found.
%End

    virtual double vertexAngle( QgsVertexId vertex ) const = 0;
%Docstring
Returns approximate angle at a vertex. This is usually the average angle
between adjacent segments, and can be pictured as the orientation of a
line following the curvature of the geometry at the specified vertex.

:param vertex: the vertex id

:return: rotation in radians, clockwise from north
%End

    virtual int vertexCount( int part = 0, int ring = 0 ) const = 0;
%Docstring
Returns the number of vertices of which this geometry is built.
%End

    virtual int ringCount( int part = 0 ) const = 0;
%Docstring
Returns the number of rings of which this geometry is built.
%End

    virtual int partCount() const = 0;
%Docstring
Returns count of parts contained in the geometry.

.. seealso:: :py:func:`vertexCount`

.. seealso:: :py:func:`ringCount`
%End

    virtual bool addZValue( double zValue = 0 ) = 0;
%Docstring
Adds a z-dimension to the geometry, initialized to a preset value.

:param zValue: initial z-value for all nodes

:return: ``True`` on success

.. seealso:: :py:func:`dropZValue`

.. seealso:: :py:func:`addMValue`
%End

    virtual bool addMValue( double mValue = 0 ) = 0;
%Docstring
Adds a measure to the geometry, initialized to a preset value.

:param mValue: initial m-value for all nodes

:return: ``True`` on success

.. seealso:: :py:func:`dropMValue`

.. seealso:: :py:func:`addZValue`
%End

    virtual bool dropZValue() = 0;
%Docstring
Drops any z-dimensions which exist in the geometry.

:return: ``True`` if Z values were present and have been removed

.. seealso:: :py:func:`addZValue`

.. seealso:: :py:func:`dropMValue`
%End

    virtual bool dropMValue() = 0;
%Docstring
Drops any measure values which exist in the geometry.

:return: ``True`` if m-values were present and have been removed

.. seealso:: :py:func:`addMValue`

.. seealso:: :py:func:`dropZValue`
%End

    virtual void swapXy() = 0;
%Docstring
Swaps the x and y coordinates from the geometry. This can be used to
repair geometries which have accidentally had their latitude and
longitude coordinates reversed.

.. versionadded:: 3.2
%End

    virtual bool convertTo( Qgis::WkbType type );
%Docstring
Converts the geometry to a specified type.

:return: ``True`` if conversion was successful
%End

    virtual const QgsAbstractGeometry *simplifiedTypeRef() const /HoldGIL/;
%Docstring
Returns a reference to the simplest lossless representation of this
geometry, e.g. if the geometry is a multipart geometry type with a
single member geometry, a reference to that part will be returned.

This method employs the following logic:

- For multipart geometries containing a single part only a direct reference to that part will be returned.
- For compound curve geometries containing a single curve only a direct reference to that curve will be returned.

This method returns a reference only, and does not involve any geometry
cloning.

.. note::

   Ownership of the returned geometry is NOT transferred, and remains with the original
   geometry object. Callers must take care to ensure that the original geometry object
   exists for the lifespan of the returned object.

.. versionadded:: 3.20
%End

    virtual bool isValid( QString &error /Out/, Qgis::GeometryValidityFlags flags = Qgis::GeometryValidityFlags() ) const = 0;
%Docstring
Checks validity of the geometry, and returns ``True`` if the geometry is
valid.

:param flags: indicates optional flags which control the type of
              validity checking performed (corresponding to
              :py:class:`Qgis`.GeometryValidityFlags).

:return: - ``True`` if geometry is valid
         - error: the validity error message

.. versionadded:: 3.8
%End

    virtual bool transform( QgsAbstractGeometryTransformer *transformer, QgsFeedback *feedback = 0 ) = 0;
%Docstring
Transforms the vertices from the geometry in place, using the specified
geometry ``transformer`` object.

Depending on the ``transformer`` used, this may result in an invalid
geometry.

The optional ``feedback`` argument can be used to cancel the
transformation before it completes. If this is done, the geometry will
be left in a semi-transformed state.

:return: ``True`` if the geometry was successfully transformed.

.. versionadded:: 3.18
%End


    QgsGeometryPartIterator parts();
%Docstring
Returns Java-style iterator for traversal of parts of the geometry. This
iterator can safely be used to modify parts of the geometry.

Example

.. code-block:: python

       # print the WKT representation of each part in a multi-point geometry
       geometry = QgsGeometry.fromWkt( 'MultiPoint( 0 0, 1 1, 2 2)' )
       for part in geometry.parts():
           print(part.asWkt())

       # single part geometries only have one part - this loop will iterate once only
       geometry = QgsGeometry.fromWkt( 'LineString( 0 0, 10 10 )' )
       for part in geometry.parts():
           print(part.asWkt())

       # parts can be modified during the iteration
       geometry = QgsGeometry.fromWkt( 'MultiPoint( 0 0, 1 1, 2 2)' )
       for part in geometry.parts():
           part.transform(ct=QgsCoordinateTransform()) # Dummy transform

       # part iteration can also be combined with vertex iteration
       geometry = QgsGeometry.fromWkt( 'MultiPolygon((( 0 0, 0 10, 10 10, 10 0, 0 0 ),( 5 5, 5 6, 6 6, 6 5, 5 5)),((20 2, 22 2, 22 4, 20 4, 20 2)))' )
       for part in geometry.parts():
           for v in part.vertices():
               print(v.x(), v.y())

.. seealso:: :py:func:`vertices`

.. versionadded:: 3.6
%End


    QgsVertexIterator vertices() const;
%Docstring
Returns a read-only, Java-style iterator for traversal of vertices of
all the geometry, including all geometry parts and rings.

.. warning::

   The iterator returns a copy of individual vertices, and accordingly geometries cannot be
   modified using the iterator. See :py:func:`~QgsAbstractGeometry.transformVertices` for a safe method to modify vertices "in-place".

Example

.. code-block:: python

       # print the x and y coordinate for each vertex in a LineString
       geometry = QgsGeometry.fromWkt( 'LineString( 0 0, 1 1, 2 2)' )
       for v in geometry.vertices():
           print(v.x(), v.y())

       # vertex iteration includes all parts and rings
       geometry = QgsGeometry.fromWkt( 'MultiPolygon((( 0 0, 0 10, 10 10, 10 0, 0 0 ),( 5 5, 5 6, 6 6, 6 5, 5 5)),((20 2, 22 2, 22 4, 20 4, 20 2)))' )
       for v in geometry.vertices():
           print(v.x(), v.y())

.. seealso:: :py:func:`parts`
%End

    virtual QgsAbstractGeometry *createEmptyWithSameType() const = 0 /Factory/;
%Docstring
Creates a new geometry with the same class and same WKB type as the
original and transfers ownership. To create it, the geometry is default
constructed and then the WKB is changed.

.. seealso:: :py:func:`clone`
%End

  protected:

    int sortIndex() const;
%Docstring
Returns the sort index for the geometry, used in the
:py:func:`~QgsAbstractGeometry.compareTo` method to compare geometries
of different types.

.. versionadded:: 3.20
%End

    virtual int compareToSameClass( const QgsAbstractGeometry *other ) const = 0;
%Docstring
Compares to an ``other`` geometry of the same class, and returns a
integer for sorting of the two geometries.

.. note::

   The actual logic for the sorting is an internal detail only and is subject to change
   between QGIS versions. The result should only be used for direct comparison of geometries
   and not stored for later use.

.. versionadded:: 3.20
%End

    virtual bool hasChildGeometries() const;
%Docstring
Returns whether the geometry has any child geometries (``False`` for
point / curve, ``True`` otherwise)

.. note::

   used for vertex_iterator implementation
%End

    virtual int childCount() const;
%Docstring
Returns number of child geometries (for geometries with child
geometries) or child points (for geometries without child geometries -
i.e. curve / point)

.. note::

   used for vertex_iterator implementation
%End

    virtual QgsAbstractGeometry *childGeometry( int index ) const;
%Docstring
Returns pointer to child geometry (for geometries with child geometries
- i.e. geom. collection / polygon)

.. note::

   used for vertex_iterator implementation
%End

    virtual QgsPoint childPoint( int index ) const;
%Docstring
Returns point at index (for geometries without child geometries - i.e.
curve / point)

.. note::

   used for vertex_iterator implementation
%End

  protected:

    void setZMTypeFromSubGeometry( const QgsAbstractGeometry *subggeom, Qgis::WkbType baseGeomType );
%Docstring
Updates the geometry type based on whether sub geometries contain z or m
values.
%End

    virtual QgsRectangle calculateBoundingBox() const;
%Docstring
Default calculator for the minimal bounding box for the geometry.
Derived classes should override this method if a more efficient bounding
box calculation is available.
%End

    virtual QgsBox3D calculateBoundingBox3D() const;
%Docstring
Calculates the minimal 3D bounding box for the geometry.

.. seealso:: :py:func:`calculateBoundingBox`

.. versionadded:: 3.34
%End

    virtual void clearCache() const;
%Docstring
Clears any cached parameters associated with the geometry, e.g.,
bounding boxes
%End

};




class QgsVertexIterator
{
%Docstring(signature="appended")
Java-style iterator for traversal of vertices of a geometry.
%End

%TypeHeaderCode
#include "qgsabstractgeometry.h"
%End
  public:

    QgsVertexIterator();

    QgsVertexIterator( const QgsAbstractGeometry *geometry );
%Docstring
Constructs iterator for the given geometry
%End

    bool hasNext() const;
%Docstring
Find out whether there are more vertices
%End

    QgsPoint next();
%Docstring
Returns next vertex of the geometry (undefined behavior if
:py:func:`~QgsVertexIterator.hasNext` returns ``False`` before calling
:py:func:`~QgsVertexIterator.next`)
%End

    QgsVertexIterator *__iter__();
%MethodCode
    sipRes = sipCpp;
%End

    SIP_PYOBJECT __next__() /TypeHint="QgsPoint"/;
%MethodCode
    if ( sipCpp->hasNext() )
      sipRes = sipConvertFromType( new QgsPoint( sipCpp->next() ), sipType_QgsPoint, Py_None );
    else
      PyErr_SetString( PyExc_StopIteration, "" );
%End

};

class QgsGeometryPartIterator
{
%Docstring(signature="appended")
Java-style iterator for traversal of parts of a geometry.

.. versionadded:: 3.6
%End

%TypeHeaderCode
#include "qgsabstractgeometry.h"
%End
  public:

    QgsGeometryPartIterator();

    QgsGeometryPartIterator( QgsAbstractGeometry *geometry );
%Docstring
Constructs iterator for the given geometry
%End

    bool hasNext() const /HoldGIL/;
%Docstring
Find out whether there are more parts
%End

    QgsAbstractGeometry *next();
%Docstring
Returns next part of the geometry (undefined behavior if
:py:func:`~QgsGeometryPartIterator.hasNext` returns ``False`` before
calling :py:func:`~QgsGeometryPartIterator.next`)
%End

    QgsGeometryPartIterator *__iter__();
%MethodCode
    sipRes = sipCpp;
%End

    SIP_PYOBJECT __next__() /TypeHint="QgsAbstractGeometry"/;
%MethodCode
    if ( sipCpp->hasNext() )
      sipRes = sipConvertFromType( sipCpp->next(), sipType_QgsAbstractGeometry, NULL );
    else
      PyErr_SetString( PyExc_StopIteration, "" );
%End

};


class QgsGeometryConstPartIterator
{
%Docstring(signature="appended")
Java-style iterator for const traversal of parts of a geometry.

.. versionadded:: 3.6
%End

%TypeHeaderCode
#include "qgsabstractgeometry.h"
%End
  public:

    QgsGeometryConstPartIterator();

    QgsGeometryConstPartIterator( const QgsAbstractGeometry *geometry );
%Docstring
Constructs iterator for the given geometry
%End

    bool hasNext() const /HoldGIL/;
%Docstring
Find out whether there are more parts
%End

    const QgsAbstractGeometry *next();
%Docstring
Returns next part of the geometry (undefined behavior if
:py:func:`~QgsGeometryConstPartIterator.hasNext` returns ``False``
before calling :py:func:`~QgsGeometryConstPartIterator.next`)
%End

    QgsGeometryConstPartIterator *__iter__();
%MethodCode
    sipRes = sipCpp;
%End

    SIP_PYOBJECT __next__() /TypeHint="QgsAbstractGeometry"/;
%MethodCode
    if ( sipCpp->hasNext() )
      sipRes = sipConvertFromType( const_cast< QgsAbstractGeometry * >( sipCpp->next() ), sipType_QgsAbstractGeometry, NULL );
    else
      PyErr_SetString( PyExc_StopIteration, "" );
%End

};

QFlags<QgsAbstractGeometry::WkbFlag> operator|(QgsAbstractGeometry::WkbFlag f1, QFlags<QgsAbstractGeometry::WkbFlag> f2);


/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/geometry/qgsabstractgeometry.h                              *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.py again   *
 ************************************************************************/