23.9. Escribir nuevos algoritmos de procesamiento como scripts de Python

Extendiendo QgsProcessingAlgorithm
El decorador @alg
Tipos de entrada y salida para algoritmos de procesamiento
- Tipos de entrada
- Tipos de salida
Manejo de salida de algoritmo
La comunicación con el usuario
Documentando sus scripts
Banderas
Las mejores practivas al escribir scripts de algoritmos

Hay dos opciones para escribir algoritmos de procesamiento usando Python.

Dentro de QGIS, puede usar Crear nuevo script en el menú :guilabel:` Scripts` en la parte superior de Barra de Herramientas Procesos para abrir Editor de Scripst de Procesos donde puede escribir tu codigo. Para simplificar la tarea, puede comenzar con una plantilla de script usando Crear nuevo script desde plantilla del mismo menú. Esto abre una plantilla que se extiende QgsProcessingAlgorithm.

Si guarda el script en la carpeta: file: scripts (la ubicación predeterminada) con la extensión .py, el algoritmo estará disponible en Caja de Herramientas de Procesos.

23.9.1. Extendiendo QgsProcessingAlgorithm 

El siguiente código

toma una capa vectorial como entrada
cuenta el número de objetos
hace una operación de buffer
crea una capa ráster a partir del resultado de la operación buffer
devuelve la capa buffer, la capa ráster y el número de objetos

from qgis.PyQt.QtCore import QCoreApplication
from qgis.core import (QgsProcessing,
                       QgsProcessingAlgorithm,
                       QgsProcessingException,
                       QgsProcessingOutputNumber,
                       QgsProcessingParameterDistance,
                       QgsProcessingParameterFeatureSource,
                       QgsProcessingParameterVectorDestination,
                       QgsProcessingParameterRasterDestination)
from qgis import processing


class ExampleProcessingAlgorithm(QgsProcessingAlgorithm):
    """
    This is an example algorithm that takes a vector layer,
    creates some new layers and returns some results.
    """

    def tr(self, string):
        """
        Returns a translatable string with the self.tr() function.
        """
        return QCoreApplication.translate('Processing', string)

    def createInstance(self):
        # Must return a new copy of your algorithm.
        return ExampleProcessingAlgorithm()

    def name(self):
        """
        Returns the unique algorithm name.
        """
        return 'bufferrasterextend'

    def displayName(self):
        """
        Returns the translated algorithm name.
        """
        return self.tr('Buffer and export to raster (extend)')

    def group(self):
        """
        Returns the name of the group this algorithm belongs to.
        """
        return self.tr('Example scripts')

    def groupId(self):
        """
        Returns the unique ID of the group this algorithm belongs
        to.
        """
        return 'examplescripts'

    def shortHelpString(self):
        """
        Returns a localised short help string for the algorithm.
        """
        return self.tr('Example algorithm short description')

    def initAlgorithm(self, config=None):
        """
        Here we define the inputs and outputs of the algorithm.
        """
        # 'INPUT' is the recommended name for the main input
        # parameter.
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                'INPUT',
                self.tr('Input vector layer'),
                types=[QgsProcessing.TypeVectorAnyGeometry]
            )
        )
        self.addParameter(
            QgsProcessingParameterVectorDestination(
                'BUFFER_OUTPUT',
                self.tr('Buffer output'),
            )
        )
        # 'OUTPUT' is the recommended name for the main output
        # parameter.
        self.addParameter(
            QgsProcessingParameterRasterDestination(
                'OUTPUT',
                self.tr('Raster output')
            )
        )
        self.addParameter(
            QgsProcessingParameterDistance(
                'BUFFERDIST',
                self.tr('BUFFERDIST'),
                defaultValue = 1.0,
                # Make distance units match the INPUT layer units:
                parentParameterName='INPUT'
            )
        )
        self.addParameter(
            QgsProcessingParameterDistance(
                'CELLSIZE',
                self.tr('CELLSIZE'),
                defaultValue = 10.0,
                parentParameterName='INPUT'
            )
        )
        self.addOutput(
            QgsProcessingOutputNumber(
                'NUMBEROFFEATURES',
                self.tr('Number of features processed')
            )
        )

    def processAlgorithm(self, parameters, context, feedback):
        """
        Here is where the processing itself takes place.
        """
        # First, we get the count of features from the INPUT layer.
        # This layer is defined as a QgsProcessingParameterFeatureSource
        # parameter, so it is retrieved by calling
        # self.parameterAsSource.
        input_featuresource = self.parameterAsSource(parameters,
                                                     'INPUT',
                                                     context)
        numfeatures = input_featuresource.featureCount()

        # Retrieve the buffer distance and raster cell size numeric
        # values. Since these are numeric values, they are retrieved
        # using self.parameterAsDouble.
        bufferdist = self.parameterAsDouble(parameters, 'BUFFERDIST',
                                            context)
        rastercellsize = self.parameterAsDouble(parameters, 'CELLSIZE',
                                                context)
        if feedback.isCanceled():
            return {}
        buffer_result = processing.run(
            'native:buffer',
            {
                # Here we pass on the original parameter values of INPUT
                # and BUFFER_OUTPUT to the buffer algorithm.
                'INPUT': parameters['INPUT'],
                'OUTPUT': parameters['BUFFER_OUTPUT'],
                'DISTANCE': bufferdist,
                'SEGMENTS': 10,
                'DISSOLVE': True,
                'END_CAP_STYLE': 0,
                'JOIN_STYLE': 0,
                'MITER_LIMIT': 10
            },
            # Because the buffer algorithm is being run as a step in
            # another larger algorithm, the is_child_algorithm option
            # should be set to True
            is_child_algorithm=True,
            #
            # It's important to pass on the context and feedback objects to
            # child algorithms, so that they can properly give feedback to
            # users and handle cancelation requests.
            context=context,
            feedback=feedback)

        # Check for cancelation
        if feedback.isCanceled():
            return {}

        # Run the separate rasterization algorithm using the buffer result
        # as an input.
        rasterized_result = processing.run(
            'qgis:rasterize',
            {
                # Here we pass the 'OUTPUT' value from the buffer's result
                # dictionary off to the rasterize child algorithm.
                'LAYER': buffer_result['OUTPUT'],
                'EXTENT': buffer_result['OUTPUT'],
                'MAP_UNITS_PER_PIXEL': rastercellsize,
                # Use the original parameter value.
                'OUTPUT': parameters['OUTPUT']
            },
            is_child_algorithm=True,
            context=context,
            feedback=feedback)

        if feedback.isCanceled():
            return {}

        # Return the results
        return {'OUTPUT': rasterized_result['OUTPUT'],
                'BUFFER_OUTPUT': buffer_result['OUTPUT'],
                'NUMBEROFFEATURES': numfeatures}

Funciones estándar del algoritmo de Porcesamiento:

createInstance (obligatorio)
Debe devolver una nueva copia de su algoritmo. Si cambia el nombre de la clase, asegúrese de actualizar también el valor devuelto aquí para que coincida.
nombre (obligatorio)
Devuelve el nombre exclusivo del algoritmo, que se utiliza para identificar el algoritmo.
displayName (obligatorio)
Devuelve el nombre del algoritmo traducido.
grupo
Devuelve el nombre del grupo al que pertenece este algoritmo.
groupId
Devuelve el ID único del grupo al que pertenece este algoritmo.
shortHelpString
Devuelve una cadena de ayuda corta localizada para el algoritmo.
initAlgorithm (obligatorio)
Aquí definimos las entradas y salidas del algoritmo.

INPUT y OUTPUT son nombres recomendados para los parámetros de entrada y salida principal, respectivamente.

Si un parámetro depende de otro parámetro, se usa parentParameterName para especificar esta relación (podría ser el campo / banda de una capa o las unidades de distancia de una capa).
processAlgorithm (obligatorio)
Aquí es donde tiene lugar el procesamiento.

Los parámetros se recuperan mediante funciones especiales, por ejemplo, parameterAsSource y parameterAsDouble.

processing.run se puede utilizar para ejecutar otros algoritmos de procesamiento desde un algoritmo de procesamiento. El primer parámetro es el nombre del algoritmo, el segundo es un diccionario de los parámetros del algoritmo. Is_child_algorithm normalmente se establece en True cuando se ejecuta un algoritmo desde dentro de otro algoritmo. El contexto y la retroalimentación informan al algoritmo sobre el entorno en el que se ejecutará y el canal para comunicarse con el usuario (capturando la solicitud de cancelación, reportando el progreso, proporcionando retroalimentación textual). Cuando se utilizan los parámetros del algoritmo (principal) como parámetros de los algoritmos «secundarios», se deben utilizar los valores de los parámetros originales (por ejemplo, parámetros ['OUTPUT']).

¡Es una buena práctica verificar el objeto de retroalimentación para la cancelación tanto como sea posible! Hacerlo permite una cancelación receptiva, en lugar de obligar a los usuarios a esperar a que ocurra un procesamiento no deseado.

El algoritmo debe devolver valores para todos los parámetros de salida que ha definido como diccionario. En este caso, eso es el búfer y las capas de salida rasterizadas, y el recuento de entidades procesadas. Las claves del diccionario deben coincidir con los nombres de salida / parámetros originales.

23.9.2. El decorador @alg 

Con el decorador @alg, puede crear sus propios algoritmos escribiendo el código Python y agregando algunas líneas adicionales para proporcionar la información adicional necesaria para convertirlo en un algoritmo de procesamiento adecuado. Esto simplifica la creación de algoritmos y la especificación de entradas y salidas.

Una limitación importante con el enfoque del decorador es que los algoritmos creados de esta manera siempre se agregarán al proveedor de Scripts de procesamiento de un usuario; no es posible agregar estos algoritmos a un proveedor personalizado, p. Ej. para su uso en complementos.

EL siguiente ejemplo usa el decorador @alg a

usa una capa vectorial como entrada
cuenta el número de objetos
hace una operación buffer
crea una capa ráster a partir del resultado de la operación buffer
devuelve la capa buffer, la capa ráster y el número de objetos

from qgis import processing
from qgis.processing import alg
from qgis.core import QgsProject

@alg(name='bufferrasteralg', label='Buffer and export to raster (alg)',
     group='examplescripts', group_label='Example scripts')
# 'INPUT' is the recommended name for the main input parameter
@alg.input(type=alg.SOURCE, name='INPUT', label='Input vector layer')
# 'OUTPUT' is the recommended name for the main output parameter
@alg.input(type=alg.RASTER_LAYER_DEST, name='OUTPUT',
           label='Raster output')
@alg.input(type=alg.VECTOR_LAYER_DEST, name='BUFFER_OUTPUT',
           label='Buffer output')
@alg.input(type=alg.DISTANCE, name='BUFFERDIST', label='BUFFER DISTANCE',
           default=1.0)
@alg.input(type=alg.DISTANCE, name='CELLSIZE', label='RASTER CELL SIZE',
           default=10.0)
@alg.output(type=alg.NUMBER, name='NUMBEROFFEATURES',
            label='Number of features processed')

def bufferrasteralg(instance, parameters, context, feedback, inputs):
    """
    Description of the algorithm.
    (If there is no comment here, you will get an error)
    """
    input_featuresource = instance.parameterAsSource(parameters,
                                                     'INPUT', context)
    numfeatures = input_featuresource.featureCount()
    bufferdist = instance.parameterAsDouble(parameters, 'BUFFERDIST',
                                            context)
    rastercellsize = instance.parameterAsDouble(parameters, 'CELLSIZE',
                                                context)
    if feedback.isCanceled():
        return {}
    buffer_result = processing.run('native:buffer',
                               {'INPUT': parameters['INPUT'],
                                'OUTPUT': parameters['BUFFER_OUTPUT'],
                                'DISTANCE': bufferdist,
                                'SEGMENTS': 10,
                                'DISSOLVE': True,
                                'END_CAP_STYLE': 0,
                                'JOIN_STYLE': 0,
                                'MITER_LIMIT': 10
                                },
                               is_child_algorithm=True,
                               context=context,
                               feedback=feedback)
    if feedback.isCanceled():
        return {}
    rasterized_result = processing.run('qgis:rasterize',
                               {'LAYER': buffer_result['OUTPUT'],
                                'EXTENT': buffer_result['OUTPUT'],
                                'MAP_UNITS_PER_PIXEL': rastercellsize,
                                'OUTPUT': parameters['OUTPUT']
                               },
                               is_child_algorithm=True, context=context,
                               feedback=feedback)
    if feedback.isCanceled():
        return {}
    return {'OUTPUT': rasterized_result['OUTPUT'],
            'BUFFER_OUTPUT': buffer_result['OUTPUT'],
            'NUMBEROFFEATURES': numfeatures}

Como puede ver, involucra dos algoritmos (“native:buffer” y “qgis:rasterize”). El último (“qgis:rasterize”) crea una capa ráster a partir de la capa de búfer que fue generada por el primero (“native:buffer”).

La parte del código donde tiene lugar este procesamiento no es difícil de entender si ha leído el capítulo anterior. Sin embargo, las primeras líneas necesitan una explicación adicional. Proporcionan la información que se necesita para convertir su código en un algoritmo que se puede ejecutar desde cualquiera de los componentes de la GUI, como la caja de herramientas o el modelador gráfico.

Todas estas líneas son llamadas a las funciones del decorador @alg que ayudan a simplificar la codificación del algoritmo.

El decorador @alg se utiliza para definir el nombre y la ubicación del algoritmo en la Caja de herramientas.
El decorador @alg.input se utiliza para definir las entradas del algoritmo.
El decorador @alg.output se utiliza para definir las salidas del algoritmo.

23.9.3. Tipos de entrada y salida para algoritmos de procesamiento 

Aquí está la lista de tipos de entrada y salida que son compatibles con Procesos con sus correspondientes constantes de decorador de alg (algfactory.py contiene la lista completa de constantes de alg). Ordenado por nombre de clase.

23.9.3.1. Tipos de entrada 

Clase	Alg constante	Descripción
`QgsProcessingParameterAuthConfig`	`alg.AUTH_CFG`	Permite a los usuarios seleccionar entre las configuraciones de autenticación disponibles o crear nuevas configuraciones de autenticación
`QgsProcessingParameterBand`	`alg.BAND`	Una banda de una capa ráster
`QgsProcessingParameterBoolean`	`alg.BOOL`	Un valor booleano
`QgsProcessingParameterColor`	`alg.COLOR`	Un color
`QgsProcessingParameterCoordinateOperation`	`alg.COORDINATE_OPERATION`	Una operación de coordenada (para transformaciones SRC)
`QgsProcessingParameterCrs`	`alg.CRS`	Un Sistema de Coordenadas de Referencia
`QgsProcessingParameterDatabaseSchema`	`alg.DATABASE_SCHEMA`	Un esquema de Base de Datos
`QgsProcessingParameterDatabaseTable`	`alg.DATABASE_TABLE`	Una tabla de Base de Datos
`QgsProcessingParameterDateTime`	`alg.DATETIME`	Una fecha y hora (o una fecha u hora pura)
`QgsProcessingParameterDistance`	`alg.DISTANCE`	Un parámetro numérico doble para valores de distancia
`QgsProcessingParameterEnum`	`alg.ENUM`	Una enumeración, permitiendo la selección de un conjunto de valores predefinidos
`QgsProcessingParameterExpression`	`alg.EXPRESSION`	Una expresión
`QgsProcessingParameterExtent`	`alg.EXTENT`	Una extensión espacial definida por xmin, xmax, ymin, ymax
`QgsProcessingParameterField`	`alg.FIELD`	Un campo en la tabla de atributos de una capa vectorial
`QgsProcessingParameterFile`	`alg.FILE`	Un nombre de archivo de un archivo existente
`QgsProcessingParameterFileDestination`	`alg.FILE_DEST`	Un nombre de archivo para un archivo de salida recién creado
`QgsProcessingParameterFolderDestination`	`alg.FOLDER_DEST`	Una carpeta (carpeta de destino)
`QgsProcessingParameterNumber`	`alg.INT`	Un entero
`QgsProcessingParameterLayout`	`alg.LAYOUT`	Un diseño
`QgsProcessingParameterLayoutItem`	`alg.LAYOUT_ITEM`	Un elemento de diseño
`QgsProcessingParameterMapLayer`	`alg.MAPLAYER`	Una capa de mapa
`QgsProcessingParameterMapTheme`	`alg.MAP_THEME`	Un tema de mapa de proyecto
`QgsProcessingParameterMatrix`	`alg.MATRIX`	Una matriz
`QgsProcessingParameterMeshLayer`	`alg.MESH_LAYER`	Una capa de malla
`QgsProcessingParameterMultipleLayers`	`alg.MULTILAYER`	Un conjunto de capas
`QgsProcessingParameterNumber`	`alg.NUMBER`	Un valor numérico
`QgsProcessingParameterPoint`	`alg.POINT`	Un punto
`QgsProcessingParameterProviderConnection`	`alg.PROVIDER_CONNECTION`	Una conexión disponible para un proveedor de base de datos
`QgsProcessingParameterRange`	`alg.RANGE`	Un rango de número
`QgsProcessingParameterRasterLayer`	`alg.RASTER_LAYER`	Una capa ráster.
`QgsProcessingParameterRasterDestination`	`alg.RASTER_LAYER_DEST`	Una capa ráster.
`QgsProcessingParameterScale`	`alg.SCALE`	Una escala de mapa
`QgsProcessingParameterFeatureSink`	`alg.SINK`	Un destino de objetos
`QgsProcessingParameterFeatureSource`	`alg.SOURCE`	Una fuente de objetos
`QgsProcessingParameterString`	`alg.STRING`	Una cadena de texto
`QgsProcessingParameterVectorLayer`	`alg.VECTOR_LAYER`	Una capa vectorial.
`QgsProcessingParameterVectorDestination`	`alg.VECTOR_LAYER_DEST`	Una capa vectorial.

23.9.3.2. Tipos de salida 

Clase	Alg constante	Descripción
`QgsProcessingOutputBoolean`	`alg.BOOL`	Un valor booleano
`QgsProcessingOutputNumber`	`alg.DISTANCE`	Un parámetro numérico doble para valores de distancia
`QgsProcessingOutputFile`	`alg.FILE`	Un nombre de archivo de un archivo existente
`QgsProcessingOutputFolder`	`alg.FOLDER`	Una carpeta
`QgsProcessingOutputHtml`	`alg.HTML`	HTML
`QgsProcessingOutputNumber`	`alg.INT`	Un Entero
`QgsProcessingOutputLayerDefinition`	`alg.LAYERDEF`	Una definición de capa
`QgsProcessingOutputMapLayer`	`alg.MAPLAYER`	Una capa de mapa
`QgsProcessingOutputMultipleLayers`	`alg.MULTILAYER`	Un conjunto de capas
`QgsProcessingOutputNumber`	`alg.NUMBER`	Un valor numérico
`QgsProcessingOutputRasterLayer`	`alg.RASTER_LAYER`	Una capa ráster.
`QgsProcessingOutputString`	`alg.STRING`	Una cadena de texto
`QgsProcessingOutputVectorLayer`	`alg.VECTOR_LAYER`	Una capa vectorial.

23.9.4. Manejo de salida de algoritmo 

Cuando declara una salida que representa una capa (ráster o vector), el algoritmo intentará agregarla a QGIS una vez que haya terminado.

Capa ráster saliente: QgsProcessingParameterRasterDestination / alg.RASTER_LAYER_DEST.
Capa vectorial saliente: QgsProcessingParameterVectorDestination / alg.VECTOR_LAYER_DEST.

Entonces, incluso si el método processing.run() no agrega las capas que crea al proyecto actual del usuario, se cargarán las dos capas de salida (búfer y búfer ráster), ya que se guardan en los destinos ingresados por el usuario (o a destinos temporales si el usuario no especifica destinos).

Si se crea una capa como salida de un algoritmo, debe declararse como tal. De lo contrario, no podrá utilizar correctamente el algoritmo en el modelador, ya que lo que se declara no coincidirá con lo que realmente crea el algoritmo.

Puede devolver cadenas, números y más especificándolos en el diccionario de resultados (como se demuestra para «NUMBEROFFEATURES»), pero siempre deben definirse explícitamente como salidas de su algoritmo. Alentamos a los algoritmos a generar tantos valores útiles como sea posible, ya que estos pueden ser valiosos para su uso en algoritmos posteriores cuando su algoritmo se usa como parte de un modelo.

23.9.5. La comunicación con el usuario 

Si su algoritmo tarda mucho en procesarse, es una buena idea informar al usuario sobre el progreso. Puedes usar feedback (QgsProcessingFeedback) para esto.

El texto de progreso y la barra de progreso se pueden actualizar usando dos métodos: setProgressText(text) y setProgress(percent).

Puede proporcionar más información utilizando pushCommandInfo(text), pushDebugInfo(text), pushInfo(text) and reportError(text).

Si su guión tiene un problema, la forma correcta de manejarlo es generar una QgsProcessingException. Puede pasar un mensaje como argumento al constructor de la excepción. Procesos se encargará de manejarlo y comunicarse con el usuario, dependiendo de dónde se esté ejecutando el algoritmo (caja de herramientas, modelador, consola Python, …)

23.9.6. Documentando sus scripts 

Puede documentar sus scripts sobrecargando el helpString() and helpUrl() methods of QgsProcessingAlgorithm.

23.9.7. Banderas 

Puede anular el método flags() de QgsProcessingAlgorithm para decirle a QGIS más sobre su algoritmo. Por ejemplo, puede decirle a QGIS que el script se ocultará al modelador, que se puede cancelar, que no es seguro para subprocesos y más.

Truco

De forma predeterminada, Procesos ejecuta algoritmos en un hilo separado para mantener la respuesta de QGIS mientras se ejecuta la tarea de procesamiento. Si su algoritmo falla regularmente, probablemente esté utilizando llamadas a la API que no son seguras de hacer en un hilo en segundo plano. Intente devolver el indicador QgsProcessingAlgorithm.FlagNoThreading del método flags() de su algoritmo para forzar a Processing a ejecutar su algoritmo en el hilo principal.

23.9.8. Las mejores practivas al escribir scripts de algoritmos 

Aquí hay un resumen rápido de ideas a considerar al crear sus algoritmos de script y, especialmente, si desea compartirlos con otros usuarios de QGIS. Seguir estas sencillas reglas garantizará la coherencia entre los diferentes elementos de procesamiento, como la caja de herramientas, el modelador o la interfaz de procesamiento por lotes.

No cargar la capa resultante. Deje al Procesamiento manejar sus resultados y cargue sus capas si es necesario.
Siempre declare las salidas que crea su algoritmo.
No muestre cuadros de mensaje ni use ningún elemento GUI del script. Si desea comunicarse con el usuario, utilice los métodos del objeto de comentarios (QgsProcessingFeedback) o lance una QgsProcessingException.

Ya hay muchos algoritmos de procesamiento disponibles en QGIS. Puede encontrar el código en https://github.com/qgis/QGIS/blob/release-3_16/python/plugins/processing/algs/qgis.