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 "qgstolerance.h"
#include "qgspointlocator.h"
#include "qgssnappingconfig.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, QgsTolerance::UnitType u )
        : layer( l )
        , type( t )
        , tolerance( tol )
        , unit( u )
      {}
 
      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;
      QgsTolerance::UnitType 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;
};
 
 
#endif // QGSSNAPPINGUTILS_H