QGIS API Documentation 3.35.0-Master (f6e073f0eed)
Loading...
Searching...
No Matches
qgspoint.h
Go to the documentation of this file.
1/***************************************************************************
2 qgspointv2.h
3 --------------
4 begin : September 2014
5 copyright : (C) 2014 by Marco Hugentobler
6 email : marco at sourcepole dot ch
7 ***************************************************************************/
8
9/***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 ***************************************************************************/
17
18#ifndef QGSPOINT_H
19#define QGSPOINT_H
20
21#include "qgis_core.h"
22#include "qgis_sip.h"
23#include "qgsabstractgeometry.h"
25#include "qgsrectangle.h"
26
27/***************************************************************************
28 * This class is considered CRITICAL and any change MUST be accompanied with
29 * full unit tests in testqgsgeometry.cpp.
30 * See details in QEP #17
31 ****************************************************************************/
32
48class CORE_EXPORT QgsPoint: public QgsAbstractGeometry
49{
50 Q_GADGET
51
52 Q_PROPERTY( double x READ x WRITE setX )
53 Q_PROPERTY( double y READ y WRITE setY )
54 Q_PROPERTY( double z READ z WRITE setZ )
55 Q_PROPERTY( double m READ m WRITE setM )
56
57 public:
58
85#ifndef SIP_RUN
86 QgsPoint( double x = std::numeric_limits<double>::quiet_NaN(), double y = std::numeric_limits<double>::quiet_NaN(), double z = std::numeric_limits<double>::quiet_NaN(), double m = std::numeric_limits<double>::quiet_NaN(), Qgis::WkbType wkbType = Qgis::WkbType::Unknown );
87#else
88 QgsPoint( SIP_PYOBJECT x SIP_TYPEHINT( Optional[Union[QgsPoint, QPointF, float]] ) = Py_None, SIP_PYOBJECT y SIP_TYPEHINT( Optional[float] ) = Py_None, SIP_PYOBJECT z SIP_TYPEHINT( Optional[float] ) = Py_None, SIP_PYOBJECT m SIP_TYPEHINT( Optional[float] ) = Py_None, SIP_PYOBJECT wkbType SIP_TYPEHINT( Optional[int] ) = Py_None ) [( double x = 0.0, double y = 0.0, double z = 0.0, double m = 0.0, Qgis::WkbType wkbType = Qgis::WkbType::Unknown )];
89 % MethodCode
90 if ( sipCanConvertToType( a0, sipType_QgsPointXY, SIP_NOT_NONE ) && a1 == Py_None && a2 == Py_None && a3 == Py_None && a4 == Py_None )
91 {
92 int state;
93 sipIsErr = 0;
94
95 QgsPointXY *p = reinterpret_cast<QgsPointXY *>( sipConvertToType( a0, sipType_QgsPointXY, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
96 if ( sipIsErr )
97 {
98 sipReleaseType( p, sipType_QgsPointXY, state );
99 }
100 else
101 {
102 sipCpp = new sipQgsPoint( QgsPoint( *p ) );
103 }
104 }
105 else if ( sipCanConvertToType( a0, sipType_QPointF, SIP_NOT_NONE ) && a1 == Py_None && a2 == Py_None && a3 == Py_None && a4 == Py_None )
106 {
107 int state;
108 sipIsErr = 0;
109
110 QPointF *p = reinterpret_cast<QPointF *>( sipConvertToType( a0, sipType_QPointF, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
111 if ( sipIsErr )
112 {
113 sipReleaseType( p, sipType_QPointF, state );
114 }
115 else
116 {
117 sipCpp = new sipQgsPoint( QgsPoint( *p ) );
118 }
119 }
120 else if (
121 ( a0 == Py_None || PyFloat_AsDouble( a0 ) != -1.0 || !PyErr_Occurred() ) &&
122 ( a1 == Py_None || PyFloat_AsDouble( a1 ) != -1.0 || !PyErr_Occurred() ) &&
123 ( a2 == Py_None || PyFloat_AsDouble( a2 ) != -1.0 || !PyErr_Occurred() ) &&
124 ( a3 == Py_None || PyFloat_AsDouble( a3 ) != -1.0 || !PyErr_Occurred() ) )
125 {
126 double x = a0 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a0 );
127 double y = a1 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a1 );
128 double z = a2 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a2 );
129 double m = a3 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a3 );
130 Qgis::WkbType wkbType = a4 == Py_None ? Qgis::WkbType::Unknown : static_cast<Qgis::WkbType>( sipConvertToEnum( a4, sipType_Qgis_WkbType ) );
131 sipCpp = new sipQgsPoint( QgsPoint( x, y, z, m, wkbType ) );
132 }
133 else // Invalid ctor arguments
134 {
135 PyErr_SetString( PyExc_TypeError, QStringLiteral( "Invalid type in constructor arguments." ).toUtf8().constData() );
136 sipIsErr = 1;
137 }
138 % End
139#endif
140
144 explicit QgsPoint( const QgsPointXY &p ) SIP_SKIP;
145
149 explicit QgsPoint( QPointF p ) SIP_SKIP;
150
156 explicit QgsPoint( Qgis::WkbType wkbType, double x = std::numeric_limits<double>::quiet_NaN(), double y = std::numeric_limits<double>::quiet_NaN(), double z = std::numeric_limits<double>::quiet_NaN(), double m = std::numeric_limits<double>::quiet_NaN() ) SIP_SKIP;
157
158#ifndef SIP_RUN
159 private:
160 bool fuzzyHelper( double epsilon,
161 const QgsAbstractGeometry &other,
162 bool is3DFlag,
163 bool isMeasureFlag,
164 std::function<bool( double, double, double, double, double, double, double, double, double )> comparator3DMeasure,
165 std::function<bool( double, double, double, double, double, double, double )> comparator3D,
166 std::function<bool( double, double, double, double, double, double, double )> comparatorMeasure,
167 std::function<bool( double, double, double, double, double )> comparator2D ) const
168 {
169 const QgsPoint *pt = qgsgeometry_cast< const QgsPoint * >( &other );
170 if ( !pt )
171 return false;
172
173 const Qgis::WkbType type = wkbType();
174
175 if ( pt->wkbType() != type )
176 return false;
177
178 if ( is3DFlag && isMeasureFlag )
179 {
180 return comparator3DMeasure( epsilon, mX, mY, mZ, mM, pt->x(), pt->y(), pt->z(), pt->m() );
181 }
182 else if ( is3DFlag )
183 {
184 return comparator3D( epsilon, mX, mY, mZ, pt->x(), pt->y(), pt->z() );
185 }
186 else if ( isMeasureFlag )
187 {
188 return comparatorMeasure( epsilon, mX, mY, mM, pt->x(), pt->y(), pt->m() );
189 }
190 return comparator2D( epsilon, mX, mY, pt->x(), pt->y() );
191 }
192#endif // !SIP_RUN
193
194 public:
195 bool fuzzyEqual( const QgsAbstractGeometry &other, double epsilon = 1e-8 ) const override SIP_HOLDGIL
196 {
197 return fuzzyHelper(
198 epsilon,
199 other,
200 is3D(),
201 isMeasure(),
202 []( double epsilon, double x1, double y1, double z1, double m1,
203 double x2, double y2, double z2, double m2 )
204 {
205 return QgsGeometryUtilsBase::fuzzyEqual( epsilon, x1, y1, z1, m1, x2, y2, z2, m2 );
206 },
207 []( double epsilon, double x1, double y1, double z1,
208 double x2, double y2, double z2 )
209 {
210 return QgsGeometryUtilsBase::fuzzyEqual( epsilon, x1, y1, z1, x2, y2, z2 );
211 },
212 []( double epsilon, double x1, double y1, double m1,
213 double x2, double y2, double m2 )
214 {
215 return QgsGeometryUtilsBase::fuzzyEqual( epsilon, x1, y1, m1, x2, y2, m2 );
216 },
217 []( double epsilon, double x1, double y1,
218 double x2, double y2 )
219 {
220 return QgsGeometryUtilsBase::fuzzyEqual( epsilon, x1, y1, x2, y2 );
221 } );
222 }
223
224 bool fuzzyDistanceEqual( const QgsAbstractGeometry &other, double epsilon = 1e-8 ) const override SIP_HOLDGIL
225 {
226 return fuzzyHelper(
227 epsilon,
228 other,
229 is3D(),
230 isMeasure(),
231 []( double epsilon, double x1, double y1, double z1, double m1,
232 double x2, double y2, double z2, double m2 )
233 {
234 return QgsGeometryUtilsBase::fuzzyDistanceEqual( epsilon, x1, y1, z1, m1, x2, y2, z2, m2 );
235 },
236 []( double epsilon, double x1, double y1, double z1,
237 double x2, double y2, double z2 )
238 {
239 return QgsGeometryUtilsBase::fuzzyDistanceEqual( epsilon, x1, y1, z1, x2, y2, z2 );
240 },
241 []( double epsilon, double x1, double y1, double m1,
242 double x2, double y2, double m2 )
243 {
244 return QgsGeometryUtilsBase::fuzzyDistanceEqual( epsilon, x1, y1, m1, x2, y2, m2 );
245 },
246 []( double epsilon, double x1, double y1,
247 double x2, double y2 )
248 {
249 return QgsGeometryUtilsBase::fuzzyDistanceEqual( epsilon, x1, y1, x2, y2 );
250 } );
251 }
252
253 bool operator==( const QgsAbstractGeometry &other ) const override SIP_HOLDGIL
254 {
255 return fuzzyEqual( other, 1e-8 );
256 }
257
258 bool operator!=( const QgsAbstractGeometry &other ) const override SIP_HOLDGIL
259 {
260 return !fuzzyEqual( other, 1e-8 );
261 }
262
268 double x() const SIP_HOLDGIL { return mX; }
269
275 double y() const SIP_HOLDGIL { return mY; }
276
282 double z() const SIP_HOLDGIL { return mZ; }
283
289 double m() const SIP_HOLDGIL { return mM; }
290
298 double &rx() SIP_SKIP { clearCache(); return mX; }
299
307 double &ry() SIP_SKIP { clearCache(); return mY; }
308
316 double &rz() SIP_SKIP { clearCache(); return mZ; }
317
325 double &rm() SIP_SKIP { clearCache(); return mM; }
326
332 void setX( double x ) SIP_HOLDGIL
333 {
334 clearCache();
335 mX = x;
336 }
337
343 void setY( double y ) SIP_HOLDGIL
344 {
345 clearCache();
346 mY = y;
347 }
348
356 void setZ( double z ) SIP_HOLDGIL
357 {
358 if ( !is3D() )
359 return;
360 clearCache();
361 mZ = z;
362 }
363
371 void setM( double m ) SIP_HOLDGIL
372 {
373 if ( !isMeasure() )
374 return;
375 clearCache();
376 mM = m;
377 }
378
382 QPointF toQPointF() const SIP_HOLDGIL
383 {
384 return QPointF( mX, mY );
385 }
386
393 double distance( double x, double y ) const SIP_HOLDGIL
394 {
395 return QgsGeometryUtilsBase::distance2D( mX, mY, x, y );
396 }
397
404 double distance( const QgsPoint &other ) const SIP_HOLDGIL
405 {
406 return QgsGeometryUtilsBase::distance2D( mX, mY, other.x(), other.y() );
407 }
408
415 double distanceSquared( double x, double y ) const SIP_HOLDGIL
416 {
417 return QgsGeometryUtilsBase::sqrDistance2D( mX, mY, x, y );
418 }
419
426 double distanceSquared( const QgsPoint &other ) const SIP_HOLDGIL
427 {
428 return QgsGeometryUtilsBase::sqrDistance2D( mX, mY, other.x(), other.y() );
429 }
430
437 double distance3D( double x, double y, double z ) const SIP_HOLDGIL
438 {
439 if ( is3D() || !std::isnan( z ) )
440 {
441 return QgsGeometryUtilsBase::distance3D( mX, mY, mZ, x, y, z );
442 }
443 return QgsGeometryUtilsBase::distance2D( mX, mY, x, y );
444 }
445
452 double distance3D( const QgsPoint &other ) const SIP_HOLDGIL
453 {
454 if ( is3D() || other.is3D() )
455 {
456 return QgsGeometryUtilsBase::distance3D( mX, mY, mZ, other.x(), other.y(), other.z() );
457 }
458 return QgsGeometryUtilsBase::distance2D( mX, mY, other.x(), other.y() );
459 }
460
467 double distanceSquared3D( double x, double y, double z ) const SIP_HOLDGIL
468 {
469 if ( is3D() || !std::isnan( z ) )
470 {
471 return QgsGeometryUtilsBase::sqrDistance3D( mX, mY, mZ, x, y, z );
472 }
473 return QgsGeometryUtilsBase::sqrDistance2D( mX, mY, x, y );
474 }
475
482 double distanceSquared3D( const QgsPoint &other ) const SIP_HOLDGIL
483 {
484 if ( is3D() || other.is3D() )
485 {
486 return QgsGeometryUtilsBase::sqrDistance3D( mX, mY, mZ, other.x(), other.y(), other.z() );
487 }
488 return QgsGeometryUtilsBase::sqrDistance2D( mX, mY, other.x(), other.y() );
489 }
490
494 double azimuth( const QgsPoint &other ) const SIP_HOLDGIL;
495
500 double inclination( const QgsPoint &other ) const SIP_HOLDGIL;
501
531 QgsPoint project( double distance, double azimuth, double inclination = 90.0 ) const SIP_HOLDGIL;
532
536 QgsVector operator-( const QgsPoint &p ) const SIP_HOLDGIL { return QgsVector( mX - p.mX, mY - p.mY ); }
537
541 QgsPoint &operator+=( QgsVector v ) SIP_HOLDGIL { mX += v.x(); mY += v.y(); return *this; }
542
546 QgsPoint &operator-=( QgsVector v ) SIP_HOLDGIL { mX -= v.x(); mY -= v.y(); return *this; }
547
551 QgsPoint operator+( QgsVector v ) const SIP_HOLDGIL { QgsPoint r = *this; r.rx() += v.x(); r.ry() += v.y(); return r; }
552
556 QgsPoint operator-( QgsVector v ) const SIP_HOLDGIL { QgsPoint r = *this; r.rx() -= v.x(); r.ry() -= v.y(); return r; }
557
558 //implementation of inherited methods
559 void normalize() final SIP_HOLDGIL;
560 bool isEmpty() const override SIP_HOLDGIL;
561 QgsBox3D boundingBox3D() const override SIP_HOLDGIL;
562 QString geometryType() const override SIP_HOLDGIL;
563 int dimension() const override SIP_HOLDGIL;
564 QgsPoint *clone() const override SIP_FACTORY;
565 QgsPoint *snappedToGrid( double hSpacing, double vSpacing, double dSpacing = 0, double mSpacing = 0 ) const override SIP_FACTORY;
566 bool removeDuplicateNodes( double epsilon = 4 * std::numeric_limits<double>::epsilon(), bool useZValues = false ) override;
567 void clear() override;
568 bool fromWkb( QgsConstWkbPtr &wkb ) override;
569 bool fromWkt( const QString &wkt ) override;
570 int wkbSize( QgsAbstractGeometry::WkbFlags flags = QgsAbstractGeometry::WkbFlags() ) const override;
571 QByteArray asWkb( QgsAbstractGeometry::WkbFlags = QgsAbstractGeometry::WkbFlags() ) const override;
572 QString asWkt( int precision = 17 ) const override;
573 QDomElement asGml2( QDomDocument &doc, int precision = 17, const QString &ns = "gml", QgsAbstractGeometry::AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const override;
574 QDomElement asGml3( QDomDocument &doc, int precision = 17, const QString &ns = "gml", QgsAbstractGeometry::AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const override;
575 json asJsonObject( int precision = 17 ) const override SIP_SKIP;
576 QString asKml( int precision = 17 ) const override;
577 void draw( QPainter &p ) const override;
578 QPainterPath asQPainterPath() const override;
579 void transform( const QgsCoordinateTransform &ct, Qgis::TransformDirection d = Qgis::TransformDirection::Forward, bool transformZ = false ) override SIP_THROW( QgsCsException );
580 void transform( const QTransform &t, double zTranslate = 0.0, double zScale = 1.0, double mTranslate = 0.0, double mScale = 1.0 ) override;
581 QgsCoordinateSequence coordinateSequence() const override;
582 int nCoordinates() const override SIP_HOLDGIL;
583 int vertexNumberFromVertexId( QgsVertexId id ) const override;
584 QgsAbstractGeometry *boundary() const override SIP_FACTORY;
585 bool isValid( QString &error SIP_OUT, Qgis::GeometryValidityFlags flags = Qgis::GeometryValidityFlags() ) const override SIP_HOLDGIL;
586
587 //low-level editing
588 bool insertVertex( QgsVertexId position, const QgsPoint &vertex ) override;
589 bool moveVertex( QgsVertexId position, const QgsPoint &newPos ) override;
590 bool deleteVertex( QgsVertexId position ) override;
591
592 double closestSegment( const QgsPoint &pt, QgsPoint &segmentPt SIP_OUT, QgsVertexId &vertexAfter SIP_OUT, int *leftOf SIP_OUT = nullptr, double epsilon = 4 * std::numeric_limits<double>::epsilon() ) const override;
593 bool nextVertex( QgsVertexId &id, QgsPoint &vertex SIP_OUT ) const override;
594 void adjacentVertices( QgsVertexId vertex, QgsVertexId &previousVertex SIP_OUT, QgsVertexId &nextVertex SIP_OUT ) const override;
595
601 double vertexAngle( QgsVertexId vertex ) const override;
602
603 int vertexCount( int /*part*/ = 0, int /*ring*/ = 0 ) const override;
604 int ringCount( int /*part*/ = 0 ) const override;
605 int partCount() const override;
606 QgsPoint vertexAt( QgsVertexId /*id*/ ) const override;
607 QgsPoint *toCurveType() const override SIP_FACTORY;
608 double segmentLength( QgsVertexId startVertex ) const override;
609 bool boundingBoxIntersects( const QgsRectangle &rectangle ) const override SIP_HOLDGIL;
610 bool boundingBoxIntersects( const QgsBox3D &box3d ) const override SIP_HOLDGIL;
611
612 bool addZValue( double zValue = 0 ) override;
613 bool addMValue( double mValue = 0 ) override;
614 bool dropZValue() override;
615 bool dropMValue() override;
616 void swapXy() override;
617 bool convertTo( Qgis::WkbType type ) override;
618
619 bool transform( QgsAbstractGeometryTransformer *transformer, QgsFeedback *feedback = nullptr ) override;
620
621#ifndef SIP_RUN
622
623 void filterVertices( const std::function< bool( const QgsPoint & ) > &filter ) override;
624 void transformVertices( const std::function< QgsPoint( const QgsPoint & ) > &transform ) override;
625
632 inline static const QgsPoint *cast( const QgsAbstractGeometry *geom )
633 {
634 if ( geom && QgsWkbTypes::flatType( geom->wkbType() ) == Qgis::WkbType::Point )
635 return static_cast<const QgsPoint *>( geom );
636 return nullptr;
637 }
638#endif
639
641
642#ifdef SIP_RUN
643 SIP_PYOBJECT __repr__();
644 % MethodCode
645 QString str = QStringLiteral( "<QgsPoint: %1>" ).arg( sipCpp->asWkt() );
646 sipRes = PyUnicode_FromString( str.toUtf8().constData() );
647 % End
648#endif
649
650 protected:
651
652 int compareToSameClass( const QgsAbstractGeometry *other ) const final;
653 int childCount() const override;
654 QgsPoint childPoint( int index ) const override;
655
656 private:
657 double mX;
658 double mY;
659 double mZ;
660 double mM;
661};
662
663// clazy:excludeall=qstring-allocations
664
665#endif // QGSPOINT_H
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
WkbType
The WKB type describes the number of dimensions a geometry has.
Definition qgis.h:182
@ Unknown
Unknown.
An abstract base class for classes which transform geometries by transforming input points to output ...
Abstract base class for all geometries.
virtual QgsPoint childPoint(int index) const
Returns point at index (for geometries without child geometries - i.e.
bool isMeasure() const
Returns true if the geometry contains m values.
virtual int childCount() const
Returns number of child geometries (for geometries with child geometries) or child points (for geomet...
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 QgsAbstractGeometry * createEmptyWithSameType() const =0
Creates a new geometry with the same class and same WKB type as the original and transfers ownership.
virtual void clearCache() const
Clears any cached parameters associated with the geometry, e.g., bounding boxes.
Qgis::WkbType wkbType() const
Returns the WKB type of the geometry.
virtual bool fuzzyEqual(const QgsAbstractGeometry &other, double epsilon=1e-8) const =0
Performs fuzzy comparison between this geometry and other using an epsilon.
virtual void normalize()=0
Reorganizes the geometry into a normalized form (or "canonical" form).
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 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...
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.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44
static double sqrDistance2D(double x1, double y1, double x2, double y2)
Returns the squared 2D distance between (x1, y1) and (x2, y2).
static double distance2D(double x1, double y1, double x2, double y2)
Returns the 2D distance between (x1, y1) and (x2, y2).
static bool fuzzyEqual(T epsilon, const Args &... args) noexcept
Performs fuzzy comparison between pairs of values within a specified epsilon.
static double distance3D(double x1, double y1, double z1, double x2, double y2, double z2)
Returns the 3D distance between (x1, y1), (x2, y2) and (z2, z2).
static double sqrDistance3D(double x1, double y1, double z1, double x2, double y2, double z2)
Returns the squared 3D distance between (x1, y1), (x2, y2) and (z2, z2).
static bool fuzzyDistanceEqual(T epsilon, const Args &... args) noexcept
Compare equality between multiple pairs of values with a specified epsilon.
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
double z() const
Returns the point's z-coordinate.
Definition qgspoint.h:282
bool fuzzyDistanceEqual(const QgsAbstractGeometry &other, double epsilon=1e-8) const override
Performs fuzzy distance comparison between this geometry and other using an epsilon.
Definition qgspoint.h:224
void setY(double y)
Sets the point's y-coordinate.
Definition qgspoint.h:343
bool operator==(const QgsAbstractGeometry &other) const override
Definition qgspoint.h:253
double distance3D(const QgsPoint &other) const
Returns the Cartesian 3D distance between this point and another point.
Definition qgspoint.h:452
QgsPoint operator-(QgsVector v) const
Subtracts a vector from this point.
Definition qgspoint.h:556
double & rx()
Returns a reference to the x-coordinate of this point.
Definition qgspoint.h:298
QgsPoint operator+(QgsVector v) const
Adds a vector to this point.
Definition qgspoint.h:551
double distanceSquared3D(const QgsPoint &other) const
Returns the Cartesian 3D squared distance between this point and another point.
Definition qgspoint.h:482
void setX(double x)
Sets the point's x-coordinate.
Definition qgspoint.h:332
QgsPoint & operator+=(QgsVector v)
Adds a vector to this point in place.
Definition qgspoint.h:541
static const QgsPoint * cast(const QgsAbstractGeometry *geom)
Cast the geom to a QgsPoint.
Definition qgspoint.h:632
QPointF toQPointF() const
Returns the point as a QPointF.
Definition qgspoint.h:382
double distance(const QgsPoint &other) const
Returns the Cartesian 2D distance between this point and another point.
Definition qgspoint.h:404
double distance3D(double x, double y, double z) const
Returns the Cartesian 3D distance between this point and a specified x, y, z coordinate.
Definition qgspoint.h:437
double distanceSquared3D(double x, double y, double z) const
Returns the Cartesian 3D squared distance between this point and a specified x, y,...
Definition qgspoint.h:467
double z
Definition qgspoint.h:54
double x
Definition qgspoint.h:52
void setM(double m)
Sets the point's m-value.
Definition qgspoint.h:371
double y() const
Returns the point's y-coordinate.
Definition qgspoint.h:275
QgsPoint & operator-=(QgsVector v)
Subtracts a vector from this point in place.
Definition qgspoint.h:546
bool fuzzyEqual(const QgsAbstractGeometry &other, double epsilon=1e-8) const override
Performs fuzzy comparison between this geometry and other using an epsilon.
Definition qgspoint.h:195
double distanceSquared(const QgsPoint &other) const
Returns the Cartesian 2D squared distance between this point another point.
Definition qgspoint.h:426
double distance(double x, double y) const
Returns the Cartesian 2D distance between this point and a specified x, y coordinate.
Definition qgspoint.h:393
double m() const
Returns the point's m value.
Definition qgspoint.h:289
double & ry()
Returns a reference to the y-coordinate of this point.
Definition qgspoint.h:307
void setZ(double z)
Sets the point's z-coordinate.
Definition qgspoint.h:356
double distanceSquared(double x, double y) const
Returns the Cartesian 2D squared distance between this point a specified x, y coordinate.
Definition qgspoint.h:415
double m
Definition qgspoint.h:55
double y
Definition qgspoint.h:53
bool operator!=(const QgsAbstractGeometry &other) const override
Definition qgspoint.h:258
double & rz()
Returns a reference to the z-coordinate of this point.
Definition qgspoint.h:316
double & rm()
Returns a reference to the m value of this point.
Definition qgspoint.h:325
double x() const
Returns the point's x-coordinate.
Definition qgspoint.h:268
A rectangle specified with double values.
A class to represent a vector.
Definition qgsvector.h:30
static Qgis::WkbType flatType(Qgis::WkbType type)
Returns the flat type for a WKB type.
#define str(x)
Definition qgis.cpp:38
#define SIP_TYPEHINT(type)
Definition qgis_sip.h:232
#define SIP_SKIP
Definition qgis_sip.h:126
#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< QgsRingSequence > QgsCoordinateSequence
double closestSegment(const QgsPolylineXY &pl, const QgsPointXY &pt, int &vertexAfter, double epsilon)
Definition qgstracer.cpp:69
int precision
Utility class for identifying a unique vertex within a geometry.
Definition qgsvertexid.h:30