Scrivere un plugin di Processing

In funzione del tipo di plugin che andrai a sviluppare, la migliore opzione sarebbe quella di aggiungerlo come algoritmo di Processing (o un set di essi). Ciò consentirebbe una migliore integrazione all’interno di QGIS, funzionalità aggiuntive (poiché può essere eseguito nei moduli di Processing, come il modellatore o l’interfaccia di processing in serie), e tempistiche di sviluppo più rapide (siccome Processing farà gran parte del lavoro).

To distribute those algorithms, you should create a new plugin that adds them to the Processing Toolbox. The plugin should contain an algorithm provider, which has to be registered when the plugin is instantiated.

To create a plugin from scratch which contains an algorithm provider, you can follow these steps using the Plugin Builder:

• Installa il plugin Plugin Builder

• Crea un nuovo plugin usando il Plugin Builder. Quando il Plugin Builder ti chiederà il modello da usare, seleziona «Sorgente di Processing».

• Il plugin creato contiene una sorgente con un singolo algoritmo. Il file della sorgente e dell’algoritmo sono entrambi commentati e contengono informazioni su come modificare la sorgente e gli algoritmi aggiuntivi. Fai riferimento ad essi per maggiori informazioni.

If you want to add your existing plugin to Processing, you need to add some code.

In your metadata.txt, you need to add a variable:

hasProcessingProvider=yes

In the Python file where your plugin is setup with the initGui method, you need to adapt some lines like this:

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.