qgsgeometrysnapper.h

Go to the documentation of this file.

/***************************************************************************
 *  qgsgeometrysnapper.h                                                   *
 *  -------------------                                                    *
 *  copyright            : (C) 2014 by Sandro Mani / Sourcepole AG         *
 *  email                : smani@sourcepole.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 QGS_GEOMETRY_SNAPPER_H
#define QGS_GEOMETRY_SNAPPER_H
 
#include "qgsspatialindex.h"
#include "qgsabstractgeometry.h"
#include "qgspoint.h"
#include "qgsgeometry.h"
#include "qgsgeos.h"
#include "qgis_analysis.h"
 
#include <QMutex>
#include <QFuture>
#include <QStringList>
#include <geos_c.h>
 
class QgsVectorLayer;
 
class ANALYSIS_EXPORT QgsGeometrySnapper : public QObject
{
    Q_OBJECT
 
  public:
    enum SnapMode
    {
      PreferNodes = 0,              
      PreferClosest,                
      PreferNodesNoExtraVertices,   
      PreferClosestNoExtraVertices, 
      EndPointPreferNodes,          
      EndPointPreferClosest,        
      EndPointToEndPoint,           
    };
    enum SnapMode {…};
 
    QgsGeometrySnapper( QgsFeatureSource *referenceSource );
 
    QgsGeometry snapGeometry( const QgsGeometry &geometry, double snapTolerance, SnapMode mode = PreferNodes ) const;
 
    QgsFeatureList snapFeatures( const QgsFeatureList &features, double snapTolerance, SnapMode mode = PreferNodes );
 
    static QgsGeometry snapGeometry( const QgsGeometry &geometry, double snapTolerance, const QList<QgsGeometry> &referenceGeometries, SnapMode mode = PreferNodes );
 
  signals:
 
    void featureSnapped();
 
  private:
    struct ProcessFeatureWrapper
    {
        QgsGeometrySnapper *instance = nullptr;
        double snapTolerance;
        SnapMode mode;
        explicit ProcessFeatureWrapper( QgsGeometrySnapper *_instance, double snapTolerance, SnapMode mode )
          : instance( _instance )
          , snapTolerance( snapTolerance )
          , mode( mode )
        {}
        void operator()( QgsFeature &feature ) { instance->processFeature( feature, snapTolerance, mode ); }
    };
 
    enum PointFlag
    {
      SnappedToRefNode,
      SnappedToRefSegment,
      Unsnapped
    };
 
    QgsFeatureSource *mReferenceSource = nullptr;
    QHash<QgsFeatureId, QgsGeometry> mCachedReferenceGeometries;
 
    QgsSpatialIndex mIndex;
    mutable QMutex mIndexMutex;
    mutable QMutex mReferenceLayerMutex;
 
    void processFeature( QgsFeature &feature, double snapTolerance, SnapMode mode );
 
    static int polyLineSize( const QgsAbstractGeometry *geom, int iPart, int iRing );
};
class ANALYSIS_EXPORT QgsGeometrySnapper : public QObject {…};
 
 
class ANALYSIS_EXPORT QgsInternalGeometrySnapper
{
  public:
    QgsInternalGeometrySnapper( double snapTolerance, QgsGeometrySnapper::SnapMode mode = QgsGeometrySnapper::PreferNodes );
 
    QgsGeometry snapFeature( const QgsFeature &feature );
 
    QgsGeometryMap snappedGeometries() const { return mProcessedGeometries; }
 
  private:
    bool mFirstFeature = true;
    double mSnapTolerance = 0;
    QgsGeometrySnapper::SnapMode mMode = QgsGeometrySnapper::PreferNodes;
    QgsSpatialIndex mProcessedIndex;
    QgsGeometryMap mProcessedGeometries;
};
class ANALYSIS_EXPORT QgsInternalGeometrySnapper {…};
 
#ifndef SIP_RUN
 
class QgsSnapIndex
{
  public:
    struct CoordIdx
    {
        CoordIdx( const QgsAbstractGeometry *_geom, QgsVertexId _vidx )
          : geom( _geom )
          , vidx( _vidx )
        {}
        QgsPoint point() const { return geom->vertexAt( vidx ); }
 
        const QgsAbstractGeometry *geom = nullptr;
        QgsVertexId vidx;
    };
 
    enum SnapType
    {
      SnapPoint,
      SnapEndPoint,
      SnapSegment
    };
 
    class SnapItem
    {
      public:
        virtual ~SnapItem() = default;
        SnapType type;
        virtual QgsPoint getSnapPoint( const QgsPoint &p ) const = 0;
 
      protected:
        explicit SnapItem( SnapType _type )
          : type( _type ) {}
    };
 
    class PointSnapItem : public QgsSnapIndex::SnapItem
    {
      public:
        explicit PointSnapItem( const CoordIdx *_idx, bool isEndPoint );
        QgsPoint getSnapPoint( const QgsPoint & /*p*/ ) const override;
        const CoordIdx *idx = nullptr;
    };
 
    class SegmentSnapItem : public QgsSnapIndex::SnapItem
    {
      public:
        SegmentSnapItem( const CoordIdx *_idxFrom, const CoordIdx *_idxTo );
        QgsPoint getSnapPoint( const QgsPoint &p ) const override;
        bool getIntersection( const QgsPoint &p1, const QgsPoint &p2, QgsPoint &inter ) const;
        bool getProjection( const QgsPoint &p, QgsPoint &pProj ) const;
        bool withinSquaredDistance( const QgsPoint &p, const double squaredDistance );
        const CoordIdx *idxFrom = nullptr;
        const CoordIdx *idxTo = nullptr;
    };
 
    QgsSnapIndex();
    ~QgsSnapIndex();
 
    QgsSnapIndex( const QgsSnapIndex &rh ) = delete;
    QgsSnapIndex &operator=( const QgsSnapIndex &rh ) = delete;
 
    void addGeometry( const QgsAbstractGeometry *geom );
    QgsPoint getClosestSnapToPoint( const QgsPoint &startPoint, const QgsPoint &midPoint );
    SnapItem *getSnapItem( const QgsPoint &pos, const double tolerance, PointSnapItem **pSnapPoint = nullptr, SegmentSnapItem **pSnapSegment = nullptr, bool endPointOnly = false ) const;
 
  private:
    QList<CoordIdx *> mCoordIdxs;
    QList<SnapItem *> mSnapItems;
 
    void addPoint( const CoordIdx *idx, bool isEndPoint );
    void addSegment( const CoordIdx *idxFrom, const CoordIdx *idxTo );
 
    GEOSSTRtree *mSTRTree = nullptr;
    std::vector<geos::unique_ptr> mSTRTreeItems;
};
 
 
#endif
 
#endif // QGS_GEOMETRY_SNAPPER_H