QGIS API Documentation  3.15.0-Master (1d5bfb2cfe)
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 "qgsrectangle.h"
25 
26 /***************************************************************************
27  * This class is considered CRITICAL and any change MUST be accompanied with
28  * full unit tests in testqgsgeometry.cpp.
29  * See details in QEP #17
30  ****************************************************************************/
31 
37 class CORE_EXPORT QgsPoint: public QgsAbstractGeometry
38 {
39  Q_GADGET
40 
41  Q_PROPERTY( double x READ x WRITE setX )
42  Q_PROPERTY( double y READ y WRITE setY )
43  Q_PROPERTY( double z READ z WRITE setZ )
44  Q_PROPERTY( double m READ m WRITE setM )
45 
46  public:
47 
74 #ifndef SIP_RUN
75  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(), QgsWkbTypes::Type wkbType = QgsWkbTypes::Unknown );
76 #else
77  QgsPoint( SIP_PYOBJECT x = Py_None, SIP_PYOBJECT y = Py_None, SIP_PYOBJECT z = Py_None, SIP_PYOBJECT m = Py_None, SIP_PYOBJECT wkbType = Py_None ) [( double x = 0.0, double y = 0.0, double z = 0.0, double m = 0.0, QgsWkbTypes::Type wkbType = QgsWkbTypes::Unknown )];
78  % MethodCode
79  if ( sipCanConvertToType( a0, sipType_QgsPointXY, SIP_NOT_NONE ) && a1 == Py_None && a2 == Py_None && a3 == Py_None && a4 == Py_None )
80  {
81  int state;
82  sipIsErr = 0;
83 
84  QgsPointXY *p = reinterpret_cast<QgsPointXY *>( sipConvertToType( a0, sipType_QgsPointXY, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
85  if ( sipIsErr )
86  {
87  sipReleaseType( p, sipType_QgsPointXY, state );
88  }
89  else
90  {
91  sipCpp = new sipQgsPoint( QgsPoint( *p ) );
92  }
93  }
94  else if ( sipCanConvertToType( a0, sipType_QPointF, SIP_NOT_NONE ) && a1 == Py_None && a2 == Py_None && a3 == Py_None && a4 == Py_None )
95  {
96  int state;
97  sipIsErr = 0;
98 
99  QPointF *p = reinterpret_cast<QPointF *>( sipConvertToType( a0, sipType_QPointF, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
100  if ( sipIsErr )
101  {
102  sipReleaseType( p, sipType_QPointF, state );
103  }
104  else
105  {
106  sipCpp = new sipQgsPoint( QgsPoint( *p ) );
107  }
108  }
109  else if (
110  ( a0 == Py_None || PyFloat_AsDouble( a0 ) != -1.0 || !PyErr_Occurred() ) &&
111  ( a1 == Py_None || PyFloat_AsDouble( a1 ) != -1.0 || !PyErr_Occurred() ) &&
112  ( a2 == Py_None || PyFloat_AsDouble( a2 ) != -1.0 || !PyErr_Occurred() ) &&
113  ( a3 == Py_None || PyFloat_AsDouble( a3 ) != -1.0 || !PyErr_Occurred() ) )
114  {
115  double x = a0 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a0 );
116  double y = a1 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a1 );
117  double z = a2 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a2 );
118  double m = a3 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a3 );
119  QgsWkbTypes::Type wkbType = a4 == Py_None ? QgsWkbTypes::Unknown : static_cast<QgsWkbTypes::Type>( sipConvertToEnum( a4, sipType_QgsWkbTypes_Type ) );
120  sipCpp = new sipQgsPoint( QgsPoint( x, y, z, m, wkbType ) );
121  }
122  else // Invalid ctor arguments
123  {
124  PyErr_SetString( PyExc_TypeError, QStringLiteral( "Invalid type in constructor arguments." ).toUtf8().constData() );
125  sipIsErr = 1;
126  }
127  % End
128 #endif
129 
133  explicit QgsPoint( const QgsPointXY &p ) SIP_SKIP;
134 
138  explicit QgsPoint( QPointF p ) SIP_SKIP;
139 
145  explicit QgsPoint( QgsWkbTypes::Type 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;
146 
147  bool operator==( const QgsAbstractGeometry &other ) const override SIP_HOLDGIL
148  {
149  const QgsPoint *pt = qgsgeometry_cast< const QgsPoint * >( &other );
150  if ( !pt )
151  return false;
152 
153  const QgsWkbTypes::Type type = wkbType();
154 
155  if ( pt->wkbType() != type )
156  return false;
157 
158  const bool nan1X = std::isnan( mX );
159  const bool nan2X = std::isnan( pt->x() );
160  if ( nan1X != nan2X )
161  return false;
162  if ( !nan1X && !qgsDoubleNear( mX, pt->x(), 1E-8 ) )
163  return false;
164 
165  const bool nan1Y = std::isnan( mY );
166  const bool nan2Y = std::isnan( pt->y() );
167  if ( nan1Y != nan2Y )
168  return false;
169  if ( !nan1Y && !qgsDoubleNear( mY, pt->y(), 1E-8 ) )
170  return false;
171 
172  if ( QgsWkbTypes::hasZ( type ) )
173  {
174  const bool nan1Z = std::isnan( mZ );
175  const bool nan2Z = std::isnan( pt->z() );
176  if ( nan1Z != nan2Z )
177  return false;
178  if ( !nan1Z && !qgsDoubleNear( mZ, pt->z(), 1E-8 ) )
179  return false;
180  }
181 
182  if ( QgsWkbTypes::hasM( type ) )
183  {
184  const bool nan1M = std::isnan( mM );
185  const bool nan2M = std::isnan( pt->m() );
186  if ( nan1M != nan2M )
187  return false;
188  if ( !nan1M && !qgsDoubleNear( mM, pt->m(), 1E-8 ) )
189  return false;
190  }
191 
192  return true;
193  }
194 
195  bool operator!=( const QgsAbstractGeometry &other ) const override SIP_HOLDGIL
196  {
197  return !operator==( other );
198  }
199 
205  double x() const SIP_HOLDGIL { return mX; }
206 
212  double y() const SIP_HOLDGIL { return mY; }
213 
219  double z() const SIP_HOLDGIL { return mZ; }
220 
226  double m() const SIP_HOLDGIL { return mM; }
227 
235  double &rx() SIP_SKIP { clearCache(); return mX; }
236 
244  double &ry() SIP_SKIP { clearCache(); return mY; }
245 
253  double &rz() SIP_SKIP { clearCache(); return mZ; }
254 
262  double &rm() SIP_SKIP { clearCache(); return mM; }
263 
269  void setX( double x ) SIP_HOLDGIL
270  {
271  clearCache();
272  mX = x;
273  }
274 
280  void setY( double y ) SIP_HOLDGIL
281  {
282  clearCache();
283  mY = y;
284  }
285 
293  void setZ( double z ) SIP_HOLDGIL
294  {
295  if ( !is3D() )
296  return;
297  clearCache();
298  mZ = z;
299  }
300 
308  void setM( double m ) SIP_HOLDGIL
309  {
310  if ( !isMeasure() )
311  return;
312  clearCache();
313  mM = m;
314  }
315 
320  QPointF toQPointF() const SIP_HOLDGIL
321  {
322  return QPointF( mX, mY );
323  }
324 
332  double distance( double x, double y ) const SIP_HOLDGIL
333  {
334  return std::sqrt( ( mX - x ) * ( mX - x ) + ( mY - y ) * ( mY - y ) );
335  }
336 
343  double distance( const QgsPoint &other ) const SIP_HOLDGIL
344  {
345  return std::sqrt( ( mX - other.x() ) * ( mX - other.x() ) + ( mY - other.y() ) * ( mY - other.y() ) );
346  }
347 
355  double distanceSquared( double x, double y ) const SIP_HOLDGIL
356  {
357  return ( mX - x ) * ( mX - x ) + ( mY - y ) * ( mY - y );
358  }
359 
367  double distanceSquared( const QgsPoint &other ) const SIP_HOLDGIL
368  {
369  return ( mX - other.x() ) * ( mX - other.x() ) + ( mY - other.y() ) * ( mY - other.y() );
370  }
371 
379  double distance3D( double x, double y, double z ) const SIP_HOLDGIL;
380 
387  double distance3D( const QgsPoint &other ) const SIP_HOLDGIL;
388 
396  double distanceSquared3D( double x, double y, double z ) const SIP_HOLDGIL;
397 
405  double distanceSquared3D( const QgsPoint &other ) const SIP_HOLDGIL;
406 
411  double azimuth( const QgsPoint &other ) const SIP_HOLDGIL;
412 
418  double inclination( const QgsPoint &other ) const SIP_HOLDGIL;
419 
450  QgsPoint project( double distance, double azimuth, double inclination = 90.0 ) const SIP_HOLDGIL;
451 
456  QgsVector operator-( const QgsPoint &p ) const SIP_HOLDGIL { return QgsVector( mX - p.mX, mY - p.mY ); }
457 
462  QgsPoint &operator+=( QgsVector v ) SIP_HOLDGIL { mX += v.x(); mY += v.y(); return *this; }
463 
468  QgsPoint &operator-=( QgsVector v ) SIP_HOLDGIL { mX -= v.x(); mY -= v.y(); return *this; }
469 
474  QgsPoint operator+( QgsVector v ) const SIP_HOLDGIL { QgsPoint r = *this; r.rx() += v.x(); r.ry() += v.y(); return r; }
475 
480  QgsPoint operator-( QgsVector v ) const SIP_HOLDGIL { QgsPoint r = *this; r.rx() -= v.x(); r.ry() -= v.y(); return r; }
481 
482  //implementation of inherited methods
483  bool isEmpty() const override SIP_HOLDGIL;
484  QgsRectangle boundingBox() const override SIP_HOLDGIL;
485  QString geometryType() const override SIP_HOLDGIL;
486  int dimension() const override SIP_HOLDGIL;
487  QgsPoint *clone() const override SIP_FACTORY;
488  QgsPoint *snappedToGrid( double hSpacing, double vSpacing, double dSpacing = 0, double mSpacing = 0 ) const override SIP_FACTORY;
489  bool removeDuplicateNodes( double epsilon = 4 * std::numeric_limits<double>::epsilon(), bool useZValues = false ) override;
490  void clear() override;
491  bool fromWkb( QgsConstWkbPtr &wkb ) override;
492  bool fromWkt( const QString &wkt ) override;
493  int wkbSize( QgsAbstractGeometry::WkbFlags flags = QgsAbstractGeometry::WkbFlags() ) const override;
494  QByteArray asWkb( QgsAbstractGeometry::WkbFlags = QgsAbstractGeometry::WkbFlags() ) const override;
495  QString asWkt( int precision = 17 ) const override;
496  QDomElement asGml2( QDomDocument &doc, int precision = 17, const QString &ns = "gml", QgsAbstractGeometry::AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const override;
497  QDomElement asGml3( QDomDocument &doc, int precision = 17, const QString &ns = "gml", QgsAbstractGeometry::AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const override;
498  json asJsonObject( int precision = 17 ) const override SIP_SKIP;
499  QString asKml( int precision = 17 ) const override;
500  void draw( QPainter &p ) const override;
501  QPainterPath asQPainterPath() const override;
503  void transform( const QTransform &t, double zTranslate = 0.0, double zScale = 1.0, double mTranslate = 0.0, double mScale = 1.0 ) override;
504  QgsCoordinateSequence coordinateSequence() const override;
505  int nCoordinates() const override SIP_HOLDGIL;
506  int vertexNumberFromVertexId( QgsVertexId id ) const override;
507  QgsAbstractGeometry *boundary() const override SIP_FACTORY;
508  bool isValid( QString &error SIP_OUT, int flags = 0 ) const override SIP_HOLDGIL;
509 
510  //low-level editing
511  bool insertVertex( QgsVertexId position, const QgsPoint &vertex ) override;
512  bool moveVertex( QgsVertexId position, const QgsPoint &newPos ) override;
513  bool deleteVertex( QgsVertexId position ) override;
514 
515  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;
516  bool nextVertex( QgsVertexId &id, QgsPoint &vertex SIP_OUT ) const override;
517  void adjacentVertices( QgsVertexId vertex, QgsVertexId &previousVertex SIP_OUT, QgsVertexId &nextVertex SIP_OUT ) const override;
518 
524  double vertexAngle( QgsVertexId vertex ) const override;
525 
526  int vertexCount( int /*part*/ = 0, int /*ring*/ = 0 ) const override;
527  int ringCount( int /*part*/ = 0 ) const override;
528  int partCount() const override;
529  QgsPoint vertexAt( QgsVertexId /*id*/ ) const override;
530  QgsPoint *toCurveType() const override SIP_FACTORY;
531  double segmentLength( QgsVertexId startVertex ) const override;
532 
533  bool addZValue( double zValue = 0 ) override;
534  bool addMValue( double mValue = 0 ) override;
535  bool dropZValue() override;
536  bool dropMValue() override;
537  void swapXy() override;
538  bool convertTo( QgsWkbTypes::Type type ) override;
539 
540 #ifndef SIP_RUN
541 
542  void filterVertices( const std::function< bool( const QgsPoint & ) > &filter ) override;
543  void transformVertices( const std::function< QgsPoint( const QgsPoint & ) > &transform ) override;
544 
552  inline const QgsPoint *cast( const QgsAbstractGeometry *geom ) const
553  {
554  if ( geom && QgsWkbTypes::flatType( geom->wkbType() ) == QgsWkbTypes::Point )
555  return static_cast<const QgsPoint *>( geom );
556  return nullptr;
557  }
558 #endif
559 
560  QgsPoint *createEmptyWithSameType() const override SIP_FACTORY;
561 
562 #ifdef SIP_RUN
563  SIP_PYOBJECT __repr__();
564  % MethodCode
565  QString str = QStringLiteral( "<QgsPoint: %1>" ).arg( sipCpp->asWkt() );
566  sipRes = PyUnicode_FromString( str.toUtf8().constData() );
567  % End
568 #endif
569 
570  protected:
571 
572  int childCount() const override;
573  QgsPoint childPoint( int index ) const override;
574 
575  private:
576  double mX;
577  double mY;
578  double mZ;
579  double mM;
580 };
581 
582 // clazy:excludeall=qstring-allocations
583 
584 #endif // QGSPOINT_H
virtual QString asWkt(int precision=17) const =0
Returns a WKT representation of the geometry.
int precision
A rectangle specified with double values.
Definition: qgsrectangle.h:41
virtual QgsAbstractGeometry * snappedToGrid(double hSpacing, double vSpacing, double dSpacing=0, double mSpacing=0) const =0
Makes a new geometry with all the points or vertices snapped to the closest point of the grid...
virtual int vertexNumberFromVertexId(QgsVertexId id) const =0
Returns the vertex number corresponding to a vertex id.
double y
Definition: qgspoint.h:42
virtual int childCount() const
Returns number of child geometries (for geometries with child geometries) or child points (for geomet...
virtual bool isEmpty() const
Returns true if the geometry is empty.
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...
QPointF toQPointF() const SIP_HOLDGIL
Returns the point as a QPointF.
Definition: qgspoint.h:320
double x() const SIP_HOLDGIL
Returns the point&#39;s x-coordinate.
Definition: qgspoint.h:205
virtual bool deleteVertex(QgsVertexId position)=0
Deletes a vertex within the geometry.
virtual bool isValid(QString &error, int flags=0) const =0
Checks validity of the geometry, and returns true if the geometry is valid.
virtual void transform(const QgsCoordinateTransform &ct, QgsCoordinateTransform::TransformDirection d=QgsCoordinateTransform::ForwardTransform, bool transformZ=false) SIP_THROW(QgsCsException)=0
Transforms the geometry using a coordinate transform.
virtual QgsAbstractGeometry * toCurveType() const =0
Returns the geometry converted to the more generic curve type.
double & rz()
Returns a reference to the z-coordinate of this point.
Definition: qgspoint.h:253
void setY(double y) SIP_HOLDGIL
Sets the point&#39;s y-coordinate.
Definition: qgspoint.h:280
QgsPoint operator-(QgsVector v) const SIP_HOLDGIL
Subtracts a vector from this point.
Definition: qgspoint.h:480
virtual bool insertVertex(QgsVertexId position, const QgsPoint &vertex)=0
Inserts a vertex into the geometry.
virtual QgsPoint childPoint(int index) const
Returns point at index (for geometries without child geometries - i.e.
QVector< QgsRingSequence > QgsCoordinateSequence
A class to represent a 2D point.
Definition: qgspointxy.h:43
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:315
virtual bool operator==(const QgsAbstractGeometry &other) const =0
TransformDirection
Enum used to indicate the direction (forward or inverse) of the transform.
bool operator!=(const QgsAbstractGeometry &other) const override SIP_HOLDGIL
Definition: qgspoint.h:195
QgsVector operator-(const QgsPoint &p) const SIP_HOLDGIL
Calculates the vector obtained by subtracting a point from this point.
Definition: qgspoint.h:456
virtual double vertexAngle(QgsVertexId vertex) const =0
Returns approximate angle at a vertex.
static Type flatType(Type type) SIP_HOLDGIL
Returns the flat type for a WKB type.
Definition: qgswkbtypes.h:702
virtual bool addMValue(double mValue=0)=0
Adds a measure to the geometry, initialized to a preset value.
QgsPoint & operator-=(QgsVector v) SIP_HOLDGIL
Subtracts a vector from this point in place.
Definition: qgspoint.h:468
virtual QgsAbstractGeometry * createEmptyWithSameType() const =0
Creates a new geometry with the same class and same WKB type as the original and transfers ownership...
virtual QDomElement asGml2(QDomDocument &doc, int precision=17, const QString &ns="gml", AxisOrder axisOrder=QgsAbstractGeometry::AxisOrder::XY) const =0
Returns a GML2 representation of the geometry.
virtual QgsAbstractGeometry * boundary() const =0
Returns the closure of the combinatorial boundary of the geometry (ie the topological boundary of the...
QgsPoint & operator+=(QgsVector v) SIP_HOLDGIL
Adds a vector to this point in place.
Definition: qgspoint.h:462
virtual bool nextVertex(QgsVertexId &id, QgsPoint &vertex) const =0
Returns next vertex id and coordinates.
virtual QgsRectangle boundingBox() const =0
Returns the minimal bounding box for the geometry.
virtual QgsAbstractGeometry * clone() const =0
Clones the geometry by performing a deep copy.
static bool hasM(Type type) SIP_HOLDGIL
Tests whether a WKB type contains m values.
Definition: qgswkbtypes.h:1093
Type
The WKB type describes the number of dimensions a geometry has.
Definition: qgswkbtypes.h:69
void setX(double x) SIP_HOLDGIL
Sets the point&#39;s x-coordinate.
Definition: qgspoint.h:269
double y() const SIP_HOLDGIL
Returns the point&#39;s y-coordinate.
Definition: qgspoint.h:212
virtual double closestSegment(const QgsPoint &pt, QgsPoint &segmentPt, QgsVertexId &vertexAfter, int *leftOf=nullptr, double epsilon=4 *std::numeric_limits< double >::epsilon()) const =0
Searches for the closest segment of the geometry to a given point.
virtual void clearCache() const
Clears any cached parameters associated with the geometry, e.g., bounding boxes.
virtual double segmentLength(QgsVertexId startVertex) const =0
Returns the length of the segment of the geometry which begins at startVertex.
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...
Utility class for identifying a unique vertex within a geometry.
#define SIP_HOLDGIL
Definition: qgis_sip.h:157
#define SIP_SKIP
Definition: qgis_sip.h:126
virtual QString asKml(int precision=17) const =0
Returns a KML representation of the geometry.
T qgsgeometry_cast(const QgsAbstractGeometry *geom)
void setZ(double z) SIP_HOLDGIL
Sets the point&#39;s z-coordinate.
Definition: qgspoint.h:293
double m() const SIP_HOLDGIL
Returns the point&#39;s m value.
Definition: qgspoint.h:226
virtual int ringCount(int part=0) const =0
Returns the number of rings of which this geometry is built.
#define SIP_FACTORY
Definition: qgis_sip.h:76
double & rx()
Returns a reference to the x-coordinate of this point.
Definition: qgspoint.h:235
Abstract base class for all geometries.
virtual int dimension() const =0
Returns the inherent dimension of the geometry.
double distance(const QgsPoint &other) const SIP_HOLDGIL
Returns the Cartesian 2D distance between this point and another point.
Definition: qgspoint.h:343
Point geometry type, with support for z-dimension and m-values.
Definition: qgspoint.h:37
AxisOrder
Axis order for GML generation.
virtual int wkbSize(QgsAbstractGeometry::WkbFlags flags=QgsAbstractGeometry::WkbFlags()) const =0
Returns the length of the QByteArray returned by asWkb()
void setM(double m) SIP_HOLDGIL
Sets the point&#39;s m-value.
Definition: qgspoint.h:308
A class to represent a vector.
Definition: qgsvector.h:29
virtual QByteArray asWkb(WkbFlags flags=QgsAbstractGeometry::WkbFlags()) const =0
Returns a WKB representation of the geometry.
double distanceSquared(double x, double y) const SIP_HOLDGIL
Returns the Cartesian 2D squared distance between this point a specified x, y coordinate.
Definition: qgspoint.h:355
virtual QgsCoordinateSequence coordinateSequence() const =0
Retrieves the sequence of geometries, rings and nodes.
static bool hasZ(Type type) SIP_HOLDGIL
Tests whether a WKB type contains the z-dimension.
Definition: qgswkbtypes.h:1043
double z() const SIP_HOLDGIL
Returns the point&#39;s z-coordinate.
Definition: qgspoint.h:219
virtual void adjacentVertices(QgsVertexId vertex, QgsVertexId &previousVertex, QgsVertexId &nextVertex) const =0
Returns the vertices adjacent to a specified vertex within a geometry.
double & rm()
Returns a reference to the m value of this point.
Definition: qgspoint.h:262
virtual void clear()=0
Clears the geometry, ie reset it to a null geometry.
double distance(double x, double y) const SIP_HOLDGIL
Returns the Cartesian 2D distance between this point and a specified x, y coordinate.
Definition: qgspoint.h:332
bool isMeasure() const SIP_HOLDGIL
Returns true if the geometry contains m values.
virtual bool moveVertex(QgsVertexId position, const QgsPoint &newPos)=0
Moves a vertex within the geometry.
bool is3D() const SIP_HOLDGIL
Returns true if the geometry is 3D and contains a z-value.
virtual void draw(QPainter &p) const =0
Draws the geometry using the specified QPainter.
const QgsPoint * cast(const QgsAbstractGeometry *geom) const
Cast the geom to a QgsPoint.
Definition: qgspoint.h:552
#define SIP_OUT
Definition: qgis_sip.h:58
virtual bool addZValue(double zValue=0)=0
Adds a z-dimension to the geometry, initialized to a preset value.
virtual int vertexCount(int part=0, int ring=0) const =0
Returns the number of vertices of which this geometry is built.
Class for doing transforms between two map coordinate systems.
QgsPoint operator+(QgsVector v) const SIP_HOLDGIL
Adds a vector to this point.
Definition: qgspoint.h:474
QgsWkbTypes::Type wkbType() const SIP_HOLDGIL
Returns the WKB type of the geometry.
#define SIP_THROW(name)
Definition: qgis_sip.h:189
virtual bool convertTo(QgsWkbTypes::Type type)
Converts the geometry to a specified type.
double z
Definition: qgspoint.h:43
Transform from source to destination CRS.
virtual bool removeDuplicateNodes(double epsilon=4 *std::numeric_limits< double >::epsilon(), bool useZValues=false)=0
Removes duplicate nodes from the geometry, wherever removing the nodes does not result in a degenerat...
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:65
virtual bool dropMValue()=0
Drops any measure values which exist in the geometry.
virtual bool fromWkt(const QString &wkt)=0
Sets the geometry from a WKT string.
virtual QgsPoint vertexAt(QgsVertexId id) const =0
Returns the point corresponding to a specified vertex id.
virtual int nCoordinates() const
Returns the number of nodes contained in the geometry.
virtual void swapXy()=0
Swaps the x and y coordinates from the geometry.
virtual QPainterPath asQPainterPath() const =0
Returns the geometry represented as a QPainterPath.
virtual json asJsonObject(int precision=17) const
Returns a json object representation of the geometry.
double & ry()
Returns a reference to the y-coordinate of this point.
Definition: qgspoint.h:244
double distanceSquared(const QgsPoint &other) const SIP_HOLDGIL
Returns the Cartesian 2D squared distance between this point another point.
Definition: qgspoint.h:367
double ANALYSIS_EXPORT leftOf(const QgsPoint &thepoint, const QgsPoint *p1, const QgsPoint *p2)
Returns whether &#39;thepoint&#39; is left or right of the line from &#39;p1&#39; to &#39;p2&#39;. Negative values mean left ...
Definition: MathUtils.cpp:292
virtual bool dropZValue()=0
Drops any z-dimensions which exist in the geometry.
virtual int partCount() const =0
Returns count of parts contained in the geometry.
double m
Definition: qgspoint.h:44
virtual QDomElement asGml3(QDomDocument &doc, int precision=17, const QString &ns="gml", AxisOrder axisOrder=QgsAbstractGeometry::AxisOrder::XY) const =0
Returns a GML3 representation of the geometry.
virtual QString geometryType() const =0
Returns a unique string representing the geometry type.
virtual bool fromWkb(QgsConstWkbPtr &wkb)=0
Sets the geometry from a WKB string.
double x
Definition: qgspoint.h:41