Cartographier des données linguistiques avec Python – 1

Certaines recherches en linguistique peuvent donner lieu à une collecte de données géographiques, et bénéficieraient alors grandement d’une représentation visuelle sous forme de carte.

Même sans grandes connaissances de la géomatique, il est possible de produire des représentations cartographiques, certes basiques mais informatives. Pour commencer, je vous présente dans cet article comment produire, à partir d’un fichier CSV, une carte en HTML avec des données représentées par des points, en Python 3.

Prérequis

Je mets habituellement mon code à disposition sous forme de scripts. Pour cette fois il me semble plus pertinent de partager un notebook Jupyter, plus pratique pour avoir un aperçu de la représentation visuelle. Pour utiliser le code, il vous faudra donc être en mesure d’ouvrir et manipuler le notebook : si vous ne pouvez pas le faire sur votre machine, il existe des solutions en ligne comme nbviewer1.

Les données du fichier d’entrée seront lues via le module csv, qui fait partie de la bibliothèque standard de Python. Pour pouvoir générer la carte, vous devrez installer la librairie folium (documentation). Par ailleurs, votre version de Python devra être 3.6 ou plus récente.

Construction du code Python

Le notebook Jupyter présenté dans cet article est mis à disposition sur Gitlab. L’exemple de fichier d’entrée ainsi que le fichier HTML de la carte obtenue sont également téléchargeables.
La carte peut être consultée sur cette page sans télécharger le code source.

Le but sera d’obtenir une carte semblable à celle-ci (voir en ligne) :

Selon vos besoins et vos préférences, l’aspect final sera plus ou moins différent, puisqu’il est possible de paramétrer le fond de carte ainsi que l’aspect des points.

Les étapes à suivre seront les suivantes :

  1. Déclaration et paramétrage du fond de carte.
  2. Création d’une couche de données pour y placer les points.
  3. Lecture du fichier d’entrée pour ajout des points à la couche de données (avec paramétrage des points).
  4. Ajout de la couche de données à la carte.
  5. Enregistrement de la carte dans un fichier HTML.

Fichier d’entrée

Comme indiqué précédemment, pour produire une carte vous aurez besoin d’un simple fichier CSV (ou TSV). Il servira à renseigner les coordonnées géographiques des points et devra donc comporter au moins deux colonnes : latitude et longitude. S’agissant de représenter des données de recherche (en linguistique, dans le cas présent), il est bien entendu tout à fait pertinent de prévoir en plus de ça au moins une troisième colonne indiquant à quoi correspond chaque point (une ligne du tableau = un point sur la carte).

Le fichier d’entrée que j’ai utilisé pour l’exemple représente l’implantation des langues hmong-mien, à partir de données que j’ai récupérées sur Glottolog2. Puisque sur Glottolog les langues sont caractérisées par leur nom, mais aussi par un identifiant (qui permet notamment de retrouver la page qui leur est consacrée), il y a donc quatre colonnes : Name, ID, Latitude et Longitude.

Note : Le fichier HTML produit en sortie sera encodé en UTF-8, il est donc vivement recommandé d’utiliser un fichier d’entrée qui utilise le même encodage.

Fond de carte

La carte est une instance d’objet folium.Map(), qui prend en paramètre location les coordonnées sur lesquelles elle doit être centrée, sous forme d’une liste [latitude, longitude].

Le choix de ces coordonnées n’est pas forcément évident, d’autant plus qu’à ce stade on ne visualise pas encore la distribution des points. Il faudra éventuellement tâtonner, par exemple en choisissant pour débuter les coordonnées d’un lieu qui devrait a priori se trouver à proximité de certains points, voire les coordonnées d’un des points, récupérées dans le fichier d’entrée. Puis d’y revenir une fois que les points sont ajoutés, et réajuster jusqu’à obtenir l’aspect voulu si l’affichage par défaut de la carte n’est pas satisfaisant.

Ce couple de coordonnées est le seul paramètre obligatoire, mais vous pouvez paramétrer bien plus finement la carte: notamment choisir le niveau de zoom par défaut (zoom_start)3 ou sélectionner un fond de carte (tiles). C’est ce que j’ai fait dans l’exemple :

ma_carte = folium.Map(location=[25.6618, 108.533], zoom_start=6, tiles='Stamen Toner')

La liste des fonds de carte disponibles et autres paramètres se trouve sur cette page de la documentation de folium.

Déclaration d’une couche de données

Il faut maintenant créer une couche de données, sur laquelle les points seront placés et qui se superposera au fond de carte.

Il est possible d’ajouter les points directement à la carte sans passer au préalable par une couche de données. Dans l’exemple proposé ici, il n’y a qu’une seule série de points, ça ne changerait pas énormément. Si toutefois il y avait plusieurs séries de données/de points à représenter, leur consacrer des couches distinctes serait beaucoup plus efficace pour, entre autres, avoir des marqueurs d’aspects différents suivant les données, ou filtrer les couches à afficher ou non sur la carte en HTML4.

La couche de données est un objet folium.FeatureGroup() qui prend en paramètre name l’intitulé qu’on souhaite lui attribuer. Dans l’exemple, j’ai associé cet objet à la variable hmongmien.

Ajout des points

Le fichier d’entrée étant en CSV (ou TSV), il est très simple de le lire avec le module csv. C’est ce qui est fait ici, en utilisant csv.DictReader()5 :

lecteur = csv.DictReader(tableau, delimiter='\t')

Le paramètre delimiter doit bien sûr correspondre au séparateur utilisé dans le fichier, sinon les informations ne seront pas lues correctement.

Il suffit maintenant de créer une boucle qui va lire le fichier d’entrée ligne par ligne (ou plus exactement, l’objet DictReader() correspondant, ici appelé lecteur), et déclarer un point pour chaque ligne. La déclaration minimale d’un point est structurée comme suit :

folium.Marker([latitude, longitude]).add_to(nom_de_la_couche_de_donnees)

Comme pour le fond de carte, il faut au moins fournir les coordonnées sur lesquelles placer le point, mais d’autres options peuvent être paramétrées (diamètre du point, couleur, opacité…). Le marqueur par défaut est folium.Marker() mais il en existe d’autres ; ici j’ai choisi folium.CircleMarker() pour que mes points soient marqués par un cercle. Voici le code correspondant à la déclaration d’un point, tel qu’il figure dans le notebook téléchargeable :

folium.CircleMarker(
            [latitude, longitude],
            popup = f'{nom} (<a href="https://glottolog.org/resource/languoid/id/{identifiant}">{identifiant}</a>)',
            fill = True,
            fill_opacity = 0.6,
            color = 'blue',
            radius = 6
        ).add_to(hmongmien)

Les marqueurs seront donc ici des cercles (folium.CircleMarker()), de couleur bleue (color), avec un remplissage (fill) légèrement transparent (fill_opacity). C’est finalement assez intuitif.

Voici quelques précisions à propos de l’option popup utilisée ici :

  • J’indiquais dans la description du fichier d’entrée que les données provenaient de Glottolog, où chaque langue répertoriée est associée à un identifiant : cet identifiant permet de retrouver la page consacrée à une langue donnée, en passant par une URL dont la syntaxe est https://glottolog.org/resource/languoid/id/identifiant-de-la-langue.
  • Cet identifiant figure dans la colonne ID du fichier d’entrée. Il est donc possible de reconstituer l’URL de la page correspondante, pour chaque ligne du tableau. C’est ce qui a été fait ici avec https://glottolog.org/resource/languoid/id/{identifiant} (identifiant = ligne['ID'], pour chaque ligne du lecteur)6.
  • Puisque la carte produite en sortie est un fichier HTML, la valeur de popup peut être du HTML également, ce qui permet ici d’ajouter un lien vers l’URL reconstituée (cf ci-dessus).

Chaque point de la carte est cliquable, ce qui fait apparaître une étiquette comportant le nom de la langue, puis un lien vers la page Glottolog correspondante. Comme sur l’image suivante (ou sur la carte complète) :

Il est possible d’afficher l’étiquette au survol plutôt qu’au clic en remplaçant popup par tooltip7.

Les points sont maintenant ajoutés à la couche de données (ici nommée hmongmien) mais pas à la carte. Il est nécessaire d’ajouter la couche de données à la carte, simplement avec nom_de_la_couche.add_to(nom_de_la_carte), soit pour la couche hmongmien et la carte ma_carte :

hmongmien.add_to(ma_carte)

Si vous voulez ajouter plusieurs séries de points, vous pouvez répéter les étapes création de coucheajout de pointsajout de la couche à la carte autant de fois que nécessaire.

Sauvegarde de la carte dans un fichier HTML

La carte est terminée, il ne reste plus qu’à l’enregistrer, ce qui se fait simplement avec une ligne de code nom_de_la_carte.save('chemin_du_fichier_de_sortie.html'). Vous pourrez ensuite l’ouvrir avec le navigateur web de votre choix.

Si vous avez suivi le notebook sans le modifier et en utilisant le fichier d’entrée fourni en exemple, vous devriez obtenir cette carte (code source), enregistrée dans un fichier nommé carte_hmong-mien.html.

Citer ce billet : “Cartographier des données linguistiques avec Python – 1”, par Alexander Delaporte. Publié sur Tekipaki le 18/01/2021. Lien : https://tekipaki.hypotheses.org/1225.
  1. Sur Gitlab, vous pourrez lire le texte et le code du notebook mais les aperçus de la carte ne s’afficheront pas. Vous pouvez alors récupérer l’URL du notebook sur Gitlab et l’utiliser dans nbviewer. []
  2. Les données du fichier d’entrée (hmon1336.tsv) sont issues de la page Family: Hmong-Mien de Glottolog (Glottolog 4.3 par Hammarström, Harald & Forkel, Robert & Haspelmath, Martin & Bank, Sebastian sous licence Creative Commons Attribution 4.0 International License). []
  3. Comme pour les coordonnées, il faudra probablement faire quelques essais avant de trouver la meilleure valeur. []
  4. Je ne détaille pas ça ici, mais ce sera abordé dans un prochain article (08/02/2021 : voir cet article). []
  5. Si vous ne connaissez par le module csv et sa classe DictReader(), cet article vous apportera des explications. []
  6. Les valeurs des variables sont intégrées à la chaîne de caractères grâce à une f-string (documentation). []
  7. Ce que je vous déconseille fortement si votre étiquette comporte un lien, puisqu’il deviendrait alors très compliqué de cliquer dessus. []

Auteur/autrice : Alexander Delaporte

Ingénieur d'études au Centre de recherches linguistiques sur l'Asie Orientale et chercheur associé BnF 2019-2021

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.