Schreiben eines Python-Verarbeitungsskripts mit Qgis 3.0

Nach dem Update auf Qgis 3.0 ist es sehr schwierig geworden, Informationen zum Schreiben von Verarbeitungsskripten in Qgis 3.0 zu finden.

@Underdark (siehe hier ) hat eine Basis für das Skelett bereitgestellt. Dieser Code scheint auch in Qgis hinzugefügt worden zu sein, wenn ein neues Skript aus einer Vorlage (Qgis 3.0.2) geschrieben wird.

Ich konnte jedoch keinen Weg finden, Python-Neulingen wie mir zu helfen, zu verstehen, wie dieser Code geändert wird, insbesondere für die Eingabe- und Ausgabe-Layer.

Mein Ziel ist es, ein Skript mit zwei Rasterebenen und einer doppelten als Eingabe zu schreiben, das zwei Ebenen ausgibt.

Welche Änderungen wären am Beispielcode erforderlich, um dies zu ermöglichen?

Für Qgis 2.x hätte ich die folgende Syntax verwendet:

##Layer1=raster
##Layer2=raster 
##myDouble=Double
##OutLayer1=output raster
##OutLayer2=output raster   

Soweit ich weiß, müssen die Änderungen in der folgenden Prozedur vorgenommen werden, aber ich bin nicht sicher, was installiert werden soll.

    def initAlgorithm(self, config=None):
    self.addParameter(QgsProcessingParameterFeatureSource(
        self.INPUT,
        self.tr("Input layer"),
        [QgsProcessing.TypeVectorAnyGeometry]))
    self.addParameter(QgsProcessingParameterFeatureSink(
        self.OUTPUT,
        self.tr("Output layer"),
        QgsProcessing.TypeVectorAnyGeometry))

Am 16. Mai wurde die Qgis-Python-API- Dokumentation veröffentlicht. Allerdings ist mir noch unklar, wie ich es hier verwenden soll. (Was sehr wohl ein Mangel an Python-Kenntnissen sein könnte)

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?

1. Importieren Sie alle erforderlichen Klassen.
2. Definieren Sie den Algorithmus als eine Klasse, von der er erbt QgsProcessingAlgorithm.
3. 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.
4. Fügen Sie die Methoden hinzu, die Ihren Algorithmus mit der Verarbeitungs-Toolbox-GUI verbinden, und stellen Sie Hilfezeichenfolgen usw. bereit.
5. 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.
6. Ü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.).
7. Mach deine Berechnung.
8. 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 .