Importante

La traduzione è uno sforzo comunitario you can join. Questa pagina è attualmente tradotta al 100.00%.

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

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

     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 che contiene il file algoritmo di esempio. Copia/incolla il contenuto del file script template file e modificalo conformemente alle tue esigenze.

   Dovresti avere un albero simile a questo:

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

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

17.1.1. Creazione di un algoritmo personalizzato

Ecco un semplice esempio di algoritmo buffer personalizzato:

from qgis.core import (
    QgsProcessingAlgorithm,
    QgsProcessingParameterFeatureSource,
    QgsProcessingParameterNumber,
    QgsProcessingParameterFeatureSink,
    QgsFeatureSink,
)

class BufferAlgorithm(QgsProcessingAlgorithm):

    INPUT = 'INPUT'
    DISTANCE = 'DISTANCE'
    OUTPUT = 'OUTPUT'

    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterFeatureSource(self.INPUT, 'Input layer'))
        self.addParameter(QgsProcessingParameterNumber(self.DISTANCE, 'Buffer distance', defaultValue=100.0))
        self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, 'Output layer'))

    def processAlgorithm(self, parameters, context, feedback):
        source = self.parameterAsSource(parameters, self.INPUT, context)
        distance = self.parameterAsDouble(parameters, self.DISTANCE, context)
        (sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
                                               source.fields(), source.wkbType(), source.sourceCrs())

        for f in source.getFeatures():
            f.setGeometry(f.geometry().buffer(distance, 5))
            sink.addFeature(f, QgsFeatureSink.FastInsert)

        return {self.OUTPUT: dest_id}

    def name(self):
        return 'buffer'

    def displayName(self):
        return 'Buffer Features'

    def group(self):
        return 'Examples'

    def groupId(self):
        return 'examples'

    def createInstance(self):
        return BufferAlgorithm()