Wraz z przejściem z QGIS2.x do QGIS3.x cała struktura przetwarzania została przerobiona, a jej duże części działają teraz jako klasy C ++, z którymi można współdziałać za pomocą Pythona. Niestety prosta składnia parametrów we / wy danych / zestawu danych nie jest już ważna. Nowa struktura parametrów jest znacznie bardziej zorientowana po wbudowanych algorytmach przetwarzania (Python), które znajdują się w preinstalowanym zestawie narzędzi.
Jak widzę, śledziłeś już opis nowej struktury algorytmu przez @underdark. Aby jednak dostosować tę strukturę do swoich wymagań (warstwy rastrowe, podwójne wprowadzanie itp.), Musisz zmienić kod w wielu miejscach skryptu. Zakodowałem szorstki przykład z krótkim wyjaśnieniem (tylko szkielet algorytmu oparty na przykładzie @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
Jakie kroki są zrobione?
- Zaimportuj wszystkie niezbędne klasy.
- Zdefiniuj algorytm jako klasę dziedziczącą po
QgsProcessingAlgorithm.
- Najpierw musisz zadeklarować nazwy parametrów wejściowych i wyjściowych jako zmienne łańcuchowe (nazwy parametrów) klasy algorytmu (tj.
INPUT_RASTER_A = 'INPUT_RASTER_A') W celu odniesienia swojego algorytmu do parametrów dostarczonych przez strukturę przetwarzania.
- Dodaj metody, które łączą algorytm z interfejsem GUI przybornika przetwarzania i dostarczają pomocy itp.
- Następnie dodajesz parametry struktury przetwarzania. Są one definiowane jako klasach potomnych
QgsProcessingParameterType- w przypadku swojego algorytmu: QgsProcessingParameterRasterLayer, QgsProcessingParameterNumber, i tak dalej. Możesz przejrzeć wpisy API (tj. QgsProcessingParameterRasterLayer), Aby przekazać odpowiednie argumenty i zbudować obiekty parametrów.
- Przekaż parametry obok
contexti feedbackobiekty do processAlgorithm()metody, w której uzyskujesz wejściowe zestawy danych z parametrów w czasie wykonywania (w tym przypadku obiekty QgsRasterLayer przy użyciu parameterAsRasterLayer()metody itp.).
- Wykonaj swoje obliczenia.
- Dodaj dane wyjściowe do słownika wyników i zwróć je w wyniku wywołania
processAlgorithm().
Mam nadzieję, że mógłbym dać ci wgląd w sposób projektowania algorytmów Python w QGIS3. Ilekroć utkniesz, zawsze pomocne jest sprawdzenie, jak istniejące algorytmy struktury przetwarzania przetwarzają parametry. Możesz je zobaczyć tutaj .