qgsprocessingalgorithm.h

Go to the documentation of this file.

/***************************************************************************
                         qgsprocessingalgorithm.h
                         ------------------------
    begin                : December 2016
    copyright            : (C) 2016 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 QGSPROCESSINGALGORITHM_H
#define QGSPROCESSINGALGORITHM_H
 
#include "qgis_core.h"
#include "qgis.h"
#include "qgsprocessingparameters.h"
#include "qgsprocessingoutputs.h"
#include "qgsprocessingcontext.h"
#include "qgsfeaturesource.h"
#include "qgsprocessingutils.h"
#include <QString>
#include <QVariant>
#include <QIcon>
 
class QgsProcessingProvider;
class QgsProcessingFeedback;
class QgsFeatureSink;
class QgsProcessingModelAlgorithm;
class QgsProcessingAlgorithmConfigurationWidget;
class QgsMeshLayer;
 
#ifdef SIP_RUN
% ModuleHeaderCode
#include <qgsprocessingmodelalgorithm.h>
% End
#endif
 
class CORE_EXPORT QgsProcessingAlgorithm
{
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( dynamic_cast< QgsProcessingModelAlgorithm * >( sipCpp ) != NULL )
      sipType = sipType_QgsProcessingModelAlgorithm;
    else if ( dynamic_cast< QgsProcessingFeatureBasedAlgorithm * >( sipCpp ) != NULL )
      sipType = sipType_QgsProcessingFeatureBasedAlgorithm;
    else
      sipType = sipType_QgsProcessingAlgorithm;
    SIP_END
#endif
 
  public:
 
    enum Flag
    {
      FlagHideFromToolbox = 1 << 1, 
      FlagHideFromModeler = 1 << 2, 
      FlagSupportsBatch = 1 << 3,  
      FlagCanCancel = 1 << 4, 
      FlagRequiresMatchingCrs = 1 << 5, 
      FlagNoThreading = 1 << 6, 
      FlagDisplayNameIsLiteral = 1 << 7, 
      FlagSupportsInPlaceEdits = 1 << 8, 
      FlagKnownIssues = 1 << 9, 
      FlagCustomException = 1 << 10, 
      FlagPruneModelBranchesBasedOnAlgorithmResults = 1 << 11, 
      FlagSkipGenericModelLogging = 1 << 12, 
      FlagDeprecated = FlagHideFromToolbox | FlagHideFromModeler, 
    };
    Q_DECLARE_FLAGS( Flags, Flag )
 
    
    QgsProcessingAlgorithm() = default;
 
    virtual ~QgsProcessingAlgorithm();
 
    QgsProcessingAlgorithm( const QgsProcessingAlgorithm &other ) = delete;
    QgsProcessingAlgorithm &operator=( const QgsProcessingAlgorithm &other ) = delete;
 
    /*
     * IMPORTANT: While it seems like /Factory/ would be the correct annotation here, that's not
     * the case.
     * As per Phil Thomson's advice on https://www.riverbankcomputing.com/pipermail/pyqt/2017-July/039450.html:
     *
     * "
     * /Factory/ is used when the instance returned is guaranteed to be new to Python.
     * In this case it isn't because it has already been seen when being returned by createInstance()
     * (However for a different sub-class implemented in C++ then it would be the first time it was seen
     * by Python so the /Factory/ on create() would be correct.)
     *
     * You might try using /TransferBack/ on create() instead - that might be the best compromise.
     * "
     */
 
    QgsProcessingAlgorithm *create( const QVariantMap &configuration = QVariantMap() ) const SIP_THROW( QgsProcessingException ) SIP_TRANSFERBACK;
 
    virtual QString name() const = 0;
 
    QString id() const;
 
    virtual QString displayName() const = 0;
 
    virtual QString shortDescription() const;
 
    virtual QStringList tags() const { return QStringList(); }
 
    virtual QString shortHelpString() const;
 
    Q_DECL_DEPRECATED virtual QString helpString() const SIP_DEPRECATED;
 
    virtual QString helpUrl() const;
 
    virtual QIcon icon() const;
 
    virtual QString svgIconPath() const;
 
    virtual QString group() const { return QString(); }
 
    virtual QString groupId() const { return QString(); }
 
    virtual Flags flags() const;
 
    virtual bool canExecute( QString *errorMessage SIP_OUT = nullptr ) const;
 
    virtual bool checkParameterValues( const QVariantMap &parameters,
                                       QgsProcessingContext &context, QString *message SIP_OUT = nullptr ) const;
 
    virtual QVariantMap preprocessParameters( const QVariantMap &parameters );
 
    QgsProcessingProvider *provider() const;
 
    QgsProcessingParameterDefinitions parameterDefinitions() const { return mParameters; }
 
    const QgsProcessingParameterDefinition *parameterDefinition( const QString &name ) const;
 
    int countVisibleParameters() const;
 
    QgsProcessingParameterDefinitions destinationParameterDefinitions() const;
 
    QgsProcessingOutputDefinitions outputDefinitions() const { return mOutputs; }
 
    const QgsProcessingOutputDefinition *outputDefinition( const QString &name ) const;
 
    bool hasHtmlOutputs() const;
 
    enum PropertyAvailability
    {
      NotAvailable, 
      Available, 
    };
 
    struct VectorProperties
    {
      QgsFields fields;
 
      QgsWkbTypes::Type wkbType = QgsWkbTypes::Unknown;
 
      QgsCoordinateReferenceSystem crs;
 
      QgsProcessingAlgorithm::PropertyAvailability availability = QgsProcessingAlgorithm::NotAvailable;
    };
 
    virtual QgsProcessingAlgorithm::VectorProperties sinkProperties( const QString &sink,
        const QVariantMap &parameters,
        QgsProcessingContext &context,
        const QMap< QString, QgsProcessingAlgorithm::VectorProperties > &sourceProperties ) const;
 
    QVariantMap run( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback, bool *ok SIP_OUT = nullptr, const QVariantMap &configuration = QVariantMap() ) const;
 
    bool prepare( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback );
 
    QVariantMap runPrepared( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) SIP_THROW( QgsProcessingException );
 
    QVariantMap postProcess( QgsProcessingContext &context, QgsProcessingFeedback *feedback );
 
    virtual QWidget *createCustomParametersWidget( QWidget *parent = nullptr ) const SIP_FACTORY;
 
    virtual QgsExpressionContext createExpressionContext( const QVariantMap &parameters,
        QgsProcessingContext &context, QgsProcessingFeatureSource *source = nullptr ) const;
 
    virtual bool validateInputCrs( const QVariantMap &parameters,
                                   QgsProcessingContext &context ) const;
 
    virtual QString asPythonCommand( const QVariantMap &parameters, QgsProcessingContext &context ) const;
 
    void setProvider( QgsProcessingProvider *provider );
 
  protected:
 
    virtual QgsProcessingAlgorithm *createInstance() const = 0 SIP_FACTORY SIP_VIRTUALERRORHANDLER( processing_exception_handler );
 
    virtual void initAlgorithm( const QVariantMap &configuration = QVariantMap() ) = 0;
 
    bool addParameter( QgsProcessingParameterDefinition *parameterDefinition SIP_TRANSFER, bool createOutput = true );
 
    void removeParameter( const QString &name );
 
    bool addOutput( QgsProcessingOutputDefinition *outputDefinition SIP_TRANSFER );
 
    virtual bool prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) SIP_THROW( QgsProcessingException ) SIP_VIRTUALERRORHANDLER( processing_exception_handler );
 
    virtual QVariantMap processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) SIP_THROW( QgsProcessingException ) = 0 SIP_VIRTUALERRORHANDLER( processing_exception_handler );
 
    virtual QVariantMap postProcessAlgorithm( QgsProcessingContext &context, QgsProcessingFeedback *feedback ) SIP_THROW( QgsProcessingException ) SIP_VIRTUALERRORHANDLER( processing_exception_handler );
 
    QString parameterAsString( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const;
 
    QString parameterAsExpression( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const;
 
    double parameterAsDouble( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const;
 
    int parameterAsInt( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const;
 
    QList<int> parameterAsInts( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const;
 
    int parameterAsEnum( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const;
 
    QList<int> parameterAsEnums( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const;
 
    bool parameterAsBool( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const;
 
    bool parameterAsBoolean( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const;
 
    QgsFeatureSink *parameterAsSink( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, QString &destinationIdentifier SIP_OUT,
                                     const QgsFields &fields, QgsWkbTypes::Type geometryType = QgsWkbTypes::NoGeometry, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem(), QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags() ) const SIP_THROW( QgsProcessingException ) SIP_FACTORY;
 
    QgsProcessingFeatureSource *parameterAsSource( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const SIP_FACTORY;
 
    QString parameterAsCompatibleSourceLayerPath( const QVariantMap &parameters, const QString &name,
        QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = nullptr );
 
    QString parameterAsCompatibleSourceLayerPathAndLayerName( const QVariantMap &parameters, const QString &name,
        QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = nullptr, QString *layerName SIP_OUT = nullptr );
 
    QgsMapLayer *parameterAsLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QgsRasterLayer *parameterAsRasterLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QgsMeshLayer *parameterAsMeshLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
 
    QString parameterAsOutputLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QString parameterAsFileOutput( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QgsVectorLayer *parameterAsVectorLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QgsCoordinateReferenceSystem parameterAsCrs( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QgsRectangle parameterAsExtent( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context,
                                    const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() ) const;
 
    QgsGeometry parameterAsExtentGeometry( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context,
                                           const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
 
    QgsCoordinateReferenceSystem parameterAsExtentCrs( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context );
 
    QgsPointXY parameterAsPoint( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context,
                                 const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() ) const;
 
    QgsCoordinateReferenceSystem parameterAsPointCrs( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context );
 
    QString parameterAsFile( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QVariantList parameterAsMatrix( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QList< QgsMapLayer *> parameterAsLayerList( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QStringList parameterAsFileList( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QList<double> parameterAsRange( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QStringList parameterAsFields( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const;
 
    QgsPrintLayout *parameterAsLayout( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context );
 
    QgsLayoutItem *parameterAsLayoutItem( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, QgsPrintLayout *layout );
 
    QColor parameterAsColor( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context );
 
    QString parameterAsConnectionName( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context );
 
    QString parameterAsSchema( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context );
 
    QString parameterAsDatabaseTableName( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context );
 
    QDateTime parameterAsDateTime( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context );
 
 
    static QString invalidSourceError( const QVariantMap &parameters, const QString &name );
 
    static QString invalidRasterError( const QVariantMap &parameters, const QString &name );
 
    static QString invalidSinkError( const QVariantMap &parameters, const QString &name );
 
    virtual bool supportInPlaceEdit( const QgsMapLayer *layer ) const;
 
  private:
 
    QgsProcessingProvider *mProvider = nullptr;
    QgsProcessingParameterDefinitions mParameters;
    QgsProcessingOutputDefinitions mOutputs;
    bool mHasPrepared = false;
    bool mHasExecuted = false;
    bool mHasPostProcessed = false;
    std::unique_ptr< QgsProcessingContext > mLocalContext;
 
    bool createAutoOutputForParameter( QgsProcessingParameterDefinition *parameter );
 
 
    friend class QgsProcessingProvider;
    friend class TestQgsProcessing;
    friend class QgsProcessingModelAlgorithm;
    friend class QgsProcessingToolboxProxyModel;
 
#ifdef SIP_RUN
    QgsProcessingAlgorithm( const QgsProcessingAlgorithm &other );
#endif
 
};
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingAlgorithm::Flags )
 
 
 
 
class CORE_EXPORT QgsProcessingFeatureBasedAlgorithm : public QgsProcessingAlgorithm
{
  public:
 
    QgsProcessingFeatureBasedAlgorithm() = default;
 
    QgsProcessingAlgorithm::Flags flags() const override;
 
    virtual QgsFeatureList processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) SIP_THROW( QgsProcessingException ) = 0 SIP_VIRTUALERRORHANDLER( processing_exception_handler );
 
  protected:
 
    void initAlgorithm( const QVariantMap &configuration = QVariantMap() ) override;
 
    virtual QString inputParameterName() const;
 
    virtual QString inputParameterDescription() const;
 
    virtual QString outputName() const = 0;
 
    virtual QList<int> inputLayerTypes() const;
 
    virtual QgsProcessing::SourceType outputLayerType() const;
 
    virtual QgsProcessingFeatureSource::Flag sourceFlags() const;
 
    virtual QgsFeatureSink::SinkFlags sinkFlags() const;
 
    virtual QgsWkbTypes::Type outputWkbType( QgsWkbTypes::Type inputWkbType ) const;
 
    virtual QgsFields outputFields( const QgsFields &inputFields ) const;
 
    virtual QgsCoordinateReferenceSystem outputCrs( const QgsCoordinateReferenceSystem &inputCrs ) const;
 
    virtual void initParameters( const QVariantMap &configuration = QVariantMap() );
 
    QgsCoordinateReferenceSystem sourceCrs() const;
 
 
    QVariantMap processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) override SIP_THROW( QgsProcessingException );
 
    virtual QgsFeatureRequest request() const;
 
    bool supportInPlaceEdit( const QgsMapLayer *layer ) const override;
 
    void prepareSource( const QVariantMap &parameters, QgsProcessingContext &context );
 
    QgsProcessingAlgorithm::VectorProperties sinkProperties( const QString &sink,
        const QVariantMap &parameters,
        QgsProcessingContext &context,
        const QMap< QString, QgsProcessingAlgorithm::VectorProperties > &sourceProperties ) const override;
 
  private:
 
    std::unique_ptr< QgsProcessingFeatureSource > mSource;
 
};
 
// clazy:excludeall=qstring-allocations
 
#endif // QGSPROCESSINGALGORITHM_H