Importante

A tradução é um esforço comunitário você pode contribuir. Esta página está atualmente traduzida em 81.25%.

17. Escrevendo um complemento de processamento

Dependendo do tipo de plug-in que você desenvolverá, pode ser uma opção melhor adicionar sua funcionalidade como um algoritmo de Processar (ou um conjunto deles). Isso proporcionaria uma melhor integração ao QGIS, funcionalidade adicional (já que pode ser executada nos componentes do Processar, como o modelador ou a interface de processamento em lote) e um tempo de desenvolvimento mais rápido (já que o Processar consumirá grande parte do trabalhos).

Para distribuir esses algoritmos, você deve criar um nov complemento que os adicione à Caixa de Ferramentas de Processar. O complemento deve conter um provedor de algoritmos, que deve ser registrado quando o complemento é instanciado.

17.1. Atualizando um complemento

Se você deseja adicionar seu complemento existente ao Processar, precisará adicionar algum código.

1. No seu arquivo metadata.txt, você precisa adicionar uma variável:

   hasProcessingProvider=yes
   

2. No arquivo Python em que seu complemento está configurado com o método initGui, você precisa adaptar algumas linhas como esta:

   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. Você pode criar uma pasta processing_provider com três arquivos:

   • __init__.py com nada nele. Isso é necessário para criar um pacote Python válido.

   • provider.py que criará o Provedor de Processamento e exporá seus algoritmos.

     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 que contém o arquivo de algoritmo de exemplo. Copie/cole o conteúdo do arquivo script template e atualize-o de acordo com suas necessidades.

   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
   

4. Agora você pode recarregar seu complemento no QGIS e deverá ver o seu exemplo de script na caixa de ferramentas Processar e modelador.

17.1.1. Creating a custom algorithm

Here’s a simple example of a custom buffer algorithm:

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