QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsgeometry.h
Go to the documentation of this file.
1/***************************************************************************
2 qgsgeometry.h - Geometry (stored as Open Geospatial Consortium WKB)
3 -------------------------------------------------------------------
4Date : 02 May 2005
5Copyright : (C) 2005 by Brendan Morley
6email : morb at ozemail dot com dot au
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#ifndef QGSGEOMETRY_H
17#define QGSGEOMETRY_H
18
19#include <functional>
20
21#include <QDomDocument>
22#include <QJsonObject>
23#include <QSet>
24#include <QString>
25#include <QVector>
26
27#include <climits>
28#include <limits>
29#include <memory>
30
31#include "qgis_core.h"
32#include "qgis_sip.h"
33
34#include "qgsabstractgeometry.h"
35#include "qgspointxy.h"
36#include "qgspoint.h"
37#include "qgsfeatureid.h"
38#include "qgsvertexid.h"
39
40#ifndef SIP_RUN
41#include <nlohmann/json_fwd.hpp>
42using namespace nlohmann;
43#endif
44
46class QgsVectorLayer;
47class QgsMapToPixel;
48class QPainter;
49class QgsPolygon;
50class QgsLineString;
51class QgsCurve;
52class QgsFeedback;
53
62typedef QVector<QgsPointXY> QgsPolylineXY;
63
71
73#ifndef SIP_RUN
74typedef QVector<QgsPolylineXY> QgsPolygonXY;
75#else
76typedef QVector<QVector<QgsPointXY>> QgsPolygonXY;
77#endif
78
80typedef QVector<QgsPointXY> QgsMultiPointXY;
81
83#ifndef SIP_RUN
84typedef QVector<QgsPolylineXY> QgsMultiPolylineXY;
85#else
86typedef QVector<QVector<QgsPointXY>> QgsMultiPolylineXY;
87#endif
88
90#ifndef SIP_RUN
91typedef QVector<QgsPolygonXY> QgsMultiPolygonXY;
92#else
93typedef QVector<QVector<QVector<QgsPointXY>>> QgsMultiPolygonXY;
94#endif
95
96class QgsRectangle;
97
98class QgsConstWkbPtr;
99
100struct QgsGeometryPrivate;
101
108class CORE_EXPORT QgsGeometryParameters
109{
110 public:
111
122 double gridSize() const { return mGridSize; }
123
134 void setGridSize( double size ) { mGridSize = size; }
135
136 private:
137
138 double mGridSize = -1;
139};
140
161class CORE_EXPORT QgsGeometry
162{
163 Q_GADGET
164 Q_PROPERTY( bool isNull READ isNull )
165 Q_PROPERTY( Qgis::GeometryType type READ type )
166
167 public:
168
170
172 QgsGeometry( const QgsGeometry & );
173
178 QgsGeometry &operator=( QgsGeometry const &rhs ) SIP_SKIP;
179
185
191 explicit QgsGeometry( std::unique_ptr< QgsAbstractGeometry > geom ) SIP_SKIP;
192
193 virtual ~QgsGeometry();
194
205 const QgsAbstractGeometry *constGet() const SIP_HOLDGIL;
206
218 QgsAbstractGeometry *get();
219
231 void set( QgsAbstractGeometry *geometry SIP_TRANSFER ) SIP_DEPRECATED;
232
240 bool isNull() const SIP_HOLDGIL;
241
243 Q_INVOKABLE static QgsGeometry fromWkt( const QString &wkt );
245 static QgsGeometry fromPointXY( const QgsPointXY &point ) SIP_HOLDGIL;
246
252 static QgsGeometry fromPoint( const QgsPoint &point ) SIP_HOLDGIL;
253
255 static QgsGeometry fromMultiPointXY( const QgsMultiPointXY &multipoint );
256
267 static QgsGeometry fromPolylineXY( const QgsPolylineXY &polyline );
268
277 static QgsGeometry fromPolyline( const QgsPolyline &polyline );
278
282 static QgsGeometry fromMultiPolylineXY( const QgsMultiPolylineXY &multiline );
283
284#ifndef SIP_RUN
285
289#else
290
308#endif
309 static QgsGeometry fromPolygonXY( const QgsPolygonXY &polygon );
310
314 static QgsGeometry fromMultiPolygonXY( const QgsMultiPolygonXY &multipoly );
315
317 static QgsGeometry fromRect( const QgsRectangle &rect ) SIP_HOLDGIL;
318
326 static QgsGeometry fromBox3D( const QgsBox3D &box ) SIP_HOLDGIL;
327
328
330 static QgsGeometry collectGeometry( const QVector<QgsGeometry> &geometries );
331
347 static QgsGeometry createWedgeBuffer( const QgsPoint &center, double azimuth, double angularWidth,
348 double outerRadius, double innerRadius = 0 );
349
363 static QgsGeometry createWedgeBufferFromAngles( const QgsPoint &center, double startAngle, double endAngle,
364 double outerRadius, double innerRadius = 0 );
365
371 void fromWkb( unsigned char *wkb, int length ) SIP_SKIP;
372
376 void fromWkb( const QByteArray &wkb );
377
382 Qgis::WkbType wkbType() const SIP_HOLDGIL;
383
388 Qgis::GeometryType type() const SIP_HOLDGIL;
389
396 bool isEmpty() const SIP_HOLDGIL;
397
399 bool isMultipart() const SIP_HOLDGIL;
400
414 bool equals( const QgsGeometry &geometry ) const;
415
431 bool isGeosEqual( const QgsGeometry & ) const;
432
439 bool isGeosValid( Qgis::GeometryValidityFlags flags = Qgis::GeometryValidityFlags() ) const;
440
448 bool isSimple() const;
449
463 bool isAxisParallelRectangle( double maximumDeviation, bool simpleRectanglesOnly = false ) const;
464
476 double area() const;
477
491 double length() const;
492
500 double distance( const QgsGeometry &geom ) const;
501
502#ifndef SIP_RUN
503
504 // TODO QGIS 4: consider renaming vertices_begin, vertices_end, parts_begin, parts_end, etc
505 // to camelCase
506
510 QgsAbstractGeometry::vertex_iterator vertices_begin() const;
511
515 QgsAbstractGeometry::vertex_iterator vertices_end() const;
516#endif
517
540 QgsVertexIterator vertices() const;
541
542#ifndef SIP_RUN
543
553
563
572 QgsAbstractGeometry::const_part_iterator const_parts_begin() const;
573
582 QgsAbstractGeometry::const_part_iterator const_parts_end() const;
583#endif
584
623
656 QgsGeometryConstPartIterator constParts() const;
657
674 double hausdorffDistance( const QgsGeometry &geom ) const;
675
693 double hausdorffDistanceDensify( const QgsGeometry &geom, double densifyFraction ) const;
694
709 double frechetDistance( const QgsGeometry &geom ) const SIP_THROW( QgsNotSupportedException );
710
733 double frechetDistanceDensify( const QgsGeometry &geom, double densifyFraction ) const SIP_THROW( QgsNotSupportedException );
734
747 QgsPointXY closestVertex( const QgsPointXY &point, int &closestVertexIndex SIP_OUT, int &previousVertexIndex SIP_OUT, int &nextVertexIndex SIP_OUT, double &sqrDist SIP_OUT ) const;
748
756 double distanceToVertex( int vertex ) const;
757
764 double angleAtVertex( int vertex ) const;
765
778 void adjacentVertices( int atVertex, int &beforeVertex SIP_OUT, int &afterVertex SIP_OUT ) const;
779
792 bool insertVertex( double x, double y, int beforeVertex );
793
806 bool insertVertex( const QgsPoint &point, int beforeVertex );
807
815 bool addTopologicalPoint( const QgsPoint &point, double snappingTolerance = 1e-8, double segmentSearchEpsilon = 1e-12 );
816
824 bool moveVertex( double x, double y, int atVertex );
825
833 bool moveVertex( const QgsPoint &p, int atVertex );
834
846 bool deleteVertex( int atVertex );
847
855 bool toggleCircularAtVertex( int atVertex );
856
862 QgsPoint vertexAt( int atVertex ) const;
863
869 double sqrDistToVertexAt( QgsPointXY &point SIP_IN, int atVertex ) const;
870
875 QgsGeometry nearestPoint( const QgsGeometry &other ) const;
876
886 QgsGeometry shortestLine( const QgsGeometry &other ) const;
887
894 double closestVertexWithContext( const QgsPointXY &point, int &atVertex SIP_OUT ) const;
895
907 double closestSegmentWithContext( const QgsPointXY &point, QgsPointXY &minDistPoint SIP_OUT, int &nextVertexIndex SIP_OUT, int *leftOrRightOfSegment SIP_OUT = nullptr, double epsilon = DEFAULT_SEGMENT_EPSILON ) const;
908
914 Qgis::GeometryOperationResult addRing( const QVector<QgsPointXY> &ring );
915
922
930 Q_DECL_DEPRECATED Qgis::GeometryOperationResult addPart( const QVector<QgsPointXY> &points, Qgis::GeometryType geomType = Qgis::GeometryType::Unknown ) SIP_PYNAME( addPointsXY ) SIP_DEPRECATED;
931
939 Qgis::GeometryOperationResult addPartV2( const QVector<QgsPointXY> &points, Qgis::WkbType wkbType = Qgis::WkbType::Unknown ) SIP_PYNAME( addPointsXYV2 );
940
948 Q_DECL_DEPRECATED Qgis::GeometryOperationResult addPart( const QgsPointSequence &points, Qgis::GeometryType geomType = Qgis::GeometryType::Unknown ) SIP_PYNAME( addPoints ) SIP_DEPRECATED;
949
957 Qgis::GeometryOperationResult addPartV2( const QgsPointSequence &points, Qgis::WkbType wkbType = Qgis::WkbType::Unknown ) SIP_PYNAME( addPointsV2 );
958
967
976
982 Qgis::GeometryOperationResult addPart( const QgsGeometry &newPart ) SIP_PYNAME( addPartGeometry );
983
989 QgsGeometry removeInteriorRings( double minimumAllowedArea = -1 ) const;
990
995 Qgis::GeometryOperationResult translate( double dx, double dy, double dz = 0.0, double dm = 0.0 );
996
1012
1021 Qgis::GeometryOperationResult transform( const QTransform &t, double zTranslate = 0.0, double zScale = 1.0, double mTranslate = 0.0, double mScale = 1.0 );
1022
1029 Qgis::GeometryOperationResult rotate( double rotation, const QgsPointXY &center );
1030
1041 Q_DECL_DEPRECATED Qgis::GeometryOperationResult splitGeometry( const QVector<QgsPointXY> &splitLine, QVector<QgsGeometry> &newGeometries, bool topological, QVector<QgsPointXY> &topologyTestPoints, bool splitFeature = true ) SIP_SKIP;
1042
1064 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;
1065
1066
1067 /*
1068 This SIP code is to support overloaded methods of splitGeometry.
1069 When the deprecated method is removed in QGIS 4.0 this code can be dropped
1070 TODO QGIS 4 remove MethodCode
1071 */
1072#ifdef SIP_RUN
1073
1092 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]]] );
1093 % MethodCode
1094 {
1095 int sipIsErr = 0;
1096 int state;
1097
1098 if ( PyList_Check( a0 ) && PyList_GET_SIZE( a0 ) )
1099 {
1100 PyObject *p0 = PyList_GetItem( a0, 0 );
1101 if ( sipCanConvertToType( p0, sipType_QgsPointXY, SIP_NOT_NONE ) &&
1102 sipCanConvertToType( a0, sipType_QVector_0100QgsPointXY, SIP_NOT_NONE ) )
1103 {
1104 QVector<QgsGeometry> newGeometries;
1105 QVector<QgsPointXY> topologyTestPoints;
1106
1107 QVector<QgsPointXY> *splitLine = reinterpret_cast<QVector<QgsPointXY> *>( sipConvertToType( a0, sipType_QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
1108 if ( sipIsErr )
1109 {
1110 sipReleaseType( splitLine, sipType_QVector_0100QgsPointXY, state );
1111 }
1112 else
1113 {
1114 Qgis::GeometryOperationResult result = sipCpp->splitGeometry( *splitLine, newGeometries, a1, topologyTestPoints, a2 );
1115
1116 PyObject *o0 = sipConvertFromEnum( static_cast<int>( result ), sipType_Qgis_GeometryOperationResult );
1117 PyObject *o1 = sipConvertFromType( &newGeometries, sipType_QVector_0100QgsGeometry, Py_None );
1118 PyObject *o2 = sipConvertFromType( &topologyTestPoints, sipType_QVector_0100QgsPointXY, Py_None );
1119
1120 sipRes = PyTuple_New( 3 );
1121 PyTuple_SET_ITEM( sipRes, 0, o0 );
1122 PyTuple_SET_ITEM( sipRes, 1, o1 );
1123 PyTuple_SET_ITEM( sipRes, 2, o2 );
1124 }
1125 }
1126
1127 else if ( sipCanConvertToType( p0, sipType_QgsPoint, SIP_NOT_NONE ) &&
1128 sipCanConvertToType( a0, sipType_QVector_0100QgsPoint, SIP_NOT_NONE ) )
1129 {
1130 QVector<QgsGeometry> newGeometries;
1131 QVector<QgsPoint> topologyTestPoints;
1132
1133 QVector<QgsPoint> *splitLine = reinterpret_cast<QVector<QgsPoint> *>( sipConvertToType( a0, sipType_QVector_0100QgsPoint, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
1134 if ( sipIsErr )
1135 {
1136 sipReleaseType( splitLine, sipType_QVector_0100QgsPoint, state );
1137 }
1138 else
1139 {
1140 Qgis::GeometryOperationResult result = sipCpp->splitGeometry( *splitLine, newGeometries, a1, topologyTestPoints, a2 );
1141
1142 PyObject *o0 = sipConvertFromEnum( static_cast<int>( result ), sipType_Qgis_GeometryOperationResult );
1143 PyObject *o1 = sipConvertFromType( &newGeometries, sipType_QVector_0100QgsGeometry, Py_None );
1144 PyObject *o2 = sipConvertFromType( &topologyTestPoints, sipType_QVector_0100QgsPoint, Py_None );
1145
1146 sipRes = PyTuple_New( 3 );
1147 PyTuple_SET_ITEM( sipRes, 0, o0 );
1148 PyTuple_SET_ITEM( sipRes, 1, o1 );
1149 PyTuple_SET_ITEM( sipRes, 2, o2 );
1150 }
1151 }
1152 else
1153 {
1154 sipIsErr = 1;
1155 PyErr_SetString( PyExc_TypeError, QStringLiteral( "Could not convert first argument to a list of QgsPoint or QgsPointXY." ).toUtf8().constData() );
1156 }
1157 }
1158 else
1159 {
1160 sipIsErr = 1;
1161 PyErr_SetString( PyExc_TypeError, QStringLiteral( "First argument is not a list of points or is empty." ).toUtf8().constData() );
1162 }
1163 }
1164 % End
1165#endif
1166
1178 Qgis::GeometryOperationResult splitGeometry( const QgsCurve *curve, QVector<QgsGeometry> &newGeometries SIP_OUT, bool preserveCircular, bool topological, QgsPointSequence &topologyTestPoints SIP_OUT, bool splitFeature = true );
1179
1184 Qgis::GeometryOperationResult reshapeGeometry( const QgsLineString &reshapeLineString );
1185
1191 int makeDifferenceInPlace( const QgsGeometry &other ) SIP_SKIP;
1192
1199 QgsGeometry makeDifference( const QgsGeometry &other ) const;
1200
1205 QgsRectangle boundingBox() const;
1206
1212 QgsBox3D boundingBox3D() const;
1213
1224 QgsGeometry orientedMinimumBoundingBox( double &area SIP_OUT, double &angle SIP_OUT, double &width SIP_OUT, double &height SIP_OUT ) const;
1225
1234 QgsGeometry orientedMinimumBoundingBox() const SIP_SKIP;
1235
1243 QgsGeometry minimalEnclosingCircle( QgsPointXY &center SIP_OUT, double &radius SIP_OUT, unsigned int segments = 36 ) const;
1244
1249 QgsGeometry minimalEnclosingCircle( unsigned int segments = 36 ) const SIP_SKIP;
1250
1258 QgsGeometry orthogonalize( double tolerance = 1.0E-8, int maxIterations = 1000, double angleThreshold = 15.0 ) const;
1259
1272 QgsGeometry triangularWaves( double wavelength, double amplitude, bool strictWavelength = false ) const;
1273
1292 QgsGeometry triangularWavesRandomized( double minimumWavelength, double maximumWavelength, double minimumAmplitude, double maximumAmplitude, unsigned long seed = 0 ) const;
1293
1306 QgsGeometry squareWaves( double wavelength, double amplitude, bool strictWavelength = false ) const;
1307
1326 QgsGeometry squareWavesRandomized( double minimumWavelength, double maximumWavelength, double minimumAmplitude, double maximumAmplitude, unsigned long seed = 0 ) const;
1327
1340 QgsGeometry roundWaves( double wavelength, double amplitude, bool strictWavelength = false ) const;
1341
1360 QgsGeometry roundWavesRandomized( double minimumWavelength, double maximumWavelength, double minimumAmplitude, double maximumAmplitude, unsigned long seed = 0 ) const;
1361
1375 QgsGeometry applyDashPattern( const QVector< double > &pattern,
1376 Qgis::DashPatternLineEndingRule startRule = Qgis::DashPatternLineEndingRule::NoRule,
1377 Qgis::DashPatternLineEndingRule endRule = Qgis::DashPatternLineEndingRule::NoRule,
1378 Qgis::DashPatternSizeAdjustment adjustment = Qgis::DashPatternSizeAdjustment::ScaleBothDashAndGap,
1379 double patternOffset = 0 ) const;
1380
1392 QgsGeometry snappedToGrid( double hSpacing, double vSpacing, double dSpacing = 0, double mSpacing = 0 ) const;
1393
1413 bool removeDuplicateNodes( double epsilon = 4 * std::numeric_limits<double>::epsilon(), bool useZValues = false );
1414
1424 bool intersects( const QgsRectangle &rectangle ) const;
1425
1440 bool intersects( const QgsGeometry &geometry ) const;
1441
1450 bool boundingBoxIntersects( const QgsRectangle &rectangle ) const;
1451
1460 bool boundingBoxIntersects( const QgsGeometry &geometry ) const;
1461
1465 bool contains( const QgsPointXY *p ) const;
1466
1472 bool contains( double x, double y ) const;
1473
1483 bool contains( const QgsGeometry &geometry ) const;
1484
1494 bool disjoint( const QgsGeometry &geometry ) const;
1495
1505 bool touches( const QgsGeometry &geometry ) const;
1506
1516 bool overlaps( const QgsGeometry &geometry ) const;
1517
1527 bool within( const QgsGeometry &geometry ) const;
1528
1538 bool crosses( const QgsGeometry &geometry ) const;
1539
1547 QgsGeometry buffer( double distance, int segments ) const;
1548
1560 QgsGeometry buffer( double distance, int segments, Qgis::EndCapStyle endCapStyle, Qgis::JoinStyle joinStyle, double miterLimit ) const;
1561
1569 QgsGeometry offsetCurve( double distance, int segments, Qgis::JoinStyle joinStyle, double miterLimit ) const;
1570
1585 QgsGeometry singleSidedBuffer( double distance, int segments, Qgis::BufferSide side,
1586 Qgis::JoinStyle joinStyle = Qgis::JoinStyle::Round,
1587 double miterLimit = 2.0 ) const;
1588
1606 QgsGeometry taperedBuffer( double startWidth, double endWidth, int segments ) const;
1607
1622 QgsGeometry variableWidthBufferByM( int segments ) const;
1623
1629 QgsGeometry extendLine( double startDistance, double endDistance ) const;
1630
1632 QgsGeometry simplify( double tolerance ) const;
1633
1642 QgsGeometry densifyByCount( int extraNodesPerSegment ) const;
1643
1657 QgsGeometry densifyByDistance( double distance ) const;
1658
1674 QgsGeometry convertToCurves( double distanceTolerance = 1e-8, double angleTolerance = 1e-8 ) const;
1675
1689 QgsGeometry centroid() const;
1690
1704 QgsGeometry pointOnSurface() const;
1705
1717 QgsGeometry poleOfInaccessibility( double precision, double *distanceToBoundary SIP_OUT = nullptr ) const;
1718
1742 QgsGeometry largestEmptyCircle( double tolerance, const QgsGeometry &boundary = QgsGeometry() ) const SIP_THROW( QgsNotSupportedException );
1743
1758 QgsGeometry minimumWidth() const SIP_THROW( QgsNotSupportedException );
1759
1781 double minimumClearance() const SIP_THROW( QgsNotSupportedException );
1782
1794 QgsGeometry minimumClearanceLine() const SIP_THROW( QgsNotSupportedException );
1795
1804 QgsGeometry convexHull() const;
1805
1819 QgsGeometry concaveHull( double targetPercent, bool allowHoles = false ) const SIP_THROW( QgsNotSupportedException );
1820
1835 QgsGeometry voronoiDiagram( const QgsGeometry &extent = QgsGeometry(), double tolerance = 0.0, bool edgesOnly = false ) const;
1836
1847 QgsGeometry delaunayTriangulation( double tolerance = 0.0, bool edgesOnly = false ) const;
1848
1861 QgsGeometry constrainedDelaunayTriangulation() const SIP_THROW( QgsNotSupportedException );
1862
1880 Qgis::CoverageValidityResult validateCoverage( double gapWidth, QgsGeometry *invalidEdges SIP_OUT = nullptr ) const SIP_THROW( QgsNotSupportedException );
1881
1902 QgsGeometry simplifyCoverageVW( double tolerance, bool preserveBoundary ) const SIP_THROW( QgsNotSupportedException );
1903
1915 QgsGeometry unionCoverage() const;
1916
1927 QgsGeometry node() const;
1928
1943 QgsGeometry sharedPaths( const QgsGeometry &other ) const;
1944
1966 QgsGeometry subdivide( int maxNodes = 256, const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;
1967
1982 QgsGeometry interpolate( double distance ) const;
1983
1994 double lineLocatePoint( const QgsGeometry &point ) const;
1995
2004 double interpolateAngle( double distance ) const;
2005
2017 QgsGeometry intersection( const QgsGeometry &geometry, const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;
2018
2025 QgsGeometry clipped( const QgsRectangle &rectangle );
2026
2041 QgsGeometry combine( const QgsGeometry &geometry, const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;
2042
2050 QgsGeometry mergeLines() const;
2051
2063 QgsGeometry difference( const QgsGeometry &geometry, const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;
2064
2076 QgsGeometry symDifference( const QgsGeometry &geometry, const QgsGeometryParameters &parameters = QgsGeometryParameters() ) const;
2077
2079 QgsGeometry extrude( double x, double y );
2080
2081#ifndef SIP_RUN
2082
2104 QVector< QgsPointXY > randomPointsInPolygon( int count, const std::function< bool( const QgsPointXY & ) > &acceptPoint, unsigned long seed = 0, QgsFeedback *feedback = nullptr, int maxTriesPerPoint = 0 ) const;
2105
2119 QVector< QgsPointXY > randomPointsInPolygon( int count, unsigned long seed = 0, QgsFeedback *feedback = nullptr ) const;
2121#else
2122
2136 SIP_PYOBJECT randomPointsInPolygon( int count, unsigned long seed = 0 ) const SIP_TYPEHINT( QgsPolylineXY );
2137 % MethodCode
2138 const Qgis::GeometryType type = sipCpp->type();
2139 if ( sipCpp->isNull() )
2140 {
2141 PyErr_SetString( PyExc_ValueError, QStringLiteral( "Cannot generate points inside a null geometry." ).toUtf8().constData() );
2142 sipIsErr = 1;
2143 }
2144 else if ( type != Qgis::GeometryType::Polygon )
2145 {
2146 PyErr_SetString( PyExc_TypeError, QStringLiteral( "Cannot generate points inside a %1 geometry. Only Polygon types are permitted." ).arg( QgsWkbTypes::displayString( sipCpp->wkbType() ) ).toUtf8().constData() );
2147 sipIsErr = 1;
2148 }
2149 else
2150 {
2151 const sipTypeDef *qvector_type = sipFindType( "QVector<QgsPointXY>" );
2152 sipRes = sipConvertFromNewType( new QVector< QgsPointXY >( sipCpp->randomPointsInPolygon( a0, a1 ) ), qvector_type, Py_None );
2153 }
2154 % End
2155
2156
2157#endif
2159
2167 int wkbSize( QgsAbstractGeometry::WkbFlags flags = QgsAbstractGeometry::WkbFlags() ) const;
2168
2175 QByteArray asWkb( QgsAbstractGeometry::WkbFlags flags = QgsAbstractGeometry::WkbFlags() ) const;
2176
2182 Q_INVOKABLE QString asWkt( int precision = 17 ) const;
2183
2184#ifdef SIP_RUN
2185 SIP_PYOBJECT __repr__();
2186 % MethodCode
2187 QString str;
2188 if ( sipCpp->isNull() )
2189 str = QStringLiteral( "<QgsGeometry: null>" );
2190 else
2191 {
2192 QString wkt = sipCpp->asWkt();
2193 if ( wkt.length() > 1000 )
2194 wkt = wkt.left( 1000 ) + QStringLiteral( "..." );
2195 str = QStringLiteral( "<QgsGeometry: %1>" ).arg( wkt );
2196 }
2197 sipRes = PyUnicode_FromString( str.toUtf8().constData() );
2198 % End
2199#endif
2200
2204 QString asJson( int precision = 17 ) const;
2205
2211 virtual json asJsonObject( int precision = 17 ) const SIP_SKIP;
2212
2239 QVector< QgsGeometry > coerceToType( Qgis::WkbType type, double defaultZ = 0, double defaultM = 0 ) const;
2240
2252 QgsGeometry convertToType( Qgis::GeometryType destType, bool destMultipart = false ) const;
2253
2254 /* Accessor functions for getting geometry data */
2255
2256#ifndef SIP_RUN
2257
2266 QgsPointXY asPoint() const;
2267#else
2268
2279 SIP_PYOBJECT asPoint() const SIP_TYPEHINT( QgsPointXY );
2280 % MethodCode
2281 if ( sipCpp->isNull() )
2282 {
2283 PyErr_SetString( PyExc_ValueError, QStringLiteral( "Null geometry cannot be converted to a point." ).toUtf8().constData() );
2284 sipIsErr = 1;
2285 }
2286 else
2287 {
2288 const QgsAbstractGeometry *geom = sipCpp->constGet();
2290 {
2291 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() );
2292 sipIsErr = 1;
2293 }
2294 else
2295 {
2296 sipRes = sipConvertFromNewType( new QgsPointXY( sipCpp->asPoint() ), sipType_QgsPointXY, Py_None );
2297 }
2298 }
2299 % End
2300#endif
2301
2302#ifndef SIP_RUN
2303
2312 QgsPolylineXY asPolyline() const;
2313#else
2314
2326 SIP_PYOBJECT asPolyline() const SIP_TYPEHINT( QgsPolylineXY );
2327 % MethodCode
2328 const Qgis::WkbType type = sipCpp->wkbType();
2329 if ( sipCpp->isNull() )
2330 {
2331 PyErr_SetString( PyExc_ValueError, QStringLiteral( "Null geometry cannot be converted to a polyline." ).toUtf8().constData() );
2332 sipIsErr = 1;
2333 }
2335 {
2336 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() );
2337 sipIsErr = 1;
2338 }
2339 else
2340 {
2341 const sipTypeDef *qvector_type = sipFindType( "QVector< QgsPointXY >" );
2342 sipRes = sipConvertFromNewType( new QgsPolylineXY( sipCpp->asPolyline() ), qvector_type, Py_None );
2343 }
2344 % End
2345#endif
2346
2347#ifndef SIP_RUN
2348
2357 QgsPolygonXY asPolygon() const;
2358#else
2359
2371 SIP_PYOBJECT asPolygon() const SIP_TYPEHINT( QgsPolygonXY );
2372 % MethodCode
2373 const Qgis::WkbType type = sipCpp->wkbType();
2374 if ( sipCpp->isNull() )
2375 {
2376 PyErr_SetString( PyExc_ValueError, QStringLiteral( "Null geometry cannot be converted to a polygon." ).toUtf8().constData() );
2377 sipIsErr = 1;
2378 }
2380 {
2381 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() );
2382 sipIsErr = 1;
2383 }
2384 else
2385 {
2386 const sipTypeDef *qvector_type = sipFindType( "QVector<QVector<QgsPointXY>>" );
2387 sipRes = sipConvertFromNewType( new QgsPolygonXY( sipCpp->asPolygon() ), qvector_type, Py_None );
2388 }
2389 % End
2390#endif
2391
2392#ifndef SIP_RUN
2393
2401 QgsMultiPointXY asMultiPoint() const;
2402#else
2403
2414 SIP_PYOBJECT asMultiPoint() const SIP_TYPEHINT( QgsMultiPointXY );
2415 % MethodCode
2416 const Qgis::WkbType type = sipCpp->wkbType();
2417 if ( sipCpp->isNull() )
2418 {
2419 PyErr_SetString( PyExc_ValueError, QStringLiteral( "Null geometry cannot be converted to a multipoint." ).toUtf8().constData() );
2420 sipIsErr = 1;
2421 }
2423 {
2424 PyErr_SetString( PyExc_TypeError, QStringLiteral( "%1 geometry cannot be converted to a multipoint. Only multipoint types are permitted." ).arg( QgsWkbTypes::displayString( type ) ).toUtf8().constData() );
2425 sipIsErr = 1;
2426 }
2427 else
2428 {
2429 const sipTypeDef *qvector_type = sipFindType( "QVector< QgsPointXY >" );
2430 sipRes = sipConvertFromNewType( new QgsPolylineXY( sipCpp->asMultiPoint() ), qvector_type, Py_None );
2431 }
2432 % End
2433#endif
2434
2435#ifndef SIP_RUN
2436
2445 QgsMultiPolylineXY asMultiPolyline() const;
2446#else
2447
2459 SIP_PYOBJECT asMultiPolyline() const SIP_TYPEHINT( QgsMultiPolylineXY );
2460 % MethodCode
2461 const Qgis::WkbType type = sipCpp->wkbType();
2462 if ( sipCpp->isNull() )
2463 {
2464 PyErr_SetString( PyExc_ValueError, QStringLiteral( "Null geometry cannot be converted to a multilinestring." ).toUtf8().constData() );
2465 sipIsErr = 1;
2466 }
2468 {
2469 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() );
2470 sipIsErr = 1;
2471 }
2472 else
2473 {
2474 const sipTypeDef *qvector_type = sipFindType( "QVector<QVector<QgsPointXY>>" );
2475 sipRes = sipConvertFromNewType( new QgsMultiPolylineXY( sipCpp->asMultiPolyline() ), qvector_type, Py_None );
2476 }
2477 % End
2478#endif
2479
2480#ifndef SIP_RUN
2481
2490 QgsMultiPolygonXY asMultiPolygon() const;
2491#else
2492
2504 SIP_PYOBJECT asMultiPolygon() const SIP_TYPEHINT( QgsMultiPolygonXY );
2505 % MethodCode
2506 const Qgis::WkbType type = sipCpp->wkbType();
2507 if ( sipCpp->isNull() )
2508 {
2509 PyErr_SetString( PyExc_ValueError, QStringLiteral( "Null geometry cannot be converted to a multipolygon." ).toUtf8().constData() );
2510 sipIsErr = 1;
2511 }
2513 {
2514 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() );
2515 sipIsErr = 1;
2516 }
2517 else
2518 {
2519 const sipTypeDef *qvector_type = sipFindType( "QVector<QVector<QVector<QgsPointXY>>>" );
2520 sipRes = sipConvertFromNewType( new QgsMultiPolygonXY( sipCpp->asMultiPolygon() ), qvector_type, Py_None );
2521 }
2522 % End
2523#endif
2524
2528 QVector<QgsGeometry> asGeometryCollection() const;
2529
2534 QPointF asQPointF() const SIP_HOLDGIL;
2535
2547 QPolygonF asQPolygonF() const SIP_HOLDGIL;
2548
2554 bool deleteRing( int ringNum, int partNum = 0 );
2555
2560 bool deletePart( int partNum );
2561
2570 bool convertToMultiType();
2571
2587 bool convertToCurvedMultiType();
2588
2598 bool convertToSingleType();
2599
2609 bool convertGeometryCollectionToSubclass( Qgis::GeometryType geomType );
2610
2622 Q_DECL_DEPRECATED int avoidIntersections( const QList<QgsVectorLayer *> &avoidIntersectionsLayers,
2623 const QHash<QgsVectorLayer *, QSet<QgsFeatureId> > &ignoreFeatures SIP_PYARGREMOVE = ( QHash<QgsVectorLayer *, QSet<QgsFeatureId> >() ) ) SIP_DEPRECATED;
2624
2636 Qgis::GeometryOperationResult avoidIntersectionsV2( const QList<QgsVectorLayer *> &avoidIntersectionsLayers,
2637 const QHash<QgsVectorLayer *, QSet<QgsFeatureId> > &ignoreFeatures SIP_PYARGREMOVE = ( QHash<QgsVectorLayer *, QSet<QgsFeatureId> >() ) );
2638
2659 QgsGeometry makeValid( Qgis::MakeValidMethod method = Qgis::MakeValidMethod::Linework, bool keepCollapsed = false ) const SIP_THROW( QgsNotSupportedException );
2660
2670 Qgis::AngularDirection polygonOrientation() const;
2671
2685 bool isPolygonCounterClockwise() const { return polygonOrientation() == Qgis::AngularDirection::CounterClockwise; }
2686
2700 bool isPolygonClockwise() const { return polygonOrientation() == Qgis::AngularDirection::Clockwise; }
2701
2702
2717 QgsGeometry forceRHR() const;
2718
2729 QgsGeometry forcePolygonClockwise() const;
2730
2741 QgsGeometry forcePolygonCounterClockwise() const;
2742
2747 class CORE_EXPORT Error
2748 {
2749 public:
2751 : mMessage( QStringLiteral( "none" ) )
2752 {}
2753
2754 explicit Error( const QString &m )
2755 : mMessage( m )
2756 {}
2757
2758 Error( const QString &m, const QgsPointXY &p )
2759 : mMessage( m )
2760 , mLocation( p )
2761 , mHasLocation( true ) {}
2762
2766 QString what() const;
2767
2771 QgsPointXY where() const;
2772
2776 bool hasWhere() const;
2777
2778#ifdef SIP_RUN
2779 SIP_PYOBJECT __repr__();
2780 % MethodCode
2781 QString str = QStringLiteral( "<QgsGeometry.Error: %1>" ).arg( sipCpp->what() );
2782 sipRes = PyUnicode_FromString( str.toUtf8().data() );
2783 % End
2784#endif
2785
2786 // TODO c++20 - replace with = default
2787 bool operator==( const QgsGeometry::Error &other ) const
2788 {
2789 return other.mMessage == mMessage && other.mHasLocation == mHasLocation && other.mLocation == mLocation;
2790 }
2791
2792 private:
2793 QString mMessage;
2794 QgsPointXY mLocation;
2795 bool mHasLocation = false;
2796 };
2797
2805 void validateGeometry( QVector<QgsGeometry::Error> &errors SIP_OUT, Qgis::GeometryValidationEngine method = Qgis::GeometryValidationEngine::QgisInternal, Qgis::GeometryValidityFlags flags = Qgis::GeometryValidityFlags() ) const;
2806
2816 void normalize();
2817
2826 static QgsGeometry unaryUnion( const QVector<QgsGeometry> &geometries, const QgsGeometryParameters &parameters = QgsGeometryParameters() );
2827
2835 static QgsGeometry polygonize( const QVector<QgsGeometry> &geometries );
2836
2843 void convertToStraightSegment( double tolerance = M_PI / 180., QgsAbstractGeometry::SegmentationToleranceType toleranceType = QgsAbstractGeometry::MaximumAngle );
2844
2850 bool requiresConversionToStraightSegments() const;
2851
2856 void mapToPixel( const QgsMapToPixel &mtp );
2857
2862 void draw( QPainter &p ) const;
2863
2873 bool vertexIdFromVertexNr( int number, QgsVertexId &id SIP_OUT ) const;
2874
2885 int vertexNrFromVertexId( QgsVertexId id ) const;
2886
2893 QString lastError() const SIP_HOLDGIL;
2894
2904 void filterVertices( const std::function< bool( const QgsPoint & ) > &filter ) SIP_SKIP;
2905
2920 void transformVertices( const std::function< QgsPoint( const QgsPoint & ) > &transform ) SIP_SKIP;
2921
2926 static QgsGeometry fromQPointF( QPointF point ) SIP_HOLDGIL;
2927
2934 static QgsGeometry fromQPolygonF( const QPolygonF &polygon );
2935
2943 Q_DECL_DEPRECATED static QgsPolylineXY createPolylineFromQPolygonF( const QPolygonF &polygon ) SIP_DEPRECATED;
2944
2952 Q_DECL_DEPRECATED static QgsPolygonXY createPolygonFromQPolygonF( const QPolygonF &polygon ) SIP_DEPRECATED;
2953
2954#ifndef SIP_RUN
2955
2964 static bool compare( const QgsPolylineXY &p1, const QgsPolylineXY &p2,
2965 double epsilon = 4 * std::numeric_limits<double>::epsilon() );
2966
2975 static bool compare( const QgsPolygonXY &p1, const QgsPolygonXY &p2,
2976 double epsilon = 4 * std::numeric_limits<double>::epsilon() );
2977
2987 static bool compare( const QgsMultiPolygonXY &p1, const QgsMultiPolygonXY &p2,
2988 double epsilon = 4 * std::numeric_limits<double>::epsilon() );
2989#else
2990
3009 static bool compare( PyObject *obj1, PyObject *obj2, double epsilon = 4 * std::numeric_limits<double>::epsilon() );
3010 % MethodCode
3011 {
3012 sipRes = false;
3013 int state0;
3014 int state1;
3015 int sipIsErr = 0;
3016
3017 if ( PyList_Check( a0 ) && PyList_Check( a1 ) &&
3018 PyList_GET_SIZE( a0 ) && PyList_GET_SIZE( a1 ) )
3019 {
3020 PyObject *o0 = PyList_GetItem( a0, 0 );
3021 PyObject *o1 = PyList_GetItem( a1, 0 );
3022 if ( o0 && o1 )
3023 {
3024 // compare polyline - polyline
3025 if ( sipCanConvertToType( o0, sipType_QgsPointXY, SIP_NOT_NONE ) &&
3026 sipCanConvertToType( o1, sipType_QgsPointXY, SIP_NOT_NONE ) &&
3027 sipCanConvertToType( a0, sipType_QVector_0100QgsPointXY, SIP_NOT_NONE ) &&
3028 sipCanConvertToType( a1, sipType_QVector_0100QgsPointXY, SIP_NOT_NONE ) )
3029 {
3030 QgsPolylineXY *p0;
3031 QgsPolylineXY *p1;
3032 p0 = reinterpret_cast<QgsPolylineXY *>( sipConvertToType( a0, sipType_QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state0, &sipIsErr ) );
3033 p1 = reinterpret_cast<QgsPolylineXY *>( sipConvertToType( a1, sipType_QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state1, &sipIsErr ) );
3034 if ( sipIsErr )
3035 {
3036 sipReleaseType( p0, sipType_QVector_0100QgsPointXY, state0 );
3037 sipReleaseType( p1, sipType_QVector_0100QgsPointXY, state1 );
3038 }
3039 else
3040 {
3041 sipRes = QgsGeometry::compare( *p0, *p1, a2 );
3042 }
3043 }
3044 else if ( PyList_Check( o0 ) && PyList_Check( o1 ) &&
3045 PyList_GET_SIZE( o0 ) && PyList_GET_SIZE( o1 ) )
3046 {
3047 PyObject *oo0 = PyList_GetItem( o0, 0 );
3048 PyObject *oo1 = PyList_GetItem( o1, 0 );
3049 if ( oo0 && oo1 )
3050 {
3051 // compare polygon - polygon
3052 if ( sipCanConvertToType( oo0, sipType_QgsPointXY, SIP_NOT_NONE ) &&
3053 sipCanConvertToType( oo1, sipType_QgsPointXY, SIP_NOT_NONE ) &&
3054 sipCanConvertToType( a0, sipType_QVector_0600QVector_0100QgsPointXY, SIP_NOT_NONE ) &&
3055 sipCanConvertToType( a1, sipType_QVector_0600QVector_0100QgsPointXY, SIP_NOT_NONE ) )
3056 {
3057 QgsPolygonXY *p0;
3058 QgsPolygonXY *p1;
3059 p0 = reinterpret_cast<QgsPolygonXY *>( sipConvertToType( a0, sipType_QVector_0600QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state0, &sipIsErr ) );
3060 p1 = reinterpret_cast<QgsPolygonXY *>( sipConvertToType( a1, sipType_QVector_0600QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state1, &sipIsErr ) );
3061 if ( sipIsErr )
3062 {
3063 sipReleaseType( p0, sipType_QVector_0600QVector_0100QgsPointXY, state0 );
3064 sipReleaseType( p1, sipType_QVector_0600QVector_0100QgsPointXY, state1 );
3065 }
3066 else
3067 {
3068 sipRes = QgsGeometry::compare( *p0, *p1, a2 );
3069 }
3070 }
3071 else if ( PyList_Check( oo0 ) && PyList_Check( oo1 ) &&
3072 PyList_GET_SIZE( oo0 ) && PyList_GET_SIZE( oo1 ) )
3073 {
3074 PyObject *ooo0 = PyList_GetItem( oo0, 0 );
3075 PyObject *ooo1 = PyList_GetItem( oo1, 0 );
3076 if ( ooo0 && ooo1 )
3077 {
3078 // compare multipolygon - multipolygon
3079 if ( sipCanConvertToType( ooo0, sipType_QgsPointXY, SIP_NOT_NONE ) &&
3080 sipCanConvertToType( ooo1, sipType_QgsPointXY, SIP_NOT_NONE ) &&
3081 sipCanConvertToType( a0, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, SIP_NOT_NONE ) &&
3082 sipCanConvertToType( a1, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, SIP_NOT_NONE ) )
3083 {
3086 p0 = reinterpret_cast<QgsMultiPolygonXY *>( sipConvertToType( a0, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state0, &sipIsErr ) );
3087 p1 = reinterpret_cast<QgsMultiPolygonXY *>( sipConvertToType( a1, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, 0, SIP_NOT_NONE, &state1, &sipIsErr ) );
3088 if ( sipIsErr )
3089 {
3090 sipReleaseType( p0, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, state0 );
3091 sipReleaseType( p1, sipType_QVector_0600QVector_0600QVector_0100QgsPointXY, state1 );
3092 }
3093 else
3094 {
3095 sipRes = QgsGeometry::compare( *p0, *p1, a2 );
3096 }
3097 }
3098 }
3099 }
3100 }
3101 }
3102 }
3103 }
3104 }
3105 % End
3106#endif
3107
3123 QgsGeometry smooth( unsigned int iterations = 1, double offset = 0.25,
3124 double minimumDistance = -1.0, double maxAngle = 180.0 ) const;
3125
3163 static QgsGeometryEngine *createGeometryEngine( const QgsAbstractGeometry *geometry, double precision = 0.0 ) SIP_FACTORY;
3164
3170 static void convertPointList( const QVector<QgsPointXY> &input, QgsPointSequence &output );
3171
3177 static void convertPointList( const QgsPointSequence &input, QVector<QgsPointXY> &output );
3178
3180 operator QVariant() const
3181 {
3182 return QVariant::fromValue( *this );
3183 }
3184
3185 private:
3186
3187 QgsGeometryPrivate *d; //implicitly shared data pointer
3188
3190 mutable QString mLastError;
3191
3196 void detach();
3197
3202 void reset( std::unique_ptr< QgsAbstractGeometry > newGeometry );
3203
3204 static void convertPolygon( const QgsPolygon &input, QgsPolygonXY &output );
3205
3207 QgsGeometry convertToPoint( bool destMultipart ) const;
3209 QgsGeometry convertToLine( bool destMultipart ) const;
3211 QgsGeometry convertToPolygon( bool destMultipart ) const;
3212
3224 std::unique_ptr< QgsLineString > smoothLine( const QgsLineString &line, unsigned int iterations = 1, double offset = 0.25,
3225 double minimumDistance = -1, double maxAngle = 180.0 ) const;
3226
3238 std::unique_ptr< QgsPolygon > smoothPolygon( const QgsPolygon &polygon, unsigned int iterations = 1, double offset = 0.25,
3239 double minimumDistance = -1, double maxAngle = 180.0 ) const;
3240
3241
3243
3244}; // class QgsGeometry
3245
3247
3248
3249CORE_EXPORT QDataStream &operator<<( QDataStream &out, const QgsGeometry &geometry );
3251CORE_EXPORT QDataStream &operator>>( QDataStream &in, QgsGeometry &geometry );
3252
3253#endif
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
@ CounterClockwise
Counter-clockwise direction.
@ Clockwise
Clockwise direction.
GeometryOperationResult
Success or failure of a geometry operation.
Definition qgis.h:1889
QFlags< GeometryValidityFlag > GeometryValidityFlags
Geometry validity flags.
Definition qgis.h:1922
GeometryValidationEngine
Available engines for validating geometries.
Definition qgis.h:1931
@ QgisInternal
Use internal QgsGeometryValidator method.
GeometryType
The geometry types are used to group Qgis::WkbType in a coarse way.
Definition qgis.h:337
@ Polygon
Polygons.
@ Unknown
Unknown types.
WkbType
The WKB type describes the number of dimensions a geometry has.
Definition qgis.h:256
@ Unknown
Unknown.
TransformDirection
Indicates the direction (forward or inverse) of a transform.
Definition qgis.h:2502
@ Forward
Forward transform (from source to destination)
The part_iterator class provides STL-style iterator for const references to geometry parts.
The part_iterator class provides STL-style iterator for geometry parts.
The vertex_iterator class provides STL-style iterator for vertices.
Abstract base class for all geometries.
SegmentationToleranceType
Segmentation tolerance as maximum angle or maximum difference between approximation and circle.
@ MaximumAngle
Maximum angle between generating radii (lines from arc center to output vertices)
virtual const QgsAbstractGeometry * simplifiedTypeRef() const
Returns a reference to the simplest lossless representation of this geometry, e.g.
QFlags< WkbFlag > WkbFlags
Qgis::WkbType wkbType() const
Returns the WKB type of the geometry.
A 3-dimensional box composed of x, y, z coordinates.
Definition qgsbox3d.h:43
A const WKB pointer.
Definition qgswkbptr.h:138
Class for doing transforms between two map coordinate systems.
Custom exception class for Coordinate Reference System related exceptions.
Abstract base class for curved geometry type.
Definition qgscurve.h:35
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44
Java-style iterator for const traversal of parts of a geometry.
A geometry engine is a low-level representation of a QgsAbstractGeometry object, optimised for use wi...
Encapsulates parameters under which a geometry operation is performed.
double gridSize() const
Returns the grid size which will be used to snap vertices of a geometry.
void setGridSize(double size)
Sets the grid size which will be used to snap vertices of a geometry.
Java-style iterator for traversal of parts of a geometry.
A geometry error.
Error(const QString &m)
Error(const QString &m, const QgsPointXY &p)
bool operator==(const QgsGeometry::Error &other) const
A geometry is the spatial representation of a feature.
QVector< QgsPointXY > randomPointsInPolygon(int count, const std::function< bool(const QgsPointXY &) > &acceptPoint, unsigned long seed=0, QgsFeedback *feedback=nullptr, int maxTriesPerPoint=0) const
Returns a list of count random points generated inside a (multi)polygon geometry (if acceptPoint is s...
QVector< QgsPointXY > randomPointsInPolygon(int count, unsigned long seed=0, QgsFeedback *feedback=nullptr) const
Returns a list of count random points generated inside a (multi)polygon geometry.
static bool compare(const QgsPolylineXY &p1, const QgsPolylineXY &p2, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compares two polylines for equality within a specified tolerance.
bool isPolygonClockwise() const
Returns True if the Polygon is clockwise.
This class offers geometry processing methods.
Line string geometry type, with support for z-dimension and m-values.
Perform transforms between map coordinates and device coordinates.
Custom exception class which is raised when an operation is not supported.
A class to represent a 2D point.
Definition qgspointxy.h:60
Point geometry type, with support for z-dimension and m-values.
Definition qgspoint.h:49
Polygon geometry type.
Definition qgspolygon.h:33
A rectangle specified with double values.
Represents a vector layer which manages a vector based data sets.
Java-style iterator for traversal of vertices of a geometry.
static Qgis::GeometryType geometryType(Qgis::WkbType type)
Returns the geometry type for a WKB type, e.g., both MultiPolygon and CurvePolygon would have a Polyg...
static bool isMultiType(Qgis::WkbType type)
Returns true if the WKB type is a multi type.
static QString displayString(Qgis::WkbType type)
Returns a non-translated display string type for a WKB type, e.g., the geometry name used in WKT geom...
static Qgis::WkbType flatType(Qgis::WkbType type)
Returns the flat type for a WKB type.
#define str(x)
Definition qgis.cpp:38
const double DEFAULT_SEGMENT_EPSILON
Default snapping tolerance for segments.
Definition qgis.h:6453
#define SIP_TYPEHINT(type)
Definition qgis_sip.h:232
#define SIP_IN
Definition qgis_sip.h:63
#define SIP_DEPRECATED
Definition qgis_sip.h:106
#define SIP_SKIP
Definition qgis_sip.h:126
#define SIP_PYNAME(name)
Definition qgis_sip.h:81
#define SIP_PYARGREMOVE
Definition qgis_sip.h:151
#define SIP_TRANSFER
Definition qgis_sip.h:36
#define SIP_OUT
Definition qgis_sip.h:58
#define SIP_HOLDGIL
Definition qgis_sip.h:171
#define SIP_FACTORY
Definition qgis_sip.h:76
#define SIP_THROW(name,...)
Definition qgis_sip.h:203
QVector< QgsPoint > QgsPointSequence
Q_DECLARE_METATYPE(QgsDatabaseQueryLogEntry)
qint64 QgsFeatureId
64 bit feature ids negative numbers are used for uncommitted/newly added features
QVector< QgsPolylineXY > QgsPolygonXY
Polygon: first item of the list is outer ring, inner rings (if any) start from second item.
Definition qgsgeometry.h:74
CORE_EXPORT QDataStream & operator>>(QDataStream &in, QgsGeometry &geometry)
Reads a geometry from stream in into geometry. QGIS version compatibility is not guaranteed.
CORE_EXPORT QDataStream & operator<<(QDataStream &out, const QgsGeometry &geometry)
Writes the geometry to stream out. QGIS version compatibility is not guaranteed.
QVector< QgsPolylineXY > QgsMultiPolylineXY
A collection of QgsPolylines that share a common collection of attributes.
Definition qgsgeometry.h:84
QVector< QgsPointXY > QgsMultiPointXY
A collection of QgsPoints that share a common collection of attributes.
Definition qgsgeometry.h:80
QVector< QgsPointXY > QgsPolylineXY
Polyline as represented as a vector of two-dimensional points.
Definition qgsgeometry.h:62
QVector< QgsPolygonXY > QgsMultiPolygonXY
A collection of QgsPolygons that share a common collection of attributes.
Definition qgsgeometry.h:91
QgsPointSequence QgsPolyline
Polyline as represented as a vector of points.
Definition qgsgeometry.h:70
int precision
Utility class for identifying a unique vertex within a geometry.
Definition qgsvertexid.h:30