Belangrijk

Vertalen is een inspanning van de gemeenschap waaraan u deel kunt nemen. Deze pagina is momenteel voor 100.00% vertaald.

17. Een plug-in voor Processing schrijven

Afhankelijk van het soort plug-in dat u gaat ontwikkelen, zou het misschien een betere optie zijn om de functionaliteit ervan toe te voegen als een algoritme voor Processing (of een set daarvan). Dat zou tot een betere integratie in QGIS leiden, aanvullende functionaliteit (omdat het kan worden uitgevoerd in de componenten van Processing, zoals Modelontwerper of de Processing interface voor batchverwerking), en een snellere ontwikkelingstijd (omdat Processing een groot deel van het werk zal overnemen).

U zou, om deze algoritmes te kunnen distribueren, een nieuwe plug-in moeten maken die ze toevoegt aan de Toolbox van Processing. De plug-in zou een provider voor algoritmes moeten bevatten, die moet worden geregistreerd als de plug-in wordt geïnstantieerd.

17.1. Een plug-in bijwerken

U dient nog enige code toe te voegen als u uw bestaande plug-in wilt toevoegen aan Processing.

1. In uw bestand metadata.txt moet u een variabele toevoegen:

   hasProcessingProvider=yes
   

2. In het bestand van Python waar uw plug-in wordt ingesteld met de methode initGui, dient u enkele regels als volgt aan te passen:

   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. U kunt een map processing_provider maken met daarin drie bestanden:

   • __init__.py waar niets in staat. Dit is noodzakelijk om een geldig pakket voor Python te maken.

   • provider.py dat de provider voor Processing zal maken en uw algoritmes zal laten zien.

     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 wat het voorbeeldbestand voor een algoritme bevat. Kopieer/plak de inhoud van het bestand script template en werk dat naar behoefte bij.

   U zou een boom moeten hebben die er uitziet zoals deze:

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

4. Nu kunt u uw plug-in opnieuw laden in QGIS en u zou uw voorbeeldscript moeten zien in de Toolbox en Modelontwerper van Processing.

17.1.1. Een aangepast algoritme maken

Hier is een eenvoudig voorbeeld van een aangepast buffer-algoritme:

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