Important

Traducerea este un efort al comunității, la care puteți să vă alăturați. În prezent, această pagină este tradusă 21.05%.

17. Scrierea unui plugin Processing

Depending on the kind of plugin that you are going to develop, it might be a better option to add its functionality as a Processing algorithm (or a set of them). That would provide a better integration within QGIS, additional functionality (since it can be run in the components of Processing, such as the modeler or the batch processing interface), and a quicker development time (since Processing will take of a large part of the work).

To distribute those algorithms, you should create a new plugin that adds them to the Processing Toolbox. The plugin should contain an algorithm provider, which has to be registered when the plugin is instantiated.

17.1. Creating from scratch

To create a plugin from scratch which contains an algorithm provider, you can follow these steps using the Plugin Builder:

1. Install the Plugin Builder plugin

2. Creați un plugin nou, utilizând Plugin Builder. În cazul în care Plugin Builder vă cere șablonul de utilizat, selectați „Furnizor Processing”.

3. Plugin-ul creat conține un furnizor cu un singur algoritm. Atât fișierul furnizorului cât și cel al algoritmului sunt complet comentate și conțin informații cu privire la modul de modificare a furnizorului și de adăugare a algoritmilor suplimentari.

17.2. Updating a plugin

If you want to add your existing plugin to Processing, you need to add some code.

1. In your metadata.txt file, you need to add a variable:

   hasProcessingProvider=yes
   

2. In the Python file where your plugin is setup with the initGui method, you need to adapt some lines like this:

   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. You can create a folder processing_provider with three files in it:

   • __init__.py with nothing in it. This is necessary to make a valid Python package.

   • provider.py which will create the Processing provider and expose your algorithms.

     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 which contains the example algorithm file. Copy/paste the content of the script template file and update it according to your needs.

You should have a tree similar to this :

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

1. Now you can reload your plugin in QGIS and you should see your example script in the Processing toolbox and modeler.