17. Scrivere un plugin di Processing

Dipendentemente dal tipo di plugin che stai per sviluppare, potrebbe essere una scelta conveniente di aggiungere le sue funzionalità quali algoritmo di Processing (o un set di essi). Ciò fornirebbe una migliore integrazione all’interno di QGIS, funzionalità aggiuntive (dal momento che può essere eseguito nei componenti di Processing, come il modellatore o l’interfaccia di elaborazione batch), e un tempo di sviluppo più spedito (dal momento che Processing si farà carico della gran parte del lavoro).

Per distribuire questi algoritmi, è necessario creare un nuovo plugin che li aggiunge al Processing Toolbox. Il plugin dovrebbe contenere un provider di algoritmi, che deve essere registrato quando il plugin viene istanziato.

17.1. Creazione da zero

Per creare un plugin da zero che contiene un provider di algoritmi, è possibile seguire questi passaggi utilizzando il Plugin Builder:

  1. Installare il plugin Plugin Builder

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

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

17.2. Aggiornare un plugin

Se si desidera aggiungere il plugin esistente a Processing, è necessario aggiungere un po” di codice.

  1. Nel tuo metadata.txt file, bisogna che aggiungi una variabile:

    hasProcessingProvider=yes

  2. Nel file Python dove il tuo plugin è impostato tramite il metodo initGui, bisogna adattare qualche linea in questo modo:

     1from qgis.core import QgsApplication
 2from processing_provider.provider import Provider
 3
 4class YourPluginName():
 5
 6    def __init__(self):
 7        self.provider = None
 8
 9    def initProcessing(self):
10        self.provider = Provider()
11        QgsApplication.processingRegistry().addProvider(self.provider)
12
13    def initGui(self):
14        self.initProcessing()
15
16    def unload(self):
17        QgsApplication.processingRegistry().removeProvider(self.provider)

  3. Puoi creare una cartella processing_provider contenente tre files:

    • __init__.py con niente dentro. Ciò è necessario per produrre un package Python valido.

    • provider.py il quale creerà il Processing provider ed esporrà i tuoi algoritmi.

       1from qgis.core import QgsProcessingProvider
 2
 3from processing_provider.example_processing_algorithm import ExampleProcessingAlgorithm
 4
 5
 6class Provider(QgsProcessingProvider):
 7
 8    def loadAlgorithms(self, *args, **kwargs):
 9        self.addAlgorithm(ExampleProcessingAlgorithm())
10        # add additional algorithms here
11        # self.addAlgorithm(MyOtherAlgorithm())
12
13    def id(self, *args, **kwargs):
14        """The ID of your plugin, used for identifying the provider.
15
16        This string should be a unique, short, character only string,
17        eg "qgis" or "gdal". This string should not be localised.
18        """
19        return 'yourplugin'
20
21    def name(self, *args, **kwargs):
22        """The human friendly name of your plugin in Processing.
23
24        This string should be as short as possible (e.g. "Lastools", not
25        "Lastools version 1.0.1 64-bit") and localised.
26        """
27        return self.tr('Your plugin')
28
29    def icon(self):
30        """Should return a QIcon which is used for your provider inside
31        the Processing toolbox.
32        """
33        return QgsProcessingProvider.icon(self)

    • example_processing_algorithm.py che contiene il file algoritmo di esempio. Copia/incolla il contenuto del file script template file e modificalo conformemente alle tue esigenze.

  4. Ora puoi ricaricare il tuo plugin in QGIS e dovresti vedere il tuo script di esempio nella lista di Processing toolbox e modeler.