Viktigt

Översättning är en gemenskapsinsats du kan gå med i. Den här sidan är för närvarande översatt till 100.00%.

17. Skriva ett Processing-tillägg

Beroende på vilken typ av plugin du ska utveckla kan det vara ett bättre alternativ att lägga till dess funktionalitet som en Processing-algoritm (eller en uppsättning av dem). Det skulle ge en bättre integration i QGIS, ytterligare funktionalitet (eftersom den kan köras i komponenterna i Processing, t.ex. modelleraren eller batchbehandlingsgränssnittet) och en snabbare utvecklingstid (eftersom Processing kommer att ta en stor del av arbetet).

För att distribuera dessa algoritmer bör du skapa ett nytt tillägg som lägger till dem i Processing Toolbox. Tillägget ska innehålla en algoritmleverantör som måste registreras när tillägget instansieras.

17.1. Uppdatering av ett tillägg

Om du vill lägga till ditt befintliga plugin till Processing måste du lägga till lite kod.

1. I din fil metadata.txt behöver du lägga till en variabel:

   hasProcessingProvider=yes
   

2. I Python-filen där ditt tillägg konfigureras med initGui-metoden måste du anpassa några rader så här:

   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. Du kan skapa en mapp processing_provider med tre filer i den:

   • __init__.py med ingenting i den. Detta är nödvändigt för att skapa ett giltigt Python-paket.

   • provider.py som skapar Processing-providern och exponerar dina algoritmer.

     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 som innehåller exempelalgoritmfilen. Kopiera/klistra in innehållet i skriptmallfilen och uppdatera den efter dina behov.

   Du bör ha ett träd som liknar detta:

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

4. Nu kan du ladda om ditt plugin i QGIS och du bör se ditt exempelskript i verktygslådan Processing och modelleraren.

17.1.1. Skapa en anpassad algoritm

Här är ett enkelt exempel på en anpassad buffertalgoritm:

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()