qgssnappingutils.h

Go to the documentation of this file.

/***************************************************************************
  qgssnappingutils.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 QGSSNAPPINGUTILS_H
#define QGSSNAPPINGUTILS_H
 
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsmapsettings.h"
#include "qgspointlocator.h"
#include "qgssnappingconfig.h"
#include "qgstolerance.h"
 
class QgsSnappingConfig;

class CORE_EXPORT QgsSnappingUtils : public QObject
{
    Q_OBJECT
 
    Q_PROPERTY( QgsSnappingConfig config READ config WRITE setConfig NOTIFY configChanged )
 
  public:
    QgsSnappingUtils( QObject *parent SIP_TRANSFERTHIS = nullptr, bool enableSnappingForInvisibleFeature = true );
    ~QgsSnappingUtils() override;
 
    // main actions

    QgsPointLocator *locatorForLayer( QgsVectorLayer *vl );

    QgsPointLocator::Match snapToMap( QPoint point, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    QgsPointLocator::Match snapToMap( const QgsPointXY &pointMap, QgsPointLocator::MatchFilter *filter = nullptr, bool relaxed = false );

    QgsPointLocator::Match snapToCurrentLayer( QPoint point, QgsPointLocator::Types type, QgsPointLocator::MatchFilter *filter = nullptr );
 
    // environment setup

    void setMapSettings( const QgsMapSettings &settings );
    QgsMapSettings mapSettings() const { return mMapSettings; }

    void setCurrentLayer( QgsVectorLayer *layer );
    QgsVectorLayer *currentLayer() const { return mCurrentLayer; }
 
    // configuration
 
    enum IndexingStrategy
    {
      IndexAlwaysFull, 
      IndexNeverFull,  
      IndexHybrid,     
      IndexExtent      
    };

    void setIndexingStrategy( IndexingStrategy strategy ) { mStrategy = strategy; }
    IndexingStrategy indexingStrategy() const { return mStrategy; }

    struct LayerConfig
    {
        LayerConfig( QgsVectorLayer *l, QgsPointLocator::Types t, double tol, Qgis::MapToolUnit u )
          : layer( l )
          , type( t )
          , tolerance( tol )
          , unit( u )
        {}
 
        // TODO c++20 - replace with = default
        bool operator==( const QgsSnappingUtils::LayerConfig &other ) const { return layer == other.layer && type == other.type && tolerance == other.tolerance && unit == other.unit; }
        bool operator!=( const QgsSnappingUtils::LayerConfig &other ) const { return !operator==( other ); }

        QgsVectorLayer *layer = nullptr;
        QgsPointLocator::Types type;
        double tolerance;
        Qgis::MapToolUnit unit;
    };

    QList<QgsSnappingUtils::LayerConfig> layers() const { return mLayers; }

    QString dump();

    QgsSnappingConfig config() const;

    void setEnableSnappingForInvisibleFeature( bool enable );

    void addExtraSnapLayer( QgsVectorLayer *vl ) { mExtraSnapLayers.insert( vl ); }

    void removeExtraSnapLayer( QgsVectorLayer *vl ) { mExtraSnapLayers.remove( vl ); }

    QSet<QgsVectorLayer *> getExtraSnapLayers() { return mExtraSnapLayers; }
 
 
  public slots:

    void setConfig( const QgsSnappingConfig &snappingConfig );

    void toggleEnabled();
 
  signals:

    void configChanged( const QgsSnappingConfig &snappingConfig );
 
  protected:
    virtual void prepareIndexStarting( int count ) { Q_UNUSED( count ); }
    virtual void prepareIndexProgress( int index ) { Q_UNUSED( index ); }

    void clearAllLocators();
 
  private slots:

    void onInitFinished( bool ok );
 
  private:
    void onIndividualLayerSettingsChanged( const QHash<QgsVectorLayer *, QgsSnappingConfig::IndividualLayerSettings> &layerSettings );
    QgsCoordinateReferenceSystem destinationCrs() const;

    QgsPointLocator *locatorForLayerUsingStrategy( QgsVectorLayer *vl, const QgsPointXY &pointMap, double tolerance );
    QgsPointLocator *temporaryLocatorForLayer( QgsVectorLayer *vl, const QgsPointXY &pointMap, double tolerance );
 
    typedef QPair< QgsVectorLayer *, QgsRectangle > LayerAndAreaOfInterest;

    bool isIndexPrepared( QgsPointLocator *loc, const QgsRectangle &areaOfInterest );
    void prepareIndex( const QList<LayerAndAreaOfInterest> &layers, bool relaxed );
 
  private:
    // environment
    QgsMapSettings mMapSettings;
    QgsVectorLayer *mCurrentLayer = nullptr;
 
    QgsSnappingConfig mSnappingConfig;
 
    // configuration
    IndexingStrategy mStrategy = IndexHybrid;
    QList<LayerConfig> mLayers;
 
    // internal data
    typedef QMap<QgsVectorLayer *, QgsPointLocator *> LocatorsMap;
    LocatorsMap mLocators;
    LocatorsMap mTemporaryLocators;
    QSet<QString> mHybridNonindexableLayers;
    QSet<QgsVectorLayer *> mExtraSnapLayers;

    QHash<QString, double> mHybridMaxAreaPerLayer;
    int mHybridPerLayerFeatureLimit = 50000;

    bool mEnableSnappingForInvisibleFeature = true;
 
    friend class TestQgsSnappingUtils;
};
 
 
#endif // QGSSNAPPINGUTILS_H