Con la transición de QGIS2.x a QGIS3.x, todo el marco de procesamiento se ha modificado y gran parte de él se ejecuta ahora como clases de C ++ con las que puede interactuar utilizando Python. Desafortunadamente, la sintaxis simple de parámetros para datos / conjunto de datos IO ya no es válida. La nueva estructura de parámetros está mucho más orientada después de los algoritmos de procesamiento incorporados (Python) que se encuentran preinstalados en la caja de herramientas.
Como veo, ya has seguido la descripción de la nueva estructura del algoritmo por @underdark. Pero para ajustar esta estructura a sus requisitos (capas ráster, doble entrada, etc.) debe cambiar el código en varias ubicaciones en el script. He codificado un ejemplo aproximado con una breve explicación para usted (solo un esqueleto de algoritmo basado en el ejemplo @underdarks):
from qgis.PyQt.QtCore import QCoreApplication, QVariant
from qgis.core import (QgsProcessing, QgsProcessingAlgorithm,
QgsProcessingParameterRasterLayer,QgsProcessingParameterNumber,
QgsProcessingParameterRasterDestination)
class RasterAlg(QgsProcessingAlgorithm):
INPUT_RASTER_A = 'INPUT_RASTER_A'
INPUT_RASTER_B = 'INPUT_RASTER_B'
INPUT_DOUBLE = 'INPUT_DOUBLE'
OUTPUT_RASTER_A = 'OUTPUT_RASTER_A'
OUTPUT_RASTER_B = 'OUTPUT_RASTER_B'
def __init__(self):
super().__init__()
def name(self):
return "RasterAlg"
def tr(self, text):
return QCoreApplication.translate("RasterAlg", text)
def displayName(self):
return self.tr("RasterAlg script")
def group(self):
return self.tr("RasterAlgs")
def groupId(self):
return "RasterAlgs"
def shortHelpString(self):
return self.tr("RasterAlg script without logic")
def helpUrl(self):
return "https://qgis.org"
def createInstance(self):
return type(self)()
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterRasterLayer(
self.INPUT_RASTER_A,
self.tr("Input Raster A"), None, False))
self.addParameter(QgsProcessingParameterRasterLayer(
self.INPUT_RASTER_B,
self.tr("Input Raster B"), None, False))
self.addParameter(QgsProcessingParameterNumber(
self.INPUT_DOUBLE,
self.tr("Input Double"),
QgsProcessingParameterNumber.Double,
QVariant(1.0)))
self.addParameter(QgsProcessingParameterRasterDestination(
self.OUTPUT_RASTER_A,
self.tr("Output Raster A"),
None, False))
self.addParameter(QgsProcessingParameterRasterDestination(
self.OUTPUT_RASTER_B,
self.tr("Output Raster B"),
None, False))
def processAlgorithm(self, parameters, context, feedback):
raster_a = self.parameterAsRasterLayer(parameters, self.INPUT_RASTER_A, context)
raster_b = self.parameterAsRasterLayer(parameters, self.INPUT_RASTER_B, context)
double_val = self.parameterAsDouble(parameters, self.INPUT_DOUBLE,context)
output_path_raster_a = self.parameterAsOutputLayer(parameters, self.OUTPUT_RASTER_A, context)
output_path_raster_b = self.parameterAsOutputLayer(parameters, self.OUTPUT_RASTER_B, context)
#DO SOME CALCULATION
results = {}
results[self.OUTPUT_RASTER_A] = output_path_raster_a
results[self.OUTPUT_RASTER_B] = output_path_raster_b
return results
¿Qué pasos se hacen?
- Importa todas las clases necesarias.
- Defina el algoritmo como una clase heredada de
QgsProcessingAlgorithm.
- Primero debe declarar los nombres de los parámetros de entrada y salida como variables de cadena (nombres de parámetros) de la clase de algoritmo (es decir
INPUT_RASTER_A = 'INPUT_RASTER_A') para poder hacer referencia a su algoritmo con los parámetros proporcionados por el marco de procesamiento.
- Agregue los métodos que conectan su algoritmo a la interfaz gráfica de usuario de la caja de herramientas de procesamiento y proporcione cadenas de ayuda, etc.
- Luego agrega los parámetros del marco de procesamiento. Los que se definen como clases hijas de
QgsProcessingParameterType- en el caso de que su algoritmo: QgsProcessingParameterRasterLayer, QgsProcessingParameterNumbery así sucesivamente. Puede consultar las entradas de la API (es decir QgsProcessingParameterRasterLayer) para pasar los argumentos correctos y construir los objetos de parámetros.
- Pasar los parámetros junto
contexty feedbackobjetos para el processAlgorithm()método en el que se obtiene los conjuntos de datos de entrada de los parámetros en tiempo de ejecución (en este caso QgsRasterLayer objetos mediante el parameterAsRasterLayer()método, etc.).
- Haz tu cálculo.
- Agregue las salidas al diccionario de resultados y devuélvalas como resultado de la llamada
processAlgorithm().
Espero poder darle algunas ideas sobre cómo diseñar sus algoritmos de Python en QGIS3. Siempre que esté atascado, siempre es útil observar cómo los algoritmos existentes del marco de procesamiento manejan los parámetros. Puedes echarles un vistazo aquí .