mirror of
https://github.com/qgis/QGIS.git
synced 2025-10-31 00:06:02 -04:00
483 lines
18 KiB
Plaintext
483 lines
18 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/processing/qgsprocessingutils.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class QgsProcessingUtils
|
|
{
|
|
%Docstring(signature="appended")
|
|
Utility functions for use with processing classes.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingutils.h"
|
|
%End
|
|
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:`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:`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:`compatibleLayers`
|
|
|
|
.. versionadded:: 3.6
|
|
%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,
|
|
};
|
|
|
|
static QgsMapLayer *mapLayerFromString( const QString &string, QgsProcessingContext &context, bool allowLoadingNewLayers = true, QgsProcessingUtils::LayerHint typeHint = QgsProcessingUtils::LayerHint::UnknownType );
|
|
%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 );
|
|
%Docstring
|
|
Normalizes a layer ``source`` string for safe comparison across different
|
|
operating system environments.
|
|
%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 );
|
|
%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, QgsWkbTypes::Type 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.
|
|
|
|
.. note::
|
|
|
|
available in Python bindings as :py:func:`~QgsProcessingUtils.createFeatureSink`
|
|
%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/;
|
|
%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::
|
|
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();
|
|
%Docstring
|
|
Returns a session specific processing temporary folder for use in processing algorithms.
|
|
|
|
.. seealso:: :py:func:`generateTempFilename`
|
|
%End
|
|
|
|
static QString generateTempFilename( const QString &basename );
|
|
%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 QString convertToCompatibleFormat( const QgsVectorLayer *layer,
|
|
bool selectedFeaturesOnly,
|
|
const QString &baseName,
|
|
const QStringList &compatibleFormats,
|
|
const QString &preferredFormat,
|
|
QgsProcessingContext &context,
|
|
QgsProcessingFeedback *feedback, long long featureLimit = -1 );
|
|
%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.
|
|
|
|
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 );
|
|
%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
|
|
|
|
: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:`convertToCompatibleFormat`
|
|
|
|
.. versionadded:: 3.10
|
|
%End
|
|
|
|
static QgsFields combineFields( const QgsFields &fieldsA, const QgsFields &fieldsB, const QString &fieldsBPrefix = QString() );
|
|
%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 );
|
|
%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 );
|
|
%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`
|
|
|
|
.. 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`
|
|
|
|
.. versionadded:: 3.10
|
|
%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`.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsprocessingutils.h"
|
|
%End
|
|
public:
|
|
|
|
enum Flag
|
|
{
|
|
FlagSkipGeometryValidityChecks,
|
|
};
|
|
typedef QFlags<QgsProcessingFeatureSource::Flag> Flags;
|
|
|
|
|
|
QgsProcessingFeatureSource( QgsFeatureSource *originalSource, const QgsProcessingContext &context, bool ownsOriginalSource = false,
|
|
long long featureLimit = -1 );
|
|
%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.
|
|
%End
|
|
|
|
~QgsProcessingFeatureSource();
|
|
|
|
QgsFeatureIterator getFeatures( const QgsFeatureRequest &request, Flags 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 QgsFeatureSource::FeatureAvailability hasFeatures() const;
|
|
|
|
|
|
virtual QgsFeatureIterator getFeatures( const QgsFeatureRequest &request = QgsFeatureRequest() ) const;
|
|
|
|
virtual QgsCoordinateReferenceSystem sourceCrs() const;
|
|
|
|
virtual QgsFields fields() const;
|
|
|
|
virtual QgsWkbTypes::Type 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 SpatialIndexPresence hasSpatialIndex() const;
|
|
|
|
|
|
QgsExpressionContextScope *createExpressionContextScope() const /Factory/;
|
|
%Docstring
|
|
Returns an expression context scope suitable for this source.
|
|
%End
|
|
|
|
void setInvalidGeometryCheck( QgsFeatureRequest::InvalidGeometryCheck method );
|
|
%Docstring
|
|
Overrides the default geometry check method for the source.
|
|
|
|
.. versionadded:: 3.14
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/processing/qgsprocessingutils.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|