QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsabstractgeometry.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsabstractgeometry.cpp
3 -------------------------------------------------------------------
4Date : 04 Sept 2014
5Copyright : (C) 2014 by Marco Hugentobler
6email : marco.hugentobler at sourcepole dot com
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#include "qgsabstractgeometry.h"
17#include "qgspoint.h"
19#include "qgsvertexid.h"
20#include "qgscurve.h"
21#include "qgsbox3d.h"
22
23#include <nlohmann/json.hpp>
24#include <limits>
25#include <QTransform>
26
31
33{
34 if ( &geom != this )
35 {
36 clear();
37 mWkbType = geom.mWkbType;
38 }
39 return *this;
40}
41
43{
44 // compare to self
45 if ( this == other )
46 {
47 return 0;
48 }
49
50 if ( sortIndex() != other->sortIndex() )
51 {
52 //different geometry types
53 const int diff = sortIndex() - other->sortIndex();
54 return ( diff > 0 ) - ( diff < 0 );
55 }
56
57 // same types
58 if ( isEmpty() && other->isEmpty() )
59 {
60 return 0;
61 }
62
63 if ( isEmpty() )
64 {
65 return -1;
66 }
67 if ( other->isEmpty() )
68 {
69 return 1;
70 }
71
72 return compareToSameClass( other );
73}
74
76{
77 if ( !subgeom )
78 {
79 return;
80 }
81
82 //special handling for 25d types:
83 if ( baseGeomType == Qgis::WkbType::LineString &&
84 ( subgeom->wkbType() == Qgis::WkbType::Point25D || subgeom->wkbType() == Qgis::WkbType::LineString25D ) )
85 {
87 return;
88 }
89 else if ( baseGeomType == Qgis::WkbType::Polygon &&
90 ( subgeom->wkbType() == Qgis::WkbType::Point25D || subgeom->wkbType() == Qgis::WkbType::LineString25D ) )
91 {
93 return;
94 }
95
96 const bool hasZ = subgeom->is3D();
97 const bool hasM = subgeom->isMeasure();
98
99 if ( hasZ && hasM )
100 {
101 mWkbType = QgsWkbTypes::addM( QgsWkbTypes::addZ( baseGeomType ) );
102 }
103 else if ( hasZ )
104 {
105 mWkbType = QgsWkbTypes::addZ( baseGeomType );
106 }
107 else if ( hasM )
108 {
109 mWkbType = QgsWkbTypes::addM( baseGeomType );
110 }
111 else
112 {
113 mWkbType = baseGeomType;
114 }
115}
116
121
126
128{
129 double xmin = std::numeric_limits<double>::max();
130 double ymin = std::numeric_limits<double>::max();
131 double zmin = std::numeric_limits<double>::max();
132 double xmax = -std::numeric_limits<double>::max();
133 double ymax = -std::numeric_limits<double>::max();
134 double zmax = -std::numeric_limits<double>::max();
135
136 QgsVertexId id;
137 QgsPoint vertex;
138 double x, y, z;
139 if ( is3D() )
140 {
141 while ( nextVertex( id, vertex ) )
142 {
143 x = vertex.x();
144 y = vertex.y();
145 z = vertex.z();
146
147 xmin = std::min( xmin, x );
148 xmax = std::max( xmax, x );
149
150 ymin = std::min( ymin, y );
151 ymax = std::max( ymax, y );
152
153 zmin = std::min( zmin, z );
154 zmax = std::max( zmax, z );
155 }
156 }
157 else
158 {
159 while ( nextVertex( id, vertex ) )
160 {
161 x = vertex.x();
162 y = vertex.y();
163 xmin = std::min( xmin, x );
164 xmax = std::max( xmax, x );
165
166 ymin = std::min( ymin, y );
167 ymax = std::max( ymax, y );
168 }
169 zmin = std::numeric_limits<double>::quiet_NaN();
170 zmax = std::numeric_limits<double>::quiet_NaN();
171 }
172
173 return QgsBox3D( xmin, ymin, zmin, xmax, ymax, zmax );
174}
175
177{
178}
179
181{
182 int nCoords = 0;
183
185 for ( const QgsRingSequence &r : seq )
186 {
187 for ( const QgsPointSequence &p : r )
188 {
189 nCoords += p.size();
190 }
191 }
192
193 return nCoords;
194}
195
197{
198 return 0.0;
199}
200
202{
203 return 0.0;
204}
205
207{
208 return 0.0;
209}
210
212{
213 QString wkt = geometryType();
214 QString suffix;
215 if ( is3D() )
216 suffix += 'Z';
217 if ( isMeasure() )
218 suffix += 'M';
219 if ( !suffix.isEmpty() )
220 {
221 wkt += ' ' + suffix;
222 }
223 return wkt;
224}
225
227{
228 return QString::fromStdString( asJsonObject( precision ).dump() );
229}
230
232{
233 Q_UNUSED( precision ) return nullptr;
234}
235
237{
238 if ( isEmpty() )
239 return QgsPoint();
240
241 // http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
242 // Pick the first ring of first part for the moment
243
244 const int n = vertexCount( 0, 0 );
245 if ( n == 1 )
246 {
247 return vertexAt( QgsVertexId( 0, 0, 0 ) );
248 }
249
250 double A = 0.;
251 double Cx = 0.;
252 double Cy = 0.;
253 const QgsPoint v0 = vertexAt( QgsVertexId( 0, 0, 0 ) );
254 int i = 0, j = 1;
255 if ( vertexAt( QgsVertexId( 0, 0, 0 ) ) != vertexAt( QgsVertexId( 0, 0, n - 1 ) ) )
256 {
257 i = n - 1;
258 j = 0;
259 }
260 for ( ; j < n; i = j++ )
261 {
262 QgsPoint vi = vertexAt( QgsVertexId( 0, 0, i ) );
263 QgsPoint vj = vertexAt( QgsVertexId( 0, 0, j ) );
264 vi.rx() -= v0.x();
265 vi.ry() -= v0.y();
266 vj.rx() -= v0.x();
267 vj.ry() -= v0.y();
268 const double d = vi.x() * vj.y() - vj.x() * vi.y();
269 A += d;
270 Cx += ( vi.x() + vj.x() ) * d;
271 Cy += ( vi.y() + vj.y() ) * d;
272 }
273
274 if ( A < 1E-12 )
275 {
276 Cx = Cy = 0.;
277 for ( int i = 0; i < n - 1; ++i )
278 {
279 const QgsPoint vi = vertexAt( QgsVertexId( 0, 0, i ) );
280 Cx += vi.x();
281 Cy += vi.y();
282 }
283 return QgsPoint( Cx / ( n - 1 ), Cy / ( n - 1 ) );
284 }
285 else
286 {
287 return QgsPoint( v0.x() + Cx / ( 3. * A ), v0.y() + Cy / ( 3. * A ) );
288 }
289}
290
292{
293 if ( type == mWkbType )
294 return true;
295
297 return false;
298
299 const bool needZ = QgsWkbTypes::hasZ( type );
300 const bool needM = QgsWkbTypes::hasM( type );
301 if ( !needZ )
302 {
303 dropZValue();
304 }
305 else if ( !is3D() )
306 {
307 addZValue( std::numeric_limits<double>::quiet_NaN() );
308 }
309
310 if ( !needM )
311 {
312 dropMValue();
313 }
314 else if ( !isMeasure() )
315 {
316 addMValue( std::numeric_limits<double>::quiet_NaN() );
317 }
318
319 return true;
320}
321
323{
324 return this;
325}
326
327void QgsAbstractGeometry::filterVertices( const std::function<bool ( const QgsPoint & )> & )
328{
329 // Ideally this would be pure virtual, but SIP has issues with that
330}
331
332void QgsAbstractGeometry::transformVertices( const std::function<QgsPoint( const QgsPoint & )> & )
333{
334 // Ideally this would be pure virtual, but SIP has issues with that
335}
336
338{
339 const QgsGeometryCollection *collection = qgsgeometry_cast< const QgsGeometryCollection * >( this );
340 return part_iterator( this, collection ? collection->partCount() : 1 );
341}
342
347
352
354{
355 const QgsGeometryCollection *collection = qgsgeometry_cast< const QgsGeometryCollection * >( this );
356 return const_part_iterator( this, collection ? collection->partCount() : 1 );
357}
358
363
365{
366 switch ( QgsWkbTypes::flatType( mWkbType ) )
367 {
369 return 0;
371 return 1;
373 return 2;
375 return 3;
377 return 4;
379 return 5;
381 return 6;
384 return 7;
386 return 8;
388 return 9;
390 return 10;
392 return 11;
394 return 12;
396 default:
397 break;
398 }
399 return 13;
400}
401
406
408{
409 Q_UNUSED( index )
410 return QgsPoint();
411}
412
414{
415 QgsVertexId vId;
416 QgsPoint vertex;
417 return !nextVertex( vId, vertex );
418}
419
421{
422 return false;
423}
424
426{
427 return boundingBox().intersects( rectangle );
428}
429
431{
432 return boundingBox3D().intersects( box3d );
433}
434
436{
437 Q_UNUSED( tolerance )
438 Q_UNUSED( toleranceType )
439 return clone();
440}
441
442
444 : depth( 0 )
445{
446 levels.fill( Level() );
447 levels[0].g = g;
448 levels[0].index = index;
449
450 digDown(); // go to the leaf level of the first vertex
451}
452
454{
455 if ( depth == 0 && levels[0].index >= levels[0].g->childCount() )
456 return *this; // end of geometry - nowhere else to go
457
458 Q_ASSERT( !levels[depth].g->hasChildGeometries() ); // we should be at a leaf level
459
460 ++levels[depth].index;
461
462 // traverse up if we are at the end in the current level
463 while ( depth > 0 && levels[depth].index >= levels[depth].g->childCount() )
464 {
465 --depth;
466 ++levels[depth].index;
467 }
468
469 digDown(); // go to the leaf level again
470
471 return *this;
472}
473
480
482{
483 Q_ASSERT( !levels[depth].g->hasChildGeometries() );
484 return levels[depth].g->childPoint( levels[depth].index );
485}
486
488{
489 int part = 0, ring = 0, vertex = levels[depth].index;
490 if ( depth == 0 )
491 {
492 // nothing else to do
493 }
494 else if ( depth == 1 )
495 {
496 if ( QgsWkbTypes::isMultiType( levels[0].g->wkbType() ) )
497 part = levels[0].index;
498 else
499 ring = levels[0].index;
500 }
501 else if ( depth == 2 )
502 {
503 part = levels[0].index;
504 ring = levels[1].index;
505 }
506 else
507 {
508 Q_ASSERT( false );
509 return QgsVertexId();
510 }
511
512 // get the vertex type: find out from the leaf geometry
514 if ( const QgsCurve *curve = dynamic_cast<const QgsCurve *>( levels[depth].g ) )
515 {
516 QgsPoint p;
517 curve->pointAt( vertex, p, vertexType );
518 }
519
520 return QgsVertexId( part, ring, vertex, vertexType );
521}
522
524{
525 if ( depth != other.depth )
526 return false;
527 return std::equal( std::begin( levels ), std::begin( levels ) + depth + 1, std::begin( other.levels ) );
528}
529
530void QgsAbstractGeometry::vertex_iterator::digDown()
531{
532 if ( levels[depth].g->hasChildGeometries() && levels[depth].index >= levels[depth].g->childCount() )
533 return; // first check we are not already at the end
534
535 // while not "final" depth for the geom: go one level down.
536 while ( levels[depth].g->hasChildGeometries() )
537 {
538 ++depth;
539 Q_ASSERT( depth < 3 ); // that's capacity of the levels array
540 levels[depth].index = 0;
541 levels[depth].g = levels[depth - 1].g->childGeometry( levels[depth - 1].index );
542 }
543}
544
546{
547 n = i++;
548 return *n;
549}
550
552 : mIndex( index )
553 , mGeometry( g )
554{
555}
556
558{
559 const QgsGeometryCollection *collection = qgsgeometry_cast< const QgsGeometryCollection * >( mGeometry );
560 if ( !collection )
561 {
562 mIndex = 1;
563 return *this; // end of geometry -- nowhere else to go
564 }
565
566 if ( mIndex >= collection->partCount() )
567 return *this; // end of geometry - nowhere else to go
568
569 mIndex++;
570 return *this;
571}
572
574{
575 part_iterator it( *this );
576 ++*this;
577 return it;
578}
579
581{
582 QgsGeometryCollection *collection = qgsgeometry_cast< QgsGeometryCollection * >( mGeometry );
583 if ( !collection )
584 {
585 return mGeometry;
586 }
587
588 return collection->geometryN( mIndex );
589}
590
592{
593 return mIndex;
594}
595
597{
598 return mGeometry == other.mGeometry && mIndex == other.mIndex;
599}
600
602{
603 n = i++;
604 return *n;
605}
606
607
608
610 : mIndex( index )
611 , mGeometry( g )
612{
613}
614
616{
617 const QgsGeometryCollection *collection = qgsgeometry_cast< const QgsGeometryCollection * >( mGeometry );
618 if ( !collection )
619 {
620 mIndex = 1;
621 return *this; // end of geometry -- nowhere else to go
622 }
623
624 if ( mIndex >= collection->partCount() )
625 return *this; // end of geometry - nowhere else to go
626
627 mIndex++;
628 return *this;
629}
630
637
639{
640 const QgsGeometryCollection *collection = qgsgeometry_cast< const QgsGeometryCollection * >( mGeometry );
641 if ( !collection )
642 {
643 return mGeometry;
644 }
645
646 return collection->geometryN( mIndex );
647}
648
650{
651 return mIndex;
652}
653
655{
656 return mGeometry == other.mGeometry && mIndex == other.mIndex;
657}
658
660{
661 n = i++;
662 return *n;
663}
664
665bool QgsAbstractGeometry::vertex_iterator::Level::operator==( const QgsAbstractGeometry::vertex_iterator::Level &other ) const
666{
667 return g == other.g && index == other.index;
668}
VertexType
Types of vertex.
Definition qgis.h:2835
@ Segment
The actual start or end point of a segment.
WkbType
The WKB type describes the number of dimensions a geometry has.
Definition qgis.h:256
@ LineString25D
LineString25D.
@ CompoundCurve
CompoundCurve.
@ LineString
LineString.
@ MultiPoint
MultiPoint.
@ Polygon
Polygon.
@ MultiPolygon
MultiPolygon.
@ Triangle
Triangle.
@ NoGeometry
No geometry.
@ MultiLineString
MultiLineString.
@ Unknown
Unknown.
@ CircularString
CircularString.
@ GeometryCollection
GeometryCollection.
@ MultiCurve
MultiCurve.
@ CurvePolygon
CurvePolygon.
@ Point25D
Point25D.
@ MultiSurface
MultiSurface.
@ Polygon25D
Polygon25D.
The part_iterator class provides STL-style iterator for const references to geometry parts.
const_part_iterator & operator++()
The prefix ++ operator (++it) advances the iterator to the next part and returns an iterator to the n...
const_part_iterator()=default
Create invalid iterator.
const QgsAbstractGeometry * operator*() const
Returns the current item.
int partNumber() const
Returns the part number of the current item.
bool operator==(const_part_iterator other) const
The part_iterator class provides STL-style iterator for geometry parts.
part_iterator & operator++()
The prefix ++ operator (++it) advances the iterator to the next part and returns an iterator to the n...
part_iterator()=default
Create invalid iterator.
QgsAbstractGeometry * operator*() const
Returns the current item.
bool operator==(part_iterator other) const
int partNumber() const
Returns the part number of the current item.
The vertex_iterator class provides STL-style iterator for vertices.
vertex_iterator()=default
Create invalid iterator.
bool operator==(const vertex_iterator &other) const
QgsPoint operator*() const
Returns the current item.
vertex_iterator & operator++()
The prefix ++ operator (++it) advances the iterator to the next vertex and returns an iterator to the...
QgsVertexId vertexId() const
Returns vertex ID of the current item.
Abstract base class for all geometries.
virtual QgsPoint childPoint(int index) const
Returns point at index (for geometries without child geometries - i.e.
virtual bool addZValue(double zValue=0)=0
Adds a z-dimension to the geometry, initialized to a preset value.
SegmentationToleranceType
Segmentation tolerance as maximum angle or maximum difference between approximation and circle.
virtual bool convertTo(Qgis::WkbType type)
Converts the geometry to a specified type.
virtual bool dropMValue()=0
Drops any measure values which exist in the geometry.
virtual QgsBox3D calculateBoundingBox3D() const
Calculates the minimal 3D bounding box for the geometry.
virtual const QgsAbstractGeometry * simplifiedTypeRef() const
Returns a reference to the simplest lossless representation of this geometry, e.g.
QgsVertexIterator vertices() const
Returns a read-only, Java-style iterator for traversal of vertices of all the geometry,...
virtual QgsAbstractGeometry * segmentize(double tolerance=M_PI/180., SegmentationToleranceType toleranceType=MaximumAngle) const
Returns a version of the geometry without curves.
virtual int vertexCount(int part=0, int ring=0) const =0
Returns the number of vertices of which this geometry is built.
bool isMeasure() const
Returns true if the geometry contains m values.
virtual QgsRectangle calculateBoundingBox() const
Default calculator for the minimal bounding box for the geometry.
virtual QgsRectangle boundingBox() const
Returns the minimal bounding box for the geometry.
virtual void transformVertices(const std::function< QgsPoint(const QgsPoint &) > &transform)
Transforms the vertices from the geometry in place, applying the transform function to every vertex.
bool is3D() const
Returns true if the geometry is 3D and contains a z-value.
virtual QgsBox3D boundingBox3D() const =0
Returns the 3D bounding box for the geometry.
virtual QString geometryType() const =0
Returns a unique string representing the geometry type.
int sortIndex() const
Returns the sort index for the geometry, used in the compareTo() method to compare geometries of diff...
QString wktTypeStr() const
Returns the WKT type string of the geometry.
virtual double perimeter() const
Returns the planar, 2-dimensional perimeter of the geometry.
virtual int nCoordinates() const
Returns the number of nodes contained in the geometry.
virtual QgsPoint vertexAt(QgsVertexId id) const =0
Returns the point corresponding to a specified vertex id.
virtual void clearCache() const
Clears any cached parameters associated with the geometry, e.g., bounding boxes.
QgsAbstractGeometry & operator=(const QgsAbstractGeometry &geom)
virtual bool addMValue(double mValue=0)=0
Adds a measure to the geometry, initialized to a preset value.
Qgis::WkbType wkbType() const
Returns the WKB type of the geometry.
QString asJson(int precision=17)
Returns a GeoJSON representation of the geometry as a QString.
part_iterator parts_end()
Returns STL-style iterator pointing to the imaginary part after the last part of the geometry.
void setZMTypeFromSubGeometry(const QgsAbstractGeometry *subggeom, Qgis::WkbType baseGeomType)
Updates the geometry type based on whether sub geometries contain z or m values.
virtual double length() const
Returns the planar, 2-dimensional length of the geometry.
const_part_iterator const_parts_end() const
Returns STL-style iterator pointing to the imaginary const part after the last part of the geometry.
virtual bool isEmpty() const
Returns true if the geometry is empty.
virtual json asJsonObject(int precision=17) const
Returns a json object representation of the geometry.
virtual QgsCoordinateSequence coordinateSequence() const =0
Retrieves the sequence of geometries, rings and nodes.
virtual bool hasChildGeometries() const
Returns whether the geometry has any child geometries (false for point / curve, true otherwise)
virtual bool boundingBoxIntersects(const QgsRectangle &rectangle) const
Returns true if the bounding box of this geometry intersects with a rectangle.
virtual bool hasCurvedSegments() const
Returns true if the geometry contains curved segments.
virtual void clear()=0
Clears the geometry, ie reset it to a null geometry.
virtual void filterVertices(const std::function< bool(const QgsPoint &) > &filter)
Filters the vertices from the geometry in place, removing any which do not return true for the filter...
virtual bool dropZValue()=0
Drops any z-dimensions which exist in the geometry.
virtual QgsPoint centroid() const
Returns the centroid of the geometry.
virtual int dimension() const =0
Returns the inherent dimension of the geometry.
virtual int compareTo(const QgsAbstractGeometry *other) const
Comparator for sorting of geometry.
QgsAbstractGeometry()=default
virtual double area() const
Returns the planar, 2-dimensional area of the geometry.
virtual int compareToSameClass(const QgsAbstractGeometry *other) const =0
Compares to an other geometry of the same class, and returns a integer for sorting of the two geometr...
QgsGeometryConstPartIterator parts() const
Returns Java-style iterator for traversal of parts of the geometry.
virtual bool nextVertex(QgsVertexId &id, QgsPoint &vertex) const =0
Returns next vertex id and coordinates.
virtual QgsAbstractGeometry * clone() const =0
Clones the geometry by performing a deep copy.
A 3-dimensional box composed of x, y, z coordinates.
Definition qgsbox3d.h:43
bool intersects(const QgsBox3D &other) const
Returns true if box intersects with another box.
Definition qgsbox3d.cpp:132
QgsRectangle toRectangle() const
Converts the box to a 2D rectangle.
Definition qgsbox3d.h:361
Abstract base class for curved geometry type.
Definition qgscurve.h:35
int partCount() const override
Returns count of parts contained in the geometry.
const QgsAbstractGeometry * geometryN(int n) const
Returns a const reference to a geometry from within the collection.
Java-style iterator for const traversal of parts of a geometry.
const QgsAbstractGeometry * next()
Returns next part of the geometry (undefined behavior if hasNext() returns false before calling next(...
Java-style iterator for traversal of parts of a geometry.
QgsAbstractGeometry * next()
Returns next part of the geometry (undefined behavior if hasNext() returns false before calling next(...
Point geometry type, with support for z-dimension and m-values.
Definition qgspoint.h:49
double & rx()
Returns a reference to the x-coordinate of this point.
Definition qgspoint.h:298
double z
Definition qgspoint.h:54
double x
Definition qgspoint.h:52
double & ry()
Returns a reference to the y-coordinate of this point.
Definition qgspoint.h:307
double y
Definition qgspoint.h:53
A rectangle specified with double values.
bool intersects(const QgsRectangle &rect) const
Returns true when rectangle intersects with other rectangle.
Java-style iterator for traversal of vertices of a geometry.
QgsPoint next()
Returns next vertex of the geometry (undefined behavior if hasNext() returns false before calling nex...
static bool isMultiType(Qgis::WkbType type)
Returns true if the WKB type is a multi type.
static Qgis::WkbType addM(Qgis::WkbType type)
Adds the m dimension to a WKB type and returns the new type.
static Qgis::WkbType addZ(Qgis::WkbType type)
Adds the z dimension to a WKB type and returns the new type.
static bool hasZ(Qgis::WkbType type)
Tests whether a WKB type contains the z-dimension.
static bool hasM(Qgis::WkbType type)
Tests whether a WKB type contains m values.
static Qgis::WkbType flatType(Qgis::WkbType type)
Returns the flat type for a WKB type.
QVector< QgsRingSequence > QgsCoordinateSequence
QVector< QgsPointSequence > QgsRingSequence
QVector< QgsPoint > QgsPointSequence
int precision
Utility class for identifying a unique vertex within a geometry.
Definition qgsvertexid.h:30