QGIS API Documentation  3.37.0-Master (a5b4d9743e8)
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"
24 #include "qgsgeometryutils_base.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 
48 class 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 
640  QgsPoint *createEmptyWithSameType() const override SIP_FACTORY;
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.
Definition: qgsexception.h:67
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
double & ry()
Returns a reference to the y-coordinate of this point.
Definition: qgspoint.h:307
QgsPoint operator-(QgsVector v) const
Subtracts a vector from this point.
Definition: qgspoint.h:556
QgsPoint & operator-=(QgsVector v)
Subtracts a vector from this point in place.
Definition: qgspoint.h:546
static const QgsPoint * cast(const QgsAbstractGeometry *geom)
Cast the geom to a QgsPoint.
Definition: qgspoint.h:632
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
Q_GADGET double x
Definition: qgspoint.h:52
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
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
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)
Adds a vector to this point in place.
Definition: qgspoint.h:541
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 & rx()
Returns a reference to the x-coordinate of this point.
Definition: qgspoint.h:298
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
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 x() const
Returns the point's x-coordinate.
Definition: qgspoint.h:268
A rectangle specified with double values.
Definition: qgsrectangle.h:42
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.
Definition: qgswkbtypes.h:628
double ANALYSIS_EXPORT leftOf(const QgsPoint &thepoint, const QgsPoint *p1, const QgsPoint *p2)
Returns whether 'thepoint' is left or right of the line from 'p1' to 'p2'. Negative values mean left ...
Definition: MathUtils.cpp:222
#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