Con il passaggio da QGIS2.x a QGIS3.x l'intero framework di elaborazione è stato rielaborato e gran parte di esso viene ora eseguito come classi C ++ con cui è possibile interagire utilizzando Python. Sfortunatamente la semplice sintassi dei parametri per i dati / set di dati IO non è più valida. La nuova struttura dei parametri è molto più orientata dopo gli algoritmi di elaborazione integrati (Python-) che trovi preinstallati nella casella degli strumenti.
Come vedo, hai già seguito la descrizione della nuova struttura dell'algoritmo di @underdark. Ma per adattare questa struttura alle tue esigenze (livelli raster, doppio input, ecc.) Devi cambiare il codice in più posizioni nello script. Ho codificato un esempio approssimativo con una breve spiegazione per te (solo uno scheletro algoritmo basato sull'esempio di @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
Quali passaggi vengono eseguiti?
- Importa tutte le classi necessarie.
- Definire l'algoritmo come una classe che eredita da
QgsProcessingAlgorithm.
- Per prima cosa devi dichiarare i nomi dei parametri di input e output come variabili stringa (nomi dei parametri) della classe dell'algoritmo (es.
INPUT_RASTER_A = 'INPUT_RASTER_A') Per fare riferimento al tuo algoritmo con i parametri forniti dal framework di elaborazione.
- Aggiungi i metodi che collegano il tuo algoritmo alla GUI della toolbox di elaborazione e forniscono stringhe di aiuto, ecc.
- Quindi aggiungi i parametri del framework di elaborazione. Coloro che sono definiti come classi figlio di
QgsProcessingParameterType- nel caso del vostro algoritmo: QgsProcessingParameterRasterLayer, QgsProcessingParameterNumber, e così via. È possibile consultare le voci API (es. QgsProcessingParameterRasterLayer) Per passare gli argomenti giusti e costruire gli oggetti parametro.
- Passare i parametri a fianco
contexte gli feedbackoggetti al processAlgorithm()metodo in cui si ottengono i set di dati di input dai parametri in fase di esecuzione (in questo caso oggetti QgsRasterLayer utilizzando il parameterAsRasterLayer()metodo, ecc.).
- Fai il tuo calcolo.
- Aggiungi gli output al dizionario dei risultati e restituiscili come risultato della chiamata
processAlgorithm().
Spero di poterti dare alcune informazioni su come progettare i tuoi algoritmi Python in QGIS3. Ogni volta che sei bloccato, è sempre utile guardare come gli algoritmi esistenti del framework di elaborazione gestiscono i parametri. Puoi dare un'occhiata qui .