Mit dem Übergang von QGIS2.x zu QGIS3.x wurde das gesamte Verarbeitungsframework überarbeitet und große Teile davon werden jetzt als C ++ - Klassen ausgeführt, mit denen Sie mit Python interagieren können. Leider ist die einfache Parametersyntax für Daten / Datensatz-E / A nicht mehr gültig. Die neue Parameterstruktur orientiert sich viel stärker an den in der Toolbox vorinstallierten (Python-) Verarbeitungsalgorithmen.
Wie ich sehe, haben Sie bereits die Beschreibung der neuen Algorithmusstruktur von @underdark befolgt. Um diese Struktur an Ihre Anforderungen anzupassen (Rasterebenen, doppelte Eingabe usw.), müssen Sie den Code an mehreren Stellen im Skript ändern. Ich habe ein grobes Beispiel mit einer kurzen Erklärung für Sie codiert (nur ein Algorithmus-Skelett basierend auf @underdarks-Beispiel):
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
Welche Schritte werden gemacht?
- Importieren Sie alle erforderlichen Klassen.
- Definieren Sie den Algorithmus als eine Klasse, von der er erbt
QgsProcessingAlgorithm.
- Zuerst müssen Sie die Namen der Eingabe- und Ausgabeparameter als Zeichenfolgenvariablen (Parameternamen) der Algorithmusklasse (dh
INPUT_RASTER_A = 'INPUT_RASTER_A') deklarieren, um auf Ihren Algorithmus mit den vom Verarbeitungsframework bereitgestellten Parametern zu verweisen.
- Fügen Sie die Methoden hinzu, die Ihren Algorithmus mit der Verarbeitungs-Toolbox-GUI verbinden, und stellen Sie Hilfezeichenfolgen usw. bereit.
- Anschließend fügen Sie die Parameter des Verarbeitungsframeworks hinzu. Diese wird als Kind Klassen definiert
QgsProcessingParameterType- im Fall des Algorithmus: QgsProcessingParameterRasterLayer, QgsProcessingParameterNumber, und so weiter. Sie können die API-Einträge (dh QgsProcessingParameterRasterLayer) konsultieren , um die richtigen Argumente zu übergeben und die Parameterobjekte zu konstruieren.
- Übergeben die Parameter parallel
contextund feedbackObjekte das processAlgorithm()Verfahren , bei dem man die Eingabedatensätze aus den Parametern zur Laufzeit zu erhalten (in diesem Fall QgsRasterLayer Aufgaben werden durch die Verwendung von parameterAsRasterLayer()Verfahren, etc.).
- Mach deine Berechnung.
- Fügen Sie die Ausgaben zum Ergebniswörterbuch hinzu und geben Sie sie als Ergebnis des Aufrufs zurück
processAlgorithm().
Ich hoffe, ich konnte Ihnen einige Einblicke geben, wie Sie Ihre Python-Algorithmen in QGIS3 entwerfen können. Wenn Sie nicht weiterkommen, ist es immer hilfreich zu prüfen, wie vorhandene Algorithmen des Verarbeitungsframeworks mit den Parametern umgehen. Sie können sie hier ansehen .