qgsgeometrysnapper.h

Go to the documentation of this file.

/***************************************************************************
 *  qgsgeometrysnapper.h                                                   *
 *  -------------------                                                    *
 *  copyright            : (C) 2014 by Sandro Mani / Sourcepole AG         *
 *  email                : [email protected]                             *
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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 <QMutex>
#include <QFuture>
#include <QStringList>
#include "qgsspatialindex.h"
#include "qgsabstractgeometry.h"
#include "qgspoint.h"
#include "qgsgeometry.h"
#include "qgis_analysis.h"
 
class QgsVectorLayer;
 
class ANALYSIS_EXPORT QgsGeometrySnapper : public QObject
{
    Q_OBJECT
 
  public:
 
    enum SnapMode
    {
      PreferNodes = 0, 
      PreferClosest, 
      PreferNodesNoExtraVertices, 
      PreferClosestNoExtraVertices, 
      EndPointPreferNodes, 
      EndPointPreferClosest, 
      EndPointToEndPoint, 
    };
 
    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;
    QgsFeatureList mInputFeatures;
 
    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 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;
 
};
 
#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 CoordIdx *idxFrom = nullptr;
        const CoordIdx *idxTo = nullptr;
    };
 
    QgsSnapIndex( const QgsPoint &origin, double cellSize );
    ~QgsSnapIndex();
 
    QgsSnapIndex( const QgsSnapIndex &rh ) = delete;
    QgsSnapIndex &operator=( const QgsSnapIndex &rh ) = delete;
 
    void addGeometry( const QgsAbstractGeometry *geom );
    QgsPoint getClosestSnapToPoint( const QgsPoint &p, const QgsPoint &q );
    SnapItem *getSnapItem( const QgsPoint &pos, double tol, PointSnapItem **pSnapPoint = nullptr, SegmentSnapItem **pSnapSegment = nullptr, bool endPointOnly = false ) const;
 
  private:
    typedef QList<SnapItem *> Cell;
    typedef QPair<QgsPoint, QgsPoint> Segment;
 
    class GridRow
    {
      public:
        GridRow() = default;
        ~GridRow();
        const Cell *getCell( int col ) const;
        Cell &getCreateCell( int col );
        QList<SnapItem *> getSnapItems( int colStart, int colEnd ) const;
 
      private:
        QList<QgsSnapIndex::Cell> mCells;
        int mColStartIdx = 0;
    };
 
    QgsPoint mOrigin;
    double mCellSize;
 
    QList<CoordIdx *> mCoordIdxs;
    QList<GridRow> mGridRows;
    int mRowsStartIdx;
 
    void addPoint( const CoordIdx *idx, bool isEndPoint );
    void addSegment( const CoordIdx *idxFrom, const CoordIdx *idxTo );
    const Cell *getCell( int col, int row ) const;
    Cell &getCreateCell( int col, int row );
 
};
 
 
#endif
 
#endif // QGS_GEOMETRY_SNAPPER_H