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 );

  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;

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

    bool mEnableSnappingForInvisibleFeature = true;
};


#endif // QGSSNAPPINGUTILS_H