Créer une extension avec Processing

Suivant le type d’extension que vous voulez développer, il sera parfois plus judicieux d’ajouter sa fonctionnalité sous forme d’un algorithme Processing (ou un ensemble d’algorithmes). Cela vous apportera une meilleure intégration au sein de QGIS, des fonctionnalités supplémentaires (puisqu’elle pourra être également lancée dans les composants de Processing comme le modeleur ou l’interface de traitements par lots), ainsi qu’un temps de développement plus court (puisque Processing va gérer une grande partie du travail).

Pour distribuer ces algorithmes, vous devez créer un nouveau plugin qui les ajoute à la boîte à outils de traitement. Le plugin doit contenir un fournisseur d’algorithmes, qui doit être enregistré lors de l’instanciation du plugin.

Pour créer un plugin à partir de zéro qui contient un fournisseur d’algorithme, vous pouvez suivre ces étapes en utilisant Plugin Builder :

• Installez l’extension Plugin Builder

• Créez une nouvelle extension à l’aide de Plugin Builder. Lorsque l’application vous demande le modèle à utiliser, sélectionnez « Processing Provider ».

• L’extension créée contient un fournisseur disposant d’un seul algorithme. Les fichiers du fournisseur et de l’algorithme sont correctement commentés et contiennent de l’information sur comment modifier le fournisseur et comment ajouter de nouveaux algorithmes. S’y référerer pour plus d’informations.

Si vous souhaitez ajouter votre extension à Processing, il vous faut@ ajouter un peu de code.

Dans votre fichier metadata.txt vous devez ajouter une variable :

hasProcessingProvider=yes

Au sein du fichier Python qui contient la méthode initGui paramétrant votre extension, vous devez adapter quelques lignes comme suit :

from qgis.core import QgsApplication
from .processing_provider.provider import Provider


class YourPluginName():

    def __init__(self):
        self.provider = None

    def initProcessing(self):
        self.provider = Provider()
        QgsApplication.processingRegistry().addProvider(self.provider)

    def initGui(self):
        self.initProcessing()

    def unload(self):
        QgsApplication.processingRegistry().removeProvider(self.provider)

You can create a folder processing_provider with three files in it:

• __init__.py with nothing in it. This is necessary to make a valid Python package.

• provider.py which will create the Processing provider and expose your algorithms.

  from qgis.core import QgsProcessingProvider
  
  from .example_processing_algorithm import ExampleProcessingAlgorithm
  
  
  class Provider(QgsProcessingProvider):
  
      def loadAlgorithms(self, *args, **kwargs):
          self.addAlgorithm(ExampleProcessingAlgorithm())
          # add additional algorithms here
          # self.addAlgorithm(MyOtherAlgorithm())
  
      def id(self, *args, **kwargs):
          """The ID of your plugin, used for identifying the provider.
  
          This string should be a unique, short, character only string,
          eg "qgis" or "gdal". This string should not be localised.
          """
          return 'yourplugin'
  
      def name(self, *args, **kwargs):
          """The human friendly name of your plugin in Processing.
  
          This string should be as short as possible (e.g. "Lastools", not
          "Lastools version 1.0.1 64-bit") and localised.
          """
          return self.tr('Your plugin')
  
      def icon(self):
          """Should return a QIcon which is used for your provider inside
          the Processing toolbox.
          """
          return QgsProcessingProvider.icon(self)
  

• example_processing_algorithm.py which contains the example algorithm file. Copy/paste the content of the script template: https://github.com/qgis/QGIS/blob/release-3_4/python/plugins/processing/script/ScriptTemplate.py

Now you can reload your plugin in QGIS and you should see your example script in the Processing toolbox and modeler.