mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-08 00:05:09 -04:00
790 lines
26 KiB
Plaintext
790 lines
26 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/processing/qgsprocessingutils.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class QgsProcessingUtils
|
|
{
|
|
%Docstring(signature="appended")
|
|
Utility functions for use with processing classes.
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingutils.h"
|
|
%End
|
|
public:
|
|
static const QMetaObject staticMetaObject;
|
|
|
|
public:
|
|
|
|
static QList< QgsRasterLayer * > compatibleRasterLayers( QgsProject *project, bool sort = true );
|
|
%Docstring
|
|
Returns a list of raster layers from a ``project`` which are compatible
|
|
with the processing framework.
|
|
|
|
If the ``sort`` argument is ``True`` then the layers will be sorted by
|
|
their :py:func:`QgsMapLayer.name()` value.
|
|
|
|
.. seealso:: :py:func:`compatibleVectorLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleMeshLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePluginLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePointCloudLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleAnnotationLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorTileLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleTiledSceneLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleLayers`
|
|
%End
|
|
|
|
static QList< QgsVectorLayer * > compatibleVectorLayers( QgsProject *project,
|
|
const QList< int > &sourceTypes = QList< int >(),
|
|
bool sort = true );
|
|
%Docstring
|
|
Returns a list of vector layers from a ``project`` which are compatible
|
|
with the processing framework.
|
|
|
|
The ``sourceTypes`` list should be filled with a list of
|
|
:py:class:`QgsProcessing`.SourceType values. If the ``sourceTypes`` list
|
|
is non-empty then the layers will be sorted so that only layers with the
|
|
specified source type included in the list will be returned. Leaving the
|
|
``sourceTypes`` list empty will cause all vector layers, regardless of
|
|
their geometry type, to be returned.
|
|
|
|
If the ``sort`` argument is ``True`` then the layers will be sorted by
|
|
their :py:func:`QgsMapLayer.name()` value.
|
|
|
|
.. seealso:: :py:func:`compatibleRasterLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleMeshLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePluginLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePointCloudLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleAnnotationLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorTileLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleTiledSceneLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleLayers`
|
|
%End
|
|
|
|
static QList<QgsMeshLayer *> compatibleMeshLayers( QgsProject *project, bool sort = true );
|
|
%Docstring
|
|
Returns a list of mesh layers from a ``project`` which are compatible
|
|
with the processing framework.
|
|
|
|
If the ``sort`` argument is ``True`` then the layers will be sorted by
|
|
their :py:func:`QgsMapLayer.name()` value.
|
|
|
|
.. seealso:: :py:func:`compatibleRasterLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePluginLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePointCloudLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleAnnotationLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorTileLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleTiledSceneLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleLayers`
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
static QList<QgsPluginLayer *> compatiblePluginLayers( QgsProject *project, bool sort = true );
|
|
%Docstring
|
|
Returns a list of plugin layers from a ``project`` which are compatible
|
|
with the processing framework.
|
|
|
|
If the ``sort`` argument is ``True`` then the layers will be sorted by
|
|
their :py:func:`QgsMapLayer.name()` value.
|
|
|
|
.. seealso:: :py:func:`compatibleRasterLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleMeshLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePointCloudLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleAnnotationLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorTileLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleTiledSceneLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleLayers`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
static QList<QgsPointCloudLayer *> compatiblePointCloudLayers( QgsProject *project, bool sort = true );
|
|
%Docstring
|
|
Returns a list of point cloud layers from a ``project`` which are
|
|
compatible with the processing framework.
|
|
|
|
If the ``sort`` argument is ``True`` then the layers will be sorted by
|
|
their :py:func:`QgsMapLayer.name()` value.
|
|
|
|
.. seealso:: :py:func:`compatibleRasterLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleMeshLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePluginLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleAnnotationLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorTileLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleTiledSceneLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleLayers`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
static QList<QgsAnnotationLayer *> compatibleAnnotationLayers( QgsProject *project, bool sort = true );
|
|
%Docstring
|
|
Returns a list of annotation layers from a ``project`` which are
|
|
compatible with the processing framework.
|
|
|
|
If the ``sort`` argument is ``True`` then the layers will be sorted by
|
|
their :py:func:`QgsMapLayer.name()` value.
|
|
|
|
.. seealso:: :py:func:`compatibleRasterLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleMeshLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePluginLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePointCloudLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorTileLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleTiledSceneLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleLayers`
|
|
|
|
.. versionadded:: 3.22
|
|
%End
|
|
|
|
static QList<QgsVectorTileLayer *> compatibleVectorTileLayers( QgsProject *project, bool sort = true );
|
|
%Docstring
|
|
Returns a list of vector tile layers from a ``project`` which are
|
|
compatible with the processing framework.
|
|
|
|
If the ``sort`` argument is ``True`` then the layers will be sorted by
|
|
their :py:func:`QgsMapLayer.name()` value.
|
|
|
|
.. seealso:: :py:func:`compatibleRasterLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleMeshLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePluginLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePointCloudLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleAnnotationLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleTiledSceneLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleLayers`
|
|
|
|
.. versionadded:: 3.32
|
|
%End
|
|
|
|
static QList<QgsTiledSceneLayer *> compatibleTiledSceneLayers( QgsProject *project, bool sort = true );
|
|
%Docstring
|
|
Returns a list of tiled scene layers from a ``project`` which are
|
|
compatible with the processing framework.
|
|
|
|
If the ``sort`` argument is ``True`` then the layers will be sorted by
|
|
their :py:func:`QgsMapLayer.name()` value.
|
|
|
|
.. seealso:: :py:func:`compatibleRasterLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleMeshLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePluginLayers`
|
|
|
|
.. seealso:: :py:func:`compatiblePointCloudLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleAnnotationLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorTileLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleLayers`
|
|
|
|
.. versionadded:: 3.34
|
|
%End
|
|
|
|
static QList< QgsMapLayer * > compatibleLayers( QgsProject *project, bool sort = true );
|
|
%Docstring
|
|
Returns a list of map layers from a ``project`` which are compatible
|
|
with the processing framework.
|
|
|
|
If the ``sort`` argument is ``True`` then the layers will be sorted by
|
|
their :py:func:`QgsMapLayer.name()` value.
|
|
|
|
.. seealso:: :py:func:`compatibleRasterLayers`
|
|
|
|
.. seealso:: :py:func:`compatibleVectorLayers`
|
|
%End
|
|
|
|
static QString encodeProviderKeyAndUri( const QString &providerKey, const QString &uri );
|
|
%Docstring
|
|
Encodes a provider key and layer ``uri`` to a single string, for use
|
|
with :py:func:`~QgsProcessingUtils.decodeProviderKeyAndUri`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
static bool decodeProviderKeyAndUri( const QString &string, QString &providerKey /Out/, QString &uri /Out/ );
|
|
%Docstring
|
|
Decodes a provider key and layer ``uri`` from an encoded string, for use
|
|
with :py:func:`~QgsProcessingUtils.encodeProviderKeyAndUri`
|
|
|
|
:param string: encoded string, as returned by
|
|
:py:func:`~QgsProcessingUtils.encodeProviderKeyAndUri`
|
|
|
|
:return: - ``True`` if ``string`` was successfully decoded
|
|
- providerKey: ID key for corresponding data provider
|
|
- uri: decoded layer uri
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
enum class LayerHint
|
|
{
|
|
UnknownType,
|
|
Vector,
|
|
Raster,
|
|
Mesh,
|
|
PointCloud,
|
|
Annotation,
|
|
VectorTile,
|
|
TiledScene,
|
|
};
|
|
|
|
static QgsMapLayer *mapLayerFromString( const QString &string, QgsProcessingContext &context, bool allowLoadingNewLayers = true, QgsProcessingUtils::LayerHint typeHint = QgsProcessingUtils::LayerHint::UnknownType, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags() );
|
|
%Docstring
|
|
Interprets a string as a map layer within the supplied ``context``.
|
|
|
|
The method will attempt to load a layer matching the passed ``string``.
|
|
E.g. if the string matches a layer ID or name within the context's
|
|
project or temporary layer store then this layer will be returned. If
|
|
the string is a file path and ``allowLoadingNewLayers`` is ``True``,
|
|
then the layer at this file path will be loaded and added to the
|
|
context's temporary layer store. Ownership of the layer remains with the
|
|
``context`` or the context's current project.
|
|
|
|
The ``typeHint`` can be used to dictate the type of map layer expected.
|
|
%End
|
|
|
|
static QgsProcessingFeatureSource *variantToSource( const QVariant &value, QgsProcessingContext &context, const QVariant &fallbackValue = QVariant() ) /Factory/;
|
|
%Docstring
|
|
Converts a variant ``value`` to a new feature source.
|
|
|
|
Sources will either be taken from ``context``'s active project, or
|
|
loaded from external sources and stored temporarily in the ``context``.
|
|
|
|
The optional ``fallbackValue`` can be used to specify a "default" value
|
|
which is used if ``value`` cannot be successfully converted to a source.
|
|
|
|
This function creates a new object and the caller takes responsibility
|
|
for deleting the returned object.
|
|
%End
|
|
|
|
static QgsCoordinateReferenceSystem variantToCrs( const QVariant &value, QgsProcessingContext &context, const QVariant &fallbackValue = QVariant() );
|
|
%Docstring
|
|
Converts a variant ``value`` to a coordinate reference system.
|
|
|
|
The optional ``fallbackValue`` can be used to specify a "default" value
|
|
which is used if ``value`` cannot be successfully converted to a CRS.
|
|
|
|
.. versionadded:: 3.12
|
|
%End
|
|
|
|
static QString normalizeLayerSource( const QString &source ) /HoldGIL/;
|
|
%Docstring
|
|
Normalizes a layer ``source`` string for safe comparison across
|
|
different operating system environments.
|
|
%End
|
|
|
|
static QString layerToStringIdentifier( const QgsMapLayer *layer, const QString &layerName = QString() ) /HoldGIL/;
|
|
%Docstring
|
|
Returns a string representation of the source for a ``layer``. The
|
|
returned value is suitable for storage for subsequent executions of an
|
|
algorithm using the same layer source.
|
|
|
|
.. versionadded:: 3.34
|
|
%End
|
|
|
|
static QString variantToPythonLiteral( const QVariant &value );
|
|
%Docstring
|
|
Converts a variant to a Python literal.
|
|
|
|
.. seealso:: :py:func:`stringToPythonLiteral`
|
|
|
|
.. versionadded:: 3.6
|
|
%End
|
|
|
|
static QString stringToPythonLiteral( const QString &string ) /HoldGIL/;
|
|
%Docstring
|
|
Converts a string to a Python string literal. E.g. by replacing ' with
|
|
\'.
|
|
|
|
.. seealso:: :py:func:`variantToPythonLiteral`
|
|
%End
|
|
|
|
|
|
static void createFeatureSinkPython( QgsFeatureSink **sink /Out,TransferBack/, QString &destination /In,Out/, QgsProcessingContext &context, const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs, const QVariantMap &createOptions = QVariantMap() ) throw( QgsProcessingException ) /PyName=createFeatureSink/;
|
|
%Docstring
|
|
Creates a feature sink ready for adding features. The ``destination``
|
|
specifies a destination URI for the resultant layer. It may be updated
|
|
in place to reflect the actual destination for the layer.
|
|
|
|
Sink parameters such as desired ``fields``, ``geometryType`` and ``crs``
|
|
must be specified.
|
|
|
|
The ``createOptions`` map can be used to specify additional sink
|
|
creation options, which are passed to the underlying provider when
|
|
creating new layers. Known options also include 'fileEncoding', which is
|
|
used to specify a file encoding to use for created files. If
|
|
'fileEncoding' is not specified, the default encoding from the
|
|
``context`` will be used.
|
|
|
|
If a layer is created for the feature sink, the layer will automatically
|
|
be added to the ``context``'s temporary layer store.
|
|
|
|
.. note::
|
|
|
|
this version of the :py:func:`~QgsProcessingUtils.createFeatureSink` function has an API designed around use from the
|
|
SIP bindings. c++ code should call the other :py:func:`~QgsProcessingUtils.createFeatureSink` version.
|
|
|
|
|
|
%End
|
|
|
|
|
|
static QgsRectangle combineLayerExtents( const QList<QgsMapLayer *> &layers, const QgsCoordinateReferenceSystem &crs, QgsProcessingContext &context );
|
|
%Docstring
|
|
Combines the extent of several map ``layers``. If specified, the target
|
|
``crs`` will be used to transform the layer's extent to the desired
|
|
output reference system using the specified ``context``.
|
|
|
|
.. versionadded:: 3.8
|
|
%End
|
|
|
|
static QgsRectangle combineLayerExtents( const QList<QgsMapLayer *> &layers, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() ) /Deprecated="Since 3.40. Use version with QgsProcessingContext argument instead."/;
|
|
%Docstring
|
|
Combines the extent of several map ``layers``. If specified, the target
|
|
``crs`` will be used to transform the layer's extent to the desired
|
|
output reference system.
|
|
|
|
.. deprecated:: 3.40
|
|
|
|
Use version with :py:class:`QgsProcessingContext` argument instead.
|
|
%End
|
|
|
|
static QVariant generateIteratingDestination( const QVariant &input, const QVariant &id, QgsProcessingContext &context );
|
|
%Docstring
|
|
Converts an ``input`` parameter value for use in source iterating mode,
|
|
where one individual sink is created per input feature. The ``id``
|
|
parameter represents the unique ID for this output, which is embedded
|
|
into the resulting parameter value.
|
|
%End
|
|
|
|
static QString tempFolder( const QgsProcessingContext *context = 0 );
|
|
%Docstring
|
|
Returns a session specific processing temporary folder for use in
|
|
processing algorithms.
|
|
|
|
.. seealso:: :py:func:`generateTempFilename`
|
|
%End
|
|
|
|
static QString generateTempFilename( const QString &basename, const QgsProcessingContext *context = 0 );
|
|
%Docstring
|
|
Returns a temporary filename for a given file, putting it into a
|
|
temporary folder (creating that folder in the process), but not changing
|
|
the ``basename``.
|
|
|
|
.. seealso:: :py:func:`tempFolder`
|
|
%End
|
|
|
|
static QString formatHelpMapAsHtml( const QVariantMap &map, const QgsProcessingAlgorithm *algorithm );
|
|
%Docstring
|
|
Returns a HTML formatted version of the help text encoded in a variant
|
|
``map`` for a specified ``algorithm``.
|
|
%End
|
|
|
|
static int outputDefinitionIndex( const QgsProcessingAlgorithm *algorithm, const QString &name ) /HoldGIL/;
|
|
%Docstring
|
|
Returns the index of the output matching ``name`` for a specified
|
|
``algorithm``. Matching is done in a case-insensitive manner.
|
|
|
|
.. versionadded:: 3.44
|
|
%End
|
|
|
|
static QString convertToCompatibleFormat( const QgsVectorLayer *layer,
|
|
bool selectedFeaturesOnly,
|
|
const QString &baseName,
|
|
const QStringList &compatibleFormats,
|
|
const QString &preferredFormat,
|
|
QgsProcessingContext &context,
|
|
QgsProcessingFeedback *feedback,
|
|
long long featureLimit = -1,
|
|
const QString &filterExpression = QString() );
|
|
%Docstring
|
|
Converts a source vector ``layer`` to a file path of a vector layer of
|
|
compatible format.
|
|
|
|
If the specified ``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 using ``baseName``. 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.
|
|
|
|
The ``featureLimit`` argument can be used to specify a limit on the
|
|
number of features read from the layer.
|
|
|
|
Since QGIS 3.32, the optional ``filterExpression`` argument can be used
|
|
to specify a expression to use to filter the features read from the
|
|
layer.
|
|
|
|
When an algorithm is capable of handling multi-layer input files (such
|
|
as Geopackage), it is preferable to use
|
|
:py:func:`~QgsProcessingUtils.convertToCompatibleFormatAndLayerName`
|
|
which may avoid conversion in more situations.
|
|
|
|
.. seealso:: :py:func:`convertToCompatibleFormatAndLayerName`
|
|
%End
|
|
|
|
static QString convertToCompatibleFormatAndLayerName( const QgsVectorLayer *layer,
|
|
bool selectedFeaturesOnly,
|
|
const QString &baseName,
|
|
const QStringList &compatibleFormats,
|
|
const QString &preferredFormat,
|
|
QgsProcessingContext &context,
|
|
QgsProcessingFeedback *feedback,
|
|
QString &layerName /Out/,
|
|
long long featureLimit = -1,
|
|
const QString &filterExpression = QString() );
|
|
%Docstring
|
|
Converts a source vector ``layer`` to a file path and layer name of a
|
|
vector layer of compatible format.
|
|
|
|
If the specified ``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 using ``baseName``. The
|
|
function will then return the path to that temporary file.
|
|
|
|
``compatibleFormats`` should consist entirely of lowercase file
|
|
extensions, e.g. 'shp'.
|
|
|
|
The ``featureLimit`` argument can be used to specify a limit on the
|
|
number of features read from the layer.
|
|
|
|
The ``preferredFormat`` argument is used to specify to desired file
|
|
extension to use when a temporary layer export is required. This
|
|
defaults to shapefiles.
|
|
|
|
This method should be preferred over
|
|
:py:func:`~QgsProcessingUtils.convertToCompatibleFormat` when an
|
|
algorithm is able to correctly handle files with multiple layers. Unlike
|
|
:py:func:`~QgsProcessingUtils.convertToCompatibleFormat`, it will not
|
|
force a conversion in this case and will return the target layer name in
|
|
the ``layerName`` argument.
|
|
|
|
:param layer: source layer to convert (if required)
|
|
:param selectedFeaturesOnly: ``True`` if only selected features from the
|
|
layer should be used
|
|
:param baseName: base file name for converted layer, if required
|
|
:param compatibleFormats: a list of lowercase file extensions compatible
|
|
with the algorithm
|
|
:param preferredFormat: preferred format extension to use if conversion
|
|
if required
|
|
:param context: processing context
|
|
:param feedback: feedback object
|
|
:param featureLimit: can be used to place a limit on the maximum number
|
|
of features read from the layer
|
|
:param filterExpression: optional expression for filtering features read
|
|
from the layer (since QGIS 3.32)
|
|
|
|
:return: - path to source layer, or nearly converted compatible layer
|
|
- layerName: the target layer name for multi-layer sources
|
|
(e.g. Geopackage)
|
|
|
|
.. seealso:: :py:func:`convertToCompatibleFormat`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QgsFields combineFields( const QgsFields &fieldsA, const QgsFields &fieldsB, const QString &fieldsBPrefix = QString() ) /HoldGIL/;
|
|
%Docstring
|
|
Combines two field lists, avoiding duplicate field names (in a
|
|
case-insensitive manner).
|
|
|
|
Duplicate field names will be altered to "name_2", "name_3", etc,
|
|
finding the first non-duplicate name.
|
|
|
|
.. note::
|
|
|
|
Some output file formats (e.g. shapefiles) have restrictions on the maximum
|
|
length of field names, so be aware that the results of calling this method may
|
|
be truncated when saving to these formats.
|
|
%End
|
|
|
|
static QList<int> fieldNamesToIndices( const QStringList &fieldNames, const QgsFields &fields ) /HoldGIL/;
|
|
%Docstring
|
|
Returns a list of field indices parsed from the given list of field
|
|
names. Unknown field names are ignored. If the list of field names is
|
|
empty, it is assumed that all fields are required.
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
static QgsFields indicesToFields( const QList<int> &indices, const QgsFields &fields ) /HoldGIL/;
|
|
%Docstring
|
|
Returns a subset of fields based on the indices of desired fields.
|
|
|
|
.. versionadded:: 3.2
|
|
%End
|
|
|
|
static QString defaultVectorExtension();
|
|
%Docstring
|
|
Returns the default vector extension to use, in the absence of all other
|
|
constraints (e.g. provider based support for extensions).
|
|
|
|
This method returns the user-set default extension from the processing
|
|
settings, or a fallback value of "gpkg".
|
|
|
|
.. seealso:: :py:func:`defaultRasterExtension`
|
|
|
|
.. seealso:: :py:func:`defaultPointCloudExtension`
|
|
|
|
.. seealso:: :py:func:`defaultVectorTileExtension`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QString defaultRasterExtension();
|
|
%Docstring
|
|
Returns the default raster extension to use, in the absence of all other
|
|
constraints (e.g. provider based support for extensions).
|
|
|
|
This method returns the user-set default extension from the processing
|
|
settings, or a fallback value of "tif".
|
|
|
|
.. seealso:: :py:func:`defaultVectorExtension`
|
|
|
|
.. seealso:: :py:func:`defaultPointCloudExtension`
|
|
|
|
.. seealso:: :py:func:`defaultVectorTileExtension`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QString defaultPointCloudExtension();
|
|
%Docstring
|
|
Returns the default point cloud extension to use, in the absence of all
|
|
other constraints (e.g. provider based support for extensions).
|
|
|
|
This method returns a fallback value of "las".
|
|
|
|
.. seealso:: :py:func:`defaultVectorExtension`
|
|
|
|
.. seealso:: :py:func:`defaultRasterExtension`
|
|
|
|
.. seealso:: :py:func:`defaultVectorTileExtension`
|
|
|
|
.. versionadded:: 3.24
|
|
%End
|
|
|
|
static QString defaultVectorTileExtension();
|
|
%Docstring
|
|
Returns the default vector tile extension to use, in the absence of all
|
|
other constraints (e.g. provider based support for extensions).
|
|
|
|
This method returns a fallback value of "mbtiles".
|
|
|
|
.. seealso:: :py:func:`defaultVectorExtension`
|
|
|
|
.. seealso:: :py:func:`defaultRasterExtension`
|
|
|
|
.. seealso:: :py:func:`defaultPointCloudExtension`
|
|
|
|
.. versionadded:: 3.32
|
|
%End
|
|
|
|
static QVariantMap removePointerValuesFromMap( const QVariantMap &map );
|
|
%Docstring
|
|
Removes any raw pointer values from an input ``map``, replacing them
|
|
with appropriate string values where possible.
|
|
|
|
.. versionadded:: 3.26
|
|
%End
|
|
|
|
static QVariantMap preprocessQgisProcessParameters( const QVariantMap ¶meters, bool &ok, QString &error );
|
|
%Docstring
|
|
Pre-processes a set of ``parameter`` values for the qgis_process
|
|
command.
|
|
|
|
In particular, this function upgrades encoded data defined values to
|
|
:py:class:`QgsProperty` objects.
|
|
|
|
.. versionadded:: 3.30
|
|
%End
|
|
|
|
static QString resolveDefaultEncoding( const QString &defaultEncoding = "System" );
|
|
%Docstring
|
|
Returns the default encoding.
|
|
|
|
The default encoding could be the one from "/Processing/encoding" or
|
|
when it's not an allowed encoding name like "System", the default
|
|
encoding system (mostly UTF-8 on Unix-like, windows-1252 on Windows).
|
|
|
|
.. versionadded:: 3.32
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsProcessingFeatureSource : QgsFeatureSource
|
|
{
|
|
%Docstring(signature="appended")
|
|
:py:class:`QgsFeatureSource` subclass which proxies methods to an
|
|
underlying :py:class:`QgsFeatureSource`, modifying results according to
|
|
the settings in a :py:class:`QgsProcessingContext`.
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingutils.h"
|
|
%End
|
|
public:
|
|
|
|
QgsProcessingFeatureSource( QgsFeatureSource *originalSource, const QgsProcessingContext &context, bool ownsOriginalSource = false,
|
|
long long featureLimit = -1, const QString &filterExpression = QString() );
|
|
%Docstring
|
|
Constructor for QgsProcessingFeatureSource, accepting an original
|
|
feature source ``originalSource`` and processing ``context``. Ownership
|
|
of ``originalSource`` is dictated by ``ownsOriginalSource``. If
|
|
``ownsOriginalSource`` is ``False``, ownership is not transferred, and
|
|
callers must ensure that ``originalSource`` exists for the lifetime of
|
|
this object. If ``ownsOriginalSource`` is ``True``, then this object
|
|
will take ownership of ``originalSource``.
|
|
|
|
If ``featureLimit`` is set to a value > 0, then a limit is placed on the
|
|
maximum number of features which will be read from the source.
|
|
|
|
Since QGIS 3.32, the optional ``filterExpression`` can be used to
|
|
specify an expression based filter for the source.
|
|
%End
|
|
|
|
~QgsProcessingFeatureSource();
|
|
|
|
QgsFeatureIterator getFeatures( const QgsFeatureRequest &request, Qgis::ProcessingFeatureSourceFlags flags ) const;
|
|
%Docstring
|
|
Returns an iterator for the features in the source, respecting the
|
|
supplied feature ``flags``. An optional ``request`` can be used to
|
|
optimise the returned iterator, eg by restricting the returned
|
|
attributes or geometry.
|
|
%End
|
|
|
|
virtual Qgis::FeatureAvailability hasFeatures() const;
|
|
|
|
|
|
virtual QgsFeatureIterator getFeatures( const QgsFeatureRequest &request = QgsFeatureRequest() ) const;
|
|
|
|
virtual QgsCoordinateReferenceSystem sourceCrs() const;
|
|
|
|
virtual QgsFields fields() const;
|
|
|
|
virtual Qgis::WkbType wkbType() const;
|
|
|
|
virtual long long featureCount() const;
|
|
|
|
virtual QString sourceName() const;
|
|
|
|
virtual QSet<QVariant> uniqueValues( int fieldIndex, int limit = -1 ) const;
|
|
|
|
virtual QVariant minimumValue( int fieldIndex ) const;
|
|
|
|
virtual QVariant maximumValue( int fieldIndex ) const;
|
|
|
|
virtual QgsRectangle sourceExtent() const;
|
|
|
|
virtual QgsFeatureIds allFeatureIds() const;
|
|
|
|
virtual Qgis::SpatialIndexPresence hasSpatialIndex() const;
|
|
|
|
|
|
QgsExpressionContextScope *createExpressionContextScope() const /Factory/;
|
|
%Docstring
|
|
Returns an expression context scope suitable for this source.
|
|
%End
|
|
|
|
void setInvalidGeometryCheck( Qgis::InvalidGeometryCheck method );
|
|
%Docstring
|
|
Overrides the default geometry check method for the source.
|
|
|
|
.. seealso:: :py:func:`invalidGeometryCheck`
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
Qgis::InvalidGeometryCheck invalidGeometryCheck() const;
|
|
%Docstring
|
|
Returns the geometry check method for the source.
|
|
|
|
.. seealso:: :py:func:`setInvalidGeometryCheck`
|
|
|
|
.. versionadded:: 3.36
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/processing/qgsprocessingutils.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.py again *
|
|
************************************************************************/
|