Tutoriel Programmation SIG

Tutoriel Programmation SIG
Utilisation des outils Python libres
T. Guyet
Remerciements :
Version Version 0.6, Derni`ere modification : 06/2014

Table des mati`eres
I Introduction 4
1 Python et les g´eotraitements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Librairies Python pour les g´eotraitements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3 Installation de l’environnement de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.1 Installation sous Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.2 Installation sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.3 Environnement de programmation adapt´e . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4 Aides et documents de r´ef´erence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
5 Importation des librairies GDAL/GEOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
II Quelques rappels de python 10
1 ProgrammationPython ......................................... 10
1.1 Exemple de programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Ex´ecution d’un script python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2 Lesvariablespython ........................................... 11
2.1 Variables ............................................. 11
2.2 Affichagesetsaisies ....................................... 12
3 Structures de contrˆole usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.1 Structure alternative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2 Structure r´ep´etitive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4 Les structures de donn´ees usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.1 Leslistes ............................................. 13
4.2 Lesdictionnaires ......................................... 14
5 Lesfonctions ............................................... 15
5.1 D´efinir une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.2 Variables locales, variables globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.3 Exemple.............................................. 18
6 Cr´eer un programme ”autonome” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
III Utilisation des donn´ees Vecteurs 20
1 Lire et ´ecrite dans des fichiers Shapefile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.1 Les ´el´ements de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.2 Les feature ............................................ 22
1.3 Exemple.............................................. 22
1.4 Exercices ............................................. 23
2 Manipulation des formes g´eom´etriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.1 Lesformesdebase........................................ 24
2.2 Cr´eation d’une nouvelle g´eom´etrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.3 Destruction des g´eom´etries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4 Exemple de cr´eation d’un fichier Shapefile `a partir de rien ... . . . . . . . . . . . . . . . . 26
2.5 Exercices ............................................. 27
3 Op´erations g´eom´etriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.1 Pr´esentation des op´erations g´eom´etriques . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3.2 Exemple : fusion des sous-bassins versants des Grands Lacs . . . . . . . . . . . . . . . . . 29
3.3 Exercices ............................................. 31
4 Utilisation des projections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.1 Cr´eation d’un syst`eme de coordonn´ees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.2 R´ecup´eration et attribution d’un syst`eme de coordonn´ees . . . . . . . . . . . . . . . . . . 34
4.3 Transformation de syst`eme de coordonn´ees . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.4 Exemple : recopie d’un fichier dans un syst`eme de coordonn´ees Lambert II . . . . . . . . 36
4.5 Exercice.............................................. 37
IV Utilisation des donn´ees Raster 39
1 LireunfichierRaster........................................... 39
1.1 Chargement des drivers sp´ecifiques (optionnel) . . . . . . . . . . . . . . . . . . . . . . . . 39
1.2 Chargement des donn´ees d’un fichier Raster . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.3 Parcours des pixels de la matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
1.4 Coordonn´ees des pixels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2 Cr´eation d’une couche raster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2.1 Principe.............................................. 43
3 Exercices ................................................. 46
3.1 Exercices de transformation de fichiers Raster . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.2 Rasteretvecteurs ........................................ 47
V Automatisation des traitements 50
1 Fonctionnalit´e du ”syst`eme” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
1.1 ModulesdePython........................................ 50
1.2 Manipulation des noms chemins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
1.3 Ex´ecuter des commandes syst`emes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2 Exemple du traitement des fichiers par lot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3 Introduire un peu de parall´elisation dans les traitements . . . . . . . . . . . . . . . . . . . . . . . 53
4 Exercices ................................................. 53
5 Traitements par lot d’images MODIS (tutoriel) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.1 Chargement des images MODIS par lot . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
5.2 Traitements d’images par lots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5.3 Compl´ements........................................... 58
VI Automatisation des traitements dans QGis 59
1 Utilisation de la console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
2 Utilisationdescripts........................................... 60
2.1 Cr´eation d’un script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
2.2 Utilisation du Script Runner .................................. 62
3 Programmation d’un plugin en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.1 ´ Etape 1 : cr´eer une coquille vide ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.2 ´ Etape 2 : Modification de l’interface avec QtCreator . . . . . . . . . . . . . . . . . . . . . 63
3.3 Int´egration du calcul des distributions de distances 2 `a 2 . . . . . . . . . . . . . . . . . . . 64
3

Tutoriel Programmation SIG– T. Guyet CHAPITRE I. INTRODUCTION
Chapitre
I
Introduction
Ce cours pr´esentation l’utilisation des libraries 1de l’OGR : GDAL/GEOS en langage Python. Ces librairies de
programmation sont utilis´ees dans un grand nombre d’outils libres de SIG (Mapnik, GeoServer, GRASS, QGis,
gvSIG, GoogleEarth, VTP, ...). Ces librairies se d´ecomposent en 4 principales librairies compl´ementaires :
— OGR d´esigne l’ensemble des fonctions de gestion des formats et des donn´ees sous le format vectoriel
— GEOS d´esigne l’ensemble des fonctions li´ees au transformations g´eom´etriques des donn´ees en format
vectoriel
— PROJ4 d´esigne l’ensemble des fonctions li´ees aux transformations des syst`emes de r´ef´erencement g´eogra-
phiques
— GDAL d´esigne l’ensemble des fonctions consacr´e `a la gestion et `a la manipulation des donn´ees raster.
Comprendre le fonctionnement g´en´eral de ces API est un moyen de cerner le potentiel et les
limites des traitements SIG actuels.
1 Python et les g´eotraitements
L’ensemble de ces librairies est d´evelopp´e en C++, un langage plus g´en´erique que python et qui offre de tr`es
bonne performances. Comme nous allons travailler sous python, les librairies python ne sont que des binding,
c’est-`a-dire des fonctions qui font indirectement r´ef´erence aux fonctions C++. G´en´eralement, les fonctions ont
les mˆemes noms. Les informations que vous trouverez en C++ sont donc ´egalement utiles pour les versions
python. N´eanmoins, certaines fonctionnalit´es ne sont pas fonctionnelles en python bien que les fonctions existes
(j’ai personnellement rencontr´e le probl`eme !).
Python est un langage de programmation assez r´ecent (1989). C’est un langage multi-paradigme et multi-
plateformes. Il est multi-paradigme car il permet de r´ealiser des scripts, de faire de la programmation matricielle
(avec numpy), de faire de la programmation proc´edurale et de la programmation objet (il reste quand mˆeme
assez orient´e objet). Il est ´egalement multi-plateformes puisque l’environnement Python est disponible aussi
bien sous Windows, Linux et Mac. Les mˆemes programmes fonctionnent dans les trois environnements.
L’une des vis´ees du Python est de pouvoir ´ecrire rapidement des fonctionnalit´es avanc´ees. Pour cela, le langage
offre une syntaxe concise et s’accompagne d’un tr`es grand nombre de librairies compl´ementaires qui offre un
acc`es `a des fonctionnalit´es avanc´ees telles que celles permettant d’acc´eder aux donn´ees g´eographiques.
L’ex´ecution d’un programme Python passe par un interpr´eteur qui doit ˆetre install´e sur l’ordinateur ex´ecu-
tant le script. Une des contraintes de Python est l’absence de compilation, c’est `a dire d’une ´etape pr´ec´edent
l’ex´ecution qui permet, entre autre, au programmeur de v´erifier que le programme qu’il a ´et´e est ”‘correct”’.
Dans le cas de Python, on ne saura que l’´ecriture n’est pas correcte que lors de l’ex´ecution du script. Ceci rend
les programmes Python assez difficile `a finaliser proprement.
Le langage Python est en cours de mutation entre une version 2 et une version 3. La version 3 apportant des
modifications non-compatibles avec la version 2 du langage. Il est g´en´eralement recommand´e de d´evelopper pour
la version 3 du langage afin d’avoir un d´eveloppement fonctionnel `a moyen terme. N´eanmoins, dans ce tutoriel,
nous utiliserons une version 2.7 pour des raisons de disponibilit´e sous Windows de l’ensemble des librairies dont
nous nous servirons.
2 Librairies Python pour les g´eotraitements
Le langage Python offre trois possibilit´es pour la mise en place de fonctionnalit´es de g´eotraitements :
— l’utilisation de la suite de librairies de l’OGR/GDAL
— l’utilisation de la librairie accompagnant le logiciel ArcGIS : ArcPy
— l’utilisation des fonctionnalit´es int´egr´ees `a QGis
La premi`ere solution est la solution la plus g´en´erique : elle est ind´ependante de quelconque autre logiciel, elle peut
ˆetre utilis´e tr`es largement (librairies gratuites et open-sources, installable sur Windows, Linux et Mac). C’est
une solution qui est compl`ete mais basique. En effet, l’objectif de ces librairies est de fournir les fonctionnalit´es
1. on parle ´egalement d’API pour Application Programming Interface
4

CHAPITRE I. INTRODUCTION
de base de traitement de l’information g´eographique, mais elle ne comprend que de tr`es rare fonctionnalit´es
avanc´ees. Pour d´evelopper des traitements avanc´es, il faut soit d´evelopper ces nouvelles fonctionnalit´es, soit
faire appel `a des librairies plus sp´ecialis´ees (utilisant elles-mˆemes les librairies de l’OGR comme support).
La seconde solution est une solution payante, elle limite donc l’usage des outils qui sont mis en place uniquement
aux utilisateurs de ArcGIS. Cette librairie de fonctionnalit´e a ´et´e faite pour augmenter les capacit´es du logiciel
ArcGIS par des proc´edures d´evelopp´ees par l’utilisateur. L’int´erˆet principal de cette librairie est de donner
acc`es aux traitements de haut-niveau disponibles dans ArcGIS. Mais c’est aussi une contrainte de cette librairie
qui reste tr`es cloisonn´ee `a ces fonctionnalit´es. On tire le maximum de l’int´erˆet de ArcPy avec le modeler. Une
proc´edure cr´e´ee graphiquement avec le Modeler peut engendrer un code Python qu’un g´eomaticien aguerris `a
la programmation pourra adapt´e `a son besoin sp´ecifique.
La troisi`eme solution est interm´ediaire. Initialement pr´evu pour le d´eveloppement de plugins dans QGis la
librairie Python de QGis offre des fonctionnalit´es tr`es similaires `a celle de l’OGR (en faite, tout le logiciel QGis
s’appuie sur cette librairie) et ajoute la possibilit´e d’acc´eder aux fonctionnalit´es de visualisation, d’interaction
et de traitement disponibles dans QGis. Il est n´eanmoins `a noter que QGis est un logiciel pr´evu pour faire de la
visualisation et certaines fonctionnalit´es de modification des donn´ees de la librairie de GDAL (en version 1.9,
je n’ai pas regard´e depuis) semblent accessibles depuis QGis mais ne sont en faite pas impl´ement´ees. C’est le
cas, en particulier, pour l’acc`es aux donn´ees raster. Il est parfois n´ecessaire de revenir `a des objets de la librairie
GDAL pour d´evelopper son plugin complet (et ce n’est pas tr`es propre !).
Dans le cadre de ce tutoriel, nous avons choisis de pr´esenter la librairie OGR/GDAL, d’une part, pour pr´esenter
les fondements partag´es par ces librairies de g´eotraitement, ensuite, pour l’aspect g´en´erique des traitements
qui peuvent ˆetre d´evelopp´es par cette librairie. Une bonne pratique de la programmation informatique (voir,
par exemple, les mod`eles MVC) est de d´ecorr´eler les fonctionnalit´es de traitement (la d´efinition des fonctions
de traitement) et les fonctionnalit´es d’interaction (comment l’utilisateur utilise les fonctions). Nous nous in-
t´eresserons ici `a d´evelopper des fonctionnalit´es de traitement. Finalement, l’usage premier de ces outils par le
g´eomaticien consiste souvent `a effectuer des transformations simples des donn´ees et `a d´el´eguer le r´ealisation des
fonctionnalit´es de traitement avanc´e `a des informaticiens. Dans ce sens, on peut supposer que les traitements
avanc´es seront des fonctions utilisables en Python (voir le chapitre V, sur l’automatisation des traitements).
3 Installation de l’environnement de travail
L’ensemble des outils qui ont ´et´e s´electionn´es sont les logiciels open sources et libres d’usage et multi-
plateformes. Vous pouvez donc les installer et les utiliser gratuitement dans tous vos d´eveloppements.
Ce dont nous aurons besoin pour ce tutoriel :
— les librairies de l’OGR :
— OGR : pour la gestion des formats de donn´ees vectoriels (dont SHP et bases de donn´ees g´eogra-
phiques),
— GEOS : pour la manipulation des g´eom´etries,
— PROJ4 : pour la gestion des syst`emes de projection,
— GDAL : pour la gestion des formats de donn´ees raster.
— les librairies permettant l’utilisation de R sous python,
— le syst`eme d’information g´eographique QGis.
3.1 Installation sous Linux
3.1.1 Installation de Python et GDAL
L’installation sous Linux est plutˆot simple relativement `a l’installation sous Windows. En effet, tous ces outils
sont d´evelopp´es et utilis´es sous Linux en premier lieu.
Les distributions de Linux les plus usuels (Ubuntu/Fedora) dispose de ces librairies dans leur offre logiciel, il
suffit donc de les installer directement avec l’outil d’installation. Personnellement, j’utilise les outils d’installation
en ligne de commande (apt-get pour ubuntu et yum pour fedora), mais vous pouvez les retrouver `a l’aide des
outils d’installation graphiques.
Pour Ubuntu, la liste des packages `a installer sont les suivants (certains packages suppl´ementaires, comme les
librairies GDAL seront automatiquement ajout´ees `a votre installation) :
— python3
— python3-numpy
— python3-scipy
— python3-gdal
5