Développer un plugin QGIS peut sembler réservé aux programmeurs expérimentés. En réalité, avec quelques bases et une bonne méthode, il est tout à fait possible de créer ses propres plugins, même sans grande expérience en programmation.

Dans ce tutoriel, nous allons découvrir à quoi servent les plugins QGIS, pourquoi ils sont si utiles au quotidien, et surtout comment est structuré un plugin QGIS : quels fichiers le composent et quel est leur rôle.

Cette série d’articles s’adresse aux utilisateurs de QGIS débutants en Python, aux enseignants, aux agents de collectivités et à toutes celles et ceux qui souhaitent automatiser leurs traitements ou créer des outils adaptés à leurs besoins métiers.

Introduction

QGIS est aujourd’hui l’un des SIG open source les plus utilisés au monde. Sa richesse fonctionnelle est impressionnante, mais ce qui fait réellement sa force, c’est sa capacité d’extension grâce aux plugins.

Un plugin QGIS permet d’ajouter des fonctionnalités personnalisées : automatiser des tâches répétitives, créer des outils adaptés à un métier précis, tester des méthodes nouvelles ou simplement se faciliter la vie au quotidien.

Ce tutoriel s’adresse volontairement à des personnes sans grande expérience en programmation. Il n’a pas pour objectif de faire de vous un développeur Python confirmé, mais de vous donner les bases nécessaires pour :

• comprendre comment fonctionne un plugin QGIS,
• modifier un plugin existant,
• créer vos propres outils simples et utiles.

L’idée est d’apprendre juste ce qu’il faut de Python et de l’architecture QGIS pour devenir autonome.

Pourquoi développer ses propres plugins QGIS ?

Automatiser des tâches répétitives

Si vous utilisez souvent QGIS, vous avez sans doute déjà enchaîné plusieurs fois les mêmes opérations :

• charger des couches,
• appliquer des styles,
• lancer une suite de traitements,
• exporter des résultats.

Un plugin permet de regrouper ces actions en un seul bouton.

Adapter QGIS à son métier

Les besoins d’un géomaticien, d’un enseignant, d’un agent de collectivité ou d’un chercheur ne sont pas toujours couverts par les outils standards. Un plugin peut intégrer :

• des règles métiers,
• des contrôles de cohérence,
• des calculs spécifiques.

Apprendre en douceur la programmation

Développer un plugin QGIS est une excellente porte d’entrée vers Python :

• le résultat est concret et visuel,
• les erreurs sont souvent faciles à identifier,
• on peut progresser par petites étapes.

Partager (ou garder pour soi)

Un plugin peut rester strictement personnel, être partagé au sein d’une équipe, ou être diffusé publiquement via le dépôt officiel QGIS.

De quoi est constitué un plugin QGIS ?

Un plugin QGIS est avant tout un dossier contenant plusieurs fichiers. Chacun a un rôle bien précis. Bonne nouvelle : il n’est pas nécessaire de tout comprendre en profondeur dès le départ.

Voici la structure minimale d’un plugin :

MonPlugin/
├── __init__.py
├── metadata.txt
├── mon_plugin.py
└── resources.qrc (optionnel)

Nous allons passer ces fichiers en revue.

Le fichier __init__.py

C’est le point d’entrée du plugin.

Son rôle principal est de dire à QGIS quelle classe Python doit être chargée lorsque le plugin est activé.

Exemple simplifié :

def classFactory(iface):
    from .mon_plugin import MonPlugin
    return MonPlugin(iface)

À ce stade, il suffit de retenir que :

• ce fichier est obligatoire,
• il fait le lien entre QGIS et votre code principal.

Explication ligne par ligne

def classFactory(iface):

✔ QGIS recherche obligatoirement une fonction portant ce nom : classFactory

Lorsque QGIS lit votreplugin, il appelle automatiquement :

classFactory(iface)

et transmet :

• iface = l’interface de QGIS (l’objet QgisInterface)
• cet objet donne accès à :
  • la carte (mapCanvas)
• • le menu Plugins
• • la barre d’outils
• • la couche activeles messages / logs
  • etc.

➡️ C’est l’objet central permettant à un plugin d’interagir avec QGIS.

from .mon_plugin import Monplugin

• Le signe . signifie : « dans le même dossier que ce fichier ».
• QGIS charge donc la classe principale depuis :

mon_plugin.py

Cette classe contient :

• initGui() → ajoute les actions, menus, icônes
• unload() → retire les éléments du plugin
• les fonctions métiers (activation d’outil, affichage de fenêtre, etc.)

➡️ C’est la classe racine du plugin, celle qui contrôle tout.

return MonPlugin(iface)

QGIS attend une instance de la classe, pas la classe elle-même.

Donc :

• on instancie la classe MonPlugin
• on lui transmet l’interface QGIS (iface)
• QGIS utilisera cet objet pour :
  • appeler initGui() lors de l’activation du plugin
  • appeler unload() lors de la désactivation

➡️ C’est la création concrète du plugin dans QGIS.

Résumé

👉 __init__.py sert à indiquer à QGIS la classe à utiliser pour le plugin.

👉 La fonction classFactory() est obligatoirement présente dans tout plugin QGIS.

👉 iface est l’accès complet à l’interface QGIS.

👉 Le plugin ne commence réellement à fonctionner qu’après l’instanciation :

MonPlugin(iface)

Le fichier metadata.txt

Ce fichier est fondamental : sans lui, QGIS ne reconnaît pas le plugin.

Il contient les informations générales :

• nom du plugin,
• description,
• auteur,
• version,
• version minimale de QGIS.

Exemple :

[general]
name=Mon premier plugin
description=Un plugin simple pour apprendre
version=0.1
author=Votre nom
qgisMinimumVersion=3.16

C’est ce fichier qui apparaît dans le gestionnaire de plugins de QGIS.

Le fichier principal Python (ex. mon_plugin.py)

C’est ici que se trouve le cœur du plugin.

On y trouve généralement :

• la classe principale du plugin,
• les méthodes initGui() et unload(),
• le code qui ajoute un bouton ou un menu dans QGIS.

Très schématiquement :

class MonPlugin:
    def __init__(self, iface):
        self.iface = iface

    def initGui(self):
        pass

    def unload(self):
        pass

Pas de panique si cela vous semble obscur : chaque élément sera expliqué progressivement dans les articles suivants.

Les fichiers optionnels mais très courants

Les interfaces graphiques (.ui)

QGIS utilise Qt pour les interfaces graphiques. Les fichiers .ui sont créés avec Qt Designer, sans écrire de code.

Ils permettent de construire des fenêtres avec :

• boutons,
• listes déroulantes,
• champs de saisie.

Les ressources (resources.qrc)

Ce fichier sert à regrouper :

• icônes,
• images,
• autres ressources graphiques.

Il est compilé en Python pour être utilisable dans le plugin.

Ce que vous devez retenir pour l’instant

À ce stade, l’essentiel est de comprendre que :

• un plugin QGIS est une structure de fichiers, pas un gros programme compliqué,
• chaque fichier a un rôle précis,
• on peut créer des plugins simples et très utiles avec peu de code.

Et dans le prochain article ?

Dans le prochain article, nous verrons :

• comment créer un plugin vide à l’aide de Plugin Builder,
• où placer les fichiers,
• comment charger le plugin dans QGIS et le tester.

L’objectif sera d’obtenir un premier plugin fonctionnel, même s’il ne fait encore presque rien.

👉 Le plus important n’est pas d’aller vite, mais de comprendre chaque étape.

Si cet article vous a intéressé et que vous pensez qu'il pourrait bénéficier à d'autres personnes, n'hésitez pas à le partager sur vos réseaux sociaux en utilisant les boutons ci-dessous. Votre partage est apprécié !

Atilio Francois