mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-11 00:04:09 -04:00
3c1e4fe723
This change adds a new "feature filter" option alongside the existing feature limit and invalid geometry handling options available for all vector inputs to processing layers. It allows users to enter an expression to subset the layer dynamically when running the tool, avoiding the need for separate steps to set layer filters or create layer subsets. Sponsored by City of Canning
4771 lines
164 KiB
Plaintext
4771 lines
164 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/processing/qgsprocessingparameters.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class QgsProcessingFeatureSourceDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
|
|
Encapsulates settings relating to a feature source input to a processing algorithm.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
enum Flag
|
|
{
|
|
FlagOverrideDefaultGeometryCheck,
|
|
FlagCreateIndividualOutputPerInputFeature,
|
|
};
|
|
typedef QFlags<QgsProcessingFeatureSourceDefinition::Flag> Flags;
|
|
|
|
|
|
QgsProcessingFeatureSourceDefinition( const QString &source = QString(), bool selectedFeaturesOnly = false, long long featureLimit = -1,
|
|
QgsProcessingFeatureSourceDefinition::Flags flags = QgsProcessingFeatureSourceDefinition::Flags(), QgsFeatureRequest::InvalidGeometryCheck geometryCheck = QgsFeatureRequest::GeometryAbortOnInvalid, const QString &filterExpression = QString() );
|
|
%Docstring
|
|
Constructor for QgsProcessingFeatureSourceDefinition, accepting a static string ``source``.
|
|
|
|
If ``selectedFeaturesOnly`` is ``True``, then only selected features from the source will be used.
|
|
|
|
The optional ``featureLimit`` can be set to a value > 0 to place a hard limit on the maximum number
|
|
of features which will be read from the source.
|
|
|
|
Since QGIS 3.32, the optional ``filterExpression`` argument can be used to specify a expression to use
|
|
to filter the features read from the source.
|
|
|
|
The ``flags`` argument can be used to specify flags which dictate the source behavior.
|
|
|
|
If the QgsProcessingFeatureSourceDefinition.Flag.FlagOverrideDefaultGeometryCheck is set in ``flags``, then the value of ``geometryCheck`` will override
|
|
the default geometry check method (as dictated by :py:class:`QgsProcessingContext`) for this source.
|
|
%End
|
|
|
|
QgsProcessingFeatureSourceDefinition( const QgsProperty &source, bool selectedFeaturesOnly = false, long long featureLimit = -1,
|
|
QgsProcessingFeatureSourceDefinition::Flags flags = QgsProcessingFeatureSourceDefinition::Flags(), QgsFeatureRequest::InvalidGeometryCheck geometryCheck = QgsFeatureRequest::GeometryAbortOnInvalid, const QString &filterExpression = QString() );
|
|
%Docstring
|
|
Constructor for QgsProcessingFeatureSourceDefinition, accepting a QgsProperty source.
|
|
|
|
If ``selectedFeaturesOnly`` is ``True``, then only selected features from the source will be used.
|
|
|
|
The optional ``featureLimit`` can be set to a value > 0 to place a hard limit on the maximum number
|
|
of features which will be read from the source.
|
|
|
|
Since QGIS 3.32, the optional ``filterExpression`` argument can be used to specify a expression to use
|
|
to filter the features read from the source.
|
|
|
|
The ``flags`` argument can be used to specify flags which dictate the source behavior.
|
|
|
|
If the QgsProcessingFeatureSourceDefinition.Flag.FlagOverrideDefaultGeometryCheck is set in ``flags``, then the value of ``geometryCheck`` will override
|
|
the default geometry check method (as dictated by :py:class:`QgsProcessingContext`) for this source.
|
|
%End
|
|
|
|
QgsProperty source;
|
|
|
|
bool selectedFeaturesOnly;
|
|
|
|
long long featureLimit;
|
|
|
|
QString filterExpression;
|
|
|
|
Flags flags;
|
|
|
|
QgsFeatureRequest::InvalidGeometryCheck geometryCheck;
|
|
|
|
QVariant toVariant() const;
|
|
%Docstring
|
|
Saves this source definition to a QVariantMap, wrapped in a QVariant.
|
|
You can use :py:class:`QgsXmlUtils`.writeVariant to save it to an XML document.
|
|
|
|
.. seealso:: :py:func:`loadVariant`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
bool loadVariant( const QVariantMap &map );
|
|
%Docstring
|
|
Loads this source definition from a QVariantMap, wrapped in a QVariant.
|
|
You can use :py:class:`QgsXmlUtils`.readVariant to load it from an XML document.
|
|
|
|
.. seealso:: :py:func:`toVariant`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
bool operator==( const QgsProcessingFeatureSourceDefinition &other ) const;
|
|
|
|
bool operator!=( const QgsProcessingFeatureSourceDefinition &other ) const;
|
|
|
|
operator QVariant() const;
|
|
|
|
};
|
|
|
|
QFlags<QgsProcessingFeatureSourceDefinition::Flag> operator|(QgsProcessingFeatureSourceDefinition::Flag f1, QFlags<QgsProcessingFeatureSourceDefinition::Flag> f2);
|
|
|
|
|
|
|
|
class QgsProcessingOutputLayerDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
|
|
Encapsulates settings relating to a feature sink or output raster layer for a processing algorithm.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingOutputLayerDefinition( const QString &sink = QString(), QgsProject *destinationProject = 0 );
|
|
%Docstring
|
|
Constructor for QgsProcessingOutputLayerDefinition, accepting a static sink/layer string.
|
|
The ``destinationProject`` parameter can be set to a :py:class:`QgsProject` instance in which
|
|
to automatically load the resulting sink/layer after completing processing.
|
|
%End
|
|
|
|
QgsProcessingOutputLayerDefinition( const QgsProperty &sink, QgsProject *destinationProject = 0 );
|
|
%Docstring
|
|
Constructor for QgsProcessingOutputLayerDefinition, accepting a QgsProperty sink/layer.
|
|
The ``destinationProject`` parameter can be set to a :py:class:`QgsProject` instance in which
|
|
to automatically load the resulting sink/layer after completing processing.
|
|
%End
|
|
|
|
QgsProperty sink;
|
|
|
|
QgsProject *destinationProject;
|
|
|
|
QString destinationName;
|
|
|
|
QVariantMap createOptions;
|
|
|
|
bool useRemapping() const;
|
|
%Docstring
|
|
Returns ``True`` if the output uses a remapping definition.
|
|
|
|
.. seealso:: :py:func:`remappingDefinition`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
QgsRemappingSinkDefinition remappingDefinition() const;
|
|
%Docstring
|
|
Returns the output remapping definition, if :py:func:`~QgsProcessingOutputLayerDefinition.useRemapping` is ``True``.
|
|
|
|
.. seealso:: :py:func:`useRemapping`
|
|
|
|
.. seealso:: :py:func:`setRemappingDefinition`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
void setRemappingDefinition( const QgsRemappingSinkDefinition &definition );
|
|
%Docstring
|
|
Sets the remapping ``definition`` to use when adding features to the output layer.
|
|
|
|
Calling this method will set :py:func:`~QgsProcessingOutputLayerDefinition.useRemapping` to ``True``.
|
|
|
|
.. seealso:: :py:func:`remappingDefinition`
|
|
|
|
.. seealso:: :py:func:`useRemapping`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
QVariant toVariant() const;
|
|
%Docstring
|
|
Saves this output layer definition to a QVariantMap, wrapped in a QVariant.
|
|
You can use :py:class:`QgsXmlUtils`.writeVariant to save it to an XML document.
|
|
|
|
.. seealso:: :py:func:`loadVariant`
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
bool loadVariant( const QVariantMap &map );
|
|
%Docstring
|
|
Loads this output layer definition from a QVariantMap, wrapped in a QVariant.
|
|
You can use :py:class:`QgsXmlUtils`.readVariant to load it from an XML document.
|
|
|
|
.. seealso:: :py:func:`toVariant`
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
operator QVariant() const;
|
|
|
|
bool operator==( const QgsProcessingOutputLayerDefinition &other ) const;
|
|
bool operator!=( const QgsProcessingOutputLayerDefinition &other ) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
|
|
Base class for the definition of processing parameters.
|
|
|
|
Parameter definitions encapsulate properties regarding the behavior of parameters,
|
|
their acceptable ranges, defaults, etc.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameteraggregate.h"
|
|
#include "qgsprocessingparameterdxflayers.h"
|
|
#include "qgsprocessingparameterfieldmap.h"
|
|
#include "qgsprocessingparametertininputlayers.h"
|
|
#include "qgsprocessingparametervectortilewriterlayers.h"
|
|
#include "qgsprocessingparametermeshdataset.h"
|
|
%End
|
|
%ConvertToSubClassCode
|
|
if ( sipCpp->type() == QgsProcessingParameterBoolean::typeName() )
|
|
sipType = sipType_QgsProcessingParameterBoolean;
|
|
else if ( sipCpp->type() == QgsProcessingParameterCrs::typeName() )
|
|
sipType = sipType_QgsProcessingParameterCrs;
|
|
else if ( sipCpp->type() == QgsProcessingParameterMapLayer::typeName() )
|
|
sipType = sipType_QgsProcessingParameterMapLayer;
|
|
else if ( sipCpp->type() == QgsProcessingParameterExtent::typeName() )
|
|
sipType = sipType_QgsProcessingParameterExtent;
|
|
else if ( sipCpp->type() == QgsProcessingParameterPoint::typeName() )
|
|
sipType = sipType_QgsProcessingParameterPoint;
|
|
else if ( sipCpp->type() == QgsProcessingParameterGeometry::typeName() )
|
|
sipType = sipType_QgsProcessingParameterGeometry;
|
|
else if ( sipCpp->type() == QgsProcessingParameterFile::typeName() )
|
|
sipType = sipType_QgsProcessingParameterFile;
|
|
else if ( sipCpp->type() == QgsProcessingParameterMatrix::typeName() )
|
|
sipType = sipType_QgsProcessingParameterMatrix;
|
|
else if ( sipCpp->type() == QgsProcessingParameterMultipleLayers::typeName() )
|
|
sipType = sipType_QgsProcessingParameterMultipleLayers;
|
|
else if ( sipCpp->type() == QgsProcessingParameterNumber::typeName() )
|
|
sipType = sipType_QgsProcessingParameterNumber;
|
|
else if ( sipCpp->type() == QgsProcessingParameterDistance::typeName() )
|
|
sipType = sipType_QgsProcessingParameterDistance;
|
|
else if ( sipCpp->type() == QgsProcessingParameterDuration::typeName() )
|
|
sipType = sipType_QgsProcessingParameterDuration;
|
|
else if ( sipCpp->type() == QgsProcessingParameterScale::typeName() )
|
|
sipType = sipType_QgsProcessingParameterScale;
|
|
else if ( sipCpp->type() == QgsProcessingParameterRange::typeName() )
|
|
sipType = sipType_QgsProcessingParameterRange;
|
|
else if ( sipCpp->type() == QgsProcessingParameterRasterLayer::typeName() )
|
|
sipType = sipType_QgsProcessingParameterRasterLayer;
|
|
else if ( sipCpp->type() == QgsProcessingParameterMeshLayer::typeName() )
|
|
sipType = sipType_QgsProcessingParameterMeshLayer;
|
|
else if ( sipCpp->type() == QgsProcessingParameterEnum::typeName() )
|
|
sipType = sipType_QgsProcessingParameterEnum;
|
|
else if ( sipCpp->type() == QgsProcessingParameterString::typeName() )
|
|
sipType = sipType_QgsProcessingParameterString;
|
|
else if ( sipCpp->type() == QgsProcessingParameterExpression::typeName() )
|
|
sipType = sipType_QgsProcessingParameterExpression;
|
|
else if ( sipCpp->type() == QgsProcessingParameterAuthConfig::typeName() )
|
|
sipType = sipType_QgsProcessingParameterAuthConfig;
|
|
else if ( sipCpp->type() == QgsProcessingParameterVectorLayer::typeName() )
|
|
sipType = sipType_QgsProcessingParameterVectorLayer;
|
|
else if ( sipCpp->type() == QgsProcessingParameterField::typeName() )
|
|
sipType = sipType_QgsProcessingParameterField;
|
|
else if ( sipCpp->type() == QgsProcessingParameterFeatureSource::typeName() )
|
|
sipType = sipType_QgsProcessingParameterFeatureSource;
|
|
else if ( sipCpp->type() == QgsProcessingParameterFeatureSink::typeName() )
|
|
sipType = sipType_QgsProcessingParameterFeatureSink;
|
|
else if ( sipCpp->type() == QgsProcessingParameterVectorDestination::typeName() )
|
|
sipType = sipType_QgsProcessingParameterVectorDestination;
|
|
else if ( sipCpp->type() == QgsProcessingParameterRasterDestination::typeName() )
|
|
sipType = sipType_QgsProcessingParameterRasterDestination;
|
|
else if ( sipCpp->type() == QgsProcessingParameterPointCloudDestination::typeName() )
|
|
sipType = sipType_QgsProcessingParameterPointCloudDestination;
|
|
else if ( sipCpp->type() == QgsProcessingParameterFileDestination::typeName() )
|
|
sipType = sipType_QgsProcessingParameterFileDestination;
|
|
else if ( sipCpp->type() == QgsProcessingParameterFolderDestination::typeName() )
|
|
sipType = sipType_QgsProcessingParameterFolderDestination;
|
|
else if ( sipCpp->type() == QgsProcessingParameterBand::typeName() )
|
|
sipType = sipType_QgsProcessingParameterBand;
|
|
else if ( sipCpp->type() == QgsProcessingParameterLayout::typeName() )
|
|
sipType = sipType_QgsProcessingParameterLayout;
|
|
else if ( sipCpp->type() == QgsProcessingParameterLayoutItem::typeName() )
|
|
sipType = sipType_QgsProcessingParameterLayoutItem;
|
|
else if ( sipCpp->type() == QgsProcessingParameterColor::typeName() )
|
|
sipType = sipType_QgsProcessingParameterColor;
|
|
else if ( sipCpp->type() == QgsProcessingParameterCoordinateOperation::typeName() )
|
|
sipType = sipType_QgsProcessingParameterCoordinateOperation;
|
|
else if ( sipCpp->type() == QgsProcessingParameterMapTheme::typeName() )
|
|
sipType = sipType_QgsProcessingParameterMapTheme;
|
|
else if ( sipCpp->type() == QgsProcessingParameterDateTime::typeName() )
|
|
sipType = sipType_QgsProcessingParameterDateTime;
|
|
else if ( sipCpp->type() == QgsProcessingParameterProviderConnection::typeName() )
|
|
sipType = sipType_QgsProcessingParameterProviderConnection;
|
|
else if ( sipCpp->type() == QgsProcessingParameterDatabaseSchema::typeName() )
|
|
sipType = sipType_QgsProcessingParameterDatabaseSchema;
|
|
else if ( sipCpp->type() == QgsProcessingParameterDatabaseTable::typeName() )
|
|
sipType = sipType_QgsProcessingParameterDatabaseTable;
|
|
else if ( sipCpp->type() == QgsProcessingParameterFieldMapping::typeName() )
|
|
sipType = sipType_QgsProcessingParameterFieldMapping;
|
|
else if ( sipCpp->type() == QgsProcessingParameterTinInputLayers::typeName() )
|
|
sipType = sipType_QgsProcessingParameterTinInputLayers;
|
|
else if ( sipCpp->type() == QgsProcessingParameterVectorTileWriterLayers::typeName() )
|
|
sipType = sipType_QgsProcessingParameterVectorTileWriterLayers;
|
|
else if ( sipCpp->type() == QgsProcessingParameterDxfLayers::typeName() )
|
|
sipType = sipType_QgsProcessingParameterDxfLayers;
|
|
else if ( sipCpp->type() == QgsProcessingParameterMeshDatasetGroups::typeName() )
|
|
sipType = sipType_QgsProcessingParameterMeshDatasetGroups;
|
|
else if ( sipCpp->type() == QgsProcessingParameterMeshDatasetTime::typeName() )
|
|
sipType = sipType_QgsProcessingParameterMeshDatasetTime;
|
|
else if ( sipCpp->type() == QgsProcessingParameterPointCloudLayer::typeName() )
|
|
sipType = sipType_QgsProcessingParameterPointCloudLayer;
|
|
else if ( sipCpp->type() == QgsProcessingParameterAnnotationLayer::typeName() )
|
|
sipType = sipType_QgsProcessingParameterAnnotationLayer;
|
|
else
|
|
sipType = nullptr;
|
|
%End
|
|
public:
|
|
|
|
enum Flag
|
|
{
|
|
FlagAdvanced,
|
|
FlagHidden,
|
|
FlagOptional,
|
|
FlagIsModelOutput,
|
|
};
|
|
typedef QFlags<QgsProcessingParameterDefinition::Flag> Flags;
|
|
|
|
|
|
QgsProcessingParameterDefinition( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false, const QString &help = QString() );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterDefinition.
|
|
%End
|
|
|
|
virtual ~QgsProcessingParameterDefinition();
|
|
|
|
virtual QgsProcessingParameterDefinition *clone() const = 0 /Factory/;
|
|
%Docstring
|
|
Creates a clone of the parameter definition.
|
|
%End
|
|
|
|
virtual QString type() const = 0;
|
|
%Docstring
|
|
Unique parameter type name.
|
|
%End
|
|
|
|
virtual bool isDestination() const;
|
|
%Docstring
|
|
Returns ``True`` if this parameter represents a file or layer destination, e.g. parameters
|
|
which are used for the destination for layers output by an algorithm will return
|
|
``True``.
|
|
%End
|
|
|
|
QString name() const;
|
|
%Docstring
|
|
Returns the name of the parameter. This is the internal identifier by which
|
|
algorithms access this parameter.
|
|
|
|
.. seealso:: :py:func:`setName`
|
|
%End
|
|
|
|
void setName( const QString &name );
|
|
%Docstring
|
|
Sets the ``name`` of the parameter. This is the internal identifier by which
|
|
algorithms access this parameter.
|
|
|
|
.. seealso:: :py:func:`name`
|
|
%End
|
|
|
|
QString description() const;
|
|
%Docstring
|
|
Returns the description for the parameter. This is the user-visible string
|
|
used to identify this parameter.
|
|
|
|
.. seealso:: :py:func:`setDescription`
|
|
%End
|
|
|
|
void setDescription( const QString &description );
|
|
%Docstring
|
|
Sets the ``description`` for the parameter. This is the user-visible string
|
|
used to identify this parameter.
|
|
|
|
.. seealso:: :py:func:`description`
|
|
%End
|
|
|
|
QString help() const;
|
|
%Docstring
|
|
Returns the help for the parameter.
|
|
|
|
This is a descriptive (possibly lengthy), translated string explaining
|
|
the parameter's behavior and use in depth.
|
|
|
|
.. seealso:: :py:func:`setHelp`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
void setHelp( const QString &help );
|
|
%Docstring
|
|
Sets the ``help`` for the parameter.
|
|
|
|
The ``help`` string should be a descriptive, translated string explaining
|
|
the parameter's behavior and use in depth.
|
|
|
|
.. seealso:: :py:func:`help`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
QVariant defaultValue() const;
|
|
%Docstring
|
|
Returns the default value for the parameter.
|
|
|
|
.. seealso:: :py:func:`setDefaultValue`
|
|
|
|
.. seealso:: :py:func:`defaultValueForGui`
|
|
|
|
.. seealso:: :py:func:`guiDefaultValueOverride`
|
|
%End
|
|
|
|
void setDefaultValue( const QVariant &value );
|
|
%Docstring
|
|
Sets the default ``value`` for the parameter. Caller takes responsibility
|
|
to ensure that ``value`` is a valid input for the parameter subclass.
|
|
|
|
.. seealso:: :py:func:`defaultValue`
|
|
|
|
.. seealso:: :py:func:`setGuiDefaultValueOverride`
|
|
%End
|
|
|
|
QVariant guiDefaultValueOverride() const;
|
|
%Docstring
|
|
Returns the default value to use in the GUI for the parameter.
|
|
|
|
Usually this will return an invalid variant, which indicates that the standard :py:func:`~QgsProcessingParameterDefinition.defaultValue`
|
|
will be used in the GUI.
|
|
|
|
.. seealso:: :py:func:`defaultValue`
|
|
|
|
.. seealso:: :py:func:`setGuiDefaultValueOverride`
|
|
|
|
.. seealso:: :py:func:`defaultValueForGui`
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
void setGuiDefaultValueOverride( const QVariant &value );
|
|
%Docstring
|
|
Sets the default ``value`` to use for the parameter in GUI widgets. Caller takes responsibility
|
|
to ensure that ``value`` is a valid input for the parameter subclass.
|
|
|
|
Usually the :py:func:`~QgsProcessingParameterDefinition.guiDefaultValueOverride` is a invalid variant, which indicates that the standard :py:func:`~QgsProcessingParameterDefinition.defaultValue`
|
|
should be used in the GUI. In cases where it is decided that a previous default value was inappropriate,
|
|
setting a non-invalid default GUI value can be used to change the default value for the parameter shown
|
|
to users when running algorithms without changing the actual :py:func:`~QgsProcessingParameterDefinition.defaultValue` and potentially breaking
|
|
third party scripts.
|
|
|
|
.. seealso:: :py:func:`guiDefaultValueOverride`
|
|
|
|
.. seealso:: :py:func:`setDefaultValue`
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
QVariant defaultValueForGui() const;
|
|
%Docstring
|
|
Returns the default value to use for the parameter in a GUI.
|
|
|
|
This will be the parameter's :py:func:`~QgsProcessingParameterDefinition.defaultValue`, unless a :py:func:`~QgsProcessingParameterDefinition.guiDefaultValueOverride` is set to
|
|
override that.
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
Flags flags() const;
|
|
%Docstring
|
|
Returns any flags associated with the parameter.
|
|
|
|
.. seealso:: :py:func:`setFlags`
|
|
%End
|
|
|
|
void setFlags( Flags flags );
|
|
%Docstring
|
|
Sets the ``flags`` associated with the parameter.
|
|
|
|
.. seealso:: :py:func:`flags`
|
|
%End
|
|
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
%Docstring
|
|
Checks whether the specified ``input`` value is acceptable for the
|
|
parameter. Returns ``True`` if the value can be accepted.
|
|
The optional ``context`` parameter can be specified to allow a more stringent
|
|
check to be performed, capable of checking for the presence of required
|
|
layers and other factors within the context.
|
|
%End
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
%Docstring
|
|
Returns a string version of the parameter input ``value``, which is suitable for use as an input
|
|
parameter value when running an algorithm directly from a Python command.
|
|
|
|
.. seealso:: :py:func:`valueAsJsonObject`
|
|
|
|
.. seealso:: :py:func:`valueAsString`
|
|
%End
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
%Docstring
|
|
Returns a version of the parameter input ``value``, which is suitable for use in a JSON object.
|
|
|
|
This method must return only simple values which can be losslessly encapsulated in a serialized
|
|
JSON map. For instance, any QGIS class values (such as :py:class:`QgsCoordinateReferenceSystem`) must be
|
|
converted to a simple string or numeric value equivalent.
|
|
|
|
.. seealso:: :py:func:`valueAsPythonString`
|
|
|
|
.. seealso:: :py:func:`valueAsString`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
%Docstring
|
|
Returns a string version of the parameter input ``value`` (if possible).
|
|
|
|
:param value: value to convert
|
|
:param context: processing context
|
|
|
|
:return: - value converted to string
|
|
- ok: will be set to ``True`` if value could be represented as a string.
|
|
|
|
.. seealso:: :py:func:`valueAsStringList`
|
|
|
|
.. seealso:: :py:func:`valueAsJsonObject`
|
|
|
|
.. seealso:: :py:func:`valueAsPythonString`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
virtual QStringList valueAsStringList( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
%Docstring
|
|
Returns a string list version of the parameter input ``value`` (if possible).
|
|
|
|
:param value: value to convert
|
|
:param context: processing context
|
|
|
|
:return: - value converted to string list
|
|
- ok: will be set to ``True`` if value could be represented as a string list
|
|
|
|
.. seealso:: :py:func:`valueAsString`
|
|
|
|
.. seealso:: :py:func:`valueAsJsonObject`
|
|
|
|
.. seealso:: :py:func:`valueAsPythonString`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
virtual QString valueAsPythonComment( const QVariant &value, QgsProcessingContext &context ) const;
|
|
%Docstring
|
|
Returns a Python comment explaining a parameter ``value``, or an empty string if no comment is required.
|
|
|
|
.. versionadded:: 3.20
|
|
%End
|
|
|
|
virtual QString asScriptCode() const;
|
|
%Docstring
|
|
Returns the parameter definition encoded in a string which can be used within a
|
|
Processing script.
|
|
%End
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
%Docstring
|
|
Returns the parameter definition as a Python command which can be used within a
|
|
Python Processing script.
|
|
|
|
The ``outputType`` argument specifies the desired output format for the Python string,
|
|
i.e. the intended end use of the generated Python code.
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
%Docstring
|
|
Saves this parameter to a QVariantMap. Subclasses should ensure that they call the base class
|
|
method and then extend the result with additional properties.
|
|
|
|
.. seealso:: :py:func:`fromVariantMap`
|
|
%End
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
%Docstring
|
|
Restores this parameter to a QVariantMap. Subclasses should ensure that they call the base class
|
|
method.
|
|
|
|
.. seealso:: :py:func:`toVariantMap`
|
|
%End
|
|
|
|
|
|
QVariantMap &metadata();
|
|
%Docstring
|
|
Returns the parameter's freeform metadata. This is mostly used by parameter widget wrappers
|
|
in order to customize their appearance and behavior.
|
|
|
|
.. seealso:: :py:func:`setMetadata`
|
|
%End
|
|
|
|
void setMetadata( const QVariantMap &metadata );
|
|
%Docstring
|
|
Sets the parameter's freeform ``metadata``. This is mostly used by parameter widget wrappers
|
|
in order to customize their appearance and behavior.
|
|
|
|
.. seealso:: :py:func:`metadata`
|
|
%End
|
|
|
|
virtual QStringList dependsOnOtherParameters() const;
|
|
%Docstring
|
|
Returns a list of other parameter names on which this parameter is dependent (e.g.
|
|
field parameters which depend on a parent layer parameter).
|
|
%End
|
|
|
|
QgsProcessingAlgorithm *algorithm() const;
|
|
%Docstring
|
|
Returns a pointer to the algorithm which owns this parameter. May be ``None``
|
|
for non-owned parameters.
|
|
|
|
.. seealso:: :py:func:`provider`
|
|
%End
|
|
|
|
QgsProcessingProvider *provider() const;
|
|
%Docstring
|
|
Returns a pointer to the provider for the algorithm which owns this parameter. May be ``None``
|
|
for non-owned parameters or algorithms.
|
|
|
|
.. seealso:: :py:func:`algorithm`
|
|
%End
|
|
|
|
virtual QString toolTip() const;
|
|
%Docstring
|
|
Returns a formatted tooltip for use with the parameter, which gives helpful information
|
|
like parameter description, ID, and extra content like default values (depending on parameter type).
|
|
%End
|
|
|
|
bool isDynamic() const;
|
|
%Docstring
|
|
Returns ``True`` if the parameter supports is dynamic, and can support data-defined values
|
|
(i.e. :py:class:`QgsProperty` based values).
|
|
|
|
.. seealso:: :py:func:`setIsDynamic`
|
|
|
|
.. seealso:: :py:func:`dynamicPropertyDefinition`
|
|
|
|
.. seealso:: :py:func:`dynamicLayerParameterName`
|
|
%End
|
|
|
|
void setIsDynamic( bool dynamic );
|
|
%Docstring
|
|
Sets whether the parameter is ``dynamic``, and can support data-defined values
|
|
(i.e. :py:class:`QgsProperty` based values).
|
|
|
|
.. seealso:: :py:func:`isDynamic`
|
|
|
|
.. seealso:: :py:func:`setDynamicPropertyDefinition`
|
|
|
|
.. seealso:: :py:func:`setDynamicLayerParameterName`
|
|
%End
|
|
|
|
QgsPropertyDefinition dynamicPropertyDefinition() const;
|
|
%Docstring
|
|
Returns the property definition for dynamic properties.
|
|
|
|
.. seealso:: :py:func:`isDynamic`
|
|
|
|
.. seealso:: :py:func:`setDynamicPropertyDefinition`
|
|
|
|
.. seealso:: :py:func:`dynamicLayerParameterName`
|
|
%End
|
|
|
|
void setDynamicPropertyDefinition( const QgsPropertyDefinition &definition );
|
|
%Docstring
|
|
Sets the property ``definition`` for dynamic properties.
|
|
|
|
.. seealso:: :py:func:`isDynamic`
|
|
|
|
.. seealso:: :py:func:`dynamicPropertyDefinition`
|
|
|
|
.. seealso:: :py:func:`setDynamicLayerParameterName`
|
|
%End
|
|
|
|
QString dynamicLayerParameterName() const;
|
|
%Docstring
|
|
Returns the name of the parameter for a layer linked to a dynamic parameter, or an empty string if this is not set.
|
|
|
|
Dynamic parameters (see :py:func:`~QgsProcessingParameterDefinition.isDynamic`) can have an optional vector layer parameter linked to them,
|
|
which indicates which layer the fields and values will be available from when evaluating
|
|
the dynamic parameter.
|
|
|
|
.. seealso:: :py:func:`setDynamicLayerParameterName`
|
|
|
|
.. seealso:: :py:func:`isDynamic`
|
|
|
|
.. seealso:: :py:func:`dynamicPropertyDefinition`
|
|
%End
|
|
|
|
void setDynamicLayerParameterName( const QString &name );
|
|
%Docstring
|
|
Sets the ``name`` for the parameter for a layer linked to a dynamic parameter, or an empty string if this is not set.
|
|
|
|
Dynamic parameters (see :py:func:`~QgsProcessingParameterDefinition.isDynamic`) can have an optional vector layer parameter linked to them,
|
|
which indicates which layer the fields and values will be available from when evaluating
|
|
the dynamic parameter.
|
|
|
|
.. seealso:: :py:func:`dynamicLayerParameterName`
|
|
|
|
.. seealso:: :py:func:`isDynamic`
|
|
|
|
.. seealso:: :py:func:`setDynamicPropertyDefinition`
|
|
%End
|
|
|
|
QStringList additionalExpressionContextVariables() const;
|
|
%Docstring
|
|
Returns a list of additional expression context variables which are available for use when evaluating
|
|
this parameter.
|
|
|
|
The additional variables will be added to the variables exposed from the usual expression
|
|
context available to the parameter. They can be used to expose variables which are ONLY available
|
|
to this parameter.
|
|
|
|
The returned list should contain the variable names only, without the usual "@" prefix.
|
|
|
|
.. seealso:: :py:func:`setAdditionalExpressionContextVariables`
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
void setAdditionalExpressionContextVariables( const QStringList &variables );
|
|
%Docstring
|
|
Sets a list of additional expression context ``variables`` which are available for use when evaluating
|
|
this parameter.
|
|
|
|
The additional variables will be added to the variables exposed from the usual expression
|
|
context available to the parameter. They can be used to expose variables which are ONLY available
|
|
to this parameter.
|
|
|
|
The ``variables`` list should contain the variable names only, without the usual "@" prefix.
|
|
|
|
.. note::
|
|
|
|
Specifying variables via this method is for metadata purposes only. It is the algorithm's responsibility
|
|
to correctly set the value of these additional variables in all expression context used when evaluating the parameter,
|
|
in whichever way is appropriate for that particular variable.
|
|
|
|
.. seealso:: :py:func:`additionalExpressionContextVariables`
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
|
|
protected:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
QFlags<QgsProcessingParameterDefinition::Flag> operator|(QgsProcessingParameterDefinition::Flag f1, QFlags<QgsProcessingParameterDefinition::Flag> f2);
|
|
|
|
|
|
|
|
typedef QList< const QgsProcessingParameterDefinition * > QgsProcessingParameterDefinitions;
|
|
|
|
|
|
class QgsProcessingParameters
|
|
{
|
|
%Docstring(signature="appended")
|
|
|
|
A collection of utilities for working with parameters when running a processing algorithm.
|
|
|
|
Parameters are stored in a QVariantMap and referenced by a unique string key.
|
|
The QVariants in parameters are not usually accessed
|
|
directly, and instead the high level API provided through :py:class:`QgsProcessingParameters`
|
|
:py:func:`~QgsProcessingParameterDefinition.parameterAsString`, :py:func:`~QgsProcessingParameterDefinition.parameterAsDouble` are used instead.
|
|
|
|
Parameters are evaluated using a provided :py:class:`QgsProcessingContext`, allowing
|
|
the evaluation to understand available map layers and expression contexts
|
|
(for expression based parameters).
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
static bool isDynamic( const QVariantMap ¶meters, const QString &name );
|
|
%Docstring
|
|
Returns ``True`` if the parameter with matching ``name`` is a dynamic parameter, and must
|
|
be evaluated once for every input feature processed.
|
|
%End
|
|
|
|
static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a static string value.
|
|
%End
|
|
|
|
static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a static string value.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to an expression.
|
|
%End
|
|
|
|
static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definitionand`` ``value`` to an expression.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a static double value.
|
|
%End
|
|
|
|
static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a static double value.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a static integer value.
|
|
%End
|
|
|
|
static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a static integer value.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QList<int> parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a list of integer values.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QList<int> parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a list of integer values.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QDateTime parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a static datetime value.
|
|
|
|
.. seealso:: :py:func:`parameterAsDate`
|
|
|
|
.. seealso:: :py:func:`parameterAsTime`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QDateTime parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a static datetime value.
|
|
|
|
.. seealso:: :py:func:`parameterAsDate`
|
|
|
|
.. seealso:: :py:func:`parameterAsTime`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QDate parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a static date value.
|
|
|
|
.. seealso:: :py:func:`parameterAsDateTime`
|
|
|
|
.. seealso:: :py:func:`parameterAsTime`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QDate parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a static date value.
|
|
|
|
.. seealso:: :py:func:`parameterAsDateTime`
|
|
|
|
.. seealso:: :py:func:`parameterAsTime`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QTime parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a static time value.
|
|
|
|
.. seealso:: :py:func:`parameterAsDateTime`
|
|
|
|
.. seealso:: :py:func:`parameterAsDate`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QTime parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a static time value.
|
|
|
|
.. seealso:: :py:func:`parameterAsDateTime`
|
|
|
|
.. seealso:: :py:func:`parameterAsDate`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a enum value.
|
|
%End
|
|
|
|
static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a enum value.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to list of enum values.
|
|
%End
|
|
|
|
static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to list of enum values.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QString parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a static enum string.
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
static QString parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a static enum string.
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
static QStringList parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to list of static enum strings.
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
static QStringList parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to list of static enum strings.
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a static boolean value.
|
|
%End
|
|
|
|
static bool parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a static boolean value.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a static boolean value.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static bool parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a static boolean value.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
static QgsFeatureSink *parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters,
|
|
const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs,
|
|
QgsProcessingContext &context, QString &destinationIdentifier /Out/, QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(), const QVariantMap &createOptions = QVariantMap(), const QStringList &datasourceOptions = QStringList(), const QStringList &layerOptions = QStringList() ) /Factory/;
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a feature sink.
|
|
|
|
The ``fields``, ``geometryType`` and ``crs`` parameters dictate the properties
|
|
of the resulting feature sink.
|
|
|
|
Sinks will either be taken from ``context``'s active project, or created from external
|
|
providers and stored temporarily in the ``context``. The ``destinationIdentifier``
|
|
argument will be set to a string which can be used to retrieve the layer corresponding
|
|
to the sink, e.g. via calling :py:func:`QgsProcessingUtils.mapLayerFromString()`.
|
|
|
|
The ``createOptions`` argument is used to pass on creation options such as layer name.
|
|
|
|
The ``datasourceOptions`` and ``layerOptions`` arguments is used to pass on GDAL-specific format driver options.
|
|
|
|
This function creates a new object and the caller takes responsibility for deleting the returned object.
|
|
%End
|
|
|
|
static QgsFeatureSink *parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariant &value,
|
|
const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs,
|
|
QgsProcessingContext &context, QString &destinationIdentifier /Out/, QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(), const QVariantMap &createOptions = QVariantMap(), const QStringList &datasourceOptions = QStringList(), const QStringList &layerOptions = QStringList() ) throw( QgsProcessingException ) /Factory/;
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a feature sink.
|
|
|
|
The ``fields``, ``geometryType`` and ``crs`` parameters dictate the properties
|
|
of the resulting feature sink.
|
|
|
|
Sinks will either be taken from ``context``'s active project, or created from external
|
|
providers and stored temporarily in the ``context``. The ``destinationIdentifier``
|
|
argument will be set to a string which can be used to retrieve the layer corresponding
|
|
to the sink, e.g. via calling :py:func:`QgsProcessingUtils.mapLayerFromString()`.
|
|
|
|
The ``createOptions`` argument is used to pass on creation options such as layer name.
|
|
|
|
The ``datasourceOptions`` and ``layerOptions`` arguments is used to pass on GDAL-specific format driver options.
|
|
|
|
This function creates a new object and the caller takes responsibility for deleting the returned object.
|
|
|
|
:raises QgsProcessingException:
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context ) /Factory/;
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a feature source.
|
|
|
|
Sources will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``.
|
|
|
|
This function creates a new object and the caller takes responsibility for deleting the returned object.
|
|
%End
|
|
|
|
static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) /Factory/;
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a feature source.
|
|
|
|
Sources will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``.
|
|
|
|
This function creates a new object and the caller takes responsibility for deleting the returned object.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QString parameterAsCompatibleSourceLayerPath( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters,
|
|
QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = 0 );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a source vector layer file path of compatible format.
|
|
|
|
If the parameter is evaluated to an existing layer, and that layer is not of the format listed in the
|
|
``compatibleFormats`` argument, then the layer will first be exported to a compatible format
|
|
in a temporary location. The function will then return the path to that temporary file.
|
|
|
|
``compatibleFormats`` should consist entirely of lowercase file extensions, e.g. 'shp'.
|
|
|
|
The ``preferredFormat`` argument is used to specify to desired file extension to use when a temporary
|
|
layer export is required. This defaults to shapefiles, because shapefiles are the future (don't believe the geopackage hype!).
|
|
|
|
When an algorithm is capable of handling multi-layer input files (such as Geopackage), it is preferable
|
|
to use :py:func:`~QgsProcessingParameters.parameterAsCompatibleSourceLayerPathAndLayerName` which may avoid conversion in more situations.
|
|
%End
|
|
|
|
static QString parameterAsCompatibleSourceLayerPathAndLayerName( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters,
|
|
QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = 0, QString *layerName /Out/ = 0 );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a source vector layer file path and layer name of compatible format.
|
|
|
|
If the parameter is evaluated to an existing layer, and that layer is not of the format listed in the
|
|
``compatibleFormats`` argument, then the layer will first be exported to a compatible format
|
|
in a temporary location. The function will then return the path to that temporary file.
|
|
|
|
``compatibleFormats`` should consist entirely of lowercase file extensions, e.g. 'shp'.
|
|
|
|
The ``preferredFormat`` argument is used to specify to desired file extension to use when a temporary
|
|
layer export is required. This defaults to shapefiles, because shapefiles are the future (don't believe the geopackage hype!).
|
|
|
|
This method should be preferred over :py:func:`~QgsProcessingParameters.parameterAsCompatibleSourceLayerPath` when an algorithm is able
|
|
to correctly handle files with multiple layers. Unlike :py:func:`~QgsProcessingParameters.parameterAsCompatibleSourceLayerPath`, it will not force
|
|
a conversion in this case and will return the target layer name in the ``layerName`` argument.
|
|
|
|
:param definition: associated parameter definition
|
|
:param parameters: input parameter value map
|
|
:param context: processing context
|
|
:param compatibleFormats: a list of lowercase file extensions compatible with the algorithm
|
|
:param preferredFormat: preferred format extension to use if conversion if required
|
|
:param feedback: feedback object
|
|
|
|
:return: - path to source layer, or nearly converted compatible layer
|
|
- layerName: will be set to the target layer name for multi-layer sources (e.g. Geopackage)
|
|
|
|
|
|
.. seealso:: :py:func:`parameterAsCompatibleSourceLayerPath`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QgsMapLayer *parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint = QgsProcessingUtils::LayerHint::UnknownType );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a map layer.
|
|
|
|
Layers will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``. In either case, callers do not
|
|
need to handle deletion of the returned layer.
|
|
%End
|
|
|
|
static QgsMapLayer *parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint = QgsProcessingUtils::LayerHint::UnknownType );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a map layer.
|
|
|
|
Layers will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``. In either case, callers do not
|
|
need to handle deletion of the returned layer.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a raster layer.
|
|
|
|
Layers will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``. In either case, callers do not
|
|
need to handle deletion of the returned layer.
|
|
%End
|
|
|
|
static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a raster layer.
|
|
|
|
Layers will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``. In either case, callers do not
|
|
need to handle deletion of the returned layer.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a output layer destination.
|
|
%End
|
|
|
|
static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a output layer destination.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a file based output destination.
|
|
%End
|
|
|
|
static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a file based output destination.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a vector layer.
|
|
|
|
Layers will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``. In either case, callers do not
|
|
need to handle deletion of the returned layer.
|
|
%End
|
|
|
|
static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a vector layer.
|
|
|
|
Layers will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``. In either case, callers do not
|
|
need to handle deletion of the returned layer.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QgsMeshLayer *parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a mesh layer.
|
|
|
|
Layers will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``. In either case, callers do not
|
|
need to handle deletion of the returned layer.
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
static QgsMeshLayer *parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a mesh layer.
|
|
|
|
Layers will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``. In either case, callers do not
|
|
need to handle deletion of the returned layer.
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a coordinate reference system.
|
|
%End
|
|
|
|
static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a coordinate reference system.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QgsRectangle parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context,
|
|
const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a rectangular extent.
|
|
|
|
If ``crs`` is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically
|
|
reprojected so that it is in the specified ``crs``. In this case the extent of the reproject rectangle will be returned.
|
|
|
|
.. seealso:: :py:func:`parameterAsExtentGeometry`
|
|
|
|
.. seealso:: :py:func:`parameterAsExtentCrs`
|
|
%End
|
|
|
|
static QgsRectangle parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context,
|
|
const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a rectangular extent.
|
|
|
|
If ``crs`` is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically
|
|
reprojected so that it is in the specified ``crs``. In this case the extent of the reproject rectangle will be returned.
|
|
|
|
.. seealso:: :py:func:`parameterAsExtentGeometry`
|
|
|
|
.. seealso:: :py:func:`parameterAsExtentCrs`
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QgsGeometry parameterAsExtentGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context,
|
|
const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a rectangular extent, and returns a geometry covering this extent.
|
|
|
|
If ``crs`` is set, and the original coordinate reference system of the parameter can be determined, then the extent will be automatically
|
|
reprojected so that it is in the specified ``crs``. Unlike :py:func:`~QgsProcessingParameters.parameterAsExtent`, the reprojected rectangle returned by this function
|
|
will no longer be a rectangle itself (i.e. this method returns the geometry of the actual reprojected rectangle, while :py:func:`~QgsProcessingParameters.parameterAsExtent` returns
|
|
just the extent of the reprojected rectangle).
|
|
|
|
.. seealso:: :py:func:`parameterAsExtent`
|
|
|
|
.. seealso:: :py:func:`parameterAsExtentCrs`
|
|
%End
|
|
|
|
static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Returns the coordinate reference system associated with an extent parameter value.
|
|
|
|
.. seealso:: :py:func:`parameterAsExtent`
|
|
%End
|
|
|
|
static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Returns the coordinate reference system associated with an extent parameter value.
|
|
|
|
.. seealso:: :py:func:`parameterAsExtent`
|
|
%End
|
|
|
|
|
|
static QgsPointXY parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context,
|
|
const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a point.
|
|
|
|
If ``crs`` is set then the point will be automatically reprojected so that it is in the specified ``crs``.
|
|
|
|
.. seealso:: :py:func:`parameterAsPointCrs`
|
|
%End
|
|
|
|
static QgsPointXY parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context,
|
|
const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a point.
|
|
|
|
If ``crs`` is set then the point will be automatically reprojected so that it is in the specified ``crs``.
|
|
|
|
.. seealso:: :py:func:`parameterAsPointCrs`
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Returns the coordinate reference system associated with an point parameter value.
|
|
|
|
.. seealso:: :py:func:`parameterAsPoint`
|
|
%End
|
|
|
|
static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Returns the coordinate reference system associated with an point parameter value.
|
|
|
|
.. seealso:: :py:func:`parameterAsPoint`
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
static QgsGeometry parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a geometry.
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
static QgsGeometry parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a geometry.
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
static QgsCoordinateReferenceSystem parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Returns the coordinate reference system associated with a geometry parameter value.
|
|
|
|
.. seealso:: :py:func:`parameterAsGeometry`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
static QgsCoordinateReferenceSystem parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Returns the coordinate reference system associated with an point parameter value.
|
|
|
|
.. seealso:: :py:func:`parameterAsGeometry`
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a file/folder name.
|
|
%End
|
|
|
|
static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a file/folder name.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a matrix/table of values.
|
|
Tables are collapsed to a 1 dimensional list.
|
|
%End
|
|
|
|
static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a matrix/table of values.
|
|
Tables are collapsed to a 1 dimensional list.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QList< QgsMapLayer *> parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a list of map layers.
|
|
%End
|
|
|
|
static QList< QgsMapLayer *> parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a list of map layers.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QStringList parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a list of files (for :py:class:`QgsProcessingParameterMultipleLayers` in :py:class:`QgsProcessing`:TypeFile mode).
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QStringList parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a list of files (for :py:class:`QgsProcessingParameterMultipleLayers` in :py:class:`QgsProcessing`:TypeFile mode).
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a range of values.
|
|
%End
|
|
|
|
static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a range of values.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a list of fields.
|
|
%End
|
|
|
|
static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a list of fields.
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
static QgsPrintLayout *parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a print layout.
|
|
|
|
.. warning::
|
|
|
|
This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
|
|
implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
static QgsPrintLayout *parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a print layout.
|
|
|
|
.. warning::
|
|
|
|
This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
|
|
implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
static QgsLayoutItem *parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context, QgsPrintLayout *layout );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a print layout item, taken from the specified ``layout``.
|
|
|
|
.. warning::
|
|
|
|
This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
|
|
implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
static QgsLayoutItem *parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsPrintLayout *layout );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a print layout, taken from the specified ``layout``.
|
|
|
|
.. warning::
|
|
|
|
This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
|
|
implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
static QColor parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Returns the color associated with an point parameter value, or an invalid color if the parameter was not set.
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QColor parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Returns the color associated with an color parameter value, or an invalid color if the parameter was not set.
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QString parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a connection name string.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QString parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a connection name string.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QString parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a database schema name.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QString parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a database schema name.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QString parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a database table name.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QString parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a database table name.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static QgsPointCloudLayer *parameterAsPointCloudLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to a point cloud layer.
|
|
|
|
Layers will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``. In either case, callers do not
|
|
need to handle deletion of the returned layer.
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
static QgsPointCloudLayer *parameterAsPointCloudLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to a point cloud layer.
|
|
|
|
Layers will either be taken from ``context``'s active project, or loaded from external
|
|
sources and stored temporarily in the ``context``. In either case, callers do not
|
|
need to handle deletion of the returned layer.
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
static QgsAnnotationLayer *parameterAsAnnotationLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap ¶meters, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` to an annotation layer.
|
|
|
|
Layers will be taken from ``context``'s active project. Callers do not
|
|
need to handle deletion of the returned layer.
|
|
|
|
.. warning::
|
|
|
|
Working with annotation layers is generally not thread safe (unless the layers are from
|
|
a :py:class:`QgsProject` loaded directly in a background thread). Ensure your algorithm returns the
|
|
:py:class:`QgsProcessingAlgorithm`.FlagNoThreading flag or only accesses annotation layers from a :py:func:`~QgsProcessingParameters.prepareAlgorithm`
|
|
or :py:func:`~QgsProcessingParameters.postProcessAlgorithm` step.
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
static QgsAnnotationLayer *parameterAsAnnotationLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
|
|
%Docstring
|
|
Evaluates the parameter with matching ``definition`` and ``value`` to an annotation layer.
|
|
|
|
Layers will be taken from ``context``'s active project. Callers do not
|
|
need to handle deletion of the returned layer.
|
|
|
|
.. warning::
|
|
|
|
Working with annotation layers is generally not thread safe (unless the layers are from
|
|
a :py:class:`QgsProject` loaded directly in a background thread). Ensure your algorithm returns the
|
|
:py:class:`QgsProcessingAlgorithm`.FlagNoThreading flag or only accesses annotation layers from a :py:func:`~QgsProcessingParameters.prepareAlgorithm`
|
|
or :py:func:`~QgsProcessingParameters.postProcessAlgorithm` step.
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
static QgsProcessingParameterDefinition *parameterFromVariantMap( const QVariantMap &map ) /Factory/;
|
|
%Docstring
|
|
Creates a new :py:class:`QgsProcessingParameterDefinition` using the configuration from a
|
|
supplied variant ``map``.
|
|
The caller takes responsibility for deleting the returned object.
|
|
%End
|
|
|
|
static QString descriptionFromName( const QString &name );
|
|
%Docstring
|
|
Creates an autogenerated parameter description from a parameter ``name``.
|
|
%End
|
|
|
|
static QgsProcessingParameterDefinition *parameterFromScriptCode( const QString &code ) /Factory/;
|
|
%Docstring
|
|
Creates a new :py:class:`QgsProcessingParameterDefinition` using the configuration from a
|
|
supplied script ``code`` string.
|
|
The caller takes responsibility for deleting the returned object.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
|
|
class QgsProcessingParameterBoolean : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A boolean parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterBoolean( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterBoolean.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
|
|
static QgsProcessingParameterBoolean *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
};
|
|
|
|
class QgsProcessingParameterCrs : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A coordinate reference system parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterCrs( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterCrs.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
|
|
static QgsProcessingParameterCrs *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterExtent : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A rectangular map extent parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterExtent( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterExtent.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
|
|
static QgsProcessingParameterExtent *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterPoint : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A point parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterPoint( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterPoint.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
|
|
static QgsProcessingParameterPoint *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterGeometry : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A geometry parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.16
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterGeometry( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, const QList< int > &geometryTypes = QList< int >(), bool allowMultipart = true );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterGeometry.
|
|
|
|
The ``geometryTypes`` argument allows for specifying a list of geometry types (see :py:class:`QgsWkbTypes`.GeometryType) acceptable for this
|
|
parameter. Passing a empty list will allow for any type of geometry.
|
|
The ``allowMultiPart`` argument allows specifying a multi part geometry
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
QList<int> geometryTypes() const;
|
|
%Docstring
|
|
Returns the parameter allowed geometries, as a list of :py:class:`QgsWkbTypes`.GeometryType values.
|
|
|
|
.. seealso:: :py:func:`setGeometryTypes`
|
|
%End
|
|
|
|
void setGeometryTypes( const QList<int> &geometryTypes );
|
|
%Docstring
|
|
Sets the allowed ``geometryTypes``, as a list of :py:class:`QgsWkbTypes`.GeometryType values.
|
|
|
|
.. seealso:: :py:func:`geometryTypes`
|
|
%End
|
|
|
|
bool allowMultipart() const;
|
|
%Docstring
|
|
Returns the parameter allow multipart geometries.
|
|
|
|
.. seealso:: :py:func:`setAllowMultipart`
|
|
%End
|
|
|
|
void setAllowMultipart( bool allowMultipart );
|
|
%Docstring
|
|
Sets the allow multipart geometries
|
|
|
|
.. seealso:: :py:func:`allowMultipart`
|
|
%End
|
|
|
|
|
|
|
|
static QgsProcessingParameterGeometry *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterFile : QgsProcessingParameterDefinition, QgsFileFilterGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
An input file or folder parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
enum Behavior
|
|
{
|
|
File,
|
|
Folder,
|
|
};
|
|
|
|
QgsProcessingParameterFile( const QString &name, const QString &description = QString(), Behavior behavior = File, const QString &extension = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false, const QString &fileFilter = QString() );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterFile.
|
|
|
|
The ``extension`` argument allows for specifying a file extension associated with the parameter (e.g. "html"). Use ``fileFilter``
|
|
for a more flexible approach which allows for multiple file extensions. Only one of ``extension`` or ``fileFilter`` should be specified,
|
|
if both are specified then ``fileFilter`` takes precedence.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
Behavior behavior() const;
|
|
%Docstring
|
|
Returns the parameter behavior (e.g. File or Folder).
|
|
|
|
.. seealso:: :py:func:`setBehavior`
|
|
%End
|
|
|
|
void setBehavior( Behavior behavior );
|
|
%Docstring
|
|
Sets the parameter ``behavior`` (e.g. File or Folder).
|
|
|
|
.. seealso:: :py:func:`behavior`
|
|
%End
|
|
|
|
QString extension() const;
|
|
%Docstring
|
|
Returns any specified file extension for the parameter.
|
|
|
|
.. note::
|
|
|
|
See :py:func:`~QgsProcessingParameterFile.fileFilter` for a more flexible approach.
|
|
|
|
.. seealso:: :py:func:`setExtension`
|
|
%End
|
|
|
|
void setExtension( const QString &extension );
|
|
%Docstring
|
|
Sets a file ``extension`` for the parameter.
|
|
|
|
Calling this method resets any existing :py:func:`~QgsProcessingParameterFile.fileFilter`.
|
|
|
|
.. note::
|
|
|
|
See :py:func:`~QgsProcessingParameterFile.setFileFilter` for a more flexible approach.
|
|
|
|
.. seealso:: :py:func:`extension`
|
|
%End
|
|
|
|
QString fileFilter() const;
|
|
%Docstring
|
|
Returns the file filter string for file destinations compatible with this parameter.
|
|
|
|
.. seealso:: :py:func:`setFileFilter`
|
|
|
|
.. seealso:: :py:func:`extension`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
void setFileFilter( const QString &filter );
|
|
%Docstring
|
|
Sets the file ``filter`` string for file destinations compatible with this parameter.
|
|
|
|
Calling this method resets any existing :py:func:`~QgsProcessingParameterFile.extension` setting.
|
|
|
|
.. seealso:: :py:func:`fileFilter`
|
|
|
|
.. seealso:: :py:func:`setExtension`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterFile *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition, Behavior behavior = File ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterMatrix : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A table (matrix) parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterMatrix( const QString &name, const QString &description = QString(), int numberRows = 3,
|
|
bool hasFixedNumberRows = false, const QStringList &headers = QStringList(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterMatrix.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
QStringList headers() const;
|
|
%Docstring
|
|
Returns a list of column headers (if set).
|
|
|
|
.. seealso:: :py:func:`setHeaders`
|
|
%End
|
|
|
|
void setHeaders( const QStringList &headers );
|
|
%Docstring
|
|
Sets the list of column ``headers``.
|
|
|
|
.. seealso:: :py:func:`headers`
|
|
%End
|
|
|
|
int numberRows() const;
|
|
%Docstring
|
|
Returns the fixed number of rows in the table. This parameter only has an
|
|
effect if :py:func:`~QgsProcessingParameterMatrix.hasFixedNumberRows` is ``True``.
|
|
|
|
.. seealso:: :py:func:`setNumberRows`
|
|
|
|
.. seealso:: :py:func:`setHasFixedNumberRows`
|
|
%End
|
|
|
|
void setNumberRows( int rows );
|
|
%Docstring
|
|
Sets the fixed number of ``rows`` in the table. This parameter only has an
|
|
effect if :py:func:`~QgsProcessingParameterMatrix.hasFixedNumberRows` is ``True``.
|
|
|
|
.. seealso:: :py:func:`numberRows`
|
|
|
|
.. seealso:: :py:func:`setHasFixedNumberRows`
|
|
%End
|
|
|
|
bool hasFixedNumberRows() const;
|
|
%Docstring
|
|
Returns whether the table has a fixed number of rows.
|
|
|
|
.. seealso:: :py:func:`numberRows`
|
|
|
|
.. seealso:: :py:func:`setHasFixedNumberRows`
|
|
%End
|
|
|
|
void setHasFixedNumberRows( bool hasFixedNumberRows );
|
|
%Docstring
|
|
Sets whether the table has a fixed number of rows.
|
|
|
|
.. seealso:: :py:func:`setNumberRows`
|
|
|
|
.. seealso:: :py:func:`hasFixedNumberRows`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterMatrix *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterMultipleLayers : QgsProcessingParameterDefinition, QgsFileFilterGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
A parameter for processing algorithms which accepts multiple map layers.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterMultipleLayers( const QString &name, const QString &description = QString(), QgsProcessing::SourceType layerType = QgsProcessing::TypeVectorAnyGeometry,
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterMultipleLayers.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
QgsProcessing::SourceType layerType() const;
|
|
%Docstring
|
|
Returns the layer type for layers acceptable by the parameter.
|
|
|
|
.. seealso:: :py:func:`setLayerType`
|
|
%End
|
|
|
|
void setLayerType( QgsProcessing::SourceType type );
|
|
%Docstring
|
|
Sets the layer ``type`` for layers acceptable by the parameter.
|
|
|
|
.. seealso:: :py:func:`layerType`
|
|
%End
|
|
|
|
int minimumNumberInputs() const;
|
|
%Docstring
|
|
Returns the minimum number of layers required for the parameter. If the return value is < 1
|
|
then the parameter accepts any number of layers.
|
|
|
|
.. seealso:: :py:func:`setMinimumNumberInputs`
|
|
%End
|
|
|
|
void setMinimumNumberInputs( int minimum );
|
|
%Docstring
|
|
Sets the ``minimum`` number of layers required for the parameter. The minimum must be >= 1
|
|
if the parameter is not optional.
|
|
|
|
.. seealso:: :py:func:`minimumNumberInputs`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterMultipleLayers *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterNumber : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A numeric parameter for processing algorithms.
|
|
|
|
For numeric parameters with a :py:func:`~QgsProcessingParameterMultipleLayers.dataType` of Double, the number of decimals places
|
|
shown in the parameter's widget can be specified by setting the parameter's metadata. For example:
|
|
|
|
.. code-block:: python
|
|
|
|
param = QgsProcessingParameterNumber( 'VAL', 'Threshold', type=QgsProcessingParameterNumber.Double)
|
|
# only show two decimal places in parameter's widgets, not 6:
|
|
param.setMetadata( {'widget_wrapper':
|
|
{ 'decimals': 2 }
|
|
})
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
enum Type
|
|
{
|
|
Integer,
|
|
Double,
|
|
};
|
|
|
|
explicit QgsProcessingParameterNumber( const QString &name, const QString &description = QString(),
|
|
Type type = Integer,
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false,
|
|
double minValue = -DBL_MAX + 1,
|
|
double maxValue = DBL_MAX
|
|
);
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterNumber.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString toolTip() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
double minimum() const;
|
|
%Docstring
|
|
Returns the minimum value acceptable by the parameter.
|
|
|
|
.. seealso:: :py:func:`setMinimum`
|
|
%End
|
|
|
|
void setMinimum( double minimum );
|
|
%Docstring
|
|
Sets the ``minimum`` value acceptable by the parameter.
|
|
|
|
.. seealso:: :py:func:`minimum`
|
|
%End
|
|
|
|
double maximum() const;
|
|
%Docstring
|
|
Returns the maximum value acceptable by the parameter.
|
|
|
|
.. seealso:: :py:func:`setMaximum`
|
|
%End
|
|
|
|
void setMaximum( double maximum );
|
|
%Docstring
|
|
Sets the ``maximum`` value acceptable by the parameter.
|
|
|
|
.. seealso:: :py:func:`maximum`
|
|
%End
|
|
|
|
Type dataType() const;
|
|
%Docstring
|
|
Returns the acceptable data type for the parameter.
|
|
|
|
.. seealso:: :py:func:`setDataType`
|
|
%End
|
|
|
|
void setDataType( Type type );
|
|
%Docstring
|
|
Sets the acceptable data ``type`` for the parameter.
|
|
|
|
.. seealso:: :py:func:`dataType`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterNumber *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterDistance : QgsProcessingParameterNumber
|
|
{
|
|
%Docstring(signature="appended")
|
|
A double numeric parameter for distance values. Linked to a source layer or CRS parameter
|
|
to determine what units the distance values are in.
|
|
|
|
The number of decimals places shown in a distance parameter's widget can be specified by
|
|
setting the parameter's metadata. For example:
|
|
|
|
.. code-block:: python
|
|
|
|
param = QgsProcessingParameterDistance( 'VAL', 'Threshold')
|
|
# only show two decimal places in parameter's widgets, not 6:
|
|
param.setMetadata( {'widget_wrapper':
|
|
{ 'decimals': 2 }
|
|
})
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
explicit QgsProcessingParameterDistance( const QString &name, const QString &description = QString(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
const QString &parentParameterName = QString(),
|
|
bool optional = false,
|
|
double minValue = -DBL_MAX + 1,
|
|
double maxValue = DBL_MAX );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterDistance.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
|
|
virtual QgsProcessingParameterDistance *clone() const /Factory/;
|
|
|
|
|
|
virtual QString type() const;
|
|
|
|
virtual QStringList dependsOnOtherParameters() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
QString parentParameterName() const;
|
|
%Docstring
|
|
Returns the name of the parent parameter, or an empty string if this is not set.
|
|
|
|
.. seealso:: :py:func:`setParentParameterName`
|
|
%End
|
|
|
|
void setParentParameterName( const QString &parentParameterName );
|
|
%Docstring
|
|
Sets the name of the parent layer parameter. Use an empty string if this is not required.
|
|
|
|
.. seealso:: :py:func:`parentParameterName`
|
|
%End
|
|
|
|
Qgis::DistanceUnit defaultUnit() const;
|
|
%Docstring
|
|
Returns the default distance unit for the parameter.
|
|
|
|
.. seealso:: :py:func:`setDefaultUnit`
|
|
|
|
.. versionadded:: 3.4.3
|
|
%End
|
|
|
|
void setDefaultUnit( Qgis::DistanceUnit unit );
|
|
%Docstring
|
|
Sets the default distance ``unit`` for the parameter.
|
|
|
|
.. seealso:: :py:func:`defaultUnit`
|
|
|
|
.. versionadded:: 3.4.3
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterDuration : QgsProcessingParameterNumber
|
|
{
|
|
%Docstring(signature="appended")
|
|
A double numeric parameter for duration values. The returned
|
|
value will always be in milliseconds.
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
explicit QgsProcessingParameterDuration( const QString &name, const QString &description = QString(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false,
|
|
double minValue = -DBL_MAX + 1,
|
|
double maxValue = DBL_MAX );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterDuration.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
|
|
virtual QgsProcessingParameterDuration *clone() const /Factory/;
|
|
|
|
|
|
virtual QString type() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
Qgis::TemporalUnit defaultUnit() const;
|
|
%Docstring
|
|
Returns the default duration unit for the parameter.
|
|
|
|
.. seealso:: :py:func:`setDefaultUnit`
|
|
%End
|
|
|
|
void setDefaultUnit( Qgis::TemporalUnit unit );
|
|
%Docstring
|
|
Sets the default duration ``unit`` for the parameter.
|
|
|
|
.. seealso:: :py:func:`defaultUnit`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterScale : QgsProcessingParameterNumber
|
|
{
|
|
%Docstring(signature="appended")
|
|
A double numeric parameter for map scale values.
|
|
|
|
:py:class:`QgsProcessingParameterScale` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsDouble()`,
|
|
which will return a numeric value representing the scale denominator.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
explicit QgsProcessingParameterScale( const QString &name, const QString &description = QString(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterScale.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
|
|
virtual QgsProcessingParameterScale *clone() const /Factory/;
|
|
|
|
|
|
virtual QString type() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
static QgsProcessingParameterScale *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterRange : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A numeric range parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterRange( const QString &name, const QString &description = QString(),
|
|
QgsProcessingParameterNumber::Type type = QgsProcessingParameterNumber::Integer,
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterRange.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
QgsProcessingParameterNumber::Type dataType() const;
|
|
%Docstring
|
|
Returns the acceptable data type for the range.
|
|
|
|
.. seealso:: :py:func:`setDataType`
|
|
%End
|
|
|
|
void setDataType( QgsProcessingParameterNumber::Type dataType );
|
|
%Docstring
|
|
Sets the acceptable data ``type`` for the range.
|
|
|
|
.. seealso:: :py:func:`dataType`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterRange *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterRasterLayer : QgsProcessingParameterDefinition, QgsFileFilterGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
A raster layer parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterRasterLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterRasterLayer.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
static QgsProcessingParameterRasterLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterEnum : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
An enum based parameter for processing algorithms, allowing for selection from predefined values.
|
|
|
|
Since QGIS 3.24 a list of icons corresponding to the enum values can be specified by setting the
|
|
widget wrapper metadata "icons" option, as demonstrated below. The "icons" value should be
|
|
set to a list of QIcon values.
|
|
|
|
.. code-block:: python
|
|
|
|
param = QgsProcessingParameterEnum( 'FIELD_TYPE', 'Field type', ['Integer', 'String'])
|
|
param.setMetadata( {'widget_wrapper':
|
|
{ 'icons': [QIcon('integer.svg'), QIcon('string.svg')] }
|
|
})
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterEnum( const QString &name, const QString &description = QString(), const QStringList &options = QStringList(),
|
|
bool allowMultiple = false,
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false,
|
|
bool usesStaticStrings = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterEnum.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsPythonComment( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
QStringList options() const;
|
|
%Docstring
|
|
Returns the list of acceptable options for the parameter.
|
|
|
|
.. seealso:: :py:func:`setOptions`
|
|
%End
|
|
|
|
void setOptions( const QStringList &options );
|
|
%Docstring
|
|
Sets the list of acceptable ``options`` for the parameter.
|
|
|
|
.. seealso:: :py:func:`options`
|
|
%End
|
|
|
|
bool allowMultiple() const;
|
|
%Docstring
|
|
Returns ``True`` if the parameter allows multiple selected values.
|
|
|
|
.. seealso:: :py:func:`setAllowMultiple`
|
|
%End
|
|
|
|
void setAllowMultiple( bool allowMultiple );
|
|
%Docstring
|
|
Sets whether the parameter allows multiple selected values.
|
|
|
|
.. seealso:: :py:func:`allowMultiple`
|
|
%End
|
|
|
|
bool usesStaticStrings() const;
|
|
%Docstring
|
|
Returns ``True`` if the parameter uses static (non-translated) string
|
|
values for its enumeration choice list.
|
|
|
|
.. seealso:: :py:func:`setUsesStaticStrings`
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
void setUsesStaticStrings( bool usesStaticStrings );
|
|
%Docstring
|
|
Sets whether the parameter uses static (non-translated) string
|
|
values for its enumeration choice list.
|
|
|
|
.. seealso:: :py:func:`usesStaticStrings`
|
|
|
|
.. versionadded:: 3.18
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterEnum *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterString : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A string parameter for processing algorithms.
|
|
|
|
A parameter type which allows users to enter any string value.
|
|
|
|
In some circumstances it is desirable to restrict the values available
|
|
when a user is asked to enter a string parameter to a list of predetermined
|
|
"valid" values. Since QGIS 3.22 this can be done by setting the widget wrapper metadata
|
|
"value_hints" option, as demonstrated below. (While this provides a mechanism
|
|
for guiding users to select from valid string values when running a Processing
|
|
algorithm through the GUI, it does not place any limits on the string values
|
|
accepted via PyQGIS codes or when running the algorithm via other non-gui
|
|
means. Algorithms should gracefully handle other values accordingly.)
|
|
|
|
.. code-block:: python
|
|
|
|
param = QgsProcessingParameterString( 'PRINTER_NAME', 'Printer name')
|
|
# show only printers which are available on the current system as options
|
|
# for the string input.
|
|
param.setMetadata( {'widget_wrapper':
|
|
{ 'value_hints': ['Inkjet printer', 'Laser printer'] }
|
|
})
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterString( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool multiLine = false,
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterString.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
bool multiLine() const;
|
|
%Docstring
|
|
Returns ``True`` if the parameter allows multiline strings.
|
|
|
|
.. seealso:: :py:func:`setMultiLine`
|
|
%End
|
|
|
|
void setMultiLine( bool multiLine );
|
|
%Docstring
|
|
Sets whether the parameter allows multiline strings.
|
|
|
|
.. seealso:: :py:func:`multiLine`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterString *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterAuthConfig : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A string parameter for authentication configuration ID values.
|
|
|
|
This parameter allows for users to select from available authentication configurations,
|
|
or create new authentication configurations as required.
|
|
|
|
:py:class:`QgsProcessingParameterAuthConfig` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsString()`.
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterAuthConfig( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterAuthConfig.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
|
|
static QgsProcessingParameterAuthConfig *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterExpression : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
An expression parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterExpression( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
const QString &parentLayerParameterName = QString(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterExpression.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QStringList dependsOnOtherParameters() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
QString parentLayerParameterName() const;
|
|
%Docstring
|
|
Returns the name of the parent layer parameter, or an empty string if this is not set.
|
|
|
|
.. seealso:: :py:func:`setParentLayerParameterName`
|
|
%End
|
|
|
|
void setParentLayerParameterName( const QString &parentLayerParameterName );
|
|
%Docstring
|
|
Sets the name of the parent layer parameter. Use an empty string if this is not required.
|
|
|
|
.. seealso:: :py:func:`parentLayerParameterName`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterExpression *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterLimitedDataTypes
|
|
{
|
|
%Docstring(signature="appended")
|
|
Can be inherited by parameters which require limits to their acceptable data types.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterLimitedDataTypes( const QList< int > &types = QList< int >() );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterLimitedDataTypes, with a list of acceptable data ``types``.
|
|
%End
|
|
|
|
QList< int > dataTypes() const;
|
|
%Docstring
|
|
Returns the geometry types for sources acceptable by the parameter.
|
|
|
|
.. seealso:: :py:func:`setDataTypes`
|
|
%End
|
|
|
|
void setDataTypes( const QList< int > &types );
|
|
%Docstring
|
|
Sets the geometry ``types`` for sources acceptable by the parameter.
|
|
|
|
.. seealso:: :py:func:`dataTypes`
|
|
%End
|
|
|
|
protected:
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterVectorLayer : QgsProcessingParameterDefinition, QgsProcessingParameterLimitedDataTypes, QgsFileFilterGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
A vector layer (with or without geometry) parameter for processing algorithms. Consider using
|
|
the more versatile :py:class:`QgsProcessingParameterFeatureSource` wherever possible.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterVectorLayer( const QString &name,
|
|
const QString &description = QString(),
|
|
const QList< int > &types = QList< int >(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterVectorLayer.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterVectorLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterMeshLayer : QgsProcessingParameterDefinition, QgsFileFilterGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
A mesh layer parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterMeshLayer( const QString &name,
|
|
const QString &description = QString(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterMeshLayer.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
static QgsProcessingParameterMeshLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
};
|
|
|
|
class QgsProcessingParameterMapLayer : QgsProcessingParameterDefinition, QgsProcessingParameterLimitedDataTypes, QgsFileFilterGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
A map layer parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterMapLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false,
|
|
const QList< int > &types = QList< int >() );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterMapLayer.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterMapLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterField : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A vector layer or feature source field parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
enum DataType
|
|
{
|
|
Any,
|
|
Numeric,
|
|
String,
|
|
DateTime
|
|
};
|
|
|
|
QgsProcessingParameterField( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
const QString &parentLayerParameterName = QString(),
|
|
DataType type = Any,
|
|
bool allowMultiple = false,
|
|
bool optional = false,
|
|
bool defaultToAllFields = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterField.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QStringList dependsOnOtherParameters() const;
|
|
|
|
|
|
QString parentLayerParameterName() const;
|
|
%Docstring
|
|
Returns the name of the parent layer parameter, or an empty string if this is not set.
|
|
|
|
.. seealso:: :py:func:`setParentLayerParameterName`
|
|
%End
|
|
|
|
void setParentLayerParameterName( const QString &parentLayerParameterName );
|
|
%Docstring
|
|
Sets the name of the parent layer parameter. Use an empty string if this is not required.
|
|
|
|
.. seealso:: :py:func:`parentLayerParameterName`
|
|
%End
|
|
|
|
DataType dataType() const;
|
|
%Docstring
|
|
Returns the acceptable data type for the field.
|
|
|
|
.. seealso:: :py:func:`setDataType`
|
|
%End
|
|
|
|
void setDataType( DataType type );
|
|
%Docstring
|
|
Sets the acceptable data ``type`` for the field.
|
|
|
|
.. seealso:: :py:func:`dataType`
|
|
%End
|
|
|
|
bool allowMultiple() const;
|
|
%Docstring
|
|
Returns whether multiple field selections are permitted.
|
|
|
|
.. seealso:: :py:func:`setAllowMultiple`
|
|
%End
|
|
|
|
void setAllowMultiple( bool allowMultiple );
|
|
%Docstring
|
|
Sets whether multiple field selections are permitted.
|
|
|
|
.. seealso:: :py:func:`allowMultiple`
|
|
%End
|
|
|
|
bool defaultToAllFields() const;
|
|
%Docstring
|
|
Returns whether a parameter which allows multiple selections (see :py:func:`~QgsProcessingParameterField.allowMultiple`) should automatically
|
|
select all fields as the default value.
|
|
|
|
If ``True``, this will override any existing :py:func:`~QgsProcessingParameterField.defaultValue` set on the parameter.
|
|
|
|
.. seealso:: :py:func:`setDefaultToAllFields`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
void setDefaultToAllFields( bool enabled );
|
|
%Docstring
|
|
Sets whether a parameter which allows multiple selections (see :py:func:`~QgsProcessingParameterField.allowMultiple`) should automatically
|
|
select all fields as the default value.
|
|
|
|
If ``True``, this will override any existing :py:func:`~QgsProcessingParameterField.defaultValue` set on the parameter.
|
|
|
|
.. seealso:: :py:func:`defaultToAllFields`
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterField *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterFeatureSource : QgsProcessingParameterDefinition, QgsProcessingParameterLimitedDataTypes, QgsFileFilterGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
An input feature source (such as vector layers) parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterFeatureSource( const QString &name, const QString &description = QString(),
|
|
const QList< int > &types = QList< int >(),
|
|
const QVariant &defaultValue = QVariant(), bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterFeatureSource.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterFeatureSource *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingDestinationParameter : QgsProcessingParameterDefinition, QgsFileFilterGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
Base class for all parameter definitions which represent file or layer destinations, e.g. parameters
|
|
which are used for the destination for layers output by an algorithm.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingDestinationParameter( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false, bool createByDefault = true );
|
|
%Docstring
|
|
Constructor for QgsProcessingDestinationParameter.
|
|
|
|
If ``createByDefault`` is ``False`` and the parameter is ``optional``, then the destination
|
|
output will not be created by default.
|
|
%End
|
|
|
|
virtual bool isDestination() const;
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
virtual QgsProcessingOutputDefinition *toOutputDefinition() const = 0 /Factory/;
|
|
%Docstring
|
|
Returns a new :py:class:`QgsProcessingOutputDefinition` corresponding to the definition of the destination
|
|
parameter.
|
|
%End
|
|
|
|
bool supportsNonFileBasedOutput() const;
|
|
%Docstring
|
|
Returns ``True`` if the destination parameter supports non filed-based outputs,
|
|
such as memory layers or direct database outputs.
|
|
|
|
.. seealso:: :py:func:`setSupportsNonFileBasedOutput`
|
|
%End
|
|
|
|
void setSupportsNonFileBasedOutput( bool supportsNonFileBasedOutput );
|
|
%Docstring
|
|
Sets whether the destination parameter supports non filed-based outputs,
|
|
such as memory layers or direct database outputs.
|
|
|
|
.. seealso:: :py:func:`supportsNonFileBasedOutput`
|
|
%End
|
|
|
|
virtual QString defaultFileExtension() const = 0;
|
|
%Docstring
|
|
Returns the default file extension for destination file paths
|
|
associated with this parameter.
|
|
%End
|
|
|
|
virtual QString generateTemporaryDestination() const;
|
|
%Docstring
|
|
Generates a temporary destination value for this parameter. The returned
|
|
value will be a file path or QGIS data provider URI suitable for
|
|
temporary storage of created layers and files.
|
|
%End
|
|
|
|
virtual bool isSupportedOutputValue( const QVariant &value, QgsProcessingContext &context, QString &error /Out/ ) const;
|
|
%Docstring
|
|
Tests whether a ``value`` is a supported value for this parameter.
|
|
|
|
Will return ``False`` when a ``value`` with an unsupported file extension is specified. The default implementation
|
|
calls :py:func:`QgsProcessingProvider.isSupportedOutputValue()` to test compatibility.
|
|
|
|
:param value: value to test
|
|
:param context: Processing context
|
|
|
|
:return: - ``True`` if ``value`` is supported.
|
|
- error: will be set to a descriptive error string
|
|
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
bool createByDefault() const;
|
|
%Docstring
|
|
Returns ``True`` if the destination should be created by default. For optional parameters,
|
|
a return value of ``False`` indicates that the destination should not be created by default.
|
|
|
|
.. seealso:: :py:func:`setCreateByDefault`
|
|
%End
|
|
|
|
void setCreateByDefault( bool createByDefault );
|
|
%Docstring
|
|
Sets whether the destination should be created by default. For optional parameters,
|
|
a value of ``False`` indicates that the destination should not be created by default.
|
|
|
|
.. seealso:: :py:func:`createByDefault`
|
|
%End
|
|
|
|
protected:
|
|
|
|
QgsProcessingProvider *originalProvider() const;
|
|
%Docstring
|
|
Original (source) provider which this parameter has been derived from.
|
|
In the case of destination parameters which are part of model algorithms, this
|
|
will reflect the child algorithm's provider which actually generates the
|
|
parameter, as opposed to the provider which this parameter belongs to (i.e.
|
|
the model provider)
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterFeatureSink : QgsProcessingDestinationParameter
|
|
{
|
|
%Docstring(signature="appended")
|
|
A feature sink output for processing algorithms.
|
|
|
|
A parameter which represents the destination feature sink for features created by an algorithm.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterFeatureSink( const QString &name, const QString &description = QString(), QgsProcessing::SourceType type = QgsProcessing::TypeVectorAnyGeometry, const QVariant &defaultValue = QVariant(),
|
|
bool optional = false, bool createByDefault = true, bool supportsAppend = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterFeatureSink.
|
|
|
|
If ``createByDefault`` is ``False`` and the parameter is ``optional``, then this destination
|
|
output will not be created by default.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;
|
|
|
|
virtual QString defaultFileExtension() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
virtual QStringList supportedOutputVectorLayerExtensions() const;
|
|
%Docstring
|
|
Returns a list of the vector format file extensions supported by this parameter.
|
|
|
|
.. seealso:: :py:func:`defaultFileExtension`
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
QgsProcessing::SourceType dataType() const;
|
|
%Docstring
|
|
Returns the layer type for sinks associated with the parameter.
|
|
|
|
.. seealso:: :py:func:`setDataType`
|
|
%End
|
|
|
|
bool hasGeometry() const;
|
|
%Docstring
|
|
Returns ``True`` if sink is likely to include geometries. In cases were presence of geometry
|
|
cannot be reliably determined in advance, this method will default to returning ``True``.
|
|
%End
|
|
|
|
void setDataType( QgsProcessing::SourceType type );
|
|
%Docstring
|
|
Sets the layer ``type`` for the sinks associated with the parameter.
|
|
|
|
.. seealso:: :py:func:`dataType`
|
|
%End
|
|
|
|
bool supportsAppend() const;
|
|
%Docstring
|
|
Returns ``True`` if the sink supports appending features to an existing table.
|
|
|
|
A sink only supports appending if the algorithm implements :py:class:`QgsProcessingAlgorithm`.sinkProperties for the sink parameter.
|
|
|
|
.. seealso:: :py:func:`setSupportsAppend`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
void setSupportsAppend( bool supportsAppend );
|
|
%Docstring
|
|
Sets whether the sink supports appending features to an existing table.
|
|
|
|
.. warning::
|
|
|
|
A sink only supports appending if the algorithm implements :py:class:`QgsProcessingAlgorithm`.sinkProperties for the sink parameter.
|
|
|
|
.. seealso:: :py:func:`supportsAppend`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
virtual QString generateTemporaryDestination() const;
|
|
|
|
|
|
static QgsProcessingParameterFeatureSink *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterVectorDestination : QgsProcessingDestinationParameter
|
|
{
|
|
%Docstring(signature="appended")
|
|
A vector layer destination parameter, for specifying the destination path for a vector layer
|
|
created by the algorithm.
|
|
|
|
.. note::
|
|
|
|
Consider using the more flexible QgsProcessingParameterFeatureSink wherever
|
|
possible.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterVectorDestination( const QString &name, const QString &description = QString(), QgsProcessing::SourceType type = QgsProcessing::TypeVectorAnyGeometry, const QVariant &defaultValue = QVariant(),
|
|
bool optional = false, bool createByDefault = true );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterVectorDestination.
|
|
|
|
If ``createByDefault`` is ``False`` and the parameter is ``optional``, then this destination
|
|
output will not be created by default.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;
|
|
|
|
virtual QString defaultFileExtension() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
virtual QStringList supportedOutputVectorLayerExtensions() const;
|
|
%Docstring
|
|
Returns a list of the vector format file extensions supported by this parameter.
|
|
|
|
.. seealso:: :py:func:`defaultFileExtension`
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
QgsProcessing::SourceType dataType() const;
|
|
%Docstring
|
|
Returns the layer type for this created vector layer.
|
|
|
|
.. seealso:: :py:func:`setDataType`
|
|
%End
|
|
|
|
bool hasGeometry() const;
|
|
%Docstring
|
|
Returns ``True`` if the created layer is likely to include geometries. In cases were presence of geometry
|
|
cannot be reliably determined in advance, this method will default to returning ``True``.
|
|
%End
|
|
|
|
void setDataType( QgsProcessing::SourceType type );
|
|
%Docstring
|
|
Sets the layer ``type`` for the created vector layer.
|
|
|
|
.. seealso:: :py:func:`dataType`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterVectorDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterRasterDestination : QgsProcessingDestinationParameter
|
|
{
|
|
%Docstring(signature="appended")
|
|
A raster layer destination parameter, for specifying the destination path for a raster layer
|
|
created by the algorithm.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterRasterDestination( const QString &name, const QString &description = QString(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false,
|
|
bool createByDefault = true );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterRasterDestination.
|
|
|
|
If ``createByDefault`` is ``False`` and the parameter is ``optional``, then this destination
|
|
output will not be created by default.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;
|
|
|
|
virtual QString defaultFileExtension() const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
virtual QStringList supportedOutputRasterLayerExtensions() const;
|
|
%Docstring
|
|
Returns a list of the raster format file extensions supported for this parameter.
|
|
|
|
.. seealso:: :py:func:`defaultFileExtension`
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
static QgsProcessingParameterRasterDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
};
|
|
|
|
class QgsProcessingParameterFileDestination : QgsProcessingDestinationParameter
|
|
{
|
|
%Docstring(signature="appended")
|
|
A generic file based destination parameter, for specifying the destination path for a file (non-map layer)
|
|
created by the algorithm.
|
|
|
|
In some circumstances it is desirable to avoid the usual file overwriting confirmation prompt when
|
|
users select an existing destination file for this parameter type (e.g., for algorithms which
|
|
append to an existing destination file instead of overwriting them.). This can be done by setting
|
|
the widget wrapper metadata "dontconfirmoverwrite" option:
|
|
|
|
.. code-block:: python
|
|
|
|
param = QgsProcessingParameterFileDestination( 'OUTPUT', 'Destination file')
|
|
# don't show the file overwrite warning when users select a destination file:
|
|
param.setMetadata( {'widget_wrapper':
|
|
{ 'dontconfirmoverwrite': True }
|
|
})
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterFileDestination( const QString &name, const QString &description = QString(),
|
|
const QString &fileFilter = QString(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false,
|
|
bool createByDefault = true );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterFileDestination.
|
|
|
|
If ``createByDefault`` is ``False`` and the parameter is ``optional``, then this destination
|
|
output will not be created by default.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;
|
|
|
|
virtual QString defaultFileExtension() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
QString fileFilter() const;
|
|
%Docstring
|
|
Returns the file filter string for file destinations compatible with this parameter.
|
|
|
|
.. seealso:: :py:func:`setFileFilter`
|
|
%End
|
|
|
|
void setFileFilter( const QString &filter );
|
|
%Docstring
|
|
Sets the file ``filter`` string for file destinations compatible with this parameter.
|
|
|
|
.. seealso:: :py:func:`fileFilter`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterFileDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterFolderDestination : QgsProcessingDestinationParameter
|
|
{
|
|
%Docstring(signature="appended")
|
|
A folder destination parameter, for specifying the destination path for a folder created
|
|
by the algorithm or used for creating new files within the algorithm.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterFolderDestination( const QString &name, const QString &description = QString(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false,
|
|
bool createByDefault = true );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterFolderDestination.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;
|
|
|
|
virtual QString defaultFileExtension() const;
|
|
|
|
|
|
static QgsProcessingParameterFolderDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterBand : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A raster band parameter for Processing algorithms.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterBand( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
const QString &parentLayerParameterName = QString(),
|
|
bool optional = false,
|
|
bool allowMultiple = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterBand.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QStringList dependsOnOtherParameters() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
QString parentLayerParameterName() const;
|
|
%Docstring
|
|
Returns the name of the parent layer parameter, or an empty string if this is not set.
|
|
|
|
.. seealso:: :py:func:`setParentLayerParameterName`
|
|
%End
|
|
|
|
void setParentLayerParameterName( const QString &parentLayerParameterName );
|
|
%Docstring
|
|
Sets the name of the parent layer parameter. Use an empty string if this is not required.
|
|
|
|
.. seealso:: :py:func:`parentLayerParameterName`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterBand *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
bool allowMultiple() const;
|
|
%Docstring
|
|
Returns whether multiple band selections are permitted.
|
|
|
|
.. seealso:: :py:func:`setAllowMultiple`
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
void setAllowMultiple( bool allowMultiple );
|
|
%Docstring
|
|
Sets whether multiple band selections are permitted.
|
|
|
|
.. seealso:: :py:func:`allowMultiple`
|
|
|
|
.. versionadded:: 3.4
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterLayout : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A print layout parameter, allowing users to select a print layout.
|
|
|
|
:py:class:`QgsProcessingParameterLayout` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsLayout()`.
|
|
This will return the matching layout from the context's current project. Alternatively, calling
|
|
:py:func:`QgsProcessingAlgorithm.parameterAsString()` will return the name of the target print layout.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterLayout( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterLayout.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
static QgsProcessingParameterLayout *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterLayoutItem : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A print layout item parameter, allowing users to select a particular item from a print layout.
|
|
|
|
:py:class:`QgsProcessingParameterLayoutItem` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsLayoutItem()`.
|
|
Internally, :py:class:`QgsProcessingParameterLayoutItems` are string parameters, storing references to items either by
|
|
their UUID (:py:func:`QgsLayoutItem.uuid()`) or ID (:py:func:`QgsLayoutItem.id()`).
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterLayoutItem( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
const QString &parentLayoutParameterName = QString(),
|
|
int itemType = -1,
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterLayoutItem.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
virtual QStringList dependsOnOtherParameters() const;
|
|
|
|
|
|
static QgsProcessingParameterLayoutItem *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
QString parentLayoutParameterName() const;
|
|
%Docstring
|
|
Returns the name of the parent layout parameter, or an empty string if this is not set.
|
|
|
|
.. seealso:: :py:func:`setParentLayoutParameterName`
|
|
%End
|
|
|
|
void setParentLayoutParameterName( const QString &name );
|
|
%Docstring
|
|
Sets the ``name`` of the parent layout parameter. Use an empty string if this is not required.
|
|
|
|
.. seealso:: :py:func:`parentLayoutParameterName`
|
|
%End
|
|
|
|
int itemType() const;
|
|
%Docstring
|
|
Returns the acceptable item type, or -1 if any item type is allowed.
|
|
|
|
These values correspond to the registered item types from :py:class:`QgsLayoutItemRegistry`.
|
|
|
|
.. seealso:: :py:func:`setItemType`
|
|
%End
|
|
|
|
void setItemType( int type );
|
|
%Docstring
|
|
Sets the acceptable item ``type``, or -1 if any item type is allowed.
|
|
|
|
These values correspond to the registered item types from :py:class:`QgsLayoutItemRegistry`.
|
|
|
|
.. seealso:: :py:func:`itemType`
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingParameterColor : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A color parameter for processing algorithms.
|
|
|
|
:py:class:`QgsProcessingParameterColor` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsColor()`.
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterColor( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool opacityEnabled = true,
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterColor.
|
|
|
|
If ``opacityEnabled`` is ``True``, then users will have the option of varying color opacity.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
bool opacityEnabled() const;
|
|
%Docstring
|
|
Returns ``True`` if the parameter allows opacity control.
|
|
|
|
The default behavior is to allow users to set opacity for the color.
|
|
|
|
.. seealso:: :py:func:`setOpacityEnabled`
|
|
%End
|
|
|
|
void setOpacityEnabled( bool enabled );
|
|
%Docstring
|
|
Sets whether the parameter allows opacity control.
|
|
|
|
The default behavior is to allow users to set opacity for the color.
|
|
|
|
.. seealso:: :py:func:`opacityEnabled`
|
|
%End
|
|
|
|
static QgsProcessingParameterColor *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterCoordinateOperation : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A coordinate operation parameter for processing algorithms, for selection between available
|
|
coordinate operations to use when projecting between a source and destination coordinate reference system.
|
|
|
|
:py:class:`QgsProcessingParameterCoordinateOperation` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsString()`.
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterCoordinateOperation( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
const QString &sourceCrsParameterName = QString(), const QString &destinationCrsParameterName = QString(),
|
|
const QVariant &staticSourceCrs = QVariant(), const QVariant &staticDestinationCrs = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterCoordinateOperation.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QStringList dependsOnOtherParameters() const;
|
|
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterCoordinateOperation *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
QString sourceCrsParameterName() const;
|
|
%Docstring
|
|
Returns the name of the source CRS parameter, or an empty string if this is not set.
|
|
|
|
.. seealso:: :py:func:`setSourceCrsParameterName`
|
|
|
|
.. seealso:: :py:func:`destinationCrsParameterName`
|
|
%End
|
|
|
|
void setSourceCrsParameterName( const QString &name );
|
|
%Docstring
|
|
Sets the ``name`` of the source CRS parameter. Use an empty string if this is not required.
|
|
|
|
.. seealso:: :py:func:`sourceCrsParameterName`
|
|
|
|
.. seealso:: :py:func:`setDestinationCrsParameterName`
|
|
%End
|
|
|
|
QString destinationCrsParameterName() const;
|
|
%Docstring
|
|
Returns the name of the destination CRS parameter, or an empty string if this is not set.
|
|
|
|
.. seealso:: :py:func:`setDestinationCrsParameterName`
|
|
|
|
.. seealso:: :py:func:`sourceCrsParameterName`
|
|
%End
|
|
|
|
void setDestinationCrsParameterName( const QString &name );
|
|
%Docstring
|
|
Sets the ``name`` of the destination CRS parameter. Use an empty string if this is not required.
|
|
|
|
.. seealso:: :py:func:`destinationCrsParameterName`
|
|
|
|
.. seealso:: :py:func:`setSourceCrsParameterName`
|
|
%End
|
|
|
|
QVariant sourceCrs() const;
|
|
%Docstring
|
|
Returns the static source CRS, or an invalid value if this is not set.
|
|
|
|
.. seealso:: :py:func:`setSourceCrs`
|
|
|
|
.. seealso:: :py:func:`destinationCrs`
|
|
%End
|
|
|
|
void setSourceCrs( const QVariant &crs );
|
|
%Docstring
|
|
Sets the static source ``crs``.
|
|
|
|
.. seealso:: :py:func:`sourceCrs`
|
|
|
|
.. seealso:: :py:func:`setDestinationCrs`
|
|
%End
|
|
|
|
QVariant destinationCrs() const;
|
|
%Docstring
|
|
Returns the static destination CRS, or an invalid value if this is not set.
|
|
|
|
.. seealso:: :py:func:`setDestinationCrs`
|
|
|
|
.. seealso:: :py:func:`sourceCrs`
|
|
%End
|
|
|
|
void setDestinationCrs( const QVariant &crs );
|
|
%Docstring
|
|
Sets the static destination ``crs``.
|
|
|
|
.. seealso:: :py:func:`destinationCrs`
|
|
|
|
.. seealso:: :py:func:`setSourceCrs`
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterMapTheme : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A map theme parameter for processing algorithms, allowing users to select an existing map theme from a project.
|
|
|
|
:py:class:`QgsProcessingParameterMapTheme` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsString()`.
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterMapTheme( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterMapTheme.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterMapTheme *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterDateTime : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A datetime (or pure date or time) parameter for processing algorithms.
|
|
|
|
:py:class:`QgsProcessingParameterDateTime` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsDateTime()`,
|
|
which will return a date time value.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
enum Type
|
|
{
|
|
DateTime,
|
|
Date,
|
|
Time,
|
|
};
|
|
|
|
explicit QgsProcessingParameterDateTime( const QString &name, const QString &description = QString(),
|
|
Type type = DateTime,
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false,
|
|
const QDateTime &minValue = QDateTime(),
|
|
const QDateTime &maxValue = QDateTime()
|
|
);
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterDateTime.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString toolTip() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
|
|
QDateTime minimum() const;
|
|
%Docstring
|
|
Returns the minimum value acceptable by the parameter.
|
|
|
|
An invalid QDateTime value indicates no minimum value.
|
|
|
|
.. seealso:: :py:func:`setMinimum`
|
|
%End
|
|
|
|
void setMinimum( const QDateTime &minimum );
|
|
%Docstring
|
|
Sets the ``minimum`` value acceptable by the parameter.
|
|
|
|
An invalid QDateTime value indicates no minimum value.
|
|
|
|
If the :py:func:`~QgsProcessingParameterDateTime.dataType` is QgsProcessingParameterDateTime.Time, then the date component of ``minimum``
|
|
must be set to any valid date (but this date will not actually be considered when comparing parameter
|
|
values to the specified minimum value, only the time component will be considered).
|
|
|
|
.. seealso:: :py:func:`minimum`
|
|
%End
|
|
|
|
QDateTime maximum() const;
|
|
%Docstring
|
|
Returns the maximum value acceptable by the parameter.
|
|
|
|
An invalid QDateTime value indicates no maximum value.
|
|
|
|
.. seealso:: :py:func:`setMaximum`
|
|
%End
|
|
|
|
void setMaximum( const QDateTime &maximum );
|
|
%Docstring
|
|
Sets the ``maximum`` value acceptable by the parameter.
|
|
|
|
An invalid QDateTime value indicates no maximum value.
|
|
|
|
If the :py:func:`~QgsProcessingParameterDateTime.dataType` is QgsProcessingParameterDateTime.Time, then the date component of ``maximum``
|
|
must be set to any valid date (but this date will not actually be considered when comparing parameter
|
|
values to the specified maximum value, only the time component will be considered).
|
|
|
|
.. seealso:: :py:func:`maximum`
|
|
%End
|
|
|
|
Type dataType() const;
|
|
%Docstring
|
|
Returns the acceptable data type for the parameter.
|
|
|
|
.. seealso:: :py:func:`setDataType`
|
|
%End
|
|
|
|
void setDataType( Type type );
|
|
%Docstring
|
|
Sets the acceptable data ``type`` for the parameter.
|
|
|
|
.. seealso:: :py:func:`dataType`
|
|
%End
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
static QgsProcessingParameterDateTime *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterProviderConnection : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A data provider connection parameter for processing algorithms, allowing users to select from available registered
|
|
connections for a particular data provider.
|
|
|
|
:py:class:`QgsProcessingParameterProviderConnection` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsConnectionName()`.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterProviderConnection( const QString &name, const QString &description, const QString &provider, const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterProviderConnection, for the specified ``provider`` type.
|
|
|
|
.. warning::
|
|
|
|
The provider must support the connection API methods in its :py:class:`QgsProviderMetadata` implementation
|
|
in order for the model to work correctly. This is only implemented for a subset of current data providers.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
|
|
QString providerId() const;
|
|
%Docstring
|
|
Returns the ID of the provider associated with the connections.
|
|
|
|
.. seealso:: :py:func:`setProviderId`
|
|
%End
|
|
|
|
void setProviderId( const QString &provider );
|
|
%Docstring
|
|
Sets the ID of the ``provider`` associated with the connections.
|
|
|
|
.. seealso:: :py:func:`providerId`
|
|
%End
|
|
|
|
static QgsProcessingParameterProviderConnection *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterDatabaseSchema : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A database schema parameter for processing algorithms, allowing users to select from existing schemas
|
|
on a registered database connection.
|
|
|
|
:py:class:`QgsProcessingParameterDatabaseSchema` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsSchema()`.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterDatabaseSchema( const QString &name, const QString &description, const QString &connectionParameterName = QString(), const QVariant &defaultValue = QVariant(),
|
|
bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterDatabaseSchema.
|
|
|
|
The ``connectionParameterName`` specifies the name of the parent :py:class:`QgsProcessingParameterProviderConnection` parameter.
|
|
|
|
.. warning::
|
|
|
|
The provider must support the connection API methods in its :py:class:`QgsProviderMetadata` implementation
|
|
in order for the model to work correctly. This is only implemented for a subset of current data providers.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
virtual QStringList dependsOnOtherParameters() const;
|
|
|
|
|
|
QString parentConnectionParameterName() const;
|
|
%Docstring
|
|
Returns the name of the parent connection parameter, or an empty string if this is not set.
|
|
|
|
.. seealso:: :py:func:`setParentConnectionParameterName`
|
|
%End
|
|
|
|
void setParentConnectionParameterName( const QString &name );
|
|
%Docstring
|
|
Sets the ``name`` of the parent connection parameter. Use an empty string if this is not required.
|
|
|
|
.. seealso:: :py:func:`parentConnectionParameterName`
|
|
%End
|
|
|
|
static QgsProcessingParameterDatabaseSchema *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterDatabaseTable : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
A database table name parameter for processing algorithms, allowing users to select from existing database tables
|
|
on a registered database connection (or optionally to enter a new table name).
|
|
|
|
:py:class:`QgsProcessingParameterDatabaseTable` should be evaluated by calling :py:func:`QgsProcessingAlgorithm.parameterAsDatabaseTableName()`.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterDatabaseTable( const QString &name, const QString &description,
|
|
const QString &connectionParameterName = QString(),
|
|
const QString &schemaParameterName = QString(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false,
|
|
bool allowNewTableNames = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterDatabaseTable.
|
|
|
|
The ``connectionParameterName`` specifies the name of the parent :py:class:`QgsProcessingParameterProviderConnection` parameter.
|
|
The ``schemaParameterName`` specifies the name of the parent :py:class:`QgsProcessingParameterDatabaseSchema` parameter.
|
|
|
|
.. warning::
|
|
|
|
The provider must support the connection API methods in its :py:class:`QgsProviderMetadata` implementation
|
|
in order for the model to work correctly. This is only implemented for a subset of current data providers.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString asScriptCode() const;
|
|
|
|
virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonQgsProcessingAlgorithmSubclass ) const;
|
|
|
|
virtual QVariantMap toVariantMap() const;
|
|
|
|
virtual bool fromVariantMap( const QVariantMap &map );
|
|
|
|
virtual QStringList dependsOnOtherParameters() const;
|
|
|
|
|
|
QString parentConnectionParameterName() const;
|
|
%Docstring
|
|
Returns the name of the parent connection parameter, or an empty string if this is not set.
|
|
|
|
.. seealso:: :py:func:`setParentConnectionParameterName`
|
|
%End
|
|
|
|
void setParentConnectionParameterName( const QString &name );
|
|
%Docstring
|
|
Sets the ``name`` of the parent connection parameter. Use an empty string if this is not required.
|
|
|
|
.. seealso:: :py:func:`parentConnectionParameterName`
|
|
%End
|
|
|
|
QString parentSchemaParameterName() const;
|
|
%Docstring
|
|
Returns the name of the parent schema parameter, or an empty string if this is not set.
|
|
|
|
.. seealso:: :py:func:`setParentSchemaParameterName`
|
|
%End
|
|
|
|
void setParentSchemaParameterName( const QString &name );
|
|
%Docstring
|
|
Sets the ``name`` of the parent schema parameter. Use an empty string if this is not required.
|
|
|
|
.. seealso:: :py:func:`parentSchemaParameterName`
|
|
%End
|
|
|
|
static QgsProcessingParameterDatabaseTable *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
|
|
bool allowNewTableNames() const;
|
|
%Docstring
|
|
Returns ``True`` if the parameter allows users to enter names for
|
|
a new (non-existing) tables.
|
|
|
|
.. seealso:: :py:func:`setAllowNewTableNames`
|
|
%End
|
|
|
|
void setAllowNewTableNames( bool allowed );
|
|
%Docstring
|
|
Sets whether the parameter allows users to enter names for
|
|
a new (non-existing) tables.
|
|
|
|
.. seealso:: :py:func:`allowNewTableNames`
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterPointCloudLayer : QgsProcessingParameterDefinition, QgsFileFilterGenerator
|
|
{
|
|
%Docstring(signature="appended")
|
|
A point cloud layer parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterPointCloudLayer( const QString &name, const QString &description = QString(),
|
|
const QVariant &defaultValue = QVariant(), bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterPointCloudLayer.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
static QgsProcessingParameterPointCloudLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
};
|
|
|
|
|
|
class QgsProcessingParameterAnnotationLayer : QgsProcessingParameterDefinition
|
|
{
|
|
%Docstring(signature="appended")
|
|
An annotation layer parameter for processing algorithms.
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterAnnotationLayer( const QString &name, const QString &description = QString(),
|
|
const QVariant &defaultValue = QVariant(), bool optional = false );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterAnnotationLayer.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
|
|
|
|
virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
|
|
static QgsProcessingParameterAnnotationLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
};
|
|
|
|
class QgsProcessingParameterPointCloudDestination : QgsProcessingDestinationParameter
|
|
{
|
|
%Docstring(signature="appended")
|
|
A point cloud layer destination parameter, for specifying the destination path for a point cloud layer
|
|
created by the algorithm.
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingparameters.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingParameterPointCloudDestination( const QString &name, const QString &description = QString(),
|
|
const QVariant &defaultValue = QVariant(),
|
|
bool optional = false,
|
|
bool createByDefault = true );
|
|
%Docstring
|
|
Constructor for QgsProcessingParameterPointCloudDestination.
|
|
|
|
If ``createByDefault`` is ``False`` and the parameter is ``optional``, then this destination
|
|
output will not be created by default.
|
|
%End
|
|
|
|
static QString typeName();
|
|
%Docstring
|
|
Returns the type name for the parameter class.
|
|
%End
|
|
virtual QgsProcessingParameterDefinition *clone() const /Factory/;
|
|
|
|
virtual QString type() const;
|
|
virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
|
|
|
|
virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
|
|
|
|
virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;
|
|
|
|
virtual QString defaultFileExtension() const;
|
|
|
|
virtual QString createFileFilter() const;
|
|
|
|
|
|
virtual QStringList supportedOutputPointCloudLayerExtensions() const;
|
|
%Docstring
|
|
Returns a list of the point cloud format file extensions supported for this parameter.
|
|
|
|
.. seealso:: :py:func:`defaultFileExtension`
|
|
%End
|
|
|
|
static QgsProcessingParameterPointCloudDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
|
|
%Docstring
|
|
Creates a new parameter using the definition from a script code.
|
|
%End
|
|
};
|
|
|
|
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/processing/qgsprocessingparameters.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|