qgspointlocator.h

Go to the documentation of this file.

/***************************************************************************
  qgspointlocator.h
  --------------------------------------
  Date                 : November 2014
  Copyright            : (C) 2014 by Martin Dobias
  Email                : wonder dot sk at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   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 QGSPOINTLOCATOR_H
#define QGSPOINTLOCATOR_H
 
class QgsPointXY;
class QgsFeatureRenderer;
class QgsRenderContext;
class QgsRectangle;
class QgsVectorLayerFeatureSource;
 
#include <memory>
 
#include "qgis_core.h"
#include "qgscoordinatereferencesystem.h"
#include "qgscoordinatetransform.h"
#include "qgsfeatureid.h"
#include "qgsgeometry.h"
#include "qgsgeometryutils.h"
#include "qgslinestring.h"
#include "qgspointlocatorinittask.h"
#include "qgspointxy.h"
#include "qgsvectorlayer.h"
 
#include <QPointer>

class QgsPointLocator_VisitorNearestVertex;

class QgsPointLocator_VisitorNearestCentroid;

class QgsPointLocator_VisitorNearestMiddleOfSegment;

class QgsPointLocator_VisitorNearestEdge;

class QgsPointLocator_VisitorArea;

class QgsPointLocator_VisitorEdgesInRect;
 
namespace SpatialIndex SIP_SKIP
{
  class IStorageManager;
  class ISpatialIndex;
}

class CORE_EXPORT QgsPointLocator : public QObject
{
    Q_OBJECT
  public:

    explicit QgsPointLocator( QgsVectorLayer *layer, const QgsCoordinateReferenceSystem &destinationCrs = QgsCoordinateReferenceSystem(),
                              const QgsCoordinateTransformContext &transformContext = QgsCoordinateTransformContext(),
                              const QgsRectangle *extent = nullptr );
 
    ~QgsPointLocator() override;

    QgsVectorLayer *layer() const { return mLayer; }

    QgsCoordinateReferenceSystem destinationCrs() const;

    const QgsRectangle *extent() const { return mExtent.get(); }

    void setExtent( const QgsRectangle *extent );

    void setRenderContext( const QgsRenderContext *context );

    enum Type SIP_ENUM_BASETYPE( IntFlag )
    {
      Invalid = 0, 
      Vertex  = 1 << 0, 
      Edge    = 1 << 1, 
      Area    = 1 << 2, 
      Centroid = 1 << 3, 
      MiddleOfSegment = 1 << 4, 
      LineEndpoint = 1 << 5, 
      All = Vertex | Edge | Area | Centroid | MiddleOfSegment 
    };
 
    Q_DECLARE_FLAGS( Types, Type )
 
    
    bool init( int maxFeaturesToIndex = -1, bool relaxed = false );

    bool hasIndex() const;
 
    struct Match
    {
        Match() = default;
 
        Match( QgsPointLocator::Type t, QgsVectorLayer *vl, QgsFeatureId fid, double dist, const QgsPointXY &pt, int vertexIndex = 0, QgsPointXY *edgePoints = nullptr )
          : mType( t )
          , mDist( dist )
          , mPoint( pt )
          , mLayer( vl )
          , mFid( fid )
          , mVertexIndex( vertexIndex )
        {
          if ( edgePoints )
          {
            mEdgePoints[0] = edgePoints[0];
            mEdgePoints[1] = edgePoints[1];
          }
        }
 
        QgsPointLocator::Type type() const { return mType; }
 
        bool isValid() const { return mType != Invalid; }
        bool hasVertex() const { return mType == Vertex; }
        bool hasEdge() const { return mType == Edge; }
        bool hasCentroid() const { return mType == Centroid; }
        bool hasArea() const { return mType == Area; }
        bool hasMiddleSegment() const { return mType == MiddleOfSegment; }

        bool hasLineEndpoint() const { return mType == LineEndpoint; }

        double distance() const { return mDist; }

        QgsPointXY point() const { return mPoint; }

        int vertexIndex() const { return mVertexIndex; }

        QgsVectorLayer *layer() const { return mLayer; }

        QgsFeatureId featureId() const { return mFid; }

        void edgePoints( QgsPointXY &pt1 SIP_OUT, QgsPointXY &pt2 SIP_OUT ) const
        {
          pt1 = mEdgePoints[0];
          pt2 = mEdgePoints[1];
        }

        QgsPoint interpolatedPoint( const QgsCoordinateReferenceSystem &destinationCrs = QgsCoordinateReferenceSystem() ) const
        {
          QgsPoint point;
 
          if ( mLayer )
          {
            QgsPointXY snappedPoint( mPoint );
            const QgsGeometry geom = mLayer->getGeometry( mFid );
            QgsCoordinateTransform transform( destinationCrs, mLayer->crs(), mLayer->transformContext() );
            if ( transform.isValid() )
            {
              try
              {
                snappedPoint = transform.transform( snappedPoint );
              }
              catch ( QgsCsException & )
              {
                QgsDebugError( QStringLiteral( "transformation to layer coordinate failed" ) );
              }
            }
 
            if ( !( geom.isNull() || geom.isEmpty() ) )
            {
              // when snapping to a curve we need to use real geometry in order to have correct location
              // of the snapped point, see https://github.com/qgis/QGIS/issues/53197.
              // In other cases it is ok to use only a segment to speedup calculations.
              if ( QgsWkbTypes::isCurvedType( geom.wkbType() ) )
              {
                point = QgsGeometryUtils::closestPoint( *geom.constGet(), QgsPoint( snappedPoint ) );
              }
              else
              {
                const QgsLineString line( geom.vertexAt( mVertexIndex ), geom.vertexAt( mVertexIndex + 1 ) );
                point = QgsGeometryUtils::closestPoint( line, QgsPoint( snappedPoint ) );
              }
            }
 
            if ( transform.isValid() )
            {
              try
              {
                point.transform( transform, Qgis::TransformDirection::Reverse );
              }
              catch ( QgsCsException & )
              {
                QgsDebugError( QStringLiteral( "transformation to destination coordinate failed" ) );
              }
            }
          }
 
          return point;
        }
 
        // TODO c++20 - replace with = default
        bool operator==( const QgsPointLocator::Match &other ) const
        {
          return mType == other.mType &&
                 mDist == other.mDist &&
                 mPoint == other.mPoint &&
                 mLayer == other.mLayer &&
                 mFid == other.mFid &&
                 mVertexIndex == other.mVertexIndex &&
                 mEdgePoints[0] == other.mEdgePoints[0] &&
                 mEdgePoints[1] == other.mEdgePoints[1] &&
                 mCentroid == other.mCentroid &&
                 mMiddleOfSegment == other.mMiddleOfSegment;
        }
 
      protected:
        Type mType = Invalid;
        double mDist = 0;
        QgsPointXY mPoint;
        QgsVectorLayer *mLayer = nullptr;
        QgsFeatureId mFid = 0;
        int mVertexIndex = 0; // e.g. vertex index
        QgsPointXY mEdgePoints[2];
        QgsPointXY mCentroid;
        QgsPointXY mMiddleOfSegment;
    };
 
#ifndef SIP_RUN
    typedef class QList<QgsPointLocator::Match> MatchList;
#else
    typedef QList<QgsPointLocator::Match> MatchList;
#endif

    struct MatchFilter
    {
      virtual ~MatchFilter() = default;
      virtual bool acceptMatch( const QgsPointLocator::Match &match ) = 0;
    };
 
    // intersection queries

    Match nearestVertex( const QgsPointXY &point, double tolerance, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    Match nearestCentroid( const QgsPointXY &point, double tolerance, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    Match nearestMiddleOfSegment( const QgsPointXY &point, double tolerance, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    Match nearestLineEndpoints( const QgsPointXY &point, double tolerance, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    Match nearestEdge( const QgsPointXY &point, double tolerance, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    Match nearestArea( const QgsPointXY &point, double tolerance, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    MatchList edgesInRect( const QgsRectangle &rect, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    MatchList edgesInRect( const QgsPointXY &point, double tolerance, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    MatchList verticesInRect( const QgsRectangle &rect, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    MatchList verticesInRect( const QgsPointXY &point, double tolerance, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );
 
    // point-in-polygon query
 
    // TODO: function to return just the first match?

    MatchList pointInPolygon( const QgsPointXY &point, bool relaxed = false, QgsPointLocator::MatchFilter *filter = nullptr );

    int cachedGeometryCount() const { return mGeoms.count(); }

    bool isIndexing() const { return mIsIndexing; }

    void waitForIndexingFinished();
 
  signals:

    void initFinished( bool ok );
 
  protected:
    bool rebuildIndex( int maxFeaturesToIndex = -1 );
 
  protected slots:
    void destroyIndex();
  private slots:
    void onInitTaskFinished();
    void onFeatureAdded( QgsFeatureId fid );
    void onFeatureDeleted( QgsFeatureId fid );
    void onGeometryChanged( QgsFeatureId fid, const QgsGeometry &geom );
    void onAttributeValueChanged( QgsFeatureId fid, int idx, const QVariant &value );
 
  private:

    bool prepare( bool relaxed );

    std::unique_ptr< SpatialIndex::IStorageManager > mStorage;
 
    QHash<QgsFeatureId, QgsGeometry *> mGeoms;
    std::unique_ptr< SpatialIndex::ISpatialIndex > mRTree;

    bool mIsEmptyLayer = false;
 

    QgsCoordinateTransform mTransform;
    QgsVectorLayer *mLayer = nullptr;
    std::unique_ptr< QgsRectangle > mExtent;
 
    std::unique_ptr<QgsRenderContext> mContext;
    std::unique_ptr<QgsFeatureRenderer> mRenderer;
    std::unique_ptr<QgsVectorLayerFeatureSource> mSource;
    int mMaxFeaturesToIndex = -1;
    bool mIsIndexing = false;
    bool mIsDestroying = false;
    QgsFeatureIds mAddedFeatures;
    QgsFeatureIds mDeletedFeatures;
    QPointer<QgsPointLocatorInitTask> mInitTask;
 
    friend class QgsPointLocator_VisitorNearestVertex;
    friend class QgsPointLocator_VisitorNearestCentroid;
    friend class QgsPointLocator_VisitorNearestMiddleOfSegment;
    friend class QgsPointLocator_VisitorNearestEdge;
    friend class QgsPointLocator_VisitorArea;
    friend class QgsPointLocator_VisitorEdgesInRect;
    friend class QgsPointLocator_VisitorVerticesInRect;
    friend class QgsPointLocatorInitTask;
    friend class TestQgsPointLocator;
    friend class QgsPointLocator_VisitorCentroidsInRect;
    friend class QgsPointLocator_VisitorMiddlesInRect;
    friend class QgsPointLocator_VisitorNearestLineEndpoint;
};
 
 
#endif // QGSPOINTLOCATOR_H