Important

La traduction est le fruit d’un effort communautaire auquel vous pouvez vous joindre. Cette page est actuellement traduite à 94.74%.

17. Créer une extension avec Processing

Selon le type de plugin que vous allez développer, il peut être préférable d’ajouter ses fonctionnalités en tant qu’algorithme de traitement (ou un ensemble d’entre eux). Cela permettrait une meilleure intégration dans QGIS, des fonctionnalités supplémentaires (puisqu’il peut être exécuté dans les composants de Processing, tels que le modeleur ou l’interface de traitement par lots), et un temps de développement plus rapide (puisque Processing prendra 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.

17.1. Créer à partir de zéro

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

1. Installez le plugin Plugin Builder

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

3. 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.

17.2. Mise à jour d’un plugin

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

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

   hasProcessingProvider=yes
   

2. 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)
   

3. Vous pouvez créer un dossier processing_provider avec trois fichiers dedans :

   • __init__.py avec rien dedans. Ceci est nécessaire pour faire un paquet Python valide.

   • provider.py qui va créer le provider processing et exposer vos algorithmes.

     from qgis.core import QgsProcessingProvider
     from qgis.PyQt.QtGui import QIcon
     
     from .example_processing_algorithm import ExampleProcessingAlgorithm
     
     
     class Provider(QgsProcessingProvider):
     
         """ The provider of our plugin. """
     
         def loadAlgorithms(self):
             """ Load each algorithm into the current provider. """
             self.addAlgorithm(ExampleProcessingAlgorithm())
             # add additional algorithms here
             # self.addAlgorithm(MyOtherAlgorithm())
     
         def id(self) -> str:
             """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) -> str:
             """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) -> QIcon:
             """Should return a QIcon which is used for your provider inside
             the Processing toolbox.
             """
             return QgsProcessingProvider.icon(self)
     

   • example_processing_algorithm.py qui contient le fichier de l’algorithme d’exemple. Copiez/collez le contenu du fichier modèle de script et mettez-le à jour selon vos besoins.

You should have a tree similar to this :

└── your_plugin_root_folder
   ├── __init__.py
   ├── LICENSE
   ├── metadata.txt
   └── processing_provider
         ├── example_processing_algorithm.py
         ├── __init__.py
         └── provider.py

1. Vous pouvez maintenant recharger votre plugin dans QGIS et vous devriez voir votre script d’exemple dans la boîte à outils de traitement and modeleur.