Importante

La traducción es un esfuerzo comunitario puede unirse. Esta página está actualmente traducida en |progreso de traducción|.

17. Escribir nuevos complementos de procesamiento

Dependiendo del tipo de complemento que vaya a desarrollar, podría ser una mejor opción agregar su funcionalidad como un algoritmo de procesamiento (o un conjunto de ellos). Eso proporcionaría una mejor integración dentro de QGIS, funcionalidad adicional (ya que se puede ejecutar en los componentes de Processing, como el modelador o la interfaz de procesamiento por lotes), y un tiempo de desarrollo más rápido (ya que Processing tomará una gran parte del trabajo).

Para distribuir esos algoritmos, debe crear un nuevo complemento que los agregue a Caja de Herramientas de Procesos. El complemento debe contener un proveedor de algoritmos, que debe registrarse cuando se crea una instancia del complemento.

17.1. Creando desde cero

Para crear un complemento desde cero que contenga un proveedor de algoritmos, puede seguir estos pasos utilizando el Generador de complementos:

1. Instala el complemento Plugin Builder

2. Crea un nuevo complemento, usando el Plugin Builder. En el cuadro de diálogo del Plugin Builder, selecciona «Processing provider».

3. El complemento creado contiene un proveedor con un solo algoritmo. Tanto el archivo del proveedor como el archivo del algoritmo están completamente comentados y contienen información sobre cómo modificar el proveedor y agregar algoritmos adicionales. Consúltelos para obtener más información.

17.2. Actuializar un complemento

Si quiere añadir su complemento existente a Procesos, necesitará añadir algo de código.

1. En su archivo metadata.txt, necesitará añadir una variable:

   hasProcessingProvider=yes
   

2. En el archivo Python donde tu complemento está instalado con el método initGui, necesitas adaptar algunas líneas 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. Puedes crear una carpeta processing_provider con tres archivos en ella:

   • __init__.py sin nada en él. Esto es necesario para crear un paquete Python válido.

   • provider.py que creará el proveedor de procesamiento y expondrá sus 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 el cuál contiene el archivo de ejemplo de algoritmo. Copiar/pegar el contenido de la fuente archivo de plantilla de script y actualizalo de acuerdo a tus necesidades.

Debería tener un árbol similar a este :

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

1. Ahora puede volver a cargar su complemento en QGIS y debería ver su script de ejemplo en la caja de herramientas de procesamiento y el modelador.