Belangrijk

Vertalen is een inspanning van de gemeenschap waaraan u deel kunt nemen <translation_guidelines>. 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. Maken vanaf niets

U kunt de volgende stappen volgen, met behulp van de Plugin Builder, om vanaf nul een plug-in te maken die een provider voor algoritmes bevat:

1. Installeer de plug-in Plugin Builder

2. Maak een nieuwe plug-in met de Plugin Builder. Wanneer de Plugin Builder u vraagt naar het te gebruiken sjabloon, selecteer dan “Processing provider”.

3. De gemaakte plug-in bevat een provider met één enkel algoritme. Zowel het bestand voor de provider als het bestand voor het algoritme zijn volledig voorzien van commentaar en bevatten informatie over hoe de provider aan te passen en aanvullende algoritmes toe te voegen. Verwijs daarnaar voor meer meer informatie.

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

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.