qgslinestring.h

Go to the documentation of this file.

/***************************************************************************
                         qgslinestring.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 QGSLINESTRING_H
#define QGSLINESTRING_H
 
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgscompoundcurve.h"
#include "qgscurve.h"
#include "qgsgeometryutils_base.h"
#include "qgssimplecurve.h"
 
#include <QPolygonF>
#include <QString>
 
using namespace Qt::StringLiterals;
 
class QgsLineSegment2D;
class QgsBox3D;
 
/***************************************************************************
 * 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 QgsLineString : public QgsSimpleCurve
{
  public:
    // clang-format off
    QgsLineString() SIP_HOLDGIL;
    // clang-format on
#ifndef SIP_RUN

    QgsLineString( const QVector<QgsPoint> &points );

    QgsLineString( const QVector<QgsPointXY> &points );
#else
// clang-format off

    QgsLineString( SIP_PYOBJECT points SIP_TYPEHINT( Sequence[Union[QgsPoint, QgsPointXY, Sequence[float]]] ) ) SIP_HOLDGIL [( const QVector<double> &x, const QVector<double> &y, const QVector<double> &z = QVector<double>(), const QVector<double> &m = QVector<double>(), bool is25DType = false )];
    % MethodCode
    if ( !PySequence_Check( a0 ) )
    {
      PyErr_SetString( PyExc_TypeError, u"A sequence of QgsPoint, QgsPointXY or array of floats is expected"_s.toUtf8().constData() );
      sipIsErr = 1;
    }
    else
    {
      int state;
      const int size = PySequence_Size( a0 );
      QVector< double > xl;
      QVector< double > yl;
      bool hasZ = false;
      QVector< double > zl;
      bool hasM = false;
      QVector< double > ml;
      xl.reserve( size );
      yl.reserve( size );
 
      bool is25D = false;
 
      sipIsErr = 0;
      for ( int i = 0; i < size; ++i )
      {
        PyObject *value = PySequence_GetItem( a0, i );
        if ( !value )
        {
          PyErr_SetString( PyExc_TypeError, u"Invalid type at index %1."_s.arg( i ) .toUtf8().constData() );
          sipIsErr = 1;
          break;
        }
 
        if ( PySequence_Check( value ) )
        {
          const int elementSize = PySequence_Size( value );
          if ( elementSize < 2 || elementSize > 4 )
          {
            sipIsErr = 1;
            PyErr_SetString( PyExc_TypeError, u"Invalid sequence size at index %1. Expected an array of 2-4 float values, got %2."_s.arg( i ).arg( elementSize ).toUtf8().constData() );
            Py_DECREF( value );
            break;
          }
          else
          {
            sipIsErr = 0;
            for ( int j = 0; j < elementSize; ++j )
            {
              PyObject *element = PySequence_GetItem( value, j );
              if ( !element )
              {
                PyErr_SetString( PyExc_TypeError, u"Invalid type at index %1."_s.arg( i ) .toUtf8().constData() );
                sipIsErr = 1;
                break;
              }
 
              PyErr_Clear();
              double d = PyFloat_AsDouble( element );
              if ( PyErr_Occurred() )
              {
                Py_DECREF( element );
                sipIsErr = 1;
                break;
              }
              if ( j == 0 )
                xl.append( d );
              else if ( j == 1 )
                yl.append( d );
 
              if ( i == 0 && j == 2 )
              {
                hasZ = true;
                zl.reserve( size );
                zl.append( d );
              }
              else if ( i > 0 && j == 2 && hasZ )
              {
                zl.append( d );
              }
 
              if ( i == 0 && j == 3 )
              {
                hasM = true;
                ml.reserve( size );
                ml.append( d );
              }
              else if ( i > 0 && j == 3 && hasM )
              {
                ml.append( d );
              }
 
              Py_DECREF( element );
            }
 
            if ( hasZ && elementSize < 3 )
              zl.append( std::numeric_limits< double >::quiet_NaN() );
            if ( hasM && elementSize < 4 )
              ml.append( std::numeric_limits< double >::quiet_NaN() );
 
            Py_DECREF( value );
            if ( sipIsErr )
            {
              break;
            }
          }
        }
        else
        {
          if ( sipCanConvertToType( value, sipType_QgsPointXY, SIP_NOT_NONE ) )
          {
            sipIsErr = 0;
            QgsPointXY *p = reinterpret_cast<QgsPointXY *>( sipConvertToType( value, sipType_QgsPointXY, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
            if ( !sipIsErr )
            {
              xl.append( p->x() );
              yl.append( p->y() );
            }
            sipReleaseType( p, sipType_QgsPointXY, state );
          }
          else if ( sipCanConvertToType( value, sipType_QgsPoint, SIP_NOT_NONE ) )
          {
            sipIsErr = 0;
            QgsPoint *p = reinterpret_cast<QgsPoint *>( sipConvertToType( value, sipType_QgsPoint, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
            if ( !sipIsErr )
            {
              xl.append( p->x() );
              yl.append( p->y() );
 
              if ( i == 0 && p->is3D() )
              {
                hasZ = true;
                zl.reserve( size );
                zl.append( p->z() );
              }
              else if ( i > 0 && hasZ )
              {
                zl.append( p->z() );
              }
 
              if ( i == 0 && p->isMeasure() )
              {
                hasM = true;
                ml.reserve( size );
                ml.append( p->m() );
              }
              else if ( i > 0 && hasM )
              {
                ml.append( p->m() );
              }
 
              if ( i == 0 && p->wkbType() == Qgis::WkbType::Point25D )
                is25D = true;
            }
            sipReleaseType( p, sipType_QgsPoint, state );
          }
          else
          {
            sipIsErr = 1;
          }
 
          Py_DECREF( value );
 
          if ( sipIsErr )
          {
            // couldn't convert the sequence value to a QgsPoint or QgsPointXY
            PyErr_SetString( PyExc_TypeError, u"Invalid type at index %1. Expected QgsPoint, QgsPointXY or array of floats."_s.arg( i ) .toUtf8().constData() );
            break;
          }
        }
      }
      if ( sipIsErr == 0 )
        sipCpp = new sipQgsLineString( QgsLineString( xl, yl, zl, ml, is25D ) );
    }
    % End
// clang-format on
#endif

    explicit QgsLineString( const QgsLineSegment2D &segment ) SIP_HOLDGIL;

    QgsLineString( const QVector<double> &x, const QVector<double> &y,
                   const QVector<double> &z = QVector<double>(),
                   const QVector<double> &m = QVector<double>(), bool is25DType = false ) SIP_HOLDGIL;

    QgsLineString( const QgsPoint &p1, const QgsPoint &p2 ) SIP_HOLDGIL;

    static std::unique_ptr< QgsLineString > fromBezierCurve( const QgsPoint &start, const QgsPoint &controlPoint1, const QgsPoint &controlPoint2, const QgsPoint &end, int segments = 30 );

    static std::unique_ptr< QgsLineString > fromQPolygonF( const QPolygonF &polygon );
 
#ifndef SIP_RUN
    using QgsSimpleCurve::setPoints; // make all setPoints() functions eligible for overload resolution
#endif // !SIP_RUN

    void setPoints( size_t size, const double *x, const double *y, const double *z = nullptr, const double *m = nullptr ) SIP_SKIP;

    void addVertex( const QgsPoint &pt );

    void close();

    QgsCompoundCurve *toCurveType() const override SIP_FACTORY;

    void extend( double startDistance, double endDistance );
 
#ifndef SIP_RUN

    void visitPointsByRegularDistance( double distance, const std::function< bool( double x, double y, double z, double m,
                                       double startSegmentX, double startSegmentY, double startSegmentZ, double startSegmentM,
                                       double endSegmentX, double endSegmentY, double endSegmentZ, double endSegmentM
                                                                                 ) > &visitPoint ) const;
#endif
 
    //reimplemented methods
    QString geometryType() const override SIP_HOLDGIL;
 
    QgsLineString *clone() const override SIP_FACTORY;
    void clear() override;
    int indexOf( const QgsPoint &point ) const final;
    bool isValid( QString &error SIP_OUT, Qgis::GeometryValidityFlags flags = Qgis::GeometryValidityFlags() ) const override;
    QgsLineString *snappedToGrid( double hSpacing, double vSpacing, double dSpacing = 0, double mSpacing = 0, bool removeRedundantPoints = false ) const override SIP_FACTORY;
    bool removeDuplicateNodes( double epsilon = 4 * std::numeric_limits<double>::epsilon(), bool useZValues = false ) override;
    bool isClosed() const override SIP_HOLDGIL;
    bool isClosed2D() const override SIP_HOLDGIL;
    bool boundingBoxIntersects( const QgsRectangle &rectangle ) const override SIP_HOLDGIL;
    bool boundingBoxIntersects( const QgsBox3D &box3d ) const override SIP_HOLDGIL;

    QVector< QgsVertexId > collectDuplicateNodes( double epsilon = 4 * std::numeric_limits<double>::epsilon(), bool useZValues = false ) const;
 
    QPolygonF asQPolygonF() const override;
 
    QgsLineString *simplifyByDistance( double tolerance ) const override SIP_FACTORY;
 
    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;
 
    //curve interface
    double length() const override SIP_HOLDGIL;
 
#ifndef SIP_RUN
    std::tuple< std::unique_ptr< QgsCurve >, std::unique_ptr< QgsCurve > > splitCurveAtVertex( int index ) const final;
#endif

    QVector<QgsLineString *> splitToDisjointXYParts() const SIP_FACTORY;

    double length3D() const SIP_HOLDGIL;

    QgsLineString *curveToLine( double tolerance = M_PI_2 / 90, SegmentationToleranceType toleranceType = MaximumAngle ) const override  SIP_FACTORY;
 
    void draw( QPainter &p ) const override;
 
    void addToPainterPath( QPainterPath &path ) const override;
    void drawAsPolygon( QPainter &p ) const override;
 
    bool insertVertex( QgsVertexId position, const QgsPoint &vertex ) override;
    bool deleteVertex( QgsVertexId position ) override;
    bool deleteVertices( const QSet<QgsVertexId> &positions ) override;
 
    QgsLineString *reversed() const override SIP_FACTORY;
    QgsPoint *interpolatePoint( double distance ) const override SIP_FACTORY;
    QgsLineString *curveSubstring( double startDistance, double endDistance ) const override SIP_FACTORY;
 
    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 pointAt( int node, QgsPoint &point, Qgis::VertexType &type ) const override;
 
    QgsPoint centroid() const override;

    void sumUpArea( double &sum SIP_OUT ) const override;

    void sumUpArea3D( double &sum SIP_OUT ) const override;
 
    double vertexAngle( QgsVertexId vertex ) const override;
    double segmentLength( QgsVertexId startVertex ) const override;
    double distanceBetweenVertices( QgsVertexId fromVertex, QgsVertexId toVertex ) const override;
 
    bool convertTo( Qgis::WkbType type ) override;
 
#ifndef SIP_RUN
    inline static const QgsLineString *cast( const QgsAbstractGeometry *geom ) // cppcheck-suppress duplInheritedMember
    {
      if ( geom && QgsWkbTypes::flatType( geom->wkbType() ) == Qgis::WkbType::LineString )
        return static_cast<const QgsLineString *>( geom );
      return nullptr;
    }

    inline static QgsLineString *cast( QgsAbstractGeometry *geom ) // cppcheck-suppress duplInheritedMember
    {
      if ( geom && QgsWkbTypes::flatType( geom->wkbType() ) == Qgis::WkbType::LineString )
        return static_cast<QgsLineString *>( geom );
      return nullptr;
    }
#endif
 
    QgsLineString *createEmptyWithSameType() const override SIP_FACTORY;
 
#ifdef SIP_RUN
// clang-format off
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString wkt = sipCpp->asWkt();
    if ( wkt.length() > 1000 )
      wkt = wkt.left( 1000 ) + u"..."_s;
    QString str = u"<QgsLineString: %1>"_s.arg( wkt );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End

    SIP_PYOBJECT __getitem__( int index ) SIP_TYPEHINT( QgsPoint );
    % MethodCode
    const int count = sipCpp->numPoints();
    if ( a0 < -count || a0 >= count )
    {
      PyErr_SetString( PyExc_IndexError, QByteArray::number( a0 ) );
      sipIsErr = 1;
    }
    else
    {
      std::unique_ptr< QgsPoint > p;
      if ( a0 >= 0 )
        p = std::make_unique< QgsPoint >( sipCpp->pointN( a0 ) );
      else
        p = std::make_unique< QgsPoint >( sipCpp->pointN( count + a0 ) );
      sipRes = sipConvertFromType( p.release(), sipType_QgsPoint, Py_None );
    }
    % End

    void __setitem__( int index, const QgsPoint &point );
    % MethodCode
    const int count = sipCpp->numPoints();
    if ( a0 < -count || a0 >= count )
    {
      PyErr_SetString( PyExc_IndexError, QByteArray::number( a0 ) );
      sipIsErr = 1;
    }
    else
    {
      if ( a0 < 0 )
        a0 = count + a0;
      sipCpp->setXAt( a0, a1->x() );
      sipCpp->setYAt( a0, a1->y() );
      if ( sipCpp->isMeasure() )
        sipCpp->setMAt( a0, a1->m() );
      if ( sipCpp->is3D() )
        sipCpp->setZAt( a0, a1->z() );
    }
    % End
 

    void __delitem__( int index );
    % MethodCode
    const int count = sipCpp->numPoints();
    if ( a0 >= 0 && a0 < count )
      sipCpp->deleteVertex( QgsVertexId( -1, -1, a0 ) );
    else if ( a0 < 0 && a0 >= -count )
      sipCpp->deleteVertex( QgsVertexId( -1, -1, count + a0 ) );
    else
    {
      PyErr_SetString( PyExc_IndexError, QByteArray::number( a0 ) );
      sipIsErr = 1;
    }
    % End
 
// clang-format on
#endif

    Q_DECL_DEPRECATED QgsBox3D calculateBoundingBox3d() const SIP_DEPRECATED;

    QgsBox3D calculateBoundingBox3D() const override;

    std::unique_ptr< QgsLineString > measuredLine( double start, double end ) const;

    std::unique_ptr< QgsLineString > interpolateM( bool use3DDistance = true ) const;

    bool lineLocatePointByM( double m, double &x SIP_OUT, double &y SIP_OUT, double &z SIP_OUT, double &distanceFromStart SIP_OUT, bool use3DDistance = true ) const;
 
  private:
    void fromWkbPoints( Qgis::WkbType type, const QgsConstWkbPtr &wkb )
    {
      mWkbType = type;
      importVerticesFromWkb( wkb );
    }
 
    bool lineLocatePointByMPrivate( double m, double &x, double &y, double &z, double &distanceFromStart, bool use3DDistance, bool haveInterpolatedM ) const;
 
    friend class QgsPolygon;
    friend class QgsTriangle;
    friend class TestQgsGeometry;
 
};
 
// clazy:excludeall=qstring-allocations
 
#endif // QGSLINESTRING_H