qgspoint.h

Go to the documentation of this file.

/***************************************************************************
                         qgspointv2.h
                         --------------
    begin                : September 2014
    copyright            : (C) 2014 by Marco Hugentobler
    email                : marco at sourcepole dot ch
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSPOINT_H
#define QGSPOINT_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsabstractgeometry.h"
#include "qgsrectangle.h"
 
/***************************************************************************
 * This class is considered CRITICAL and any change MUST be accompanied with
 * full unit tests in testqgsgeometry.cpp.
 * See details in QEP #17
 ****************************************************************************/
 
class CORE_EXPORT QgsPoint: public QgsAbstractGeometry
{
    Q_GADGET
 
    Q_PROPERTY( double x READ x WRITE setX )
    Q_PROPERTY( double y READ y WRITE setY )
    Q_PROPERTY( double z READ z WRITE setZ )
    Q_PROPERTY( double m READ m WRITE setM )
 
  public:
 
#ifndef SIP_RUN
    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 );
#else
    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 )];
    % MethodCode
    if ( sipCanConvertToType( a0, sipType_QgsPointXY, SIP_NOT_NONE ) && a1 == Py_None && a2 == Py_None && a3 == Py_None && a4 == Py_None )
    {
      int state;
      sipIsErr = 0;
 
      QgsPointXY *p = reinterpret_cast<QgsPointXY *>( sipConvertToType( a0, sipType_QgsPointXY, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
      if ( sipIsErr )
      {
        sipReleaseType( p, sipType_QgsPointXY, state );
      }
      else
      {
        sipCpp = new sipQgsPoint( QgsPoint( *p ) );
      }
    }
    else if ( sipCanConvertToType( a0, sipType_QPointF, SIP_NOT_NONE ) && a1 == Py_None && a2 == Py_None && a3 == Py_None && a4 == Py_None )
    {
      int state;
      sipIsErr = 0;
 
      QPointF *p = reinterpret_cast<QPointF *>( sipConvertToType( a0, sipType_QPointF, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
      if ( sipIsErr )
      {
        sipReleaseType( p, sipType_QPointF, state );
      }
      else
      {
        sipCpp = new sipQgsPoint( QgsPoint( *p ) );
      }
    }
    else if (
      ( a0 == Py_None || PyFloat_AsDouble( a0 ) != -1.0 || !PyErr_Occurred() ) &&
      ( a1 == Py_None || PyFloat_AsDouble( a1 ) != -1.0 || !PyErr_Occurred() ) &&
      ( a2 == Py_None || PyFloat_AsDouble( a2 ) != -1.0 || !PyErr_Occurred() ) &&
      ( a3 == Py_None || PyFloat_AsDouble( a3 ) != -1.0 || !PyErr_Occurred() ) &&
      ( a4 == Py_None || sipCanConvertToEnum( a4, sipType_QgsWkbTypes_Type ) ) )
    {
      double x = a0 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a0 );
      double y = a1 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a1 );
      double z = a2 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a2 );
      double m = a3 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a3 );
      QgsWkbTypes::Type wkbType = a4 == Py_None ? QgsWkbTypes::Unknown : static_cast<QgsWkbTypes::Type>( sipConvertToEnum( a4, sipType_QgsWkbTypes_Type ) );
      sipCpp = new sipQgsPoint( QgsPoint( x, y, z, m, wkbType ) );
    }
    else // Invalid ctor arguments
    {
      PyErr_SetString( PyExc_TypeError, QStringLiteral( "Invalid type in constructor arguments." ).toUtf8().constData() );
      sipIsErr = 1;
    }
    % End
#endif
 
    explicit QgsPoint( const QgsPointXY &p ) SIP_SKIP;
 
    explicit QgsPoint( QPointF p ) SIP_SKIP;
 
    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;
 
    bool operator==( const QgsAbstractGeometry &other ) const override
    {
      const QgsPoint *pt = qgsgeometry_cast< const QgsPoint * >( &other );
      if ( !pt )
        return false;
 
      const QgsWkbTypes::Type type = wkbType();
 
      if ( pt->wkbType() != type )
        return false;
 
      const bool nan1X = std::isnan( mX );
      const bool nan2X = std::isnan( pt->x() );
      if ( nan1X != nan2X )
        return false;
      if ( !nan1X && !qgsDoubleNear( mX, pt->x(), 1E-8 ) )
        return false;
 
      const bool nan1Y = std::isnan( mY );
      const bool nan2Y = std::isnan( pt->y() );
      if ( nan1Y != nan2Y )
        return false;
      if ( !nan1Y && !qgsDoubleNear( mY, pt->y(), 1E-8 ) )
        return false;
 
      if ( QgsWkbTypes::hasZ( type ) )
      {
        const bool nan1Z = std::isnan( mZ );
        const bool nan2Z = std::isnan( pt->z() );
        if ( nan1Z != nan2Z )
          return false;
        if ( !nan1Z && !qgsDoubleNear( mZ, pt->z(), 1E-8 ) )
          return false;
      }
 
      if ( QgsWkbTypes::hasM( type ) )
      {
        const bool nan1M = std::isnan( mM );
        const bool nan2M = std::isnan( pt->m() );
        if ( nan1M != nan2M )
          return false;
        if ( !nan1M && !qgsDoubleNear( mM, pt->m(), 1E-8 ) )
          return false;
      }
 
      return true;
    }
 
    bool operator!=( const QgsAbstractGeometry &other ) const override
    {
      return !operator==( other );
    }
 
    double x() const { return mX; }
 
    double y() const { return mY; }
 
    double z() const { return mZ; }
 
    double m() const { return mM; }
 
    double &rx() SIP_SKIP { clearCache(); return mX; }
 
    double &ry() SIP_SKIP { clearCache(); return mY; }
 
    double &rz() SIP_SKIP { clearCache(); return mZ; }
 
    double &rm() SIP_SKIP { clearCache(); return mM; }
 
    void setX( double x )
    {
      clearCache();
      mX = x;
    }
 
    void setY( double y )
    {
      clearCache();
      mY = y;
    }
 
    void setZ( double z )
    {
      if ( !is3D() )
        return;
      clearCache();
      mZ = z;
    }
 
    void setM( double m )
    {
      if ( !isMeasure() )
        return;
      clearCache();
      mM = m;
    }
 
    QPointF toQPointF() const
    {
      return QPointF( mX, mY );
    }
 
    double distance( double x, double y ) const
    {
      return std::sqrt( ( mX - x ) * ( mX - x ) + ( mY - y ) * ( mY - y ) );
    }
 
    double distance( const QgsPoint &other ) const
    {
      return std::sqrt( ( mX - other.x() ) * ( mX - other.x() ) + ( mY - other.y() ) * ( mY - other.y() ) );
    }
 
    double distanceSquared( double x, double y ) const
    {
      return ( mX - x ) * ( mX - x ) + ( mY - y ) * ( mY - y );
    }
 
    double distanceSquared( const QgsPoint &other ) const
    {
      return ( mX - other.x() ) * ( mX - other.x() ) + ( mY - other.y() ) * ( mY - other.y() );
    }
 
    double distance3D( double x, double y, double z ) const;
 
    double distance3D( const QgsPoint &other ) const;
 
    double distanceSquared3D( double x, double y, double z ) const;
 
    double distanceSquared3D( const QgsPoint &other ) const;
 
    double azimuth( const QgsPoint &other ) const;
 
    double inclination( const QgsPoint &other ) const;
 
    QgsPoint project( double distance, double azimuth, double inclination = 90.0 ) const;
 
    QgsVector operator-( const QgsPoint &p ) const { return QgsVector( mX - p.mX, mY - p.mY ); }
 
    QgsPoint &operator+=( QgsVector v ) { mX += v.x(); mY += v.y(); return *this; }
 
    QgsPoint &operator-=( QgsVector v ) { mX -= v.x(); mY -= v.y(); return *this; }
 
    QgsPoint operator+( QgsVector v ) const { QgsPoint r = *this; r.rx() += v.x(); r.ry() += v.y(); return r; }
 
    QgsPoint operator-( QgsVector v ) const { QgsPoint r = *this; r.rx() -= v.x(); r.ry() -= v.y(); return r; }
 
    //implementation of inherited methods
    bool isEmpty() const override;
    QgsRectangle boundingBox() const override;
    QString geometryType() const override;
    int dimension() const override;
    QgsPoint *clone() const override SIP_FACTORY;
    QgsPoint *snappedToGrid( double hSpacing, double vSpacing, double dSpacing = 0, double mSpacing = 0 ) const override SIP_FACTORY;
    bool removeDuplicateNodes( double epsilon = 4 * std::numeric_limits<double>::epsilon(), bool useZValues = false ) override;
    void clear() override;
    bool fromWkb( QgsConstWkbPtr &wkb ) override;
    bool fromWkt( const QString &wkt ) override;
    QByteArray asWkb( QgsAbstractGeometry::WkbFlags = nullptr ) const override;
    QString asWkt( int precision = 17 ) const override;
    QDomElement asGml2( QDomDocument &doc, int precision = 17, const QString &ns = "gml", QgsAbstractGeometry::AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const override;
    QDomElement asGml3( QDomDocument &doc, int precision = 17, const QString &ns = "gml", QgsAbstractGeometry::AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const override;
    json asJsonObject( int precision = 17 ) const override SIP_SKIP;
    QString asKml( int precision = 17 ) const override;
    void draw( QPainter &p ) const override;
    void transform( const QgsCoordinateTransform &ct, QgsCoordinateTransform::TransformDirection d = QgsCoordinateTransform::ForwardTransform, bool transformZ = false ) override SIP_THROW( QgsCsException );
    void transform( const QTransform &t, double zTranslate = 0.0, double zScale = 1.0, double mTranslate = 0.0, double mScale = 1.0 ) override;
    QgsCoordinateSequence coordinateSequence() const override;
    int nCoordinates() const override;
    int vertexNumberFromVertexId( QgsVertexId id ) const override;
    QgsAbstractGeometry *boundary() const override SIP_FACTORY;
    bool isValid( QString &error SIP_OUT, int flags = 0 ) const override;
 
    //low-level editing
    bool insertVertex( QgsVertexId position, const QgsPoint &vertex ) override;
    bool moveVertex( QgsVertexId position, const QgsPoint &newPos ) override;
    bool deleteVertex( QgsVertexId position ) override;
 
    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;
    bool nextVertex( QgsVertexId &id, QgsPoint &vertex SIP_OUT ) const override;
    void adjacentVertices( QgsVertexId vertex, QgsVertexId &previousVertex SIP_OUT, QgsVertexId &nextVertex SIP_OUT ) const override;
 
    double vertexAngle( QgsVertexId vertex ) const override;
 
    int vertexCount( int /*part*/ = 0, int /*ring*/ = 0 ) const override;
    int ringCount( int /*part*/ = 0 ) const override;
    int partCount() const override;
    QgsPoint vertexAt( QgsVertexId /*id*/ ) const override;
    QgsPoint *toCurveType() const override SIP_FACTORY;
    double segmentLength( QgsVertexId startVertex ) const override;
 
    bool addZValue( double zValue = 0 ) override;
    bool addMValue( double mValue = 0 ) override;
    bool dropZValue() override;
    bool dropMValue() override;
    void swapXy() override;
    bool convertTo( QgsWkbTypes::Type type ) override;
 
#ifndef SIP_RUN
 
    void filterVertices( const std::function< bool( const QgsPoint & ) > &filter ) override;
    void transformVertices( const std::function< QgsPoint( const QgsPoint & ) > &transform ) override;
 
    inline const QgsPoint *cast( const QgsAbstractGeometry *geom ) const
    {
      if ( geom && QgsWkbTypes::flatType( geom->wkbType() ) == QgsWkbTypes::Point )
        return static_cast<const QgsPoint *>( geom );
      return nullptr;
    }
#endif
 
    QgsPoint *createEmptyWithSameType() const override SIP_FACTORY;
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsPoint: %1>" ).arg( sipCpp->asWkt() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
  protected:
 
    int childCount() const override;
    QgsPoint childPoint( int index ) const override;
 
  private:
    double mX;
    double mY;
    double mZ;
    double mM;
};
 
// clazy:excludeall=qstring-allocations
 
#endif // QGSPOINT_H