Avec la transition de QGIS2.x à QGIS3.x, l'ensemble de l'infrastructure de traitement a été retravaillé et de grandes parties de celui-ci s'exécutent maintenant en tant que classes C ++ avec lesquelles vous pouvez interagir avec Python. Malheureusement, la simple syntaxe des paramètres pour les données / jeux de données IO n'est plus valide. La nouvelle structure de paramètres est beaucoup plus orientée après les algorithmes de traitement intégrés (Python-) que vous trouvez préinstallés dans la boîte à outils.
Comme je le vois, vous avez déjà suivi la description de la nouvelle structure d'algorithme par @underdark. Mais pour ajuster cette structure à vos besoins (couches raster, double entrée, etc.), vous devez modifier le code à plusieurs endroits dans le script. J'ai codé un exemple approximatif avec une courte explication pour vous (juste un squelette d'algorithme basé sur l'exemple @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
Quelles étapes sont effectuées?
- Importez toutes les classes nécessaires.
- Définissez l'algorithme comme une classe héritant de
QgsProcessingAlgorithm.
- Vous devez d'abord déclarer les noms des paramètres d'entrée et de sortie en tant que variables de chaîne (noms de paramètres) de la classe d'algorithme (c.-à-d.
INPUT_RASTER_A = 'INPUT_RASTER_A') Afin de référencer votre algorithme avec les paramètres fournis par le cadre de traitement.
- Ajoutez les méthodes qui câblent votre algorithme à l'interface graphique de la boîte à outils de traitement et fournissez des chaînes d'aide, etc.
- Ensuite, vous ajoutez les paramètres du cadre de traitement. Ceux -ci sont définis comme des classes d'enfants de
QgsProcessingParameterType- dans le cas de votre algorithme: QgsProcessingParameterRasterLayer, QgsProcessingParameterNumberet ainsi de suite. Vous pouvez consulter les entrées API (ie. QgsProcessingParameterRasterLayer) Afin de passer les bons arguments et construire les objets paramètres.
- Passez les paramètres à côté
contextet les feedbackobjets à la processAlgorithm()méthode où vous obtenez les jeux de données d'entrée à partir des paramètres lors de l'exécution (dans ce cas, les objets QgsRasterLayer à l'aide de la parameterAsRasterLayer()méthode, etc.).
- Faites votre calcul.
- Ajoutez les sorties au dictionnaire de résultats et renvoyez-les suite à l'appel
processAlgorithm().
J'espère que je pourrais vous donner quelques informations sur la façon de concevoir vos algorithmes python dans QGIS3. Chaque fois que vous êtes bloqué, il est toujours utile de voir comment les algorithmes existants du cadre de traitement gèrent les paramètres. Vous pouvez les consulter ici .