qgsprocessingutils.h

Go to the documentation of this file.

/***************************************************************************
                         qgsprocessingutils.h
                         ------------------------
    begin                : April 2017
    copyright            : (C) 2017 by Nyall Dawson
    email                : nyall dot dawson 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 QGSPROCESSINGUTILS_H
#define QGSPROCESSINGUTILS_H
 
#include "qgis_core.h"
 
#include "qgsrasterlayer.h"
#include "qgsfeaturesink.h"
#include "qgsfeaturesource.h"
#include "qgsprocessing.h"
#include "qgsproxyfeaturesink.h"
#include "qgsremappingproxyfeaturesink.h"
 
class QgsMeshLayer;
class QgsPluginLayer;
class QgsProject;
class QgsProcessingContext;
class QgsMapLayerStore;
class QgsProcessingFeedback;
class QgsProcessingFeatureSource;
class QgsProcessingAlgorithm;
class QgsVectorTileLayer;
class QgsPointCloudLayer;
class QgsAnnotationLayer;
class QgsVectorTileLayer;
class QgsTiledSceneLayer;
 
#include <QString>
#include <QVariant>
 
class CORE_EXPORT QgsProcessingUtils
{
    Q_GADGET
 
  public:
 
    static QList< QgsRasterLayer * > compatibleRasterLayers( QgsProject *project, bool sort = true );
 
    static QList< QgsVectorLayer * > compatibleVectorLayers( QgsProject *project,
        const QList< int > &sourceTypes = QList< int >(),
        bool sort = true );
 
    static QList<QgsMeshLayer *> compatibleMeshLayers( QgsProject *project, bool sort = true );
 
    static QList<QgsPluginLayer *> compatiblePluginLayers( QgsProject *project, bool sort = true );
 
    static QList<QgsPointCloudLayer *> compatiblePointCloudLayers( QgsProject *project, bool sort = true );
 
    static QList<QgsAnnotationLayer *> compatibleAnnotationLayers( QgsProject *project, bool sort = true );
 
    static QList<QgsVectorTileLayer *> compatibleVectorTileLayers( QgsProject *project, bool sort = true );
 
    static QList<QgsTiledSceneLayer *> compatibleTiledSceneLayers( QgsProject *project, bool sort = true );
 
    static QList< QgsMapLayer * > compatibleLayers( QgsProject *project, bool sort = true );
 
    static QString encodeProviderKeyAndUri( const QString &providerKey, const QString &uri );
 
    static bool decodeProviderKeyAndUri( const QString &string, QString &providerKey SIP_OUT, QString &uri SIP_OUT );
 
    enum class LayerHint SIP_MONKEYPATCH_SCOPEENUM : int
    {
      UnknownType, 
      Vector, 
      Raster, 
      Mesh, 
      PointCloud, 
      Annotation, 
      VectorTile, 
      TiledScene, 
    };
    enum class LayerHint SIP_MONKEYPATCH_SCOPEENUM : int {…};
    Q_ENUM( LayerHint )
 
    
    static QgsMapLayer *mapLayerFromString( const QString &string, QgsProcessingContext &context, bool allowLoadingNewLayers = true, QgsProcessingUtils::LayerHint typeHint = QgsProcessingUtils::LayerHint::UnknownType, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags() );
 
    static QgsProcessingFeatureSource *variantToSource( const QVariant &value, QgsProcessingContext &context, const QVariant &fallbackValue = QVariant() ) SIP_FACTORY;
 
    static QgsCoordinateReferenceSystem variantToCrs( const QVariant &value, QgsProcessingContext &context, const QVariant &fallbackValue = QVariant() );
 
    static QString normalizeLayerSource( const QString &source ) SIP_HOLDGIL;
 
    static QString layerToStringIdentifier( const QgsMapLayer *layer, const QString &layerName = QString() ) SIP_HOLDGIL;
 
    static QString variantToPythonLiteral( const QVariant &value );
 
    static QString stringToPythonLiteral( const QString &string ) SIP_HOLDGIL;
 
#ifndef SIP_RUN
    static QgsFeatureSink *createFeatureSink( QString &destination,
        QgsProcessingContext &context,
        const QgsFields &fields,
        Qgis::WkbType geometryType,
        const QgsCoordinateReferenceSystem &crs,
        const QVariantMap &createOptions = QVariantMap(),
        const QStringList &datasourceOptions = QStringList(),
        const QStringList &layerOptions = QStringList(),
        QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(),
        QgsRemappingSinkDefinition *remappingDefinition = nullptr ) SIP_FACTORY;
#endif
 
    static void createFeatureSinkPython( QgsFeatureSink **sink SIP_OUT SIP_TRANSFERBACK, QString &destination SIP_INOUT, QgsProcessingContext &context, const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs, const QVariantMap &createOptions = QVariantMap() ) SIP_THROW( QgsProcessingException ) SIP_PYNAME( createFeatureSink );
 
 
    static QgsRectangle combineLayerExtents( const QList<QgsMapLayer *> &layers, const QgsCoordinateReferenceSystem &crs, QgsProcessingContext &context );
 
    Q_DECL_DEPRECATED static QgsRectangle combineLayerExtents( const QList<QgsMapLayer *> &layers, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() ) SIP_DEPRECATED;
 
    static QVariant generateIteratingDestination( const QVariant &input, const QVariant &id, QgsProcessingContext &context );
 
    static QString tempFolder( const QgsProcessingContext *context = nullptr );
 
    static QString generateTempFilename( const QString &basename, const QgsProcessingContext *context = nullptr );
 
    static QString formatHelpMapAsHtml( const QVariantMap &map, const QgsProcessingAlgorithm *algorithm );
 
    static int outputDefinitionIndex( const QgsProcessingAlgorithm *algorithm, const QString &name ) SIP_HOLDGIL;
 
    static QString convertToCompatibleFormat( const QgsVectorLayer *layer,
        bool selectedFeaturesOnly,
        const QString &baseName,
        const QStringList &compatibleFormats,
        const QString &preferredFormat,
        QgsProcessingContext &context,
        QgsProcessingFeedback *feedback,
        long long featureLimit = -1,
        const QString &filterExpression = QString() );
 
    static QString convertToCompatibleFormatAndLayerName( const QgsVectorLayer *layer,
        bool selectedFeaturesOnly,
        const QString &baseName,
        const QStringList &compatibleFormats,
        const QString &preferredFormat,
        QgsProcessingContext &context,
        QgsProcessingFeedback *feedback,
        QString &layerName SIP_OUT,
        long long featureLimit = -1,
        const QString &filterExpression = QString() );
 
    static QgsFields combineFields( const QgsFields &fieldsA, const QgsFields &fieldsB, const QString &fieldsBPrefix = QString() ) SIP_HOLDGIL;
 
    static QList<int> fieldNamesToIndices( const QStringList &fieldNames, const QgsFields &fields ) SIP_HOLDGIL;
 
    static QgsFields indicesToFields( const QList<int> &indices, const QgsFields &fields ) SIP_HOLDGIL;
 
    static QString defaultVectorExtension();
 
    static QString defaultRasterExtension();
 
    static QString defaultPointCloudExtension();
 
    static QString defaultVectorTileExtension();
 
    static QVariantMap removePointerValuesFromMap( const QVariantMap &map );
 
    static QVariantMap preprocessQgisProcessParameters( const QVariantMap &parameters, bool &ok, QString &error );
 
    static QString resolveDefaultEncoding( const QString &defaultEncoding = "System" );
 
  private:
    static bool canUseLayer( const QgsRasterLayer *layer );
    static bool canUseLayer( const QgsMeshLayer *layer );
    static bool canUseLayer( const QgsPluginLayer *layer );
    static bool canUseLayer( const QgsVectorTileLayer *layer );
    static bool canUseLayer( const QgsPointCloudLayer *layer );
    static bool canUseLayer( const QgsAnnotationLayer *layer );
    static bool canUseLayer( const QgsTiledSceneLayer *layer );
    static bool canUseLayer( const QgsVectorLayer *layer,
                             const QList< int > &sourceTypes = QList< int >() );
 
    template< typename T> static QList< T * > compatibleMapLayers( QgsProject *project, bool sort = true );
 
    static QgsMapLayer *mapLayerFromStore( const QString &string, QgsMapLayerStore *store, QgsProcessingUtils::LayerHint typeHint = QgsProcessingUtils::LayerHint::UnknownType );
 
    static QgsMapLayer *loadMapLayerFromString( const QString &string, const QgsCoordinateTransformContext &transformContext, LayerHint typeHint = LayerHint::UnknownType, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags() );
 
    Q_DECL_DEPRECATED static QgsMapLayer *loadMapLayerFromString( const QString &string, LayerHint typeHint = LayerHint::UnknownType ) SIP_DEPRECATED ;
 
    static void parseDestinationString( QString &destination, QString &providerKey, QString &uri, QString &layerName, QString &format, QMap<QString, QVariant> &options, bool &useWriter, QString &extension );
 
    friend class TestQgsProcessing;
    friend class QgsProcessingProvider;
 
};
class CORE_EXPORT QgsProcessingUtils {…};
 
class CORE_EXPORT QgsProcessingFeatureSource : public QgsFeatureSource
{
  public:
 
    QgsProcessingFeatureSource( QgsFeatureSource *originalSource, const QgsProcessingContext &context, bool ownsOriginalSource = false,
                                long long featureLimit = -1, const QString &filterExpression = QString() );
 
    ~QgsProcessingFeatureSource() override;
 
    QgsFeatureIterator getFeatures( const QgsFeatureRequest &request, Qgis::ProcessingFeatureSourceFlags flags ) const;
 
    Qgis::FeatureAvailability hasFeatures() const override;
 
    QgsFeatureIterator getFeatures( const QgsFeatureRequest &request = QgsFeatureRequest() ) const override;
    QgsCoordinateReferenceSystem sourceCrs() const override;
    QgsFields fields() const override;
    Qgis::WkbType wkbType() const override;
    long long featureCount() const override;
    QString sourceName() const override;
    QSet<QVariant> uniqueValues( int fieldIndex, int limit = -1 ) const override;
    QVariant minimumValue( int fieldIndex ) const override;
    QVariant maximumValue( int fieldIndex ) const override;
    QgsRectangle sourceExtent() const override;
    QgsFeatureIds allFeatureIds() const override;
    Qgis::SpatialIndexPresence hasSpatialIndex() const override;
 
    QgsExpressionContextScope *createExpressionContextScope() const SIP_FACTORY;
 
    void setInvalidGeometryCheck( Qgis::InvalidGeometryCheck method );
 
    Qgis::InvalidGeometryCheck invalidGeometryCheck() const;
 
  private:
 
    QgsFeatureSource *mSource = nullptr;
    bool mOwnsSource = false;
    QgsCoordinateReferenceSystem mSourceCrs;
    QgsFields mSourceFields;
    Qgis::WkbType mSourceWkbType = Qgis::WkbType::Unknown;
    QString mSourceName;
    QgsRectangle mSourceExtent;
    Qgis::SpatialIndexPresence mSourceSpatialIndexPresence = Qgis::SpatialIndexPresence::Unknown;
 
    Qgis::InvalidGeometryCheck mInvalidGeometryCheck = Qgis::InvalidGeometryCheck::NoCheck;
    std::function< void( const QgsFeature & ) > mInvalidGeometryCallback;
    std::function< void( const QgsFeature & ) > mTransformErrorCallback;
 
    std::function< void( const QgsFeature & ) > mInvalidGeometryCallbackSkip;
    std::function< void( const QgsFeature & ) > mInvalidGeometryCallbackAbort;
 
    long long mFeatureLimit = -1;
    QString mFilterExpression;
 
};
class CORE_EXPORT QgsProcessingFeatureSource : public QgsFeatureSource {…};
 
#ifndef SIP_RUN
 
class CORE_EXPORT QgsProcessingFeatureSink : public QgsProxyFeatureSink
{
  public:
 
 
    QgsProcessingFeatureSink( QgsFeatureSink *originalSink, const QString &sinkName, QgsProcessingContext &context, bool ownsOriginalSink = false );
    ~QgsProcessingFeatureSink() override;
 
    void finalize() override SIP_THROW( QgsProcessingException );
 
    bool addFeature( QgsFeature &feature, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) override;
    bool addFeatures( QgsFeatureList &features, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) override;
    bool addFeatures( QgsFeatureIterator &iterator, QgsFeatureSink::Flags flags = QgsFeatureSink::Flags() ) override;
 
  private:
 
    QgsProcessingContext &mContext;
    QString mSinkName;
    bool mOwnsSink = false;
 
};
class CORE_EXPORT QgsProcessingFeatureSink : public QgsProxyFeatureSink {…};
#endif
 
#endif // QGSPROCESSINGUTILS_H