mirror of
https://github.com/qgis/QGIS.git
synced 2025-03-12 00:02:25 -04:00
cfcf580b61
output format This setting is still used and required in some circumstances, e.g. it is used as the default selection in outputs file pickers when the previously used format is not valid.
386 lines
14 KiB
Plaintext
386 lines
14 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
|
|
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 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
|
|
|
|
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 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 createFeatureSink() function has an API designed around use from the
|
|
SIP bindings. c++ code should call the other createFeatureSink() version.
|
|
|
|
.. note::
|
|
|
|
available in Python bindings as 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 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 );
|
|
%Docstring
|
|
Converts a source vector ``layer`` to a file path to 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.
|
|
%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
|
|
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 );
|
|
%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``.
|
|
%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 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;
|
|
|
|
|
|
QgsExpressionContextScope *createExpressionContextScope() const /Factory/;
|
|
%Docstring
|
|
Returns an expression context scope suitable for this source.
|
|
%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 *
|
|
************************************************************************/
|