Com a transição do QGIS2.x para o QGIS3.x, toda a estrutura de processamento foi reformulada e grande parte dela é executada agora como classes C ++ com as quais você pode interagir usando o Python. Infelizmente, a sintaxe simples dos parâmetros para IO de dados / conjunto de dados não é mais válida. A nova estrutura de parâmetros é muito mais orientada após os algoritmos de processamento interno (Python-) que você encontra pré-instalados na caixa de ferramentas.
A meu ver, você já seguiu a descrição da nova estrutura de algoritmos do @underdark. Mas, para ajustar essa estrutura aos seus requisitos (camadas raster, entrada dupla, etc.), é necessário alterar o código em vários locais do script. Eu codifiquei um exemplo aproximado com uma breve explicação para você (apenas um esqueleto de algoritmo baseado no exemplo @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
Quais etapas foram feitas?
- Importe todas as classes necessárias.
- Defina o algoritmo como uma classe herdada de
QgsProcessingAlgorithm.
- Primeiro, você deve declarar os nomes dos parâmetros de entrada e saída como variáveis de string (nomes de parâmetros) da classe de algoritmos (ou seja,
INPUT_RASTER_A = 'INPUT_RASTER_A') para fazer referência ao seu algoritmo com os parâmetros fornecidos pela estrutura de processamento.
- Adicione os métodos que conectam seu algoritmo à GUI da caixa de ferramentas de processamento e forneça instruções, etc.
- Em seguida, você adiciona os parâmetros da estrutura de processamento. Aqueles são definidos como classes filhas de
QgsProcessingParameterType- no caso do seu algoritmo: QgsProcessingParameterRasterLayer, QgsProcessingParameterNumbere assim por diante. Você pode consultar as entradas da API (ou seja, QgsProcessingParameterRasterLayer) para passar os argumentos corretos e construir os objetos de parâmetro.
- Passe os parâmetros ao lado de
contexte feedbackobjetos para o processAlgorithm()método em que você obtém os conjuntos de dados de entrada dos parâmetros em tempo de execução (nesse caso, objetos QgsRasterLayer usando o parameterAsRasterLayer()método etc.).
- Faça o seu cálculo.
- Adicione as saídas ao dicionário de resultados e retorne-as como resultado da chamada
processAlgorithm().
Espero poder fornecer algumas idéias sobre como projetar seus algoritmos python no QGIS3. Sempre que você está parado, é sempre útil observar como os algoritmos existentes da estrutura de processamento lidam com os parâmetros. Você pode dar uma olhada neles aqui .