:: Yves Jacolin :: Ludovic Granjon :: Softlibre :: OSGeo-fr ::
"Quand on veut reprendre avec utilité, et montrer à un autre qu'il se trompe, il faut observer par quel côté il envisage la chose, car elle est vraie ordinairement de ce côté-là, et lui avouer cette vérité, mais lui découvrir le côté où elle est fausse." Pascal, Pensées Br. 9, Lafuma 5.

Étendre les fonctionnalités de QGIS avec les plugins en Python

Workshop FOSS4G 2008

  • Auteurs : Dr. Marco Hugentobler, Dr Horst Düste, Tim Sutton
  • Traducteur : Yves Jacolin

Septembre 2008

Introduction

QGIS est un SIG populaire écrit en C++. Au delà d'écrire des extensions en C++, il y une interface en python dans QGIS (PyQGIS). Il y a trois moyens d'utiliser PyQGIS :

  • à partir de la console en ligne de commande qui est intéressante pour le débugage ;
  • comme un plugin de QGIS écrit en Python. Ces plugins peuvent être activé dans le gestionnaire de plugin comme les plugins C++.
  • des applications indépendantes en Python avec leur propre interface utilisateur peuvent utiliser les fonctionnalités de la bibliothèque QGIS.

Ce workshop fournit un tutorial pour débutant pour l'écriture de plugins en Python pour QGIS. Téléchargez le !

Pourquoi Python ?

Python est un langage de script qui a été conçu afin d'être facile à écrire. Il a un mécanisme qui nettoie automatiquement la mémoire qui n'est plus utilisée (collecteur de déchet). Un avantage supplémentaire est que plusieurs programmes écrit en C++ ou Java offre la possibilité d'écrire des extensions en Python, comme OpenOffice.org ou GIMP. C'est donc un bon investissement d'apprendre le langage Python.

Licence

Les plugins PyGQIS utilisent les fonctionnalités de libqgis_core.so et libqgis_gui.so. Comme les deux sont publiés sous licence GPL, les plugins Python pour QGIS doivent être publiés sous licence GPL également. Cela signifie que vous pouvez utiliser votre plugin dans n'importe quel but et vous n'êtes pas obligé de les publier. Toutefois, si vous voulez les publier, ils doivent être dans les conditions de la licence GPL. Avec les programmes en Python, ces restrictions n'ont pas autant d'importance que pour les programmes compilés puisque le code source est visible (NdT : vous autorisez néanmoins quiconque à pouvoir modifier et diffuser votre code).

Qu'avez vous besoin d'installer pour démarrer ?

Sur les ordinateurs du labs, tout ce qui est nécessaire est déjà installé. Si vous programmez chez vous, vous aurez besoin des bibliothèques et programmes suivants :

Si vous utilisez un système Linux ou équivalent, il existe des binaires pour toutes les distributions majeures. Pour les utilisateurs de Windows, l'installateur PyQT contient déjà Qt, PyQT et les outils de développement de PyQT.

Un exemple de plugin en PyQGIS en trois étapes

Notre exemple de plugin restera intentionnellement simple. Il ajoute un bouton à la barre de menu de QGIS. Si le bouton est cliqué, une boîte de dialogue apparait dans laquelle un utilisateur peut charger un fichier shape.

Pour chaque plugin Python, un répertoire dédié qui contient les fichiers du plugins est nécessaire. Par défaut, QGIS cherche des plugins dans $QGIS_DIR/share/qgis/plugins (dans notre workshop /usr/share/qgis/plugins). Sous Linux, il y a la possibilité d'avoir des plugins dans $HOME/.qgis/python/plugins afin qu'il soit seulement visible par un utilisateur.

Étape 1 : reconnaissance du plugin par le gestionnaire de plugin

Pour fournir les informations nécessaire pour QGIS, le plugin nécessite d'implémenter les méthodes name(), description() et version() qui renvoie les chaînes descriptives. Un plugin nécessite également une méthode classFactory(QgisInterface) qui est appelé par le gestionnaire de plugin pour créer une instance du plugin. L'argument de type QGisInterface est utilisé par le plugin pour accéder aux fonctions de l'instance QGIS. Nous allons travailler avec cet objet à l'étape 2.

Notez qui, contrairement aux autres langages de programmation, l'indentation est très importante. L'interpréteur Python renvoie une erreur si elle n'est pas correcte.

D'abord nous créons le répertoire du plugin foss4g_plugin dans QGIS/python/plugins. Puis nous ajoutons deux nouveaux fichiers textes dans ce répertoire, foss4gplugin.py et _ _init_ _.py.

  • Le fichier foss4gplugin.py contient la classe du plugin :
#-*- coding: utf-8 -*-
# Import les bibliothèques PyQT et QGIS
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from qgis.core import *
# Initialisation des ressources Qt à partir du fichier ressources.py
import resources
class FOSS4GPlugin:
	def __init__(self,iface):
		#Sauve les références dans l'interface QGIS
		self.iface = iface
 
	def initGui(self):
		print 'Initialising GUI'
 
	def unload(self):
		print 'Unloading plugin'
  • Le fichier _ _init_ _.py contient les méthodes name, description, version, et classFactory évoqué plus haut. Comme nous somme en train de créer une nouvelle instance de la classe plugin, nous devons importer le code de cette classe :
#-*- coding: utf-8 -*-
from foss4gplugni import FOSS4GPlugin
def name():
	return "Exemple du FOSS4G"
def description():
	return "Un plugin d'exemple simple pour charger des fichiers Shape."
def version():
	return "Version 0.1"
def classFactory(iface):
	return FOSS4GPlugin(iface)

Maintenant le plugin possède l'infrastructure nécessaire pour apparaître dans le gestionnaire de plugin QGIS et être chargé/déchargé.

Étape 2 : ajouter un bouton au menu

Icône

Pour que votre icône graphique soit disponible dans votre programme, nous avons d'un fichier “ressource”. Dans ce fichier ressource, le graphique est contenu sous forme hexadécimale. Heureusement nous n'avons pas à nous occuper de sa représentation parce que nous utilisons le compilateur pyrcc, un outil qui lit le fichier ressource.qrc et créé un fichier ressource.

Le fichier foss4g.png et le ficher ressource peuvent être téléchargé à partir de http://karlinapp.ethz.ch/python_foss4g. Déplacez ces fichiers dans le répertoire du plugin exemple. Ouvrez une console, déplacez vous dans le répertoire du plugin, et entrez : <chemin_vers_le_répertoire_QGIS>/pyrcc4 -o ressources.py ressources.qrc.

Ajouter un menu et un bouton

Dans cette partie, nous allons implémenter le contenu des méthodes initGui() et unload(). Nous avons besoins d'une instance de la classe QAction qui exécuté la méthode run() du plugin. Avec l'objet action, nous somme alors capable de générer l'entrée du menu et le bouton :

import ressources
 
def initGui(self):
	# Créer une action qui démmarera la configuration du plugin
	self.action = QAction(QIcon(":/plugins/foss4g_plugin/foss4g.png"),"FOSS4G plugin", self.iface.getMainWindow())
	# Connecter l'action à la méthode run
	QObject.connect(self.action, SIGNAL("activated()"),self.run)
	# Ajoutez le bouton de la barre d'outil et l'entrée du menu
	self.iface.addToolBarIcon(self.action)
	self.iface.addPluginMenu("FOSS-GIS plugin ...",self.action)
 
def unload(self):
	# Supprime les entrées des menu et de l'icône
	self.iface.removePluginMenu("FOSS-GIS plugin ...",self.action)
	self.iface.removeToolBarIcon(self.action)

Étape 3 : charger une couche à partir d'un shapefile

Dans cette étape nous allons implémenter les fonctionnalités réelles du plugin dans la méthode run(). La méthode Qt4 QFileDialog::getOpenFileName ouvre une boîte de dialogue et renvoie le chemin du fichier choisit. Si l'utilisateur annule la boîte de dialogue, le chemin est un objet null, que nous allons tester. Puis nous appelons la méthode addVectorLayer de l'objet interface qui charge la couche. La méthode possède seulement trois arguments : le chemin du fichier, le nom de la couche qui sera affichée dans la légende et le nom du fournisseur de données. Pour les Shapefiles, c'est 'ogr' car QGIS utilise en interne la bibliothèque OGR pour accéder aux shapefiles :

def run(self):
	fileName = QFileDialog.getOpenFileName(None,QString.fromLocal8Bit("Sélectionnez un fichier :"),"","*.shp *.gml")
	if fileName.isNull():
		QMessageBox.information(None,"Cancel","Sélection du fichier annulée")
	else:
		vlayer = self.iface.addVectorLayer(fileName,"myLayer","ogr")

Plus d'informations

Comme vous pouvez voir, vous avez besoin d'informations de différentes sources pour écrire des plugins PyQGIS. Les développeurs de plugins doivent connaître Python et l'interface de plugin de QGIS ainsi que les classes et outils de Qt4. Au début il est important d'apprendre à partir des exemples et de copier les mécanismes de plugins existant. En utilisant l'installateur de plugins de QGIS, qui est lui même un plugin Python, il est possible de télécharger plusieurs plugins et de les étudier.

Nous finirons ce tutorial avec une sélection de documentation en ligne qui peuvent être utile pour les programmeurs de PyQGIS :


Yves Jacolin 2008/11/02 20:01

Contact - Information et copyright - Statistique

Recent changes RSS feed Creative Commons License Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki