J'ai l'honneur de vous annoncer aujourd'hui la sortie du plugin cadastre pour QGIS.

Il a été financé par l'Europe, le Conseil Régional de Picardie et l'Aduga et développé par la société 3Liz.

Il est disponible gratuitement dans le dépôt officiel des plugins QGIS

*** Attention, pensez à afficher les extensions expérimentales ***

Ses fonctionnalités principales sont :

• Import des données EDIGEO et/ou MAJIC (format 2012 et 2013) dans PostGIS ou Spatialite
• Chargement des données dans une projet (vierge ou existant) avec mise en forme automatique de la symbologie, étiquettes, etc. (2 styles disponibles : classique comme cadastre.gouv.fr et orthophoto)
• Interrogation des données fiscale : recherche par lieux, adresse et propriétaire
• Édition de relevé de parcelles et de relevé de propriétaire

Pour en savoir plus, vous pouvez consulter la documentation en ligne (elle est également présente dans le plugin) : https://github.com/3liz/QgisCadastrePlugin/blob/master/doc/index.rst

Quelques vidéos de démonstration :

• Import et chargement des données :http://vimeo.com/75004889
• Recherche des données par adresse, lieu et propriétaire :http://vimeo.com/74807532

Nous espérons que cet outil sera une réelle alternative aux outils propriétaires existants et faciliter l'intégration de QGIS au sein des collectivités.

N'hésitez pas à faire un retour d'utilisation et nous remonter d'éventuels bugs sur le forumSIG http://www.forumsig.org/showthread.php/37917-Un-plugin-cadastre-libre-po...!

	Type :	script pour la boite à outils traitement
	Licence :	GPL

Suite à cette discussion sur le forumSIG http://www.forumsig.org/showthread.php/37661-Logiciel-Ajustement-spatial... , où je cherchais une méthode pour faire du géoréférencement vectoriel, voici le protocole mis en place pour y parvenir.

Attention, cette méthode nécessite que QGIS utilise gdal 1.10 ou supérieur.

Faire un fichier texte de points de correspondance (une ligne par point) formaté ainsi :

pointNonGeoref_x pointNonGeoref_y pointGeoref_x pointGeoref_y

Pour cela à l'aide de l'outil identification / dérivées / copier les valeurs d'attributs (on fait ça pour le fichier à géoréférencer et sur le référentiel à utiliser pour géoréférencer, le plus simple étant d'avoir 2 instances de qgis simultanées, l'une avec le fichier à géoréférencer sans reprojection à la volée et l'autre avec le référentiel permettant de récupérer les bonnes coordonnées)

Exemple

-869784.220806 273824.996155 475353.856328 267608.211198
-869786.957227 273804.951538 475351.619893 267590.139363
-869767.137134 273845.613669 475369.467973 267625.62811
-869758.781489 273830.170332 475377.513896 267610.888946

A noter qu'il est également possible d'utiliser le plugin copy_Coords de QGIS, plus simple d'utilisation, mais moins précis.

On lance ensuite le script joint (celui-ci ne fait que remplacer la commande d'ogr2ogr proposée par gene http://www.forumsig.org/showthread.php/37661-Logiciel-Ajustement-spatial...) mais permet d'éviter la ligne de commande.

Décompresser le zip dans le dossier script de l'outil traitements (voir Traitements / options / scripts / Scripts folder)

Dans la boite à outils de traitements / scripts, une entrée "[Géoréférencement] / ajustementSpatial" a du apparaitre, lancer le script et remplir comme précisé dans la documentation.

Si tout se passe bien, le fichier nouvellement géoréférencé doit s'ouvrir, placé correctement.

Le nombre de points de correspondance définit l'ordre du polynôme utilisé pour le géoréférencement.

Le script a été testé sous linux et sous windows avec l'installateur OSGEO.

Sous Mac, il est nécessaire de remplacer la ligne

ogr = 'ogr2ogr -a_srs EPSG:'+epsg+''

par

ogr = '/Library/Frameworks/GDAL.framework/Versions/1.10/Programs/ogr2ogr -a_srs EPSG:'+epsg+''

En pratique, dans le script téléchargé, commenter la première ligne en y insérant un # devant et décommenter la ligne pour Mac en supprimant le #.

En espérant que cela vous sera utile, n'hésitez pas à faire un retour si vous avez des soucis sur la discussion du forumSIG.

script QGIS permettant de faire un ajustement spatial

	Niveau	Débutant
	Logiciels utilisés	Qgis
	Plateforme

Combien de fois ai-je entendu des utilisateurs pester contre leur logiciel SIG parce qu'il "ramait" !

Eh bien, avant d'incriminer son logiciel préféré, mieux vaut savoir quelles erreurs ne pas commettre et quoi faire pour que son document Qgis soit le plus fluide possible.

Je vais ici parler de Qgis mais c'est totalement applicable dans n'importe quel logiciel SIG (même pour des serveurs carto). 

1) Les seuils d'affichage (visibilité dépendante de l'échelle)

Définissez des seuils d'affichage pour vos couches, surtout pour les couches les plus lourdes.

Par exemple, il n'y a guère d'interêt à afficher une couche des parcelles au 50 000 ème. Si vous le faites, le logiciel devra dessiner ces objets (ces milliers voire dizaines de milliers d'objets)  sur l'écran, entrainant des performances fortement ralenties. Bien sûr, c'est un exemple extrême mais le principe n'en reste pas moins à utiliser.

De même pour un .vrt d'un scan 25 affiché au 100 000 ème. De très nombreuses dalles seront affichées à l'écran, entraînant un affichage ralenti alors que cela n'a pas d'utilité.

Rendez vous dans les propriétés de la couche, onglet général pour régler ces seuils :

2) L'index spatial

Veillez à ce que vos couches vectorielles aient un index spatial. Celui-ci va fortement accélérer l'affichage des entités de la couche en permettant au logiciel de connaître très rapidement quelles entités sont à afficher (NB : l'index spatial est en fait le rectangle englobant de chaque entité).

En bonus, l'index spatial va accélérer vos géotraitements, en permettant un premier tri rapide (pour une intersection, premier tri avec les intersections des rectangles englobants des 2 couches avant de calculer la véritable intersection).

Pour calculer l'index spatial d'une couche dans Qgis, rendez vous dans les propriétés de la couche, onglet Général (cf. l'imprime-écran du point 1).

3) Le piège de la reprojection à la volée.

La reprojection à la volée est une option très pratique dans Qgis, puisqu'elle vous permet de superposer correctement des couches vectorielles ou rasters ayant des systèmes de coordonnées différents.

Qu'est ce que la reprojection à la volée ? Il s'agit pour une couche vectorielle de convertir toutes les coordonnées des sommets dans le système de coordonnées du document Qgis, permettant ainsi de les afficher dynamiquement au bon endroit. Autant dire que cela utilise une puissance de calcul loin d'être négligeable.

Pour les rasters, ca se corse encore plus, puisqu'il s'agit de recalculer la position des pixels du raster. La puissance de calcul demandée est ainsi encore plus importante.

Si vous voulez un document Qgis rapide, désactivez la projection à la volée et reprojetez toutes vos couches dans la même projection avant de les inclure. Non seulement cela améliorera vos performances d'affichage mais cela rendra vos géotraitements plus rapides (voire les empechera de planter).

En bref, réservez la projection à la volée à la découverte des données et non pas à leur exploitation ! Veillez donc à avoir en exploitation des données dans un système de coordonnées unique.

Et si jamais vous devez pour une raison ou pour une autre conserver des systèmes de coordonnées différents, préférez toujours le système de coordonnées des données les plus "lourdes" (raster, couches vectorielles complexes) comme système de coordonnées du document.

4) Les pyramides pour les raster.

Les pyramides sont des aperçus du raster à différentes échelles. Ils permettent donc à QGIS, une fois générés, d'afficher très rapidement un raster qu'elle que soit l'échelle (ci dessous la BD Alti 75m de l'IGN sur toute la France).

Vous pouvez choisir les niveaux de pyramides à générer et ainsi faire un compromis optimal poids / performance (et ceci d'autant plus en combinant les pyramides avec des seuils de zoom adaptés).

Pour générer les pyramides, rendez vous dans les propriétés d'un raster, onglet pyramides. Sélectionnez les niveaux de pyramides souhaités puis générez les.

A titre personnel, je préfère les générer en fichier externe (d'ailleurs, Qgis vous y incitera fortement). Un fichier ovr les contenant (qui peut très vite devenir imposant pour une ortho départementale :-) ) sera généré à côté du raster. Bien sûr, cela fonctionne avec les rasters virtuels (.vrt).

Et en bonus, une petite info pour conserver un Qgis performant, toutes les extensions python activées sont chargées à l'ouverture de QGis, pouvant fortement le ralentir. N'hésitez pas à désactiver les extensions les moins utiles et à ne les activer qu'en cas de besoin.

	Niveau	Débutant
	Logiciels utilisés	QGIS Plugin Qgis2threejs
	Plateforme	Windows | Mac | Linux | FreeBSD

Cela vous intéresse-t-il de passer d'une vue 2D classique du type:

à une vue en 3D interactive (mise à l'échelle, rotation, etc.):

Le tout avec un simple navigateur ? Oui ? Alors installez le plugin Qgis2threejs de Minoru Akagi.

Principes:

Ce plugin utilise la librairie JavaScript three.js qui permet de créer et d'afficher de la 3D dans son navigateur avec la technologie WebGL. À la différence de solutions comme GRASS GIS, qui permettent de créer et traiter les éléments 3D, Qgis2threejs ne permet donc que leur visualisation.

Comme j'ai rencontré des problèmes pour le faire fonctionner sur Mac OS X, j'ai été amené à en décortiquer le code pour le faire fonctionner. Ceci m'a aussi permis d'en comprendre les principes.

1. Qgis2threejs n'utilise pas les couches individuelles, mais le canevas (la vue)  avec toutes les couches affichées et leurs enjolivures;
2. dans un premier temps, il sauve cette vue comme une image géoréférencée (comme dans le menu Projet/Sauvegarder comme image);
   1. cela signifie que le format des couches affichées n'a aucune importance;
   2. mais il faut impérativement qu'un MNT soit présent (pour la 3D);
3. en combinant cette vue géoréférencée et le MNT, le plugin va créer à l'aide de GDAL, un fichier JavaScript avec les couches au format WebGL.
4. en même temps, il crée un fichier HTML qui permet de visualiser le modèle dans un navigateur compatible avec WebGL  et l'ouvre dans ce navigateur.

Le dialogue du plugin qui permet, entre autres, de spécifier la couche MNT dans toutes les couches disponibles:

Exemples:

• l'exemple montré en introduction utilise un MNT et une couche WMS (afficher exemple pour le Portail SIG, attention, il vous faut un navigateur qui supporte le WebGL. Dans mon cas, ça marche très bien avec Firefox et il faut lui laisser un certain temps):

• le deuxième exemple montre le même MNT, mais avec une couche raster (carte géologique):

• un troisième exemple montre les limites des formations géologiques (couche shapefile) sur le WMS:

• un autre exemple montre la couche OpenStreetMap obtenue par le plugin OpenLayers:

• et enfin le dernier exemple est celui fourni par l'auteur du plugin: le Mont Fugi:

Conclusions:

• à la différence de GRASS GIS (voir nviz dans GRASS GIS pas à pas pour les débutants: 5 - le module nviz et la création de modèles 3D multicouches) tous les traitements doivent donc être réalisés en amont de l'utilisation du plugin (dans la dernière version sur GitHub l'exagération des hauteurs « en live » est néanmoins possible) ;
• et enfin, comme déjà souligné, cela reste de la simple visualisation sans exportation du résultat possible pour une autre utlisation, mais le résultat reste très plaisant à voir (du moins, c'est mon avis).
• les suggestions sont proposées sur la liste QGIS-Developper et visibles sur Qgis2threejs suggestions....

Tous les traitements ont été réalisés sur Mac OS X avec QGIS 2.0 Dufour et une version de QGIS master (2.1) avec une version modifiée du script qgis2threejs.py pour qu'il fonctionne sur Mac OS X (voir ma réponse sur Qgis2threejs suggestions....).

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Intermédiaire
	Logiciels utilisés	QGIS Plugin MMQGIS
	Plateforme	Windows | Mac | Linux | FreeBSD

Les cartes de flux, notamment les mappemondes montrant de jolies liaisons courbes, sont difficiles à réaliser. Anita Graser proposait il y a quelques temps une méthode pour les réaliser avec PostGIS, mais avec la disponibilité de QGIS 2.0 il est désormais possible de le faire directement et plus simplement.

Pour rester dans la thématique des liaisons aériennes, nous allons utiliser le jeu de données diffusé par OpenFlights. On en a extrait deux fichiers : la localisation des aéroports et le nombre de routes aériennes les reliant deux à deux, pour pouvoir travailler sur un exemple simple mais réel.

Fichiers utiles :

• aeroports.csv
• liaisons_t.csv (totales)
• liaisons_p6.csv (plus de 6 liaisons seulement)

Le principe de création de cette carte de flux est le suivant :

1. Conversion du fichier texte en couche de points projetée spécialement
2. Génération des lignes de flux
3. Densification de ces lignes pour permettre la courbure
4. Changement de projection pour revenir à une représentation habituelle

1. Conversion des fichiers texte en couches de points projetées spécialement

La première étape consiste à convertir le fichier csv (texte délimité) des aéroports en fichier de formes de points. On peut le faire simplement dans QGIS 2 en utilisant le menu "Couche" puis "Ajouter une couche de texte délimité".

Le paramétrage est simple : il s'agit d'un fichier délimité par des virgules (csv), les coordonnées X des points sont dans le champ nommé "long", les Y dans le champ "lat".

Une fois importé, ce fichier devient une couche SIG localisant les aéroports dans le monde.

On va ensuite créer une projection personnalisée pour pouvoir projeter cette couche spécifiquement : une projection conique équidistante, centrée sur le pôle nord. Les lignes aériennes, crées dans cette projection, apparaîtront sous la forme de belles courbes (des loxodromes ou grands cercles) sur une projection plus conventionnelle.

Dans QGIS 2, il faut aller chercher le menu "Préférences" puis "Projection personnalisée".

Les paramètres Proj4 sont :

"+proj=eqdc +lat_0=0 +lon_0=0 +lat_1=60 +lat_2=60 +x_0=0 +y_0=0 +a=6371000 +b=6371000 +units=m +no_defs"

Enfin, on enregistre la couche aéroport en tant que fichier de formes dans cette projection :

Lorsque l'on démarre un nouveau projet QGIS et que l'on charge ce nouveau fichier, on obtient une représentation nouvelle :

Après le fichier des aéroports, il faut maintenant créer un second fichier de formes, à partir des liaisons, pour pouvoir créer les lignes aériennes entre aéroports.

Pour cela, on va tout d'abord charger le second fichier texte, contenant les liaisons, en utilisant la même fonction d'importation de couche de texte délimité, mais cette fois en précisant qu'il n'y a pas de géométrie. On obtient une table de données que l'on va devoir géolocaliser en utilisant le premier fichier.

La création des lignes, qui sera expliquée dans la partie suivante, nécessite la présence de deux fichiers de formes de points : des "moyeux" (hubs) auxquels seront reliés des "rayons" (spokes), selon la métaphore de la roue de vélo. Si cette technique est à la base prévue pour la création de cartes "en oursins", il est tout à fait possible de réaliser des lignes simples.

Il faut donc créer un second fichier de formes de points, regroupant les aéroports de destination des liaisons aériennes, que l'on pourra ensuite utiliser pour réaliser les liaisons en le comparant avec le fichier des aéroports d'origine.

Pour ajouter une géométrie de point aux aéroports de destination du fichier des liaisons, le plus simple est de réaliser une jointure avec le fichier des aéroports, sur le champ dst_apt_id :

Ensuite, on va enregistrer le résultat de cette jointure, en ne sélectionnant que les aéroports de destination, ceux où la jointure contient des données, dans un nouveau fichier de formes, en gardant la même projection : destinations.shp (Par exemple en ouvrant la table d'attributs, puis en triant les entités selon le champ liaisons_nbroutes, en ne sélectionnant que les valeurs non nulles, et en enregistrant la sélection par le menu "couche").

2. Générer les lignes de flux entre aéroports

La création concrète des géométries linéaires des liaisons aérienne est faite par le biais d'un plugin, MMQGIS de Michaël Minn : http://michaelminn.com/linux/mmqgis/

Ce plugin contient de nombreuses fonctionnalités, celle qui nous intéresse s'appelle "Hub lines".

Dans notre cas, on va créer des lignes entre les points du fichier aéroports, qui seront les points d'origine des liaisons, et les points du fichier destinations.shp, en utilisant l'identifiant des aéroports comme champ de connexion.
 

3. Densification des lignes

Pour que les liaisons aériennes adoptent de belles formes courbes une fois la projection revenue à un système plus courant, il faut que les géométries linéaires qui les composent soient complexifiées, comportant des séries de segments de ligne, plutôt qu'un seul segment entre deux points.

Cette opération de densification se réalise directement sous QGIS 2 par le menu "Vecteur", puis "Outls de géométrie" et enfin "Densification".

Le seul paramètre concerne le nombre de subdivisions à créer. C'est dommage de ne pas pouvoir utiliser une distance plutôt qu'un nombre, car nos liaisons aériennes présentent des longueurs très variables. Pour que l'effet de courbure soit assez lisse tout en ne créant pas un fichier trop lourd, on peut choisir une valeur entre 40 et 100 points de plus par ligne. On enregistre le résultat dans un nouveau fichier, pour éventuellement pouvoir choisir une nouvelle valeur plus tard.

Le résultat, en mode édition :

4. Changement de projection pour revenir à une représentation habituelle

Pour que nos liaisons affectent l'aspect de courbes, de grands cercles, il faut maintenant revenir à une projection plus adaptée. Puisque nous cherchons à représenter des données mondiales, on peut choisir une projection de type équivalente, qui va conserver les rapports de surface, pour éviter d'avoir une déformation inutile des continents.

La projection Eckert-IV est assez courante et produit une image équilibrée des continents. On peut l'ajouter à QGIS 2 par la même procédure que précédemment, par le menu "Préférences".

"+proj=eck4 +lon_0=0 +x_0=0 +y_0=0 +a=6371000 +b=6371000 +units=m +no_defs"

Si l'on superpose ces lignes aériennes sur un fond mondial simplifié, que l'on utilise un style d'affichage proportionnel à la valeur du nombre de liaisons et légèrement transparent, on commence à voir apparaître une représentation utilisable. Pour améliorer la représentation, il faudra filtrer, ne garder que certaines liaisons par une sélection géographique ou quantitative, ou bien rendre la représentation interactive.

Le problème des liaisons aériennes traversant la ligne de changement de date dans le Pacifique peut être réglé en coupant ces lignes à la main.

Il y a quelques temps j'avais fait un article sur comment gérer un catalogue d'images à l'aide des plugins Image boundary et Show/Hide Image : Plugin QGIS - Image boundary et Show/Hide Image : Gérer un catalogue d'images. Malheureusement si Image Boundary existe encore pour QGIS 2, ce n'est pas le cas pour Show/Hide Image. Alors comment faire en se passant de ces deux plugins ?

Image Boundary permet de créer un tableau d'assemblage de rasters contenus dans un dossier, il est possible de faire la même chose à l'aide de gdaltindex, disponible également dans QGIS :

Menu Raster / Divers / Index de tuiles

Je choisis d'écrire le chemin absolu dans le shapefile, mais un chemin relatif fonctionne tout aussi bien, et permet de déplacer les rasters et le tableau d'assemblage ailleurs sans avoir à modifier le tableau d'assemblage.

Une fois le tableau d'assemblage créé, il faut l'ouvrir dans QGIS.

Nous allons utiliser les actions pour gérer l'affichage ou non de nos rasters :

Il faut ouvrir les propriétés du tableau d'assemblage (clic droit sur la couche / Propriétés) puis se rendre sur l'onglet actions. Nous allons créer deux actions de type python, l'une pour ouvrir le raster et l'autre pour le fermer :

action openRaster :

• choisir le type python
• donner un nom à l'action : openRaster
• puis entrer le code suivant dans la zone Action :

importoschemin='[% "location" %]'nomCouche = str(os.path.splitext(os.path.split(chemin)[1])[0])qgis.utils.iface.addRasterLayer(chemin,nomCouche)

[% "location" %] correspond au nom du champ contenant le chemin vers le raster

• puis cliquer sur Ajouter l'action à la liste

action closeRaster :

Faire de même que pour openRaster, mais dans la zone Action, entrez le code suivant :

importos
chemin='[% "location" %]'
nomCouche = str(os.path.splitext(os.path.split(chemin)[1])[0])
instRegistry = QgsMapLayerRegistry.instance()
couche = instRegistry.mapLayersByName(nomCouche)
iflen(couche)> 0:
        instRegistry.removeMapLayer(couche[0].id())

Vous devez maintenant avoir deux actions liées au tableau d'assemblage

Appliquez et fermez les propiétés en validant par OK, puis vous pourrez utiliser les boutons d'actions :

Il ne vous reste plus qu'à sélectionner le tableau d'assemblage comme couche active, choisir l'une ou l'autre des actions et cliquer sur la dalle souhaitée.

L'inconvénient majeur de cette solution, c'est que les actions sont enregistrées dans le document courant, si vous ouvrez votre tableau d'assemblage dans un autre document, elles ne seront plus présentes. Il est possible de régler ce problème en cliquant sur le bouton Sauvegarder par défaut des propriétés de la couche. Ainsi lorsque vous ouvrirez à nouveau votre tableau d'assemblage, les actions seront présentes.

Il est probablement possible de faire mieux et plus propre, mais on voit qu'en quelques minutes il est possible de faire des choses très utiles assez simplement, j'espère que cela vous sera utile.

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Débutant
	Logiciels utilisés	VirtualBox
	Plateforme	Windows | Linux

On croise souvent sur le net des tutoriels portant sur des sujets assez complexes et nécessitant déjà une bonne connaissance des outils de la géomatique. Mais qu'en est-il de tutoriels permettant d'installer et de configurer ces outils ? Certes, il y a bien les différentes documentations des outils en question mais au cours de mes nombreuses explorations sur la toile, je n'ai pas pu trouver, en français du moins, un tutoriel permettant à partir de rien (c'est à dire un ordinateur tournant sous windows) de se constituer un environnement propice à la pratique de la géomatique et plus particulièrement du SIG.

En ce qui me concerne, j'ai une préférence pour la virtualisation d'Ubuntu, après libre à chacun de travailler sur la distribution linux qui lui plaît mais ce tutoriel a été rédigé pour un environnement Ubuntu 12.04 LTS. La première étape de ce tutoriel qui sera découpé en plusieurs partie étant donnée sa longueur va donc être l'installation et la configuration d'une machine virtuelle tournant sous ce système d'exploitation.

Installer Ubuntu 12.04 LTS sur VirtualBox

1) VirtualBox

Avant toute chose, il faut télécharger VirtualBox pour émuler Ubuntu sur notre ordinateur. Nous aurions pu également installer Ubuntu en dual-boot, mais de une, cette opération est plus compliquée, et de deux, elle laisse moins le droit à l’erreur et aux tests puisque Ubuntu aurait été installé directement sur notre machine. Or là, nous pourrons faire autant de test que nous voudrons puisque si une machine virtuelle plante, il n’y aura qu’à la supprimer pour en charger une version antérieure. Au moment où ces lignes ont été écrites, la dernière version de VirtualBox disponible était la version 4.3.6.

 Pour télécharger directement l’exécutable permettant d’installer la dernière version de VirtualBox, nous allons ici pour gagner du temps, directement rentrer l’URL suivante dans un navigateur :

 http://download.virtualbox.org/virtualbox/4.3.6/VirtualBox-4.3.6-91406-Win.exe

Tant que nous y sommes, nous allons également télécharger les extensions de VirtualBox afin d’optimiser l’affichage de la machine virtuelle en plein écran, de pouvoir effectuer des copier-coller et des glisser-déposer entre le système physique et la machine virtuelle et vice versa ou encore de pouvoir utiliser une clé usb dans la machine virtuelle. Pour cela, rentrer l’URL suivante dans le navigateur :

http://download.virtualbox.org/virtualbox/4.3.6/Oracle_VM_VirtualBox_Extension_Pack-4.3.6-91406.vbox-extpack

Dès que les deux téléchargements sont effectués, nous pouvons installer VirtualBox en double-cliquant sur l’exécutable que nous venons de télécharger. Ensuite, il n’y a qu’à se laisser guider par la procédure. L’installation terminée, un double-clic sur l’installateur des extensions permettra de les incorporer au logiciel.

2) Ubuntu

La version d’Ubuntu utilisée pour ces tests a été la version 12.04 LTS dite Precise en 64 bits. Ce n’est pas la dernière disponible, mais c’est celle qui possède la garantie de support la plus longue actuellement. Jusqu’à 25 GO de mémoire ont été alloués à la machine de manière dynamique sur le disque dur de l’ordinateur. L’image ISO d’installation en 64 bits est disponible à cette adresse :

http://www.ubuntu.com/download/desktop/thank-you?distro=desktop&bits=64&release=lts

Pour un téléchargement en 32 bits, remplacer 64 par 32 dans l’URL ci-dessus. Dès que le fichier ISO est entièrement téléchargé, nous pouvons créer une nouvelle machine virtuelle sous VirtualBox. Pour cela, nous allons ouvrir l’interface de VirtualBox qui se présente comme ceci :

Ici, nous pouvons voir qu’il y a déjà une machine virtuelle qui existe, en théorie, après l’installation de VirtualBox, la colonne de gauche devrait bien entendu être vide. Il se trouve juste qu’ici, nous avions déjà configuré une machine ubuntu, mais cela ne change rien à la suite de ce tutoriel.

Nous allons donc cliquer sur Nouvelle en haut à gauche de l’écran pour ouvrir la fenêtre de paramétrage de notre nouvelle machine virtuelle. Une nouvelle fenêtre s’ouvre et nous allons y renseigner les informations suivantes :

La fenêtre suivante permet d’allouer une certaine quantité de mémoire vive à la machine virtuelle. Pour une mémoire optimale, placer le curseur à l’extrémité de partie verte de la barre comme ceci :

Sur la fenêtre suivante, nous allons choisir de créer un nouveau disque dur virtuel. Ensuite, choisir l’option vdmk, cliquer sur suivant et là, choisir une taille de disque dynamiquement allouée puis sur la dernière fenêtre choisir la taille de ce disque dur virtuel qui est par défaut de 8 GO. Ici, le choix dépend de la configuration du stockage de l’application mais en général, une taille de 25 GO permet amplement de faire du SIG sur Ubuntu. Une fois le choix de taille effectué, cliquer sur créer et notre nouvelle machine apparaît dans l’interface principale de VirtualBox en compagnie de celle déjà existante.

Il nous faut maintenant installer ubuntu sur la machine virtuelle que nous venons de créer. Pour cela, nous allons configurer notre machine virtuelle pour qu’elle boote sur l’ISO d’installation d’ubuntu. Pour ce faire, nous allons sélectionner notre nouvelle machine virtuelle vierge de manière à la mettre en surbrillance dans la liste puis cliquer sur le bouton configurer de l’interface principale.

Dans l’onglet stockage de la fenêtre de configuration, nous allons choisir le fichier ISO à insérer dans le lecteur CD virtuel en cliquant sur le bouton encadré en rouge ci-dessous :

Il nous est alors demandé de choisir une image de disque à insérer et logiquement l’explorateur de fichier s’ouvre directement dans le répertoire de téléchargements. Nous ouvrons donc ici l’image d’ubuntu 12.04 que nous avions téléchargée auparavant puis nous cliquons deux fois sur OK pour fermer ces fenêtres de configuration.

Lançons ensuite la machine virtuelle en cliquant sur démarrer et laissons nous guider par l’installation d’Ubuntu. Une fois l’installation terminée et la machine virtuelle redémarrée, il ne reste plus qu’à installer les additions de VirtualBox via le raccourci CtrlD + D ou via le menu périphériques de VirtualBox. Redémarrer la machine en pensant à éjecter du lecteur CD virtuel tout disque pouvant s’y trouver et nous disposons d’une version vierge d’Ubuntu.

Nous sommes parvenus à la fin de cette première partie du tutoriel. Dans les parties suivantes, nous verrons comment installer et configurer le SGBD PostgreSQL et sa cartouche spatiale PostGIS.

	Niveau	Expert
	Logiciels utilisés	Qgis
	Plateforme	Windows | Mac | Linux | FreeBSD

La géologie structurale traite des relations entre des objets spatiaux en trois dimensions:

• une carte géologique n'est que la représentation 2D de l'intersection de ces structures géologiques et d'un plan plus ou moins horizontal (mais un géologue la voit toujours en 3D). C'est ce que l'on peut visualiser dans un SIG;
• cette 3D est approchée par les coupes géologiques (intersection avec un plan vertical ou incliné, comme les falaises ou les parois de montagne) ou les modélisations géologiques 3D. Il faut alors utiliser des logiciels de modélisation géologique spécialisés ou éventuellement un SIG comme dans Grass Gis et Paraview: la modélisation géologique 3D pour les démunis, ou les enthousiastes... ou PyQGIS (QGIS 2): les coupes géologiques (colorisation d'un profil topographique élaboré à partir d'un MNT en fonction des couleurs d'un raster et placement des points d'intersection avec les limites des couches géologiques) sur le Portail.

figure tirée de Martin-Luther-Univestät Halle-Wittenberg: 3D Modelling Geology and Mining: 3D geomodeller

Mais il est aussi important d'analyser les rapports d'orientation de ces éléments dans l'espace, indépendamment de leur position géographique (modèle d'orientation préférentielle des couches, des fractures, ou de n'importe quel objet linéaire sur une carte pour en extraire des classes, des tendances, des relations).

Dans ce système, chaque objet est défini par:

1. sa direction (ou azimut)
2. son pendage (ou plongement)

Suivant ces critères, il est  possible d'utiliser:

• les histogrammes et les diagrammes de direction ou rosaces directionnelles (« rose diagram ») pour analyser les caractéristiques d'une variable (pendage ou direction). Dans certains cas comme l'analyse des orientations des linéaments sur photo aérienne, c'est le seul moyen puisque l'on ne connait que leurs directions;

• les canevas stéreographiques (« stereonets ») qui permettent d'analyser les deux variables en même temps (un objet est défini par son pendage et sa direction).

Comme le but ici n'est pas un cours de géologie, je laisse à d'autres le soin d'expliquer ces méthodes pour me focaliser sur leurs implémentations directes dans QGIS avec Python.

Objectif

Il existe déjà beaucoup d'applications, libres, gratuites ou payantes, pour effectuer ces traitements. Il en existe même certaines qui permettent de placer directement les points de mesure sur un fond Google Map, comme Stereonet de Rick Allmendinger, ou d'extraire les valeurs structurales à partir d'une carte géologique sous format image, comme GeolMapDataExtractor, du même auteur (programmes gratuits pour une utilisation non commerciale, versions Windows et Mac OS X).

Mais le problème de toutes ces solutions est que pour les utiliser à partir d'un SIG, il est nécessaire de passer par un fichier intermédiaire (du SIG vers le logiciel). Il existe néanmoins quelques solutions natives pour ArcGIS, sous forme d'extension, comme Orientation Analysis Tools for GIS (ArcGIS).

Le but ici est donc d'obtenir les résultats/graphiques directement dans QGIS, et ce,  sans logiciel tiers.

Je n'ai pas le temps de réinventer la roue et il existe heureusement des solutions en Python, prêtes à l'emploi:

• Rose diagram code pour le traitement des diagrammes en rosaces géologiques;
• mplstereonet pour le traitement des projections stéréographiques (stereonet). Il dispose nativement de beaucoup de traitements (voir les exemples).

Elles utilisent toutes les deux le module Python matplotlib pour les figures. Il y a donc moyen de sauver les figures obtenues dans divers formats dont le format vectoriel SVG.

Dans les deux cas, je me suis contenté d'adapter quelque peu les scripts originaux et de rajouter quelques traitements en utilisant mes versions en Python des scripts originaux pour Matlab publiés dans Structural Geology Algorithms Vectors and Tensors de R.W. Allmendinger, N.Cardozo, et D.M. Fisher (2012), pp;93-97) et disponibles dans la partie ressources du site (avec leur accord).

Résultats

Mes premières réalisations ont été directement effectuées dans la console Python de QGIS ou avec un script externe à l'aide du plugin ScriptRunner (il y a des exemples des résultats obtenus dans QGIS : lancer des scripts Python ou des commandes Shell depuis la Console Python ou avec Script Runner (sans créer d'extension) et Python: utilisation des couches vectorielles et matricielles dans une perspective géologique, sans logiciel SIG.

Le défaut principal de ces solutions est qu'elles ne sont pas interactives. Je voulais:

1. pouvoir traiter directement des éléments sur la carte, en en sélectionnant certains ou dans leur totalité;
2. cliquer sur un simple élément pour obtenir les résultats
3. recommencer autant de fois que je le désire avec d'autres paramètres (en modifiant rapidement les scripts, si nécessaire).

La solution idéale était donc de créer des scripts Python dans la Boîte à outil de Traitements (Processing): il suffit de cliquer dessus, et l'interface est créée automatiquement (voir plus bas, similaire à la création de modules dans GRASS GIS).

1) rosaces géologiques

Interface obtenue avec le module processing: (angle = intervalle angulaire pour créer le diagramme)

Diagramme des directions de toutes les failles représentées sur une carte:

Résultats avec quelques failles sélectionnées:

Diagramme des directions de quelques mesures de schistosité sélectionnées:

2) canevas stéréographiques

interface obtenue avec le module processing:

Projections stéréographiques des pôles des plans de stratification d'un ensemble de points choisis sur la carte (canevas de Schmidt, hémisphère inférieur, il y a aussi moyen d'utiliser le canevas de Wullf):

Pôles et grands cercles de quelques mesures de stratification sélectionnées sur la carte:

Contour de quelques mesures de stratification sélectionnées sur la carte (plusieurs algorithmes sont disponibles, Khamb etc.) :

Estimation de l'axe d'un pli  :

J'utilise ici ma version Bingham.py du programme Bingham.m pour Matlab (Structural Geology Algorithms Vectors and Tensors, pp;93-97) .

Réalisation:

Création de l'interface:

Le simple en-tête d'un script:

#Interface#==================================##[Mes scripts GEOL]=group##entree=vector##entree2=raster##dip_dir=field entree##dip=field entree##angle=number 10##contour=number 0##sortie=output vector

fournira l'interface suivante:

Il y a moyen de définir (voir Using processing algorithms)

• une ou plusieurs couches en entrées: vector1=vector, vector2=vector, raster1 = raster;
• une ou plusieurs couches en sorties: vector3 = vector output, raster3 = raster output;
• plusieurs champs à sélectionner/choisir;
• des valeurs numériques, alphanumériques, etc.

Obtention des données à partir des couches vectorielles:

Les données sont de deux types:

• les valeurs d'un champ (ou de plusieurs champs) qui doivent être extraites de la table attributaire (pendages et les directions, par exemple);
• des calculs à partir des coordonnées géographiques (les valeurs de direction/azimut, par exemple).

De plus il faut pouvoir choisir entre:

• traiter toutes les données;
• ne traiter que les valeurs sélectionnées.

1) obtenir l'azimut de tous les segments d'une couche polyligne

Ce calcul a été présenté dans PyQGIS: des géométries, des vecteurs, de l'algèbre vectorielle ou des cosinus directeurs, exemples d'applications  et GIS Stack Exchange: How do I find vector line bearing in QGIS or GRASS?. Il suffit d'utililiser la fonction Point1.azimuth(Point2) de PyQGIS.

Les résultats (angles entre 0 et 360°) se retrouvent sous forme de liste dans une variable.

2) extraction des valeurs des champs de la table choisis: exemple pour 2 champs, choix entre utiliser les valeurs sélectionnées ou la totalité des valeurs:

# Interface##[Mes scripts GEOL]=group##entree=vector##dip_dir=field entree##dip=field entree# Traitementsfrom qgis.coreimport*layer = processing.getObject(entree)dip_dir_index = layer.fieldNameIndex(dip_dir)dip_index = layer.fieldNameIndex(dip)if layer.selectedFeatureCount():    T,P = zip(*((elem.attributes()[dip_dir_index],elem.attributes()[dip_index])for elem in layer.selectedFeatures()))else:    T,P = zip(*((elem.attributes()[dip_dir_index],elem.attributes()[dip_index])for elem in layer.getFeatures()))

Les valeurs de direction se retrouvent dans la variable T, celles de pendage dans la variable P.

Traitements proprement dits

Il suffit d'importer et d'utiliser les modules cités (après en avoir compris les principes en se basant sur les exemples).

1) importation du premier module, NorthPolarAxes (rosaces géologiques): et traitements

import numpy as npimport matplotlib.pyplotas plfrom matplotlib.projectionsimport register_projectionfrom NorthPolarAxes import NorthPolarAxesregister_projection(NorthPolarAxes)# traitement de la variable T suivant les scripts d'exemples

En pratique, j'ai inséré la classe NorthPolarAxes dans mon script (au lieu de l'importer).

2) importation du deuxième module, mplstereonet et traitements

import matplotlib.pyplotas pltimport mplstereonetfig = plt.figure()ax = fig.add_subplot(111, projection='stereonet')ax.pole(T, P, 'bo', markersize=5)ax.grid()plt.show()

Conclusions

Mon objectif de géologue utilsant un SIG dans une perspective géologique est atteint. Á partir de QGIS et de scripts dans la Boîte à outils de Traitements, je peux maintenant intéractivement:

• créer des modèles 3D: QGIS, représentation 3D des couches vectorielles (shapefiles dits 3D ou shapefiles avec attributs z) avec les modules Python Matplotlib ou Visvis à partir de la console Python
• entamer une coupe géologique: PyQGIS (QGIS 2): les coupes géologiques (colorisation d'un profil topographique élaboré à partir d'un MNT en fonction des couleurs d'un raster et placement des points d'intersection avec les limites des couches géologiques)
• créer des rosaces géologique ou des canevas stéréographiques à partir d'éléments choisis

Tous les traitements ont été effectués sur Mac OS X ici, mais aussi Linux et Windows avec plusieurs versions de QGIS 2.x

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Débutant
	Logiciels utilisés	Postgresql-9.3 PgAdmin3
	Plateforme	Windows | Linux

Dans la première partie de ce tutoriel, nous avons vu comment installer et configurer Ubuntu 12.04 sur une machine virtuelle tournant sous VirtualBox. Maintenant, nous allons aborder la phase d'installation et de configuration du Système de Gestion et de Base de Données (SGBD) PostgreSQL.

Installation de PostgreSQL

1) Préambule

Afin de pouvoir installer les applications dont nous aurons besoin par la suite, il est conseillé d’installer dès le départ les dépôts qui ne seraient pas présents nativement dans la version 12.04 d’Ubuntu, autrement dit, le dépôt UbuntuGis, qui comme son nom l’indique permet d’installer des librairies et des logiciels permettant de faire du SIG sur Ubuntu ; le dépôt postgresql qui contient la dernière version (9.3) du SGBD et le dépôt QGIS qui lui aussi contient la dernière version en date du logiciel éponyme (2.2-Valmiera).

a) Dépôt UbuntuGIS

Pour installer le dépôt UbuntuGIS, il faut avant tout ouvrir la logithèque Ubuntu représentée dans la barre des tâches par l’icône ci-après :

 

 

 

Quand la logithèque est ouverte, diriger le curseur vers le coin gauche de l’écran pour faire apparaître la barre des menus. Choisir le menu Edition, puis tout en bas de celui-ci, cliquer sur Source de logiciel. 

La fenêtre suivante s’ouvre : 

Cliquer sur Autres logiciels pour vous retrouver sur l’interface suivante : 

 

En théorie, par défaut, la dernière ligne de source de logiciel disponible à cet endroit est celle encadrée en rouge sur l’image, mais comme ce tutoriel a été rédigé après installation des paquets mentionnés plus hauts, ils y figurent déjà. Nous allons donc faire comme s’ils n’étaient pas là.

Pour ajouter le dépôt UbuntuGIS, il suffit de cliquer sur ajouter et de remplir le formulaire qui s’ouvre dans la fenêtre suivante comme ceci : 

 

Cliquer ensuite sur ajouter une source de mise à jour pour constater que le dépôt ubuntugis a bien été ajouté aux sources de logiciels. 

b) Dépôt Postgresql

Le principe est exactement le même pour Postgresql sauf qu’il faut remplacer ppa:ubuntugis/ppa par deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main dans la fenêtre ci-dessus.

c) Dépôt QGIS

Le procédé est identique pour qgis sauf qu’il faut ici remplacer ppa:ubuntugis/ppa par deb http://qgis.org/debian precise main

Une fois que les trois dépôts ont été installés dans les sources de logiciel de la logithèque, ouvrir un terminal et taper la ligne de commande suivante en prenant bien soin de taper correctement le mot de passe ensuite: 

sudo apt-get update

Dès lors que cette ligne de commande a été rentrée dans le terminal, les paquets d’Ubuntu sont mis à jour et nous pourrons donc utiliser la commande suivante pour mettre à jour les applications déjà présentes sur la machine :

sudo apt-get upgrade

Le processus mettra plus ou moins de temps car il dépend de la vitesse de votre connexion internet, de la quantité de paquets et d’applications à mettre à jour, ainsi que de la rapidité de traitement de votre machine virtuelle pour tout installer. Une fois ceci effectué, nous pouvons passer à l’installation des applications qui vont nous servir à faire du SIG sur Ubuntu.

2) Postgresql 9.3

a) Installation de Postgresql

Pour installer Postgresql deux options s'offrent à nous : 

La première est d’installer cette application directement depuis la logithèque Ubuntu en rentrant « postgresql » dans la barre de recherche comme indiqué ci-dessous :  

 

La seconde possibilité qui est conseillée car plus rapide est de rentrer la ligne de commande suivante dans un terminal : 

sudo apt-get install postgresql-9.3

Il nous est demandé au cours de cette installation de bien vouloir confirmer que nous souhaitons installer PostgreSQL.  Il faudra donc appuyer sur la touche « o » quand cela sera nécessaire.

Il est à noter que cette commande va installer différents paquets permettant de bien faire fonctionner le SGBD dans sa dernière version en date, PostgreSQL-9.3.

Dès lors que PostgreSQL est correctement installé, nous allons pouvoir passer à la phase de configuration.

b) Installation de Postgresql

Par défaut, l’installation de PostgreSQL entraîne la création de l’utilisateur «postgres», super-administrateur de PostgreSQL. Pour l’instant, seul cet utilisateur a la possibilité de créer une base de données PostgreSQL, créer des rôles de connexion, etc. Nous allons donc nous connecter à cet utilisateur pour créer un nouveau rôle de connexion super-administrateur autre que «postgres», par exemple «admin». Rentrer la ligne de commande suivante pour vous connecter à l’utilisateur «postgres» :

 sudo -i -u postgres

Pour information, le –i permet d’ouvrir une session du terminal en mode root et le –u permet de se connecter à un utilisateur, en l’occurrence, l’utilisateur «postgres». La combinaison des deux permet donc d’ouvrir une session en mode root avec l’utilisateur «postgres» En début de ligne devrait apparaître la chose suivante :

postgres@nom_ordinateur/serveur:~$

Cela veut dire que la connexion à l’utilisateur « postgres » s’est bien effectuée. Nous pouvons donc maintenant créer un autre super-utilisateur à qui nous assignerons un mot de passe pour qu’il puisse se connecter à une base PostgreSQL et y effectuer toutes les opérations d’administration et de maintenance de la base. Pour l’exemple, il s’appellera «admin» et son mot de passe sera «admin». Il va de soi qu’en théorie pour une installation sécurisée, il faudrait choisir un mot de passe différent du nom d’utilisateur et dans l’idéal, un qui soit généré de manière aléatoire.

Pour créer ce super-utilisateur, rentrer la ligne de commande suivante dans le terminal : 

createuser -P -s admin

Pour information, le –P nous permet de signifier à PostgreSQL que nous voulons assigner un mot de passe à l’utilisateur. Le -s nous permet d’indiquer que nous voulons que cet utilisateur que l’on va crée et qui s’appelle admin soit un super-administrateur de PostgreSQL.

Une fois que nous avons validé la commande précédente, il nous est demandé par deux fois de renseigner le mot de passe que nous souhaitons assigner à l’utilisateur admin. Ici il faudra donc rentrer deux fois admin et à chaque fois appuyer sur entrée pour valider.

Cette opération effectuée, nous pouvons nous déconnecter de l’utilisateur postgres en rentrant tout simplement la commande suivante dans le terminal : 

exit

Il faut maintenant redémarrer PostgreSQL pour prendre en compte les modifications que nous venons de lui apporter. Pour cela, même principe que pour Tomcat 7 auparavant, deux solutions sont envisageables : 

sudo /etc/init.d/postgresql restart

sudo service postgresql restart

Afin de sécuriser au maximum les connexions à la base données, il est conseillé de modifier le fichier de configuration intitulé pg_hba.conf et situé par défaut dans /etc/postgresql/9.3/main/ et qui permet de gérer les méthodes d’authentification des différents hôtes.

 

Pour l’éditer, le principe est le même que pour éditer le fichier des utilisateurs de Tomcat, à savoir, rentrer la ligne de commande suivante dans un terminal :

sudo gedit /etc/postgresql/9.3/main/pg_hba.conf

Aller ensuite à la fin du document pour trouver les lignes suivantes :

# "local" is for Unix domain socket connections only

local              all               all                                 peer

Quelque soit le projet, il vaut mieux, en règle générale, utiliser une connexion par mot de passe encrypté de type md5, plutôt que peer ou trust par exemple qui autorise la connexion à la base de données sans demander de mot de passe.

Après modifications, les lignes précédentes doivent donc désormais ressembler à ceci :

# "local" is for Unix domain socket connections only

local            all             all                                     md5

Une fois cette modification effectuée, enregistrer le fichier et fermer l’éditeur de texte. Dans le terminal, redémarrer à nouveau PostgreSQL avec une des deux méthodes précédemment citées.

C’est là que l’étape de création d’un mot de passe au moment de la création de l’utilisateur «admin» prend tout son sens car il n’aurait pas pu, avec cette méthode d’identification, effectuer la moindre opération sur la base de données si nous ne lui avions pas attribué un mot de passe.

c) Test

Le plus simple pour voir l’intérêt de l’étape de configuration est de télécharger une interface graphique d’administration de PostgreSQL. Il en existe 2. PgAdmin3 qui s’utilise en local, et PhpPgAdmin qui s’utilise à distance via le répertoire de publication web d’Apache. Nous testerons ici la configuration des rôles de connexions dans PostgreSQL avec l’interface la plus rapide à installer : PgAdmin3.

Comme pour Apache, nous utilisons la commande apt-get pour installer PgAdmin3 :

sudo apt-gtet install pgadmin3

Taper « o » si besoin pour confirmer le téléchargement et l’installation du paquet. L’icône de PgAdmin3 devrait alors apparaître dans la barre de raccourci. Si ce n’est pas le cas, et plutôt que de rechercher dans les différents programmes où l’application peut bien être, le plus simple est encore de taper la ligne suivante dans un terminal pour le lancer :

pgadmin3

La fenêtre suivante s’ouvre alors :

Nous allons donc tenter de nous connecter à un serveur local de base de données. Pour cela, cliquer sur l’icône en forme de prise de courant, la plus à gauche de la barre d’outils. Le formulaire suivant s’ouvre alors : 

Nous laissons volontairement le champ mot de passe vide pour observer les conséquences des modifications du fichier pg_hba.conf faîtes précédemment.

En appuyant sur valider, le message d’erreur suivant apparaît :

De cette façon, nous vérifions bien que tout utilisateur désirant accéder à la base de données doit renseigner un mot de passe pour y accéder.

Pour nous connecter donc, nous devons, après avoir fermé cette fenêtre, réitérer l’opération de connexion au serveur de base de données en renseignant cette fois-ci le mot de passe, ici « admin » dans le formulaire comme ci-dessous : 

En cliquant sur valider, la connexion réussira et vous verrez alors apparaître dans la partie gauche, en dessous de Groupe de Serveurs une ligne mentionnant que PgAdmin est un bien connecté à un serveur.

Volontairement ici, nous ne cochons pas la case « enregistrer le mot de passe » pour forcer l’utilisateur « admin » à le rentrer à chaque fois qu’il souhaitera se connecter à ce serveur de base de données.

Evidemment, il est possible à tous moments de cliquer sur enregistrer le mot de passe afin de le garder en mémoire. Cela étant, comme le précise justement PgAdmin, stocker le mot de passe dans la mémoire de l’ordinateur peut entraîner une faille de sécurité dans le système.

Aussi il est fortement déconseillé d’enregistrer le mot de passe dans la mémoire de l’ordinateur.

Pour plus de précisions, voici le message que PgAdminIII affiche quand un utilisateur choisit d’enregistrer son mot de passe :

Si cette fenêtre s’ouvre, c’est que la case « enregistrer le mot de passe » a été cochée. Dans cas, il faut cliquer sur annuler et la décocher dans le formulaire.

Si les informations ont été correctement rentrées dans le formulaire, la connexion au serveur de base de données s’établit. On peut donc voir juste en dessous de Groupe de serveurs, la ligne Serveurs (1) qui confirme que la connexion a bien fonctionné. On trouve bien le serveur Test avec pour hôte localhost et comme port 5432.

En développant au maximum l’arborescence du serveur, on obtient le résultat suivant : 

Ceci prouve que la connexion par mot de passe avec l’utilisateur « admin » s’est bien déroulée. Pour information, la base déjà présente est la base de maintenance de PostgreSQL. Elle ne doit en aucun cas être supprimée pour que les futures bases de données fonctionnent.

Nous sommes parvenus à la fin de la deuxième partie de ce tutoriel. Dans la prochaine partie, nous verrons comment installer PostGIS, la cartouche spatiale de PostgreSQL, ainsi que ses dépendances. 

	Niveau	Débutant
	Logiciels utilisés	QGIS Dropbox - clé USB (ou autre système du même genre) Python
	Plateforme	Windows | Mac | Linux | FreeBSD

Comment faire pour utiliser ses propres scripts dans la console Python de QGIS ou dans un script de la Boîte à outils de Traitements (Processing) sans en créer plusieurs copies si, comme moi, vous êtes susceptibles de travailler sur plusieurs ordinateurs avec des systèmes d'exploitation différents situés en de multiples endroits ?

Je désire en effet n'avoir qu'une seule version de ces scripts (pour leur maintenance). Ils peuvent être placés dans des dossiers  Dropbox, sur une clé USB ou n'importe quoi d'équivalent pourvu que leur contenu soit disponible partout.

(J'utiliserai ici le dossier créé par l'application Dropbox car elle est écrite en Python (voir Wikipedia: Dropbox), et qu'il est possible de manipuler le service à partir de la console Python de QGIS avec le module  Dropbox SDK)

Il s'agit ici, bien entendu, de régler le problème de l'importation de ces fichiers depuis la version de Python utilisée par QGIS, et ce, sans les déplacer.

Principes

Pour commencer l'explication, nous avons besoin d'un peu de « théorie Pythonesque ». Que se passe-t-il lorsque je veux importer un module dans la console Python ? (voir Sam et Max: Les imports en Python).

C'est le module site qui est responsable de la mise en place de l'environnement lors du démarrage de Python. Il va chercher les scripts/modules qu'il peut importer dans l'ordre suivant:

1. le répertoire d'où je lance Python ou un script Python;
2. le répertoire par défaut où se trouve l'exécutable de Python et plus particulièrement le dossier /lib/pythonx.x/sites-packages (/Library/Python/2.x/site-packages avec les versions de Python livrées sur les Macs). C'est la variable d'environnement PYTHONHOME;
3. les dossiers qui sont présents sous forme de liste dans la variable d'environnement système PYTHONPATH (qui n'existe pas par défaut, il faut la créer).

Ensuite, le module place par défaut tous ces répertoires dans une simple liste qui peut être examinée avec la variable sys.path du module sys:

• par défaut, sys.path[0] est le répertoire 1. Puisque la console Python de QGIS est elle même un script (/.../python/console/console.py), la commande me renverra uniquement le répertoire du script.
• L'élément le plus important est le dossier site-packages. Lorsque vous installez un module avec easy_install, pip, ou setup.py install, c’est dans ce répertoire qu'il va être installé.

Si mon dossier n'est pas dans la liste:

import planargraph2 # script dans mon dossierTraceback (most recent call last): File "<stdin>", line 1, in<module></module></stdin>ImportError: No module named planargraph2

Je dois donc m’assurer que mon dossier « messcriptssqgis » soit toujours dans cette liste, quelle que soit la machine considérée pour pouvoir l'utiliser partout.

Comme toujours avec Python, il y a plusieurs solutions pour le faire:

La solution 1.: se déplacer dans les répertoires à l'aide du module os 

Puisque le répertoire de travail fait aussi partie de la liste, il suffit de s'y rendre depuis la console Python de QGIS :

Et je peux alors importer les scripts/modules qui sont présents. La solution est temporaire, je dois la réécrire à chaque fois que je veux importer quelque chose qui est dans mon dossier.

La solution 2.: la plus populaire, ajouter le dossier « messcriptssqgis » à la liste

Cela se fait avec sys.path.insert() ou sys.path.append(). Si je veux ajouter mon dossier « messcriptssqgis » à la liste  pendant ma session de travail:

importsys# j'ajoute mon dossier au PYTHONPATH en dernière position de la listesys.path.append('chemin_vers/messcriptssqgis')# j'ajoute mon dossier au PYTHONPATH en première position de la listesys.path.insert('chemin_vers/messcriptssqgis')

Encore une fois, la solution est temporaire, dès que je la quitte, l'ajout est annulé.

La solution 3: créer/modifier la variable d'environnement PYTHONPATH

Les deux précédentes solutions sont temporaires et je voudrai le faire de manière permanente sans devoir réécrire les lignes de commande à chaque fois. Il faut alors créer/modifier la variable d'environnement système PYTHONPATH. Elle permet d'ajouter des éléments à la liste depuis l'extérieur de Python.

• sur Mac OS X ou Linux, il suffit d'ajouter une ligne à vos fichiers «.bash_profile », «.profile », «.bashrc»  ou autre script de login :

export PYTHONPATH=$PYTHONPATH:chemin_vers/messcriptsqgis

• Sur Windows, c'est plus complexe, car vous devez créer ou modifier une Variable d'environnement dans les Propriétés Systèmes (voir QGIS: Running Scripts in the Python Console entre autres)
• mais il y a aussi moyen de le faire directement dans QGIS comme l'indique Gary Sherman dans son livre The PyQGIS Programmer's Guide et l'illustre José Guerrero dans Script de Python para filtrar por patrón de texto los métodos de Clases en PyQGIS

figure extraite de Script de Python para filtrar por patrón de texto los métodos de Clases en PyQGIS

La solution est permanente, mais peut poser des problèmes d'implantation, surtout si je n'ai pas les autorisations pour le faire. De plus si j'ai plusieurs versions de Python installées (2.x et 3.x par exemple), cela peut aussi en créer (une seule variable d'environnement système).

La dernière solution, la plus simple, mais généralement oubliée: les fichiers de configuration .pth

Tout ça, c'est bien complexe, me direz-vous, car je dois modifier cette variable d'environnement sur chaque ordinateur que je veux utiliser ou je dois écrire os.chdir() ou sys.path.append()à chaque fois que je lance QGIS.

Que diriez-vous d'un simple fichier texte avec une seule ligne à placer dans le répertoire site-packages de chaque version utilisée ?

Il existe en effet une solution généralement oubliée sur tous les sites qui traitent de cette problématique (et du livre The PyQGIS Programmer's Guide): les fichiers de configuration path (.pth). C'est pourtant très bien expliqué dans le fichier site.py de l'installation Python:

A path configuration file is a file whose name has the form
<package>.pth; its contents are additional directories (one per line)
to be added to sys.path.  Non-existing directories (or
non-directories) are never added to sys.path; no directory is added to
sys.path more than once.  Blank lines and lines beginning with
'#' are skipped. Lines starting with 'import' are executed.

Et un article très ancien,  Using .pth files for Python development, de Bob Ipolito explique très bien la démarche.

Elle consiste donc à placer dans le(s) dossier(s) site-packages un simple fichier texte avec .pth comme extension et le chemin complet du dossier comme contenu. Le nom n'a aucune importance.

contenu du fichier « messcrips.pth » sur mon Mac.

/Users/Shared/Dropbox/messcriptsqgis

Et ce dossier se trouve de fait automatiquement dans la liste de sys.path, sans aucune manipulation complémentaire et la solution est permanente.

Cette technique offre d'autres possibilités:

• placer plusieurs répertoires (un par ligne)

/Users/Shared/Dropbox/messcriptsqgis
/Users/Shared/Dropbox/geolscript

• cela permet à easy_install, par exemple, de gèrer la version des modules à importer à partir du fichier « easy-install.pth ».

Extrait de mon fichier « easy-install.pth »

• cela permet aussi de modifier l'ordre d'importation d'un module pour être sûr qu'il se trouve en première position, car dans le cas où il y a en a plusieurs qui portent le même nom, c'est le premier sur la liste qui sera choisi. C'est ce que fait, entre autres, William Kyngesburye (KyngChaos) pour placer, sur Mac OS X, sa version du module osgeo en première position de la liste (fichier gdal-py2.x.pt) à l'aide de sys.path.insert() :

import sys; sys.path.insert(0,'/Library/Frameworks/GDAL.framework/Versions/1.10/Python/2.x/site-packages') (ou 1.11 maintenant)

• d'autres utilisent cette technique pour préserver la compatibilité avec les anciennes versions du module comme PyNGL. Le fichier « Ngl.pth » ne contient qu'une ligne avec PyNGL. Il est alors possible d'importer le module avec le nom de son ancienne version.

import Ngl# ou import PyNGL

• et enfin, si la ligne commence par import, la commande sera exécutée:

import monscript; monscript.démarre()

Application avec un dossier Dropbox sur plusieurs ordinateurs

Je montre ici le résultat avec le dossier créé par l'application Dropbox (rappelons que c'est la même chose avec une clé USB). 

Conclusions

Pourquoi cet oubli relatif, cette technique est-elle considérée comme inadéquate, trop simple ?  Je ne pense pas car si vous consultez votre dossier site-packages vous pourrez constater qu'elle est très utilisée, notamment avec easy_install déjà signalé ou les gestionnaires des environnements virtuels comme virtualenvwrapper.

Elle a bien entendu certains inconvénients, surtout sur Windows (utilisable uniquement avec les modules en pur Python, problème éventuel du chemin du dossiers, etc.), mais elle me permet de n'avoir qu'une seule version de mes scripts, quel que soit l'ordinateur et quelle que soit la version de Python (2.6.x, 2.7.x) et de QGIS. Il me suffit de créer un simple fichier texte avec le chemin du dossier et de le placer dans le dossier ad hoc.

En résumé:

• site.py ne prendra en considération que les fichiers .pth présents dans le dossier site-package. Ceux situés en dehors ne fonctionneront pas même s'ils sont dans la liste de sys.path;
• il n' y a pas moyen de créer des fichiers .pth en cascade (un fichier .pth pointant vers un autre fichier .pth);
• les lignes débutant par # seront considérées comme des commentaires;
• toutes les autres lignes seront considérées comme des chemins absolus, hormis si elles commencent par import (exécutable). Il y a moyen de travailler avec des chemins relatifs, mais c'est inutile dans mon cas.

Pour moi, en tout cas:

• plus besoin de me  tracasser avec les variables d'environnement (ce qui peut être difficile sur Windows) ni avec les os ou sys.path, et ce, sans me soucier des fichiers existants;
• la solution est permanente;
• ils ne fonctionnent que dans la version de Python où ils sont placés;
• si je veux l'utiliser dans un autre environnement Python ou sur un autre ordinateur, il suffit de le copier/coller en modifiant le chemin du dossier si nécessaire (1 ligne), même avec les versions Standalone de QGIS pour Windows qui possèdent leurs propres implémentation de Python;
• si je veux me débarrasser de l'accès aux modules, je supprime le fichier .pth;
• j'utilise aussi la technique pour travailler en Python seul;
• ils constituent donc pour moi, la meilleure solution et, en général, une excellente alternative aux autres solutions.

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Débutant
	Logiciels utilisés	PostGIS GEOS GDAL QGIS
	Plateforme	Windows | Linux

Dans la deuxième partie de ce tutoriel, nous avions vu comment installer et paramétrer PostgreSQL sur notre machine virtuelle. Nous allons maintenant voir comment rajouter la cartouche spatiale PostGIS afin de créer des bases de données spatiales.

La partie qui va suivre est en grande partie inspirée du site de Northwest Spatial Solutions expliquant comment faire du SIG sur Ubuntu. J'y ai apporté quelques modifications mais pour la majeure partie, je me suis contenté de traduire ce tutoriel qui m'a été utile à multiples reprises.

1) Pré-requis

Pour pouvoir faire fonctionner PostGIS correctement, il est nécessaire d’installer GEOS et GDAL. GEOS est un portage en C++ de la Java Topology Suite et qui permet de prendre en charge des opérations sur la topologie et la géométrie dans PostGIS. Quant à GDAL, c’est une librairie permettant de lire et de traiter un grand nombre de format de fichier de type raster à dominante spatiale tels que GeoTIFF par exemple.

Pour installer ces deux librairies, nous pourrions nous servir de la commande apt-get install étant donné que des versions récentes de ceux-ci sont comprises dans les paquets UbuntuGIS téléchargés précédemment. Cependant, comme nous souhaitons disposer des dernières versions disponibles de ces deux outils de façon à être le plus à jour possible au niveau des technologies que nous employons, nous allons devoir télécharger les sources directement sur les sites de GEOS et de GDAL pour ensuite les compiler.

Cela étant, pour pouvoir compiler et configurer GEOS et GDAL correctement, il faut auparavant installer, toujours via la commande apt-get install, différentes librairies et langages dont la liste se trouve dans les lignes de commande ci-dessous :

sudo apt-get install postgresql-server-dev-9.3 proj libjson0-dev xsltproc docbook-mathml docbook-xsl

sudo apt-get install gettext dblatex openjdk-7-jre openjdk-7-jdk icedtea-7-plugin libxml2-dev

Il faut savoir que le plugin icedtea n’est pas obligatoire pour ce tutoriel mais autant l’installer maintenant pour pouvoir exécuter openjava dans un navigateur.

sudo apt-get install swig php5-dev phpunit openjpeg-tools libopenjpeg-dev libkml-dev

sudo apt-get install libpoppler19 libpoppler-dev expat libexpat1-dev libxerces-c-dev libcurl4-openssl-dev

sudo apt-get install g++ python-dev ruby

Maintenant que nous avons installé toutes les dépendances permettant d’installer GEOS et GDAL, nous pouvons maintenant télécharger les codes sources de ces deux librairies pour pouvoir par la suite les compiler et les configurer correctement.

Pour télécharger les sources de GEOS, nous pourrions aller dans notre moteur de recherche préféré et taper par exemple « GEOS source download » mais pour gagner du temps, nous allons nous servir de la commande wget dans le terminal qui permet de télécharger directement un fichier ou répertoire ou autre depuis le terminal pour peu que l’on dispose de l’URL de téléchargement, et cela tombe bien nous l’avons.

La différence avec le fait de télécharger l’archive depuis un navigateur, est qu’elle ne se téléchargera pas par défaut dans le répertoire Téléchargements de l’utilisateur mais dans le répertoire dans lequel nous nous situons dans le terminal.

Pour remédier à cet inconvénient, il suffit d’effectuer la commande cd pour change directory et de préciser dans quel répertoire nous voulons ensuite télécharger l’archive contenant le code source de GEOS.

Voici la commande en question, en supposant que nous voulions télécharger le code source dans notre répertoire de téléchargement par défaut : 

cd ~/Téléchargements

3) Configuration de PostGIS

En théorie, l’installation de PostGIS entraîne la création d’une base de données modèle appelée originalement template_postgis mais il peut arriver qu’elle ne se crée pas automatiquement. Pour le vérifier, c’est simple, nous allons chercher à y apporter des modifications en nous connectant à l’utilisateur postgres pour être à même d’exécuter des requêtes SQL directement dans la base de données. Connectons-nous donc à l’utilisateur postgres : 

sudo -i -u postgres

Ensuite, exécutons la commande postgres permettant d’ajouter l’extension PostGIS à la base template_postgis si celle-ci existe déjà : 

psql template_postgis –c "create extension postgis;"

Grâce à cette fonction, nous allons tout de suite voir si la base de données template_postgis existe déjà ou non. Si le message suivant s’affiche, cela veut dire que la base de données avait bien été crée à l’installation de PostGIS et que l’extension du même nom lui a bien été ajoutée : 

CREATE EXTENSION

Dans le cas contraire, autrement dit, si la base template_postgis ne s’est pas crée au moment de l’installation, le message suivant s’affiche : 

Dans PgAdminIII, il est facile de constater qu’on ne peut pas se connecter au template postgis dans les bases de données car le symbole de la base de données est barré d’une croix rouge. Mais il est facile d’explorer cette base en créant une nouvelle base de données qui prend pour modèle le template postgis. Pour cela, cliquer droit sur la ligne Bases de données(X) (X étant le nombre de bases de données présentes sur le serveur) et ajouter une nouvelle base de données. Rentrer un nom au choix, par exemple Test, puis sélectionner « admin » comme propriétaire et dans l’onglet définition du formulaire, choisir comme modèle la base TEMPLATE_POSTGIS. Cette base est une copie conforme du template et peut-être manipulée sans risque.

PostGIS ayant été installé et configuré correctement, nous pourrons passer lors de l'étape suivante à l’installation de QGIS-2.2 surnommée Valmiera.

QGIS-2.2 Valmiera

1) Installation de QGIS 2.2

C’est maintenant que nous allons voir l’intérêt de l’installation du dépôt de paquet dans la première partie de ce tutoriel. En effet, si nous ne l’avions pas fait, la version la plus récente de QGIS dans le dépôt UbuntuGIS (qui est plus souvent mis à jour que les paquets présents par défaut dans la logithèque Ubuntu) étant la version 1.8, nous aurions été contraints d’installer cette dernière. Simplement, en installant le dépôt de paquets directement depuis le site de QGIS, nous pouvons désormais, à l’aide de la commande apt-get install, bénéficier de la toute dernière version de QGIS.

Rentrer donc la commande suivante dans le terminal pour installer QGIS-2.2 et ses dépendances : 

	Niveau	Intermédiaire
	Logiciels utilisés	IPython Python R Octave Graphviz GRASS GIS (via Python)
	Plateforme	Windows | Mac | Linux | FreeBSD

Qui n'a jamais rêvé d'utiliser/mélanger dans une même interface Python, R, JavaScript, Ruby, Perl, C, Julia, Fortran, Matlab® ou Mathematica®, SQLite et SQL, et compagnie, de pouvoir passer les variables d'un langage à l'autre de manière transparente, de pouvoir collaborer/partager avec d'autres et de publier directement sur Internet les démarches et les résultats, le tout étant reproductible à volonté? (la liste des programmes est celle qui a été utilisée dans la suite).

Cela n'existe pas, me direz-vous, mais c'est pourtant maintenant possible grâce aux Notebooks IPython, GitHub et les services IPython Notebook viewer et Ipython Notebook Slides Viewer qui permettent de publier instantanément les démarches et les résultats sur Internet (voir mon illustration du passage de Octave à R puis de R à Python, à titre de démonstration).

nbviewer.ipython.org/url/beowulf.csail.mit.edu/18.337/fractals.ipynb (avec Julia)

Cette combinaison est en train de devenir une petite révolution dans la communication dans le monde scientifique (et autres) qui connait Python:

• présentations diverses (comme alternative à PowerPoint et aux logiciels similaires);
• tutoriels;
• enseignement universitaire et autres;
• travaux en coopération ou en partage:
• etc.

Ils permettent aussi de publier des blogs comme Pythonic Perambulations, des articles scientifiques comme Likelihood of observing an earthquake on a continental low-angle normal fault et même des livres comme Probabilistic Programming & Bayesian Methods for Hackers.

Il suffit de consulter les sites A gallery of interesting IPython Notebooks ou IPython Notebook Examples pour s'en rendre compte.

Qu'en est-il dans le domaine géospatial ?

Il y a bien eu Adventures with GIS: an introduction to IPython and the joy of playdata qui date de 2012, mais c'est apparemment plus compliqué, car il semble difficile pour les Sigistes de concevoir un monde géomatique sans logiciel  SIG et l'utilisation de ces solutions en est encore à ses débuts.

• c'est pourquoi la solution a d'abord été utilisée comme support de présentations, de cours ou des tutoriels en utilisant des copies d'écran comme dans Accessing oceans of model data: Oceanographic analysis using IPython Notebook & ArcGIS Python interface ou An Open-Source Approach for Catchment's Physiographic Characterization, par exemple;
• puis sont arrivés les vrais tutoriels exécutables, comme dans Geospatial Data in Python, Using geospatial data with Python  ou même ESRI dans gis-stat-analysis-py-tutor;
• certains publient l'état de leurs travaux en cours comme  Sean Gillies dans le développement de Shapely;
• et enfin certains commencent à proposer des solutions complètes comme dans Analyzing whale tracks, Network Difference Tool Example Applications (avec ArcPy) ou testent les interactions entres les langages comme dans Seafloor Habitat Mapping , avec Leaflet  ou avec OpenLayers.

Quelques exemples en fonction de mes trouvailles et sans aucun à priori (il commence a y en avoir beaucoup...):

• Adventures with GIS: an introduction to IPython and the joy of play , longue vidéo YouTube qui  utilise directement PyQGIS dans un notebook, ce que je ne suis pas encore parvenu à faire;
• Shaded Relief Map in Python;
• Visualization: Mapping Global Earthquake Activity;
• Manipulating geospatial data with Shapely,Fiona and basemap (avec la figure finale non rendue par le IPython Notebook viewer car le traitement est reproductible, il suffit de  télécharger le fichier .ipynb et de l'exécuter sur son ordinateur);

• avec PyShp et matplotlib.basemap;
• So You'd Like To Make a Map Using Python;
• création de cartes choroplèthes;
• visualizing Mnt Saint Helens (avec la représentation obtenue avec le module Mayavi non visible dans le Notebook car la fenêtre est extérieure), en complément de How much rock was erupted from Mt St Helens?

• avec OpenStreetMaps;
• avec Folium;
• avec l'API Google Map ( avec quelques figures non rendues par le IPython Notebook viewer);

• avec Leaflet
• Velib' Open Data

Quelques-unes de mes réalisations:

• Utilisation de GRASS GIS avec Python,R et Octave
• Avec GDAL et Mayavi (même MNT)

Tout ça, c'est bien beau, mais il doit bien y avoir un problème quelque part ?

Eh oui, car c'est un module Python (2.x, 3.x) et pour pouvoir l'utiliser sur son ordinateur (il y a même une version pour IPhone):

1. il faut disposer d'une version de Python fonctionnelle (présente par défaut sur Linux et Mac OS X) ou en installer une (Windows);
2. il faut savoir installer des modules Python.

Ensuite avec la commande

ipython notebook ou ipython2 notebook (selon la version)

C'est cet aspect qui est le plus rédhibitoire pour ceux qui veulent les utiliser.

Si vous ne pouvez/savez pas installer IPython mais vous voulez le tester, il y a quelques solutions dans les nuages:

• SageMathCloud, gratuit après enregistrement: ("free service with support from University of Washington, the National Science Foundation and Google")

• Wakari.io de Continuum Analytics (distribution Python Anaconda), gratuit jusqu'à un certain seuil, toujours après enregistrement:

•  ou d'autres comme Picloud, payantes.

Principes, pour ceux qui souhaitent poursuivre

 Comment cela fonctionne-t-il ?

1. la feuille est d'abord élaborée dans le Notebook de IPython (voir plus bas)
2. le fichier résultant est un fichier au format JSON: .ipynb
3. ce fichier peut ensuite être transformé en une multitude de formats (HTML, PDF, ...) ou publié directement sur Internet en le plaçant dans un endroit ad hoc

Il nous faut donc commencer par une présentation,  très sommaire de IPython.

C'est quoi IPython

Il a été créé par F Perez (chercheur au Berkeley Institute for Data Science) en 2001.

The goal of IPython is to create a comprehensive environment for interactive and exploratory computing

IPython: from the shell to a book with a single tool; the method behind the madness

Il se compose de:

un terminal interactif

C'est d'abord un terminal interactif ou shell avec une pléthore d’astuces intégrées (parmi d'autres références, très nombreuses) mais ce point ne nous intéresse pas ici.

une console Qt

Entre autres choses, elle permet d'inclure directement les graphiques matplotlib, par exemple, mais ce point ne nous intéresse pas ici;

ipython qtconsole --matplotlib inline ou ipython2 qtconsole --matplotlib inline

le Notebook

C'est aussi, depuis la version 0.12 (2.2 actuellement), une nouvelle interface web riche (à la Mathematica®): le Notebook. Elle se présente sous la forme d’un shell IPython intégré dans une page Web (serveur géré par IPython). La documentation francophone la plus pratique se trouve à Utilisation du Notebook IPython.

ipython notebook ou ipython2 notebook

Le mode opératoire est simple: l'interface fonctionne avec des cellules (cells). Chacune d'entre elles peut contenir du code ou du texte:

Seules les cellules au format Code peuvent être exécutées comme dans un shell classique (avec les touches Majuscule + Return, out() dans la figure suivante et il existe de nombreuses autres astuces), les autres servent à entrer des notes (format Markdown):

De nombreux autres formats sont aussi supportés (HTML , images, videos, équations LaTex,voir IPython's Rich Display System ou Latex footnotes, citations, etc. in IPython Notebook). Voir, à titre d'exemple mes IPortail SIG et Purcell A.Deller.

Les diapositives (slides)

Il est aussi possible de créer des diapositives (slides) de présentation (SlideShow) avec l'API JavaScript reveal.js, (voir IPython Slideshows Will Change the Way You Work).

exemple de Melysa Gymreg sur melissagymrek.com et son fichier example_slideshow.ipynb

Les fichiers résultants (.ipynb)

Les fichiers résultants sont enregistrés au format JSON (fichiers .ipynb) et il est possible de constater qu'une fois les traitements terminés et le fichier sauvegardé, ce sont des fichiers statiques: tout est conservé, même les figures (figure au format png binaire ici).

Ils peuvent donc être convertis sans problème en un multitude de formats (HTML, Markdown, PDF, LaTex, etc) à l'aide du script nbconvert.

ipython nbconvert fichier.ipynb --to html (--to slides, to....) ou ipython2 nbconvert ....

Les services Ipython Notebook viewer et Slides Viewer

Ils permettent de publier directement sur Internet ces fichiers .ipynb  (classique et diaporama). GitHub offre maintenant la possibilité de stocker ces fichiers dans un répertoire Github (Portail.ipynb) ou dans un Gist (Portail2.ipynb) (mais en pratique, n'importe quelle URL au format .ipynb peut être utilisée) et de les transformer instantanément avec l'extension Open in nbviewer (.Firefox, Chrome et Safari) -> Script Portail.

(Google Chrome propose aussi l'application coLaboratory Notebook)

Slides Viewer permet de visualiser les fichiers .SlideShow  ( Présentation de Melissa Gymrek sur son blog et même présentation de à partir du fichier situé sur son dépôt GitHub avec Slides Viewer).

Quelques autres exemples IPython Notebook: An Overview ou An Open-Source Approach for Catchment's Physiographic Characterization (r.basin)

Les extensions 

Mais ce qui fait la force de la solution IPython, ce sont  les nombreuses Extensions. Ce sont des modules Python qui permettent de: 

• modifier le comportement du shell Python (comme %matplotlib inline dans l'exemple précédent), nommées magics

• utiliser d'autres programmes dans le Notebook, comme rmagic qui permet d'utiliser R dans le Notebook en utilisant les variables X,Y précédemment définies, mais il y en a des dizaines d'autres (Ruby, Julia, C, Fortran, MatLab, Octave, JavaScript, GraphViz, etc., voir Extension Index) et il s'en crée des nouvelles régulièrement. Ce sont les cell-magics. Il faut bien évidemment que ces applications tierces soient préalablement installées.

Exemple avec rmagic (anciennement load_ext rmagic):

Il y a moyen d'utiliser toutes les possibilités de R:

et d'importer les packages de R:

C'est la même chose avec les autres cellules magiques (voir par exemple, avec Graphviz , avec Octave ou avec JavaScript et la librairie D3.js).

Conclusions

Mon seul souhait est de vous avoir donné l'envie de découvrir cet environnement de travail pour faire de la géomatique, fort éloigné des logiciels SIG il est vrai. Ses principaux avantages résident, pour moi, dans:

• l'interface de travail pour mon travail personnel: la correction des erreurs est facile, il suffit de revenir dans la cellule incriminée, de les corriger puis de relancer le processus;
• la possibilité d'utiliser Python, R, GRASS GIS, et autres sans devoir ouvrir des Shells/programmes différents;
• la documentation des traitements: lorsqu'on utilise cet outil, on se sent vite obligé de commenter ses démarches. Au lieu d'avoir plusieurs documents, je n'en ai plus qu'un seul;
• la portabilité: il suffit de transporter son fichier .ipynb d'un ordinateur à l'autre ou de le placer sur GitHub;
• le partage et la coopération à plusieurs: il suffit de partager son document;
• la reproductibilité des démarches, fondamentale dans le monde scientifique;
• le plaisir de l'utiliser et de découvrir tout ce que IPython permet de faire...

Il y a encore des défauts, le principal étant qu'il faut connaître Python...

Mais les développements se poursuivent avec bientôt la possibilité de travailler directement à plusieurs sur une même feuille (il est possible d'observer que Microsoft figure parmi les Sponsors).
Pour suivre les progrès, le site officiel de IPython est la meilleure ressource.

Tous les traitements ont été effectués sur Mac OS X  avec plusieurs les versions 1.2.1 et 2.2.0 de IPython.

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Débutant
	Logiciels utilisés	QGIS
	Plateforme	Windows | Mac | Linux | FreeBSD

La bilbiothèque de symboles SVG de QGIS est assez complète mais comment ajouter d'autres symboles et surtout comment pouvoir changer la couleur et l'épaisseur des contours directement depuis QGIS ? C'est ce que nous allons voir dans cet article.

Avant d'aller plus loin, pour ceux qui auraient manqué cet article, lisez design cartographique : une liste de ressources en ligne indispensables, vous y trouverez une sélection de sites proposant des symboles SVG (en particulier FlatIcon - www.flaticon.com/ )

Ajouter de nouveaux symboles dans QGIS

Pour ajouter des symboles SVG, vous avez plusieurs méthodes possibles : 

• Une fois que vous êtes dans QGIS, dans le menu Symbole SVG vous pouvez parcourir vers le fichier SVG de votre choix via le bouton parcourir en bas de la partie Groupes SVG

• Vous pouvez copier les nouveaux symboles dans le répertoire où sont déjà présents les bibliothèques SVG par défaut (indiqué également sous la fenêtre Groupes SVG)
   
• Vous pouvez regrouper l'ensemble de vos symboles dans un répertoire sur votre machine ou votre serveur et l'ajouter dans les chemins vers les symboles SVG. Pour cela aller dans les options de QGIS > Système et ajoutez vos nouveaux chemins.

Ils apparaitront dans l'arborescence des fichiers SVG et dans les aperçus des symboles.

Modifier le SVG pour autoriser sa personnalisation sous QGIS

Principe :

Editer le fichier SVG avec n'importe quel éditeur de texte (gedit, notepadd ++, etc.)

Remplacez les paramètres de style dans le fichier SVG par :

• fill="param(fill) #FFF" --> modifie le remplissage
• stroke="param(outline) #000"--> modifie la couleur de bordure
• stroke-width="param(outline-width) 1" --> modifie l'épaisseur du contour

Cas simple, 

J'ai une étoile en SVG (oui je sais qu'il y en a déjà dans QGIS mais c'est pour l'exemple ... :-) ) --> 

J'ouvre le fichier : 

Il suffit de remplacer 

style="fill:#010101;"

par :

fill="param(fill) #FFF"

Ca fonctionne !

Cas intermédiaire

Avec un symbole en plusieurs partie sans les paramètres "fill" comme celui-ci --> 

Avec un éditeur de texte :

Vous aurez le cas de figure avec beaucoup de symboles du site FlatIcon...

Pour permettre l'édition de l'objet dans QGIS, il faut tout simplement ajouter les paramètres avant la balise <path pour chaque objet du dessin (ici en 2 parties) :

<path fill="param(fill) #FFF" stroke="param(outline) #000" stroke-width="param(outline-width) 1" d="M57.851,40.752V25.2...

Dans QGIS, il est maintenant possible d'éditer la couleur, le contour et même l'épaisseur (pour faire une sorte de halo)

Cas difficile

Et si mon SVG utilise des dégradés ?

Je créé sous Inkscape un cercle avec un dégradé radial pour une impression de volume.

Je veux ensuite l'utiliser dans QGIS ? C'est la même logique, à la place de la couleur noire, je vais remplacer par les paramètres vu au dessus :

<linearGradient

       id="linearGradient3761"

       osb:paint="gradient">

      <stop

         style="stop-color:#f7f7f7;stop-opacity:1;"

         offset="0"

         id="stop3763" />

      <stop

         style="stop-color:param(fill) #FFF;stop-opacity:1;"

         offset="1"

         id="stop3765" />

    </linearGradient> 

Dans ce cas, je ne personnalise qu'une couleur de mon dégradé (la partie noire, la blanche restera figée). Si on y ajoute un contour, alors il faut aussi modifier les lignes suivantes du code : 

<path

       sodipodi:type="arc"

       style="fill:url(#radialGradient3781);fill-opacity:1;fill-rule:evenodd;stroke:param(outline) #000;stroke-width:param(outline-width) 1;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none"

       id="path2991"

       sodipodi:cx="302"

       sodipodi:cy="427.36218"

       sodipodi:rx="54"

       sodipodi:ry="54"

       d="m 356,427.36218 a 54,54 0 1 1 -108,0 54,54 0 1 1 108,0 z"

       transform="matrix(0.46296296,0,0,0.46296296,-113.81481,828.50934)" />

Voici le résultat sur une carte QGIS (sans utiliser de contours): 

	Niveau	Intermédiaire
	Logiciels utilisés	Python R QGIS GRASS GIS OpenJUMP PostGIS SpatiaLite JavaScript
	Plateforme	Windows | Mac | Linux | FreeBSD

Comment créer (automatiquement et pas à la main, je précise)  une enveloppe concave autour d'un nuage de points (concave hull) est une question qui revient souvent sur les Forums. Il existe en effet de nombreux algorithmes qui permettent de créer une enveloppe convexe (convex hull) de surface convexe minimale contenant tous les points (ou le polyèdre convexe dans le cas de points 3D) mais pas grand-chose de précis sur la création d'enveloppes non convexes.

À l'inverse de l'enveloppe convexe dont la solution est toujours unique, il y a plusieurs solutions possibles pour les enveloppes concaves, suivant les critères et l'algorithme choisi.

Diverses enveloppes concaves (concave hull) selon le fait que l'on autorise les partitionnements (clusters) ou les  trous

Je vais présenter ici les principes de création de ces enveloppes concaves (2D) et un inventaire des moyens de les créer avec Python, R, QGIS, GRASS GIS, OpenJUMP, PostGIS, SpatiaLite et enfin JavaScript. Mais, quelques éléments théoriques sont cependant nécessaires pour éviter quelques déconvenues... (je n'ai rien trouvé pour gvSIG, mais comme les versions pour Mac OS X sont aux abonnés absents, la dernière version disponible étant la 1.12, peut-être que...)

Quelques définitions et principes

Qu'est-ce qu'une enveloppe convexe d'un ensemble de points ? C'est la surface qui minimise la zone qui contient tous les points, sans que l'angle entre deux arêtes voisines ne dépasse 180°.

Une enveloppe concave d'un ensemble de points obéit aux mêmes principes, mais autorise tous les angles. Tous les ensembles d'enveloppes situés entre l'enveloppe convexe et celle qui minimise complètement la surface sont considérés comme concaves.

Diverses enveloppes concaves possibles

Se pose alors le problème du choix de la « bonne » enveloppe concave (celle qu'on recherche...). Veut-on trouver la forme originale du nuage de points (s'il y en a une) ou la surface minimale qui les englobe tous ?

Ce problème n'est pas limité au domaine géomatique, mais intéresse de nombreux autres domaines scientifiques qui doivent traiter des nuages de points/observations en 2D ou 3D (morphométrie/reconnaissance des formes, imagerie médicale, bio-informatique, cosmologie, séismologie, écologie, physique, analyse de réseaux, etc.) ou de la conception assistée par ordinateur (CAD) et bien évidemment dans les traitements divers des données LIDAR. Ce sujet a fait l'objet de nombreux articles scientifiques, de livres ou de thèses de doctorat et ces références bibliographiques sont trop nombreuses pour être citées ici (il suffit de faire une recherche sur Internet). En fin d'article, je fournis quelques-unes d'entre elles (accessibles) pour illustrer la diversité des recherches.

De ce fait, plusieurs approches mathématiques plus ou moins complexes ont été proposées pour tenter de résoudre le problème. Elles sont dans leur majorité basées sur la triangulation de Delaunay et le modèle de forme alpha  (Alpha Shape) qui sera explicité dans la suite:

• exploitant  le modèle des formes alpha s.s.  utilisé avec Python, R et par QGIS, GRASS GIS, PostGIS et SpatiaLite, voir plus bas;
• exploitant les généralisations de ces formes alpha comme  Concave hull (pdf), qui permet les partitionnements (clusters, utililisé avec un plugin de QGIS, voir plus bas),  Alpha-Concave Hull (pdf),  alpha convex hull,  etc.;
• exploitant le modèle des characteristic shapes (pdf) qui permet de générer de manières ordonnée à l'aide d'un seul paramètre normalisé toute la famille des formes alpha depuis l'enveloppe convexe jusqu'à la surface minimale (utlilisé avec une extension d'OpenJUMP, voir plus bas)
• utilisant le modèle des formes alpha pondérées, la théorie des Graphes, celui d'enveloppe de superficie minimale (MAE : computation of Minimal Area Enclosure)  celui de fractionnement et fusion ou segmentation (split and merge procedure), celui de  Locally-Density-Adaptive-α-hull ou celui de diagramme de Voronoï contraint, non abordés ici;
• et d'autres ....
  

Au premier abord, cela n'a donc pas l'air aussi simple qu'espéré...

Les formes alpha (alpha shapes)

Il est nécessaire de présenter ici le modèle des formes alpha (alpha shape ou alpha hull), car c'est LA méthode utilisée dans toutes les solutions présentées. Sans savoir ce que c'est, impossible d'aller plus loin...

Pour commencer, disons que ce modèle est intimement lié à la triangulation de Delaunay et aux enveloppes convexes qui n'en sont qu'un cas particulier.

• C'est une triangulation de Delaunay (2D ou 3D) pour laquelle chacun des triangles ou tétraèdres (« simplex ») est comparé à la valeur d'un paramètre alpha (α)  déterminé par la distance euclidienne entre les points (la méthode a été introduite par H. Edelsbrunner, D. G. Kirckpatrick and R. Seidel. en 1983 dans On the shape of a set of points in the plane (pdf)(IEEE Trans. Inform. Theory IT-29, p. 551-559). L'objectif était d'essayer de trouver les points « frontières » d'une enveloppe en permettant même d'y créer des trous;
• Pour comprendre la signification de ce paramètre α, une allégorie intuitive  avec un bloc de crème glacée a été proposée par K. Fischer en 2000 dans Introduction to Alpha Shapes (pdf) et reprise dans CGAL 4.5 - 2D Alpha Shapes (cette librairie C++ est la solution la plus performante pour les traiter, mais elle est relativement difficile à installer).
• L'ensemble est bien expliqué en français dans le mémoire de V. Carette (Université Laval, 2008) Amélioration de la représentation géométrique 2D et 3D des agrégations de poissons en support à l'étude de leur évolution spatio-temporelle (pdf) dont je me suis inspiré pour cette partie.

K. Fischer suggère d’assimiler le concept des formes alpha à un espace 3D rempli d’une importante masse de crème glacée contenant des pépites de chocolat. Avec une cuillère à glace nous creusons et retirons toute la crème glacée que nous pouvons atteindre sans toucher aux pépites (et ce y compris depuis l'intérieur). Plus le rayon de la cuillère diminue, plus cette cuillère peut atteindre des endroits étroits et plus de crème glacée sera enlevée. Avec un rayon infiniment petit, il ne restera que les pépites. À l'inverse, une cuillère de rayon trop grand nous empêchera de la bouger, laissant la masse intacte.

Dans cette histoire de crème glacée, la valeur α est le rayon de la cuillère à glace.

• si α → 0, nous pouvons « théoriquement » manger toute la crème glacée en laissant seulement les  pépites en chocolat. L’objet résultant sera délimité par des arcs, des surfaces bombées et des points sans aucune garantie que ses différentes parties soient connectées entre elles;
• si α → ∞, le résultat sera la masse de crème glacée, c'est-à-dire son enveloppe convexe.

Les formes alpha se situent entre ces 2 valeurs extrêmes. Ce sont donc des généralisations du concept de l'enveloppe convexe. Toute enveloppe convexe est une forme alpha, mais l'inverse n'est pas vrai. En utilisant une valeur appropriée d'α entre ces limites, il est dès lors possible de créer une forme alpha non convexe qui n'est pas nécessairement en un seul morceau et peut contenir un ou plusieurs trous. Le problème est de trouver cette valeur, comme nous le verrons dans la suite.

Pour conceptualiser cette histoire en 2D, il est possible d'imaginer un disque avec un certain rayon (= α) qui parcourt l'ensemble obtenu par la triangulation de Delaunay. Partout où le disque peut passer sans toucher les noeuds d'un triangle, ce triangle sera supprimé. Formellement on appelle complexe alpha (alpha complex) la partie de la triangulation de Delaunay qui subsistera et forme alpha (alpha shape) la limite du complexe alpha.

Représentation traditionnelle de la démarche

Tout ça vous parait un peu obscur, non ? Comme rien ne vaut la pratique pour éclaircir les choses, examinons comment les calculeravec la triangulation de Delaunay (2D ici). Le principe est donc d'éliminer tous les noeuds de la triangulation de Delaunay qui appartiennent à un triangle dont le rayon de la sphère circonscrite dépasse la valeur α choisie.

1) construction de la triangulation de Delaunay de l'ensemble des points;

2) une analyse statistique sur les longueurs des arêtes ou une autre technique est effectuée pour déterminer la valeur α,
3) le complexe alpha est ensuite calculé en ôtant tous les triangles qui ont un cercle circonscrit dont le rayon est supérieur au cercle de rayon α (comme le triangle 1 sur la figure, alors que le triangle 2 sera conservé);

complexe alpha résultant

4) et enfin tous les triangles restants sont dissous (dissolve) pour former la forme alpha  (comparaison avec l'enveloppe convexe qui n'est qu'un cas particulier ci-dessous).

Solutions

Signalons en tout premier lieu un petit programme en Java, le Non-convex hulls software qui permet de « jouer» avec les différents paramètres à partir de lettres.

Ensuite, je vais commencer par les implémentations en Python car elles suivent strictement la démarche décrite précédemment et que ce sont elles qui m'ont vraiment aidé à comprendre le problème. C'est plus facile ensuite d'aborder les autres solutions en toute connaissance de cause.

Python seul:

Les algorithmes de création de formes alpha ont été bien détaillés dans:

• The Fading Shape of Alpha avec Shapely et Scipy Delaunay;
• Drawing Boundaries In Python et Drawing Boundaries avec Fiona en plus.

Toutes les démarches sont réalisées avec d'abord la triangulation de Delaunay puis le choix du paramètre alpha pour arriver à la solution. Le principal problème est qu'il faut trouver la « bonne » valeur α soi-même. En pratique cependant, si l'on désire comme résultat un polygone unique (ce n'est pas toujours possible, surtout si la forme est trop convexe), il suffit d'une simple boucle en testant le résultat obtenu par les fonctions cascaded_union ou unary_union de Shapely qui devra être un Polygone et non un MultiPolygone comme illustré dans mon script  concave_hull1.py.

Obtention de MultiPolygones résultant d'une valeur α trop petite

Polygone unique au bout de n itérations

Pour éviter cette étape de recherche, une autre solution est d'utiliser un programme spécialisé avec le module subprocess. Parmi ceux-ci, le programme C Hull(il faut le compiler) de Ken Clarkson est un des plus performants et a été utilisé dans:

• Alpha Shapes in Python et Concave Hull 

Ici, plus besoin de se préoccuper de la recherche de la valeur α, tout est fait automatiquement par le programme. Un exemple d'application est donné dans mon script concave_hull2.py ou un rayon de recherche peut être spécifié.

CGAL possède aussi une implémentation en Python, mais comme je l'ai dit, la librairie est difficile à installer. Si vous voulez tout de même la tester, il est possible de trouver quelques exemples sur Internet comme dans AlphaShape.py

R

R permet de créer des enveloppes concaves en 2D et en 3D avec les packages alphahull et alphashape3D (forme alpha).

• alphahull: an R Package for Alpha-Convex Hull
• Generalizing the Convex Hull of a Sample: The R Package alphahull (pdf)
• α – Shape generation with R
• Alpha shapes with R and lattice

Résultat avec alphahull, voir mon script alpha_shape.R (tout comme les solutions en Python, le paramètre α doit être recherché indépendamment).

Quelques exemples non géomatiques avec alphashape3D:

Il existe d'autres packages plus limités comme  rLIDAR.

QGIS

QGIS offre plusieurs manières de créer des enveloppes concaves:

• avec l'algorithme Concave Hull de la Boîte à outils de Traitements (Processing) QGIS processing: Concave hull (ConcaveHull.py). Il s'agit ici d'un algorithme de forme alpha qui permet la création de polygones troués (si on le veut). Le Threshold peut être assimilé au paramètre α.

• avec le plugin encore expérimental de Detlev Neumann (il faut le télécharger et l'installer soi-même) en Python, QGIS-ConcaveHull-Plugin. Il n'utilise pas la triangulation de Delaunay proprement dite, mais l'algorithme des K plus proches voisins suivant la méthode proposée par A. Moreira and M.B. Santos dans Concave hull : a k-nearest neighbours approach for the computation of the region occupied by a set of points (pdf) en 2007. Il permet en plus de séparer les résultats en groupes (clusters);

• avec le plugin PgRouting Layer d'Anita Graser qui utilise les fonctions de  PostGIS (voir plus bas).
• il est toujours possible d'utiliser les solutions Python ou R avec un script dans la Boîte à outils de Traitements (processing) ou directement les fonctions de PostGIS.

GRASS GIS

• Les différentes méthodes pour créer des enveloppes concaves sont présentées dans GRASS GIS Create concave hull (forme alpha)

OpenJUMP

• Comme toujours, le méconnu OpenJUMP offre aussi une extension très performante qui permet de créer des enveloppes concaves: Concave hull based on JTS. Elle est basée sur l'algorithme  « characteristic shape » proposé par M.Duckham, L.Kulik, M.Worboys & A.Galton en 2008 dans Efficient generation of simple polygons for characterizing the shape of a set of points in the plane (pdf). La forme alpha produite par la commande est contrôlée par la variable seuil (le paramètre normalisé):

Divers résultats obtenus en modifiant simplement la valeur du seuil

PostGIS

• il y a moyen de créer des enveloppes concaves avec l'extension Driving Distance extension de pgRouting, voir A Closer Look at Alpha Shapes in pgRouting de Anita Grasser ou Concave Hull – a GIS problem put to bed at last!
• les versions 2.x offrent la commande ST_ConcaveHull, voir PostGIS 2 Concave Hull;
• Anita Graser a créé un plugin pour QGIS PgRouting Layer qui exploite cette caractéristique.

SpatiaLite

• il existe aussi une implémentation dans les versions 4.x voir Delaunay Triangulation, Convex Hull and Concave Hull

JavaScript

JavaScript permet de le faire

• avec la librairie Hull.js, voir Generate Concave Hulls with Hull.js;

 images tirées de Hull.js examples

 

Divers essais avec la couche test:

• avec la nouvelle librairie Turf.js ("a modular GIS engine written in JavaScript"), voir turf-concave;
• il y a d'autres solutions comme dans alpha-shapes aka concave hulls in d3 ou ConcaveHull qui utilise la méthode Concave hull (pdf) déjà vue.

Et le reste...

Je vous invite à consulter GIS SE: What are Definition, Algorithms and Practical Solutions for Concave Hull? qui montre d'autres solutions comme:

• The Shape of Alpha de Flickr ;

• certains programmes/librairies de traitement des données LIDAR;

Conclusions

Vous aurez sans aucun doute remarqué qu'aucune enveloppe concave obtenue ici n'est strictement la même et pourtant elles sont toutes correctes.

Diverses solutions examinées

Comme vous avez le choix entre plusieurs méthodes et plusieurs paramètres, c'est à vous de jouer maintenant pour obtenir ce que vous voulez, car somme toute, c'est le résultat recherché qui compte (si on ne veut pas le faire à la main...). Les recherches scientifiques actuelles portent surtout sur les enveloppes concaves 3D.

Tous les traitements ont été effectués sur Mac OS X et les figures sont des captures d'écran des représentations avec QGIS hormis les solutions en JavaScript.

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Débutant
	Logiciels utilisés	QGIS
	Plateforme	Windows | Mac | Linux | FreeBSD

Tout le monde connait le protocole WMS qui permet d'obtenir des cartes à partir de serveurs cartographiques (Menu Couches/ Ajouter une couche/Ajouter une couche WMS)  et le plugin OpenLayers qui permet d'obtenir des fonds de carte OpenStreetMap, Google Maps, Bing Maps, MapQuest et autres en utilisant la librairie JavaScript du même nom (Menu Internet/OpenLayers plugin), mais  peu d'entre nous utilisent directement les services/protocoles  tuilés (pavés cartographiques pour les Canadiens), TMS (Tile Map Service) développé par l'OSGeo (Fondation Geospatiale Open Source), WMTS  de l'OGC Nous ne discuterons pas ici des principes, des protocoles ou des différents formats (ZXY, XYZ, ...) en renvoyant le lecteur aux nombreuses explications qu'il est possible de trouver sur Internet (Petite histoire de tuilage de neogeo,  FOSS4G 2010: OGC WMTS and OSGeo TMS standards:motivations, history and differences (pdf) ou Stockage de tuiles : comprendre WMTS et TMS de Makina Corpus, par exemple, mais il y en a beaucoup d'autres comme le livre Tile-Based Geospatial Information Systems,Principles and Practices (2010) de Sample, J.T. et  Loup, E. chez Springer). Le but ici est d'expliquer comment afficher pratiquement les cartes résultantes dans QGIS sans passer par l'une ou l'autre des solutions proposées.

Il existe à l'heure actuelle trois solutions dont je vais expliquer ici les procédures en prenant comme exemple l'affichage des tuiles de OpenTopoMap, projet allemand qui  mêle les données OSM et SRTM  pour créer des cartes topographiques ombragées avec des courbes de niveau (wiki OpenStreetMap: OpenTopoMap).

Principes

La seule exigence est que la ressource soit spécifiée par un URI (Uniform Resource Identifier)  de type:

- http://{sous-domaine}.tile.opentopomap.org/${niveau de zoom}/${x}/${y}.png (TMS)
- http://{sous-domaine}.tile.opentopomap.org/cycle/{niveau de zoom}/{colonne}/{ligne}.png (WMTS)

Les portions de l'URL circonscrites par {} sont des valeurs paramétrées pour accéder aux différentes tuiles fournies par le fournisseur de tuiles.  Le sous-domaine est utilisé par le fournisseur pour distribuer les tuiles à travers de multiples serveurs (a,b,c), mais tous les fournisseurs ne disposent pas de sous-domaines. Les autres paramètres sont utilisés par le client pour accéder dynamiquement aux cartes, elles restent telles quelles.

Dans le cas qui nous concerne, seul le format TMS sera utilisé. Pour OpenTopoMap, des URI possibles seront donc http://b.tile.opentopomap.org/${z}/${x}/${y}.png ou http://tile.opentopomap.org/${z}/${x}/${y}.png:

Avec GDAL

GDAL permet depuis la version 1.7 d'accéder aux services TMS (GDAL: TMS) (et depuis la version 2.1, aux services WMTS , GDAL:WMTS). Cela se fait par l'entremise de fichiers XML qu'il suffit d'ouvrir dans QGIS comme des couches raster. Des exemples concrets sont présentés dans Using Map Tile Servers in QGIS 2.4  et Les Tuiles OpenStreetMap dans QGIS pour OpenStreetMap. Dans le cas d'OpenTopoMap, un fichier XML est présenté  dans OSM - Opentopomap (GDAL) . Le  fichier XML utilisé ici est:

<GDAL_WMS>
    <Service name="TMS">
        <ServerUrl>http://tile.opentopomap.org/${z}/${x}/${y}.png</ServerUrl>
    </Service>
    <DataWindow>
        <UpperLeftX>-20037508.34</UpperLeftX>
        <UpperLeftY>20037508.34</UpperLeftY>
        <LowerRightX>20037508.34</LowerRightX>
        <LowerRightY>-20037508.34</LowerRightY>
        <TileLevel>18</TileLevel>
        <TileCountX>1</TileCountX>
        <TileCountY>1</TileCountY>
        <YOrigin>top</YOrigin>
    </DataWindow>
    <Projection>EPSG:3857</Projection>
    <BlockSizeX>256</BlockSizeX>
    <BlockSizeY>256</BlockSizeY>
    <BandsCount>3</BandsCount>
    <Cache/>
</GDAL_WMS>

Les propriétés sont les mêmes que celle d'une couche raster classique. Les tuiles étant fournies dans la projection Mercator (EPSG:3857), il ne faut donc pas oublier d'activer la projection à la volée pour l'utiliser dans votre système de projection favori (EPSG:31370 ici). Le problème principal de ces fichiers est qu'ils ne sont pas toujours reconnus si on les utilise derrière un proxy (université, entreprise, voir par exemple ForumSIG: Les tuiles OpenStreetMap ou Google Maps directement dans QGIS (sans extension)), à l'inverse des deux plugins.

Résultat:

Avec l'extension TileLayerPlugin de Minoru Akagi

Les explications détaillées sont fournies dans Readme: TileLayerPlugin

• chaque couche est représentée par un fichier .tsv situé dans un dossier nommé tile_layer;
• la localisation de ce dossier est précisée dans les Settings du plugin.

Des exemples concrets sont présentés dans [QGis] Afficher une carte Mapbox et Mozilla Stumbler layer: loading TMS and XYZ tilelayers in QGIS et des couches supplémentaires sont proposées dans  http://qgis.nl/tilelayers.zip

Le format de ces fichiers est (titre de la couche, crédit (très important) et URI) :

#title credit serviceUrl yOriginTop zmin zmax xmin ymin xmax ymax
OpenTopoMap    © OpenTopoMap EU    http://tile.opentopomap.org/{z}/{x}/{y}.png    1    0    19

Mais attention, les éléments doivent être séparés par des tabulations, c'est à dire

OpenTopoMap[tab]© OpenTopoMap EU[tab]http://tile.opentopomap.org/{z}/{x}/{y}.png[tab]1[tab]0[tab]19 :

La couche est chargée dans QGIS à travers le plugin:

Avec l'extension QuickMapServices proposée par NextGIS

 C'est le même principe que le précédent,mais avec cette fois-ci:

• un dossier nommé data_sources où sont stockées les couches sous forme de fichiers metadata.ini dans des sous-dossiers spécifiques;
• et un dossier nommé group où les couches peuvent être regroupées sous un intitulé commun

dossiers data_sources et group

Le format du fichier metadata.ini est:

[general]
id = openTopoMap
type = TMS
is_contrib = False

[ui]
group = osm
alias = OpenTopoMap
icon = osm.svg

[license]
name = CC-BY-SA 2.0
link = http://creativecommons.org/licenses/by-sa/2.0/
copyright_text =© OpenTopoMap EU , CC-BY-SA
copyright_link = https://www.openstreetmap.org/copyright
terms_of_use = http://wiki.openstreetmap.org/wiki/Tile_usage_policy

[tms]
url = http://tile.opentopomap.org/{z}/{x}/{y}.png

Le tag group spécifie le groupe dans lequel le couche se trouve (dossier group) et vous reconnaitrez les autres paramètres.

De nombreuses contributions supplémentaires sont proposées dans GitHub:quickmapservices_contrib avec l'avertissement classique : These services are maintained by community. They are not validated and may contain errors, license violations etc. Use at your own risk.

Il suffit de les placer dans les dossiers ad hoc (voir figures pour avoir la liste) et  la couche est chargée dans QGIS à travers le plugin:

Résultats pour les deux extensions

Les deux extensions donnent en effet les mêmes résultats:

Dans les deux cas, les propriétés ne sont pas celles des rasters. Elles permettent de régler directement la transparence des couches.

De ce fait, il est très facile de superposer les couches avec toutes les possibilités du Blending mode (overlay, etc.).

Conclusions

Beaucoup plus souples et plus rapides que les couches XML de GDAL et le plugin OpenLayers (et avec beaucoup moins de problèmes...) ces deux extensions se révèlent très pratiques. Configurer une couche TMS est très facile une fois que l'on en a compris les principes.

Tous les traitements ont été effectués sur Mac OS X ici, mais aussi Linux et Windows avec plusieurs versions de QGIS 2.x

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Intermédiaire
	Logiciels utilisés	QGIS FontForge BirdFont
	Plateforme	Windows | Mac | Linux | FreeBSD

Nicolas Rochard a présenté sur le Portail comment Ajouter et personnaliser des symboles SVG depuis QGIS, mais il est aussi possible d'utiliser des polices de caractères pour obtenir des symboles.

C'est la démarche utilisée par ESRI depuis Arcview 3.x. Alors, bien sur, si vous êtes sur Windows et qu'ArcGIS est installé sur votre PC, vous pouvez utiliser les polices ArcGIS dans QGIS, mais je ne sais pas si c'est très légal de les transférer sur un autre ordinateur sans ArcGIS installé.

Il est possible de les faire tourner de manière absolue (Rotation) ou en fonction de la valeur d'un champ, de modifier leurs couleurs (sans les problèmes rencontrés dans l'article de Nicolas Rochard comme le remplissage d'un symbole SVG) et de les utiliser pour créer des symboles composites (même en conjonction avec des symboles SVG). Il n'est pas possible d'utiliser des dégradés.

Première solution: chercher et installer des polices

Il y a une multitude de sites qui proposent des polices de caractères gratuites comme Dafont.com (non exhaustif) avec en particulier les polices de symboles ou de formes, sous divers formats. À vous de trouver votre bonheur... (pour les utilisateurs Windows, les polices True Type sont préférables avec QGIS).

Avec la police Transportation Dings par exemple:

Deuxième solution: créer ses propres polices

Il existe beaucoup de logiciels pour créer des fontes, commerciaux, gratuits ou libres (Create your own font with these 14 best tools). À l'heure actuelle, il en existe deux libres disponibles pour Windows, Mac OS X et Linux:

• FontForge
• BirdFont

Le premier est le plus connu (Wikipedia: FontForge) et dispose de nombreux tutoriels sur Internet ainsi que d'un livre gratuit (Design With FontForge). Le second est plus récent et dispose d'une double licence, libre ou libre avec donation volontaire. Les deux solutions permettent d'importer des figures au format SVG provenant d'Inkscape ou d'Adobe Illustrator comme caractère (Créer des fontes vectorielles avec Inkscape et fontforge , BirdFont: Create a Font in Illustrator ). Ils permettent aussi de générer des Fontes SVG.

Pour ceux qui veulent apprendre à créer des belles fontes, passez votre chemin, ce n'est pas le but ici. Je ne veux que créer des fontes « techniques » de symboles à utiliser dans QGIS. Je ne m'intéresserai ici qu'à FontForge (je ne connais pas bien BirdFont qui me semble moins intuitif et ne permet pas de visualiser toutes les fontes, voir QGIS: You want symbols? You’ve got it!).

Créer un symbole avec FontForge

Il est possible de modifier une fonte existante ou d'en créer une nouvelle comme dans la figure suivante:

En double-cliquant sur le caractère (en remplacement d'un caractère existant, D dans le cas présent), on obtient une interface de dessin vectoriel classique qui permet de (re)dessiner le caractère ou d'importer directement une figure Inkscape (SVG) ou d'autres formats (images, PDF, EPS, ...):

Lorsque le résultat est satisfaisant, on spécifie les informations de la police:

Puis on génère la police pour pouvoir l'utiliser dans QGIS ( format True Type ici)

Il y aura des messages d'erreurs, car je ne suis pas un spécialiste de la création de polices, mais je les ignore et le résultat final est satisfaisant pour moi:

Créer un symbole avec BirdFont

C'est le même principe, mais beaucoup moins intuitif à mon avis. Je n'irai donc pas plus loin.

Résultats dans QGIS

Choix du symbole, de la couleur et de l'angle de rotation en fonction d'un champ:

Application en géologie (pendage orienté, couches normales et retournées)

Retour vers le format SVG

Tant FontForge que BirdFont permettent d'exporter chaque caractère en divers formats, dont le SVG, ce qui permet  de les utiliser aussi comme marker SVG.

et d'appliquer les techniques de Nicolas Rochard pour autoriser une personnalisation sous QGIS (en particulier les dégradés que ne permettent pas directement les polices de caractères):

Conclusions

Les polices de caractères offrent une alternative intéressante aux symboles SVG. Il suffit de les transférer et de les installer sur un nouvel ordinateur pour qu'elles fonctionnent, sans devoir créer un dossier de symboles et ajouter son chemin dans QGIS. J'ai aussi constaté que dans le cas d'une même police installée sur divers ordinateurs (Mac OS X et Windows, par exemple), elle sera automatiquement reconnue sans devoir adapter les chemins.

La possibilté de migrations entre fontes et symboles SVG est un plus, à mon avis.

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Intermédiaire
	Logiciels utilisés	QGIS Form Value Relation
	Plateforme	Windows | Mac | Linux | FreeBSD

Qui n’a pas rêvé lors de l’édition des données dans QGIS d’utiliser dynamiquement des listes de valeurs provenant d’une autre table, c’est-à-dire que si je rentre une valeur dans un champ, QGIS me fournira automatiquement la valeur liée provenant de l’autre table dans le champ ad hoc.

Il y avait l’outil d’édition Valeur relationnelle et il y a maintenant l’extension Form Value Relation développée par Alessandro Pasotti pour et avec l’aide financière de l’ARPA Piemonte qui l’améliore (il permet le filtrage dynamique des valeurs, voir les différences dans Form Value Relation).

Pour rappel, cet outil d’édition permet de sélectionner des valeurs d’une autre table liée par un champ commun sous forme de liste. Si l’on veut aller plus loin, il faut connaître Python (How to build cascading form controls in QGis 2.4 par exemple).

La nouvelle extension est dynamique: si je rentre une valeur dans le champ IGN, le champ nom_carte sera automatiquement mis à jour (voir animations plus bas).

Principes

Son utilisation a été décrite dans:

• A new QGIS plugin allows dynamic filtering of values in forms avec uniquement des couches shapefiles ;
• Formularios personalizados en QGIS 2.12, Parte 2 avec une table CSV.

L’extension propose:

• dans l’onglet Champs des Propriétés d’une couche vectorielle un nouvel Outil d’édition: Form Value Relation

• dans les Custom scripts, l’expression/fonction CurrentFormValue()

En pratique

Je dispose de deux tables, celle sur laquelle je veux travailler, et l’autre qui contient simplement les numéros et le nom des cartes de l’IGN belge (cette table peut être celle d’une couche ou provenir d’un fichier CSV, d’un fichier Excel ou LibreOffice (OpenOffice) ou d’une table non spatiale d’une base de données). Je voudrai que chaque fois que je rentre le numéro d’une carte dans ma couche de travail, le nom de la carte soit affiché dynamiquement.

1) Dans ma table de travail, pour le champ désiré (nom_carte), je choisis l’option Form value Relation puis je commence par placer les éléments de jointure provenant de la table extérieure (IDENT, champ de jointure, et NOM_1_1000, les valeurs résultantes désirées), démarche similaire à celle de l’outil d’édition Valeur relationnelle puisque c'est, en partie, un « clone » de cet outil.

2) dans l’onglet Filtrer l’expression, je crée l’expression de jointure avec CurrentFormValue() :

"IDENT" = CurrentFormValue('num') signifie que le champs num de ma table de travail est lié au champ IDENT de ma table extérieure

3) résultat final:

4) Remarques

Pour traiter les cas où il n’y a pas de valeur correspondante, il suffit de cocher la case Autoriser une valeur nulle.

Application

Lorsque je crée un nouvel objet, tous les champs sont, bien entendu, vides, mais dès que je rentre une valeur dans le champs num, la valeur concordante, extraite de la table extérieure va s’afficher automatiquement;

Pour aller plus loin

Il y a moyen de combiner les deux outils d’éditions pour rendre les sélections d’éléments sous forme de listes de valeurs (voir aussi Formularios personalizados en QGIS 2.12, Parte 2 pour cet aspect)

Il est aussi possible de créer de multiples relations basées sur différentes tables ou sur différentes valeurs dans une table.

Conclusion

Il s’agit ici d’une extension destinée à combiner plusieurs tables de manière dynamique lors de l’entrée des données dans la phase d’édition d’une couche. En cas de consultation, elle est désactivée.

Tout se joue à l’échelle du projet QGIS (où les relations sont sauvées) et non dans celle des couches. Dans la table de travail la seule valeur qui est sauvegardée est la valeur de jonction et non la valeur résultante comme dans l’outil d’éditionValeur relationnelle.

Tous les traitements ont été effectués avec la version 2.12.1 de QGIS et LICEcap pour les gif animés.

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Débutant
	Logiciels utilisés	Python
	Plateforme	Windows | Mac | Linux | FreeBSD

La plupart des débutants dans l'utilisation des modules Python à finalité géospatiale libres commencent par le module GDAL/OGR, nommé osgeo dans la suite, du fait que l'importation du module se fait par la commande (et non open ogr).

from osgeo import ogr

Le module est certes très puissant lorsqu'on le connait bien (voir Python: utilisation des couches vectorielles et matricielles dans une perspective géologique, sans logiciel SIG , par exemple) mais son problème, pour les débutants, est qu'il est relativement difficile à appréhender, complexe à utiliser et relativement peu "Pythonesque" du fait de sa conception (interfaçage de la librairie C++ originale). Ceci n'est pas une critique, loin de là, mais je trouve qu'il est peu adapté pour débuter alors qu'il existe d'autres modules plus faciles à comprendre.

Il suffit de se rendre sur des sites comme GIS StackExchange ou le ForumSig pour s'en rendre compte: la prise en main du module est loin d'être évidente lorsqu'on débute...

De la complexité des choses...

Le très beau site Python GDAL/OGR Cookbook est une des références pour l'utilisation du module, hormis les livres. Il illustre la plupart des traitements qui peuvent être effectués. Prenons le cas de la création d'un simple Polygone qui se fait de la manière suivante (Create a Polygon):

from osgeo import ogr# Create ringring = ogr.Geometry(ogr.wkbLinearRing)ring.AddPoint(1179091.1646903288, 712782.8838459781)ring.AddPoint(1161053.0218226474, 667456.2684348812)ring.AddPoint(1214704.933941905, 641092.8288590391)ring.AddPoint(1228580.428455506, 682719.3123998424)ring.AddPoint(1218405.0658121984, 721108.1805541387)ring.AddPoint(1179091.1646903288, 712782.8838459781)# Create polygonpoly = ogr.Geometry(ogr.wkbPolygon)poly.AddGeometry(ring)

Il faut

1. créer une géométrie ogr (LinearRing), c'est-à-dire, l'enveloppe linéaire extérieure du polygone;
2. la « peupler » avec des points au format ogr, qui vont la définir;
3. créer une géométrie ogr Polygon;
4. et enfin le construire à partir de son enveloppe extérieure.

Il existe d'autres modules qui permettent de le créer de manière beaucoup plus simple (comme geojson, Shapely, PyGeoif, ShapyKarta, GeoDjango ou GeoPandas)

# Create polygonpoly = {    'type': 'Polygon',    'coordinates': [[        (1179091.1646903288, 712782.8838459781),        (1161053.0218226474, 667456.2684348812),        (1214704.933941905, 641092.8288590391),        (1228580.428455506, 682719.3123998424),        (1218405.0658121984, 721108.1805541387),        (1179091.1646903288, 712782.8838459781)]]}

ou

Polygon([(1179091.1646903288, 712782.8838459781),(1161053.0218226474, 667456.2684348812),(1214704.933941905, 641092.8288590391),(1228580.428455506, 682719.3123998424),(1218405.0658121984, 721108.1805541387),(1179091.1646903288, 712782.8838459781)])

Notons que rien ne vous empêche à ce stade d'utiliser le dictionnaire précédent (poly) pour créer une géométrie ogr

import jsonpoly = json.dumps(poly)polygon = ogr.CreateGeometryFromJson(poly)

De la simplification des choses...

Le but de ces nouveaux modules est donc clairement de simplifier la vie des utilisateurs en n'utilisant que des simples objets Python standards, listes, dictionnaires et arrays NumPy pour traiter les données sans faire appel à des commandes externes comme osgeo, PyQGIS ou ArcPy, à titre d'exemple.

1. Leur particularité est qu'ils disposent tous du protocole Geo_interface (voir Les modules Python à finalités géospatiales: quid, quando, ubi ?) où, en simplifiant, tous les traitements se font à l'aide de simples dictionnaires Python (voir Python Geo_interface applications)
2. Certains d'entre eux se basent, tout comme osgeo, sur la librairie GDAL/OGR (simplification des procédures avec un autre interfaçage de la librairie C++ originale), d'autres sur la librairie C++ GEOS, d'autres sont écrits en pur Python et enfin certains combinent le tout avec le module Pandas, module de plus en plus utilisé dans le monde scientifique (équivalent aux dataframes  de R avec une kyrielle d'applications, voir Sam & Max: Le pandas c’est bon, mangez-en, par exemple);
3. Certains fournissent des lignes de commandes comme ogr_info, etc.
4. Ils sont disponibles pour les versions 2.7.x et 3.x de python

Ils sont donc particulièrement adaptés aux débutants comme nous allons le voir. Nous nous focaliserons ici sur les couches vectorielles, laissant les couches rasters pour plus tard.

Lire des couches vectorielles

Nous utiliserons ici Fiona et GeoPandas qui sont les plus connus de cette « nouvelle vague » pour les explications.

Lecture

Je vous laisse découvrir les principes de lecture d'un fichier shapefile avec le module osgeo dans Cookbook: Vector Layers. Vous constaterez qu'il  faut beaucoup de lignes et de commandes à retenir pour simplement extraire le schéma d'un fichier shapefile, sa projection et les géométries et données de la table attributaire....

Avec Fiona

Comme déjà dit auparavant, c'est un nouvel interfaçage de la librairie C++ GDAL/OGR et donc comparable à osgeo.ogr. Tout se fait avec des dictionnaires Python.

import fiona# j'ouvre le fichier dans un itérateur Pythoncouche = fiona.open('strati_or.shp')# le schéma de couchecouche.schema{'geometry': 'Point', 'properties': OrderedDict([(u'id', 'int:10'), (u'dip', 'int:2'), (u'dip_dir', 'int:3'), (u'dir', 'int:9'), (u'type', 'str:10'), (u'x', 'int:10'), (u'y', 'int:10')])}# la projection de la couchecouche.crs# au format proj4{u'lon_0': 4.367486666666666, u'ellps': u'intl', u'y_0': 5400088.438, u'no_defs': True, u'proj': u'lcc', u'x_0': 150000.013, u'units': u'm', u'lat_2': 49.8333339, u'lat_1': 51.16666723333333, u'lat_0': 90}# premier élémentcouche.next(){'geometry': {'type': 'Point', 'coordinates': (272070.600041, 155389.38792)}, 'type': 'Feature', 'id': '0', 'properties': OrderedDict([(u'id', 0), (u'dip', 30), (u'dip_dir', 130), (u'dir', 40),(u'type', u'incliné'), (u'x', 272071), (u'y', 155389)])}# d'oùelements = [elem for elem in couche]elements[0]['geometry']{'type': 'Point', 'coordinates': (272070.600041, 155389.38792)}elements[0]['properties']OrderedDict([(u'id', 0), (u'dip', 30), (u'dip_dir', 130), (u'dir', 40), (u'type', u'inclin\xe9'), (u'x', 272071), (u'y', 155389)])elements[0]['properties']['dip_dir']130

Vous comprenez alors aisément que tous les traitements se résument à la simple manipulation de dictionnaires (modifier le schéma d'un shapefile ou modifier un élément de la table attributaire par exemple). Pour traiter ensuite les données, vous avez l'embarras du choix avec Shapely (géométries, ou les autres déjà cités)  NumPy, SciPy, Scikit-learn ou autres modules spécifiques.

Avec GeoPandas

Avec ce  module, vous entrez dans un autre monde encore peu connu des géomaticiens, le module Pandas. Vous créez directement un DataFrame, ou une Serie Pandas (respectivement GeoDataFrame et GeoSeries) à l'aide des modules Shapely et Fiona. Le traitement des DataFrames Pandas est abondamment illustré sur Internet.

import geopandas as gp# création d'un GeoDataframe à partir du fichier shapefilecouche = gp.GeoDataFrame.from_file('strati_or.shp')# affichage classique avec Pandas des 5 premiers éléments du DataFrame couche couche.head()   dip  dip_dir  dir                            geometry  id     type    x       y  0  30     130  40  POINT (272070.600041155389.38792)  0  incliné   272071 1553891  55     145  55 POINT (271066.032148154475.631377)  1 retourné   271066 1544762  40     155  65 POINT (273481.498868153923.492988)  2  incliné   273481 1539233  80     120  30 POINT (270977.604378153144.810665)  3 retourné   270978 1531454  40     130  40 POINT (267162.940066150990.398109)  4  incliné   267163 150990# aperçu rapide des propriétés de la couchecouche.describe()             dip     dip_dir         dir        id             x         y count  12.000000  12.000000  12.000000 12.000000     12.000000     12.000000mean   59.416667 170.416667  80.416667  5.500000 270592.666667 152742.166667std    21.094844  71.147042  71.147042  3.605551   2508.060364   2508.06036min   30.000000 120.000000  30.000000  0.000000 267163.000000 2150442.000000 25%   40.000000 133.750000  43.750000  2.750000 268675.500000  150910.75000050%   57.500000 145.000000  55.000000  5.500000 270824.500000 152728.000000   75%   78.500000 155.000000  65.000000  8.250000 272423.500000 154375.000000  max   90.000000 327.000000 237.000000 11.000000 274188.000000 155389.000000  

Vous pouvez alors utiliser toutes les fonctions de GeoPandas ou de Pandas pour traiter les données géométriques et numériques et utiliser le pandas Ecosystem (Statsmodels, Sklearn-pandas, etc) en plus des modules précédemment cités.

Avec les autres

Ce protocole de lecture des données sous forme de dictionnaire (geo_interface) peut être appliqué avec d'autres modules, voir ogr_geointerface.py,  PyShp_geointerface.py,  PostGIS_geointerface.py, spatialite_geointerface.py, ou mapnik_geointerface.py.

Exemple avec PyShp (shapefile):

def records(filename):      # generateur     reader = shapefile.Reader(filename)     fields = reader.fields[1:]     field_names = [field[0]for field in fields]     for sr in reader.shapeRecords():          geom = sr.shape.__geo_interface__          atr = dict(zip(field_names, sr.record))         yielddict(geometry=geom,properties=atr)   import shapefileelem = records('strati_res.shp')elem.next(){'geometry': {'type': 'Point', 'coordinates': (272070.600041, 155389.38792)}, 'properties': {'dip_dir': 130, 'dip': 30, 'cosa': -0.6428, 'sina': -0.6428}}

 Exemple avec osgeo:

def records(shapefile):      # generateur    reader = ogr.Open(shapefile)    layer = reader.GetLayer(0)    for i inrange(layer.GetFeatureCount()):        feature = layer.GetFeature(i)        yield json.loads(feature.ExportToJson())from osgeo import ogrelem = records('strati_res.shp')elem.next(){'geometry': {'type': 'Point', 'coordinates': (272070.600041, 155389.38792)}, 'properties': {'dip_dir': 130, 'dip': 30, 'cosa': -0.6428, 'sina': -0.6428}}

Sauvegarder des couches vectorielles

Avec Fiona

Vous sauvegardez des dictionnaires Python. Par exemple dans l'exemple suivant, je veux créer un nouveau shapefile basé sur le précédent en créant de nouveaux champs et en éliminant certains:

import fionafrom fiona.crsimport from_epsg # définition des fonctions de calculimportmathsind = lambda x: math.cos(math.radians(x))cosd = lambda x: math.cos(math.radians(x))# définition du schéma du nouveau shapefileschéma = {'geometry': 'Point', 'properties': {'dip' : 'int:2', 'dip_dir' :'int:3', 'cosa': 'float:11.4','sina':'float:11.4'}}# définition du crs du nouveau shapefilecrs = from_epsg(31370)# ou en reprenant simplement le crs du shapefile en entrée, comme dans la suite# je le remplis avec le dictionnairewith fiona.open('strati_or.shp')as entree:   with fiona.open('strati_res.shp','w',driver='ESRI Shapefile', crs=entree.crs,schema= schéma)as sortie:       for elem in entree:          # conctruction du dictionnaire et sauvegarde           geom = elem['geometry']# puisque c'est la même géométrie          prop = {'dip': elem['properties']['dip'],'dip_dir': elem['properties']['dip_dir'], 'cosa': cosd(elem['properties']['dip_dir']), 'sina': sind(elem['properties']['dip_dir'])}          sortie.write({'geometry':geom, 'properties': prop})

Avec GeoPandas

C'est encore plus simple, car après avoir effectué les changements dans le GeoDataFrame précédent  (couche),  il suffit, pour  sauvegarder le shapefile résultant de:

couche.to_file('strati_res.shp')

Quelques exemples pour vous convaincre

Je reprendrai ici quelques-unes de mes réponses sur GIS StackExchange

• Problem intersecting shapefiles with OGR in Python (général)
• Using Fiona to write a new shapefile from scratch (avec Fiona)
• Can't write decimal data into shape (shp) attribute table with Python (avec Fiona
• intersecting two shapefiles from Python or command line (avec Fiona ou GeoPandas);
• More Efficient Spatial join in Python without QGIS, ArcGIS, PostGIS, etc (avec Fiona) à comparer avec la version GeoPandas, More Efficient Spatial join in Python without QGIS, ArcGIS, PostGIS, etc;
• csv to shp missing file  (fichier .cvs vers shapefile, avec PyShp)
• Python buffer points and clip with line-segment (OS Open Roads in BNG) (fichier .cvs vers shapefile, avec Fiona)
• Rewriting csv file for QGIS (manipuler des données avec Pandas)
• ....

Pour ceux qui sont allergiques au format GeoJSON

Vous pouvez utiliser Shapely ou GeoPandas pour transformer vos géométries au format WKT par exemple, mais il y a une solution plus simple, le module geomet

elem= {'geometry': {'type': 'Point', 'coordinates': (272070.600041, 155389.38792)}, 'properties': {'dip_dir': 130, 'dip': 30, 'cosa': -0.6428, 'sina': -0.6428}}from geomet import wktprint wkt.dumps(elem['geometry'], decimals=2)POINT (272070.60155389.39)

Pour ceux qui préfèrent les commandes (ogr_info, ogr2ogr, etc.)

Fiona dispose de la commande Fio avec autant de possibilités que les commandes d'OGR (voir Fiona-Rasterio-Shapely Cheat Sheet)

$ fio info strati_or.shp
{"count": 12, "crs": "+ellps=intl +lat_0=90 +lat_1=51.1666672333 +lat_2=49.8333339 +lon_0=4.36748666667 +no_defs +proj=lcc +units=m +x_0=150000.013 +y_0=5400088.438", "driver": "ESRI Shapefile", "bounds": [267162.940066, 150441.970164, 274188.072595, 155389.38792], "crs_wkt": "PROJCS[\"Belge_1972_Belgian_Lambert_72\",GEOGCS[\"GCS_Belge 1972\",DATUM[\"Reseau_National_Belge_1972\",SPHEROID[\"International_1924\",6378388,297]],PRIMEM[\"Greenwich\",0],UNIT[\"Degree\",0.017453292519943295]],PROJECTION[\"Lambert_Conformal_Conic_2SP\"],PARAMETER[\"standard_parallel_1\",51.16666723333333],PARAMETER[\"standard_parallel_2\",49.8333339],PARAMETER[\"latitude_of_origin\",90],PARAMETER[\"central_meridian\",4.367486666666666],PARAMETER[\"false_easting\",150000.013],PARAMETER[\"false_northing\",5400088.438],UNIT[\"Meter\",1]]", "schéma": {"geometry": "Point", "properties": {"id": "int:10", "dip": "int:2", "dip_dir": "int:3", "dir": "int:9", "type": "str:10", "x": "int:10", "y": "int:10"}}}

Conclusions

Alors bien sûr, ces modules ne peuvent pas faire tout ce que fait le module osgeo, car ils ne s'adressent qu'à des fichiers (et non à l'accès des données provenant de SBGD comme PostGIS, MongoDB, CouchDB, SpatiaLite et autres ou le traitement des services WFS, par exemple, c'est d'ailleurs souligné dans les "Rules of Thumb" du Manuel de Fiona par Sean Gillies).  Mais ils peuvent servir à créer des fichiers à partir de ces données comme dans la question  Forum SIG: Python avec osgeo.org, ouvrir un WFS - Débutant;

D'après mon expérience, ils sont beaucoup plus faciles à maîtriser pour les débutants et sont plus rapides que PyQGIS (ou ArcPy d'après mes collègues) pour les mêmes traitements. Une fois compris, il est beaucoup plus facile d'aborder le module osgeo.

Alors pourquoi débuter avec osgeo.ogr ?

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Intermédiaire
	Logiciels utilisés	Python matplotlib (module Python) shapely (module Python) QGIS
	Plateforme	Windows | Mac | Linux | FreeBSD

Matplotlib est la librairie Python la plus ancienne et la plus complète pour les graphismes scientifiques en Python. Il y a bien sur des alternatives qui ont été proposées depuis sa naissance comme pandas, Seaborn et ggplot, simples aménagements de matplotlib, Bokeh ne dépendant pas de matplotlib et plutôt réservés aux notebooks Jupiter/IPython (du fait de sa conception), Pygal qui concerne le format SVG ou plot.ly, pour les visualisations en ligne, Vispy, basé sur OpenGL, ou Mayavi pour la 3D (inventaire non exhaustif...). Neamoins ce module reste le plus utilisé pour des graphiques complexes, du fait des multiples paramètres disponibles, complexes à souhait pour les débutants (d’ou certaines des alternatives proposées). Il permet même de créer toute sorte de cartes avec le Basemap Toolkit (nombreux exemples sur Internet). Ce thème ne sera pas abordé ici.

Matplotlib  est très utilisé dans les plugins QGIS pour créer des diagrammes à partir de diverses données (trop nombreux pour être cités) et son utilisation a été de nombreuses fois illustrées dans des articles sur le Portail (comme dans QGIS et géologie structurale: création automatique de rosaces directionnelles et de canevas stéréographiques avec PyQGIS ou PyQGIS (QGIS 2): les coupes géologiques (colorisation d'un profil topographique élaboré à partir d'un MNT en fonction des couleurs d'un raster et placement des points d'intersection avec les limites des couches géologiques).

Mais savez-vous qu'il est possible de faire l'inverse, c'est-à-dire de récupérer les résultats des graphiques pour en créer des couches vectorielles ?

C'est ce que fait déjà le Contour plugin de QGIS qui utilise le module shapely  pour convertir les résultats obtenus avec matplolib en une couche shapefile (d'une manière plus complexe, car il extrait aussi les valeurs des lignes de contour, ce que je ne présente pas ici).

Principes

Les résultats des commandes maplotlib sont des points, des lignes ou des polygones basés sur les données fournies (dans un repère cartésien, sans projection bien entendu). Si l’on connait les principes du module, il est donc possible d’extraire ces éléments géométriques et de les transformer en géométries shapely (Points, LineString, Polygon) et qui dit shapely dit aussi QGIS avec le plugin QuickWKT ou la création d’un shapefile avec le module Fiona.

La solution pratique se trouve dans la manière dont matplotlib produit ces figures: matplotlib.path.

Mais, pour commencer, je vais vous ouvrir l'appétit avec un exemple concret d'application puis je fournirai des explications.

Exemple concret: calcul des lignes tangentes (streamlines) d'un champ scalaire/vectoriel

C’est le genre de concept qui fait mathématiquement peur avec des calculs de dérivées et/ou d’intégrales (mécanique des fluides, par exemple). Théoriquement les notions ont été vues à l’école et sortent du cadre de cet article. Je laisse donc à d’autres, plus qualifiés que moi, le soin de les expliquer. Heureusement, matplotlib dispose de la commande pour faire cela simplement, streamplot(), mais cela ne vous dispense pas du fait de comprendre ce que vous faites avant de l’utiliser, sinon... (quelques liens sur les traitements Python dans le domaine spatial ou des plugins QGIS sont données en fin d'article)

1) Au départ, je dispose d’une grille régulière de points obtenue par traitements géostatistique (effectué avec R) avec des angles de direction sous forme de cosinus directeurs dont je veux obtenir les streamlines (pour simplifier ce sont les lignes de champ ou lignes tangentes à chaque point de la grille).

exemple de streamlines

ma grille de départ

2) Après importation du fichier shapefile et traitements, le résultat de la commande matplotlib quiver() (trace un champ 2D avec des flèches) est :

3) avec la commande streamplot()  (calcul des streamlines) en plus:

4) avec la commande streamplot() seule:

5) résultat dans QGIS après exportation des lignes résultantes sous forme de shapefile:

 Le script d'exportation après traitement avec matplotlib est simple

from shapely.geometryimport LineString, mappingimport fiona# lignes de résultat de la commande streamplot()lines = test.lines.get_paths()from fiona.crsimport from_epsg# définition du schéma du nouveau shapefilemonschema = {'geometry': 'LineString', 'properties': {'id' : 'int:2'}}# définition du crs du nouveau shapefilecrs = from_epsg(31370)# création du shapefile résultantwith fiona.open('stramplot_Leon3det05_1.shp','w',driver='ESRI Shapefile', crs=crs,schema= monschema)as sortie:       for n,l inenumerate(lines):              # le résultat de l.vertices est un array Numpy          vertices = [(i[0], i[1])for i inzip(l.vertices.T[0],l.vertices.T[1])]          geom = mapping(LineString(vertices))          prop = {'id': n}          sortie.write({'geometry':geom, 'properties': prop})

Explication avec un exemple simple

Comment transformer les résultats de la commande contour() en géométries shapely ? Cette question a été posée dans Converting Matplotlib contour objects to Shapely objects sur GIS Stack Exchange et je vais détailler la réponse que j’ai fournie.

Commençons par les lignes (contour seul -> contour())

import matplotlib.pyplotas pltx = [1,2,3,4]y = [1,2,3,4]m = [[15,14,13,12],[14,12,10,8],[13,10,7,4],[12,8,4,0]]cs = plt.contour(x,y,m)plt.show()

Si l’on s’en réfère aux paramètres de contour(), le nombre d’objets sur la figure (= collection de lignes) et les coordonnées de la première ligne sont donnés par:

printlen(cs.collection)7# coordonnées de la première ligneligne = cs.collections[0].get_paths()[0]v = ligne.verticesx = v[:,0]y = v[:,1]print x, y[ 4.   3.5][3.5 4. ]

Il y a donc moyen de transformer très facilement ces géométries en LineString shapely :

from shapely.geometryimport LineStringfor i inrange(len(cs.collections)):    p = cs.collections[i].get_paths()[0]    v = p.vertices    x = v[:,0]    y = v[:,1]    line = LineString([(j[0], j[1])for j inzip(x,y)])    print line.wktLINESTRING (43.5, 3.54)LINESTRING (43, 34)LINESTRING (42.5, 3.3333333333333333, 33.333333333333333, 2.54)LINESTRING (42, 32.666666666666667, 2.6666666666666673, 24)LINESTRING (41.5, 32, 23, 1.54)LINESTRING (41, 31.333333333333333, 22, 1.3333333333333333, 14)LINESTRING (21, 12)

Résultat dans QGIS en utilisant le plugin QuickWKT :

Avec les polygones (contourf())

import matplotlib.pyplotas pltx = [1,2,3,4]y = [1,2,3,4]m = [[15,14,13,12],[14,12,10,8],[13,10,7,4],[12,8,4,0]]cs = plt.contourf(x,y,m)plt.show() 

from shapely.geometryimport polygonfor i inrange(len(cs.collections)):    p = cs.collections[i].get_paths()[0]    v = p.vertices    x = v[:,0]    y = v[:,1]    poly = Polygon([(i[0], i[1])for i inzip(x,y)])    print poly.wktPOLYGON ((43.5, 44, 3.54, 43.5))POLYGON ((43, 43.5, 3.54, 34, 43, 43))POLYGON ((42.5, 43, 34, 2.54, 33.333333333333333, 3.3333333333333333, 42.5))POLYGON ((42, 42.5, 3.3333333333333333, 33.333333333333333, 2.54, 24, 2.6666666666666673, 32.666666666666667, 42, 42))POLYGON ((32, 41.5, 42, 32.666666666666667, 2.6666666666666673, 24, 1.54, 23, 32, 32))POLYGON ((22, 31.333333333333333, 41, 41.5, 32, 23, 1.54, 14, 1.3333333333333333, 22, 22))POLYGON ((21, 31, 41, 31.333333333333333, 22, 1.3333333333333333, 14, 13, 12, 21, 21))POLYGON ((12, 11, 21, 12))

Résultat dans QGIS en utilisant le plugin QuickWKT :

Explications

Les géométries matplotlib sont toujours encodées de la manière suivante :

• des vertices (points) sous forme d’array Numpy;
• des codes qui indiquent comment matplotlib traite les relations géométriques:
  • 0 = STOP: (fin du chemin), non requis;
  • 1 = MOVETO: déplace le « crayon » vers un point donné;
  • 2 = LINETO : dessine une ligne depuis un point donné vers un autre;
  • 79 = CLOSEPOLY: dessine une ligne depuis un point jusqu’à une ligne existante (fermeture de polygone).

Et d’autres qui nous intéressent moins ici comme CURVE3 et CURVE4 pour dessiner des courbes de Bézier.

Il y a moyen de visualiser ces paramètres en utilisant la manière préconisée pour travailler dans matplotlib avec les contours linéaires précédemment présentés (avec iter.segments()):

for i inrange(len(cs.collections)):    p = cs.collections[i].get_paths()[0]    for vert, codein p.iter_segments():            printcode, vert1[ 4.   3.5]2[3.5 4. ]1[ 4.  3.]2[ 3.  4.]1[ 4.   2.5]2[3.33333333 3.        ]2[ 3.          3.33333333]2[2.5 4. ]1[ 4.  2.]2[ 3.          2.66666667]2[2.66666667 3.        ]2[ 2.  4.]1[ 4.   1.5]2[ 3.  2.]2[ 2.  3.]2[1.5 4. ]1[ 4.  1.]2[ 3.          1.33333333]2[ 2.  2.]2[1.33333333 3.        ]2[ 1.  4.]1[ 2.  1.]2[ 1.  2.]

Une polyligne est donc définie par

1:[ 4.  2.] (départ) suivi de 2:[ 3. 2.66666667] (déplacement), de 2:[ 2.66666667  3] et de 2:[ 2.  4.] (fin de la ligne)

Ce qui qui correspond bien à la LINESTRING (4 2, 3 2.666666666666667, 2.666666666666667 3, 2 4)  précédemment trouvée.

Des exemples sont donnés dans Path tutorial

Notons aussi que Matplotlib dispose aussi de certains prédicats spatiaux comme:

from matplotlib.pathimport Pathp = Path([[25.774252, -80.190262], [18.466465, -66.118292], [32.321384, -64.75737]])p1=[27.254629577800088, -76.728515625]p2=[27.254629577800088, -74.928515625]p.contains_point(p1) p.contains_point(p2)1# à comparer avec from shapely.geometryimport Point, Polygonspoly = Polygon([[25.774252, -80.190262], [18.466465, -66.118292], [32.321384, -64.75737]])p1=Point(27.254629577800088, -76.728515625)p2=Point(27.254629577800088, -74.928515625)poly.contains(p1)Falsepoly.contains(p2)True

Conclusions

Il est ainsi possible de transformer tous les diagrammes de matplotlib en couches shapefiles, mais certains sont, bien entendu, inutiles.

Pour les champs vectoriels et les lignes de champs en Python ou avec QGIS (aucun ne correspond exactement à ma démarche)

• créer un champs vectoriel (grille) dans How to create Wind Maps in QGIS;
• pour les traitements avec streamlines dans le domaine spatial, les scripts Python de Mauro Alberti, Vector Field Parameters, Streamlines in a Steady flow field ou Glacial flows analysis with Open Source Tools: the case of the Rooves Glacier Grounding zone, East Antartica (analyses de trajectoires sur un glacier);

Résultats du script flowlines.py de Mauro Alberti

• comme plugin QGIS, il y a VectorFieldCalc, toujours de Mauro Alberti, ou FlowMapper

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France

	Niveau	Intermédiaire
	Logiciels utilisés	Python matplotlib (module Python) mplleaflet (module Python)
	Plateforme	Windows | Mac | Linux | FreeBSD

Après avoir vu comment convertir les graphiques matplotlib en fichiers shapefiles, examinons maintenant comme les transformer en carte interactive Leaflet. Cela se fait directement avec le module mplleaflet.

Je vais l’illustrer ici avec le module Python GeoPandas (voir Python à finalité géospatiale: pourquoi débuter avec le module ogr alors qu’il existe des alternatives plus simples et plus didactiques ?) pour traiter les fichiers shapefiles.

Mais, comme d’habitude, je vais vous ouvrir l’appétit avec un exemple concret d’application puis je fournirai des explications.

Exemple concret

Le script, très simple, est:

import geopandas# lecture du fichier shapefilecouche = geopandas.GeoDataFrame.from_file('varisque.shp')# changement de projection puisque LeafLet ne marche qu’avec les coordonnées WGS84coucheWGS84 = couche.to_crs(epsg=4326)import mplleafletax = coucheWGS84.plot()mapfile = 'montest.html'mplleaflet.show(fig=ax.figure, crs=coucheWGS84.crs, path=mapfile)

Le résultat est (la carte est visible sur le fichier résultant montest.html)

Explication

Où est matplotlib là dedans ? Si je détaille la procédure:

import geopandas# lecture du fichier shapefilecouche = geopandas.GeoDataFrame.from_file('varisque.shp')# changement de projection puisque LeafLet ne marche qu’avec les coordonnées WGS84coucheWGS84 = couche.to_crs(epsg=4326)import mplleafletimport matplotlib.pyplotas pltax = coucheWGS84.plot()# visualisation avec matplotlibplt.show()

Le résultat de matplotlib est:

C’est donc la figure maplotlib ax = coucheWGS84.plot() qui est transformée par mplleaflet au format GeoJSON (il suffit de regarder dans le fichier résultant) et superposée sur un fond OpenStreetMap ici.

Pour aller plus loin

Le module est clairement destiné à être utilisé directement dans un Notebooks Jupyter/IPython (avec mplleaflet.display au lieu de show()) et il y a moyen de:

• représenter plusieurs couches à la fois:

• utiliser plusieurs fonds (tuiles OpenStreetMap, par défaut, Thunderforest Landscape, Mapquest Open, Mapbox bright, CartoDB Positron, Stamen Watercolor et des fonds de cartes Esri (Aerial, World Topographic Map , National Geographic World Map).

La plupart des commandes matplotlib peuvent être utilisées comme contour(), vue précédemment:

ou streamplot():

Conclusions

Le seul petit défaut est qu'il n’y a pas moyen de créer d'« enjolivures ». Ce n’est pas trop difficile de les rajouter par la suite, mais ce n’est plus du Python.

Quelles sont les alternatives ?

• en Python, il y a le module Folium, présenté sur le Portail dans Python + Leaflet = Folium, ou comment créer des cartes interactives simplement. Il n’a rien à voir avec matplotlib et permet  beaucoup plus de choses à partir des géométries au format GeoJSON;
• avec QGIS, vous avez les plugins (écrits en Python) qgis2web et QGIS2leaf qui offrent beaucoup plus d’alternatives de « mise en page », d’utilisation de fonds de cartes différents ou la possibilité d’utiliser OpenLayers comme alternative (pour le premier).

Maintenant, vous savez comment utiliser les commandes de matplotlib et transformer les résultats graphiques en fichiers shapefiles ou en cartes interactives simples Leaflet.

Tous les traitements présentés ont été effectués sur Mac OS X avec Python 2.7.11 et matplotlib 1.4.x et 1.5.x

licence Creative Commons Paternité-Pas d'Utilisation Commerciale-Pas de Modification 2.0 France