Custom OpenStreetMap data processing with osm2pgsql Flex backend

Osm2pgsql tool is quite famous in the OpenStreetMap community : it allows to transform raw OSM data into a ready-to-use PostgreSQL database. It is commonly used for setting up rendering or geocoding databases. People also use it to run various data analysis, which are made quite simple using extensions like PostGIS. However, for a quite long time, it was not so intuitive to fine tune osm2pgsql to go further. This is now past as Jochen Topf released a new « flex back-end » (still in experimental phase). This mode allows to configure how the database should look at the end of data process. In particular, you can process relations and copy tags they carry on other features like nodes or ways. Some documentation and examples are now available.

As I’m working on GeoDataMine (an easy-to-use OSM data extractor for local authorities), I was stuck on a very simple use case : getting street names from associatedStreet relations. In street numbers exports I was producing, street name were available when it was set as addr:street tag on nodes, but not when a node was a part of associatedStreet relation. This was frustrating : information exists, but you can’t access it. When Flex back-end was released, I was curious about if it allowed to solve this issue. TL;DR : it does ! Let’s get through my Flex journey.

Compiling osm2pgsql

First step is to make available latest osm2pgsql version available on your machine. If it is not (yet) available in your distribution repositories, you can compile it. Don’t be afraid, the process is quite straightforward. Just make sure you’re getting latest version (master branch of the Git repository).

Configuring Flex back-end

Next step is to create a Lua script to define what the database will look like after osm2pgsql import process. Some examples are available in the repository. I’m going for the compatible.lua file, as it mimics original back-end structure.


I want to have a rel_tags columns, similar to tags hstore but for storing all tags coming from relation. So, I just add a new column in my existing tables structure :

tables.point = osm2pgsql.define_table{
    columns = {
        { column = 'tags', type = 'hstore' },
        { column = 'rel_tags', type = 'hstore' },
        { column = 'way', type = 'point' }

Note that this will work for addresses, as each node will only be part of one associatedStreet relation. If you’re working with bus lines for example, you will need a database structure handling features being part of several relations of same type.

Relation tags > node table

Creating your custom tables is a really interesting new feature in this Flex back-end. Here, I will create a table to associate relation tags to a node ID. This can be done after other tables declaration :

tables.relation_node = osm2pgsql.define_relation_table(
    'planet_osm_relation_node', -- The name of the table
        { column = 'node_id', type = 'bigint' },
        { column = 'rel_tags', type = 'hstore' }
    } -- List of supplementary columns

We do this only for nodes, as ways will be processed using another mechanism.

Process stages for ways

Flex back-end offers to process ways and relations in two separate stages :

  • Stage 1 : default initial processing. Each OSM object is reviewed, but you can only access information concerning directly this object. For a node its tags and coordinates, for a way its tags and list of nodes, for a relation its tags and list of members. So no way to get relation tags when reviewing a node or way. But you can mark here a feature as needing a second review, after every feature has already been seen.
  • Stage 2 : marked features are viewed a second time. There, you can access global variables from your script where you have stored useful information. For example, for a way ID, all tags of relations it is a part of. You can then put these tags in the database for definitive storage. Note that features marking only works for ways and relations as now (that’s why I’m using the relation_node table above) !

So let’s use this system to store relation metadata in a global variable, then associate it to ways. First, we create an empty global variable (near the start of script) :

by_way_id = {}

Then, we set-up the two stages system in the way-processing function, near the start lines of this function :

-- Ways are processed in stage 2 to retrieve relation tags
if osm2pgsql.stage == 1 then

Everything put in this function after these lines will be executed only in stage 2. That’s where we will add the code to get relation metadata and store it into the rel_tags we created earlier. This can be done using these lines (to put before any :add_row call) :

-- If there is any data from relations, add it in
local d = by_way_id[]
if d then
    object.rel_tags = d

Everything is now ready for both nodes and ways.

Store in memory relations metadata

Now, we have to edit osm2pgsql.process_relation(object) function to define what we want to save in memory or in relation_node table. This will be done by looping through all members of each relation.

-- Go through all the members and store relation tags
for _, member in ipairs(object.members) do
    -- When member is a node
    if member.type == 'n' then
        -- We add metadata to relation_node table
        local d = {}
        copy_rel_tags(type, d, object)
        tables.relation_node:add_row({ node_id = member.ref, rel_tags = d })
    -- When member is a way
    elseif member.type == 'w' then
        -- We put metadata in by_way_id global variable
        if not by_way_id[member.ref] then
            by_way_id[member.ref] = {}
        local d = by_way_id[member.ref]
        copy_rel_tags(type, d, object)
-- Outside of the process_relation, you can make available
-- the copy_rel_tags function, which is an helper to merge
-- all tags coming from various relations
function copy_rel_tags(rel_type, d, object)
    for k,v in pairs(object.tags) do
        if k ~= "type" then
            d[rel_type .. '_' .. k] = v

So, we’re good : metadata is stored, ways processed in stage 2 will retrieve it. The complete Lua script is here (a bit different because less tags are used in my database compared to compatible.lua file). Let’s run osm2pgsql.

Launch osm2pgsql

Just run the osm2pgsql command using appropriate option to use Flex back-end :

osm2pgsql --create \
	-H localhost -U postgres -P 5432 -d mydb \
	--slim --drop \
	--style "my_flex_rules.lua" \
	--output=flex \

If you have Lua-related issues, they are most likely to be originating in your script. As I’m no Lua expert, I had to redo this several times before having the perfectly-working script. Once done, your database is ready to explore.

Database final processing

Connect to your PostgreSQL database. You will see the four tables you defined. Check that each of them has data and its columns filled. For our street names use case, we’re not done yet ! In fact, ways have their rel_tags filled, but not nodes (point table). Let’s run a SQL request to fill rel_tags columns in point table :

UPDATE planet_osm_point
SET rel_tags = a.rel_tags
    -- Merge all tags for a certain node
    SELECT node_id, array_to_string(array_agg(rel_tags),',')::hstore AS rel_tags
    FROM planet_osm_relation_node
    GROUP BY node_id
) a
WHERE a.node_id = osm_id; DROP TABLE planet_osm_relation_node;

At this point, you have your rel_tags columns filled everywhere. So now, we can get street names from both nodes and relations tag. For example :

    osm_id, "addr:housenumber",
    -- Take first not null value
    COALESCE(rel_tags->'associatedStreet_name', tags->'addr:street') AS street
FROM planet_osm_point
WHERE "addr:housenumber" IS NOT NULL;

Quite handy, right ?


I’m really glad the osm2pgsql development team has released this new feature. Even if Lua is not the programming language I use the most, it’s still relatively easy to create your own configuration file. The given examples are really useful, I hope more will be released in the future to cover more use cases. I was a bit disappointed by the two-stages system not being available for nodes, but it seems temporary and shown workaround works well. It will definitely make advanced reuses of OSM data easier for developers and data analysts. You should give it a try !

Looking for OpenStreetMap data expertise for your projects ? Contact me and let’s discuss !

Calculs d’itinéraires à grande échelle avec PgRouting

Les calculs d’itinéraires sont un type d’analyse spatiale très classique, permettant de connaître l’itinéraire le plus court d’un point A à un point B. Pour réaliser ces calculs, nous devons nous appuyer sur des données géographiques de bonne qualité. Cet article va vous présenter comment réaliser des calculs d’itinéraires à grande échelle simplement avec :

  • PostgreSQL, la base de données libre de référence pour les données relationnelles volumineuses
  • PostGIS, l’extension pour l’analyse géospatiale sur PostgreSQL
  • PgRouting, l’extension pour les calculs d’itinéraires sur PostgreSQL
  • OpenStreetMap, la base de données géographique mondiale de référence
  • Osm2PgRouting, l’outil d’import de données OpenStreetMap pour PgRouting
  • Osmium, un outil de traitement de données OpenStreetMap pour convertir le format de fichier, filtrer les données et découper en plusieurs zones.

Notez que d’autres outils existent pour réaliser des calculs d’itinéraires à grande échelle sur des réseaux complexes. Ces outils sont plus pertinents dans les cas d’usages classiques (calculs pour affichage sur une page web). Ici, utiliser PgRouting présente plusieurs avantages, notamment une mise en place simple (faible besoin en compétences d’administration système) et la gestion centralisée de toutes les données dans PostgreSQL.

Vue d’ensemble de la chaîne de traitement

Je passe volontairement sur l’installation des différents outils, qui est documenté sur leurs sites respectifs. L’installation dépend largement du système d’exploitation utilisé, mais reste la plus simple à mon avis sous GNU/Linux.

La logique de traitement que nous allons mettre en place est la suivante :

Extrait des données OpenStreetMap avec Geofabrik, découpage et filtre avec Osmium, import en base avec Osm2PgRouting, calcul d'itinéraire en base avec PgRouting

Commençons tout de suite par la récupération des données.

Télécharger un extrait OSM sur Geofabrik

Geofabrik est une société allemande spécialisée sur OpenStreetMap. Cette société propose des extraits quotidiens de la base OpenStreetMap, découpés par régions (continent, pays, région administrative). Vous pouvez donc télécharger la zone de votre choix, au format .osm.pbf (le plus compact et rapide à traiter). Ici, on récupère le fichier france-latest.osm.pbf.

Filtre thématique avec Osmium

L’outil d’import Osm2PgRouting est bien pratique, mais présente deux limitations qui ont leur importance dans le choix des traitements à mettre en place :

  • Il lit uniquement des fichiers OSM XML (format .osm)
  • Il charge l’intégralité des données d’entrée en mémoire vive pour réaliser son analyse avant import en base de données.

Nous devons donc nous assurer que les fichiers en entrée de cet outil soient les plus légers possibles. Heureusement, il est possible de réaliser l’import de manière progressive en découpant par zones géographiques distinctes nos données. C’est pourquoi on utilise l’outil Osmium : pour filtrer et découper le fichier PBF téléchargé en plusieurs fichiers OSM XML correspondants au réseau par zone géographique.

On commence donc par filtrer les données OpenStreetMap pour ne garder uniquement le réseau routier. À noter qu’il est possible de s’intéresser à d’autres réseaux (eau, électricité, gaz, Internet, chemins de fer…), à condition de changer quelques configurations. La commande pour filtrer avec Osmium est la suivante :

osmium tags-filter \
	france-latest.osm.pbf \
	w/highway=motorway,motorway_link,trunk,trunk_link,primary,primary_link,secondary,secondary_link,tertiary,tertiary_link,unclassified,residential \
	-f pbf,add_metadata=false \
	-o france-roads.pbf

On peut modifier les options de cette commande pour prendre par exemple toutes les routes (au lieu d’une sélection ici), ou justement sélectionner d’autres types d’objets. Le fichier en sortie france-roads.pbf contient donc uniquement le réseau routier.

Découpage géographique avec Osmium

Nous allons désormais découper ce fichier en plusieurs zones distinctes. Cette étape est fastidieuse car vous devez définir le découpage à mettre en œuvre. L’idée est d’avoir un fichier GeoJSON par zone distincte, plus un fichier JSON décrivant votre découpage pour Osmium. Pour vos zones, vous pouvez utiliser des découpages administratifs, ou créer une grille régulière avec QGIS. Au final, vous devez avoir :

  • Plusieurs fichiers GeoJSON, contenant chacun la géométrie de la zone concernée. On peut les nommer area_1.geojson, area_2.geojson, area_3.geojson
  • Un fichier de configuration global nommé areas.json

Pour ce fichier areas.json, il doit avoir la structure suivante :

	"directory": "/tmp/",
	"extracts": [
			"output": "area_1.osm",
			"polygon": {
				"file_name": "area_1.geojson",
				"file_type": "geojson"
			"output": "area_2.osm",
			"polygon": {
				"file_name": "area_2.geojson",
				"file_type": "geojson"
			"output": "area_3.osm",
			"polygon": {
				"file_name": "area_3.geojson",
				"file_type": "geojson"

Vous devez avoir autant d’objets dans le tableau extracts que vous avez de zone à prendre en compte. Chacun de ces objets permet de connaître le nom du fichier GeoJSON à utiliser, et le nom du fichier OSM XML en sortie. Une fois tous ces fichiers en place, vous pouvez lancer la commande Osmium suivante :

osmium extract -c areas.json france-roads.pbf

Après quelques instants, vos fichiers filtrés et découpés, au format XML, seront disponibles dans le dossier de sortie choisi. On peut désormais créer la base de données.

Création de la base de données PostgreSQL

On commence donc par mettre en place la base et ses extensions :


La base est désormais prête pour l’import des données. On utilise l’outil osm2pgrouting, qui transforme directement les données brutes OSM filtrées en données utilisables en base pour réaliser des calculs d’itinéraires. De nombreuses options sont disponibles, nous utiliserons ici les commandes suivantes :

# Import des premières zones
osm2pgrouting \
	-f /tmp/area_1.osm \
	-c /usr/local/share/osm2pgrouting/mapconfig_for_cars.xml \
	--tags \
	--addnodes \
	--no-index \
	-d osmroads -U postgres
# Import de la dernière zone (avec création des index)
osm2pgrouting \
	-f /tmp/area_n.osm \
	-c /usr/local/share/osm2pgrouting/mapconfig_for_cars.xml \
	--tags \
	--addnodes \
	-d osmroads -U postgres

La première commande est à répéter autant de fois que vous avez de zones lors du découpage. La dernière zone à importer utilise la seconde commande, qui lance la création des index en base de données. L’option --addnodes est essentielle pour permettre l’import progressif des données. Ces commandes peuvent prendre un certain temps à s’exécuter selon les capacités de votre machine.

Vous avez désormais à disposition une base prête à réaliser des calculs d’itinéraires pour automobile (principalement avec la table ways).

Calculer un premier itinéraire

L’extension PgRouting dispose de nombreuses fonctions pour réaliser toutes sortes de calculs. Ici, on va réaliser un premier calcul en utilisant l’algorithme A*. Il permet d’obtenir un chemin relativement court de manière efficace. Le calcul est à lancer en SQL de cette façon :

FROM pgr_bdAstar(
	'SELECT gid AS id, source, target, cost, reverse_cost, x1, y1, x2, y2 FROM ways', -- Requête de sélection
	2365623, -- ID noeud de départ
	1779025 -- ID noeud d'arrivée
) p;

La fonction pgr_bdAstar prend trois paramètres :

  • Une requête SQL, permettant de récupérer les chemins à prendre en compte. On peut ici par exemple filtrer certains chemins non-pertinents, ou changer les valeurs de coûts de traversée (cost et reverse_cost).
  • Deux identifiants de nœuds (point de départ et d’arrivée). Ceux-ci correspondent à la colonne id de la table ways_vertices_pgr. Ce sont les intersections et extrémités de chemins de votre réseau routier.

La requête va vous retourner ce type de réponse :

 seq | path_seq | node | edge | cost | agg_cost
   1 |        1 |    2 |    4 |    1 |        0
   2 |        2 |    5 |    8 |    1 |        1
   3 |        3 |    6 |    9 |    1 |        2
   4 |        4 |    9 |   16 |    1 |        3
   5 |        5 |    4 |    3 |    1 |        4
   6 |        6 |    3 |   -1 |    0 |        5
(6 ROWS)

Chaque ligne correspond à un point de passage sur le graphe routier. Le premier est le point de départ, le deuxième le premier nœud intermédiaire, le troisième est le deuxième nœud intermédiaire… Jusqu’au nœud d’arrivée. À noter que si la requête ne renvoie pas de résultats, c’est qu’aucun itinéraire n’a été trouvé entre les deux points précisés. On retrouve en colonnes l’ordre de passage, le nœud visité, le segment visité, le coût de traversée du segment, et enfin le coût agrégé de l’itinéraire. Ce type d’interrogation simple peut être réalisé graphiquement à l’aide de QGIS et PgRoutingLayer.

Si l’on souhaite obtenir un résultat plus concis, à savoir la géométrie du parcours et son coût total, on peut joindre la table ways au résultat et fusionner les segments :

SELECT ST_LineMerge(ST_Union(w.the_geom)) AS geom, MAX(a.agg_cost) AS total_cost
FROM pgr_bdAstar(
	'SELECT gid AS id, source, target, cost, reverse_cost, x1, y1, x2, y2 FROM ways', -- Requête de sélection
	2365623, -- ID noeud de départ
	1779025 -- ID noeud d'arrivée
) a
LEFT JOIN ways w ON a.edge != -1 AND w.gid = a.edge;

Voilà, vous avez créé votre premier itinéraire !

Aller plus loin

Grâce à ces quelques conseils, vous êtes désormais en mesure de réaliser des calculs d’itinéraires à grande échelle avec un ensemble de logiciels plutôt portables. Vous pouvez adapter ce scénario à différents cas d’usages, et par exemple :

  • Changer de type de réseau : électrique, hydrographique, piéton, vélo… Vous pouvez imaginer toutes sortes de cas d’usages. La seule contrainte est d’adapter le fichier mapconfig.xml de osm2pgrouting selon les attributs utilisés.
  • Réaliser des calculs d’itinéraires en lot. Les fonctions « Many to many » de PgRouting permettent de calculer de n’importe quel point de départ vers n’importe quel point d’arrivée. Si vous êtes sur une logique de combinaisons départ > arrivée plus restreinte, l’idéal est de passer sur une fonction PLPgSQL pour boucler sur vos combinaisons.

Envie d’être accompagné sur ce sujet ? Je vous propose des formations sur ces thématiques, ou contactez-moi pour que nous discutions de vos besoins précis.

Où sont les lieux cartographiés en intérieur sur OpenStreetMap ?

La cartographie d’intérieur sur OpenStreetMap est un vaste sujet, présent depuis des années au sein de la communauté. Par cartographie d’intérieur, on entend le fait de détailler l’architecture d’un bâtiment, niveau par niveau de manière précise : pièces, couloirs, escaliers, et les activités qui se déroulent dans chacun de ces espaces. Cela est rendu possible par un ensemble d’attributs (schéma « Simple Indoor Tagging« ) qui permettent d’indiquer sur chaque objet sa typologie (salle, espace, mur) et son étage (0 pour le rez-de-chaussée, 1 pour le 1er étage…).

Exemple simple de description de l’intérieur d’un centre commercial sur OpenStreetMap

La méthode de description est au final relativement simple. On s’attendrait alors que de très nombreux lieux soient ainsi décrits. Après tout, OSM est bien la base de données de référence sur d’autres thématiques, pourquoi pas celle-ci ? Malheureusement, ce n’est pas encore le cas.

Un monde à construire

Localisation des lieux cartographiés en intérieur

À ce jour, plus de 2500 bâtiments sont cartographiés en intérieur. Pour l’instant, l’essentiel des lieux renseignés se situe dans l’hémisphère Nord, en plus particulièrement en Europe. Une dynamique liée à la communauté, puisque le projet OpenStreetMap est né au Royaume-Uni et s’est d’abord diffusé à travers l’Europe.

Nombre de bâtiments cartographiés ramenés à la population

Si on compare à la population, la tendance se confirme. Le sujet prédomine en France, Allemagne, Autriche. Mention spéciale à l’île d’Åland, avec ses 9 bâtiments cartographiés pour 27000 habitants, ce qui en fait la région où le sujet s’est le plus répandu dans la population !

Nombre absolu de bâtiments cartographiés par pays

Si l’on regarde le nombre absolu de bâtiments renseignés, l’Allemagne et la France sont au coude-à-coude, suivi par les États-Unis. Ces chiffres sont probablement liés à l’activité de certaines structures autour du sujet. On peut citer les travaux de la SNCF Transilien en France ou de la American Printing House aux États-Unis, qui ont permis la cartographie de nombreux lieux sur OpenStreetMap.

Ces chiffres sont encourageants, mais restent au final épisodiques comparés aux nombres de lieux potentiels à cartographier :

  • Plus de 400 000 centres commerciaux
  • Environ 100 000 gares
  • Plus de 100 000 universités et établissements d’enseignement supérieurs

Pourquoi donc la communauté n’avance pas plus vite sur cette thématique ?

Un sujet qui traîne…

À cause des schémas

La première trace notable de la cartographie d’intérieur sur OpenStreetMap remonte à 2011. Une première proposition d’attributs nommée IndoorOSM est publiée. Elle introduit le tag buildingpart=* ainsi que l’utilisation de relations pour créer de la cohérence entre espaces, niveaux et bâtiment. Malgré les défauts de conception du schéma, celui-ci est utilisé en partie pour commencer à décrire l’intérieur des bâtiments. Ce n’est qu’en 2014 que le schéma Simple Indoor Tagging est publié, et propose une alternative plus simple à mettre en œuvre.

Bâtiments décrits en intérieur en suivant l’ancien schéma IndoorOSM

5 ans après, environ 260 bâtiments (1 sur 10) utilisent toujours l’ancien schéma IndoorOSM. Cette co-existence des deux schémas complexifie le rendu et la réutilisation des données d’intérieur.

À cause des outils

La cartographie d’intérieur pose un défi technique : gérer les niveaux. OpenStreetMap est une base de données à plat, représentant des données principalement en 2D. C’est la logique traditionnelle des cartes papiers puis numériques. Le problème est que notre monde est en 3D, il nous manque donc la représentation de la hauteur. Pour le schéma Simple Indoor Tagging, cela est géré simplement par l’attribut level=*. Il permet d’indiquer à quel étage se trouve un objet. Problème résolu ? Pas vraiment…

Comme l’ensemble des outils autour d’OSM fonctionne sur une logique 2D, leurs interfaces ne sont pas prévues pour gérer cette notion d’étage. Donc dès qu’un bâtiment est composé de plus d’un niveau, les données se superposent. On a donc un effet vrac du plus impressionnant.

Gare de l’Est à Paris : trop de données et pas assez de sélecteur de niveau

C’est d’autant plus frustrant que jusqu’à présent, l’ajout de données dans OpenStreetMap venait enrichir la carte et donc améliorer son rendu. Dans le cas de la cartographie d’intérieur, le rendu principal devient de moins en moins lisible au fur et à mesure que l’on détaille. Heureusement que des outils dédiés à la visualisation de ces données ont émergé au cours du temps (OpenLevelUp et OpenStationMap étant les deux seuls encore actifs).

C’était également le cas pour les éditeurs : tout se superposait sans possibilité de filtrer niveau par niveau. Sur ce point, la situation a récemment évolué :

  • JOSM, l’éditeur historique et le plus complet, dispose désormais d’un sélecteur de niveaux
  • OsmInEdit, un nouvel éditeur dédié à la cartographie d’intérieur, gère nativement le filtrage par niveau. Il propose de nombreux outils facilitant la contribution.
OsmInEdit, l’éditeur pour la cartographie d’intérieur

Ce manque d’outils et de visualisations a donc largement freiné la contribution sur la thématique.

À cause du cadre

Enfin, les derniers freins ne sont pas liés à OpenStreetMap, mais à la cartographie en intérieur de manière générale. Les systèmes de navigation type GPS ne sont pas disponibles dans l’enceinte des bâtiments (les signaux traversent mal les murs), ce qui rend complexe l’acquisition de données. On doit passer sur d’autres méthodes, à savoir :

  • Si on a les moyens, du matériel professionnel d’acquisition (LIDAR)
  • Sinon, papier + crayon + mètre (fastidieux) ou le décalquage depuis les plans d’évacuation ou d’architecte du bâtiment.
À Rennes, on cartographie les stations de métro avec papier + crayon

Sur OpenStreetMap, la grande majorité des contributions sont bénévoles, et donc se font avec relativement peu de moyens. La récolte de données complètement faite « à la main » avec notes et mesures est très fastidieuse, seuls les plus motivés s’y mettront. Par ailleurs, le contexte sécuritaire rend les relevés spontanés plus délicats, il vous faudra de bons arguments pour expliquer aux agents de sécurité pourquoi vous mesurez au centimètre près tout le bâtiment…

La contribution à partir de plans existants est largement plus accessible et plus rapide, mais pose la question des droits d’auteurs. Peut-on considérer un plan de bâtiment comme une création artistique qui tombe sous le joug du droit d’auteur ? Cette question n’a pas encore clairement été tranchée, et dépend des législations en vigueur dans chaque pays.

Ces contraintes pèsent donc fortement sur la simplicité de créer des données à l’intérieur des bâtiments.

Des solutions à envisager ?

Ces constats nous permettent de mettre en lumière les contraintes qui pèsent sur la cartographie d’intérieur dans OpenStreetMap. Maintenant, voyons comment on peut avancer concrètement pour lever ces freins.

Nettoyer les données

Localisation des éléments avec l’attribut buildingpart=*

Première proposition, qui sera probablement la plus simple à mettre en oeuvre : finaliser la migration des données de l’ancien vers le nouveau schéma. Prenons le temps de convertir ces 260 bâtiments renseignés avec le schéma IndoorOSM vers le modèle Simple Indoor Tagging. On peut partir sur une transition douce, en dupliquant les attributs, ou une migration plus « directe » en remplaçant les attributs. On peut également envisager d’ajouter des règles de validations dans les outils (MapCSS pour JOSM et Osmose) pour que la migration soit distribuée entre plusieurs contributeurs. Une ébauche de règles pour JOSM a été créée, à compléter et surtout éditer les règles pré-existantes pour prendre en compte les évolutions.

Améliorer nos outils

Pour que la contribution sur la cartographie d’intérieur prenne de l’ampleur, il faut remettre en place le cercle vertueux de contribution d’OpenStreetMap : je vois la carte, j’ajoute des données visiblement manquantes, la carte s’améliore, je trouve de nouveaux manques, j’ajoute à nouveau… Cela passe donc par des outils de visualisation et d’édition efficaces.

Pour l’édition, je ne peux que vous encourager à tester OsmInEdit et à prendre part à son évolution : c’est un outil à la fois simple à utiliser et adapté au contexte de la cartographie d’intérieur. Avoir un sélecteur de niveau dans l’éditeur iD serait également un plus.

Pour la visualisation, de gros efforts sont encore possibles :

  • Le rendu principal openstreetmap-carto devrait pouvoir afficher un rendu plus propre dans les lieux cartographiés en intérieur. Pour l’instant, les différentes demandes issues de la communauté n’ont pas trouvé d’écho.
  • Les applications telles que ou OsmAnd devraient pouvoir filtrer les données étages par étages dans les zones où les bâtiments décrits.
  • Les rendus web dédiés comme OpenLevelUp doivent s’améliorer pour être plus rapides et ergonomiques, et possiblement utilisables sur mobile.

L’absence d’outils de visualisation efficace est bloquante dans la mise en place du cercle vertueux de contribution. La communauté et les équipes de développement doivent se mobiliser pour avancer sur le sujet.

Simplifier la collecte terrain

Dernier point : la facilitation de la collecte terrain. Nous avons vu que les relevés peuvent se montrer fastidieux si l’on ne se base pas sur le plan d’évacuation du bâtiment. Clarifier la loi pour déterminer si ces plans sont soumis au droit d’auteur permettra de lever le doute actuel. On peut imaginer un travail en collaboration avec les services des pompiers, qui disposent dans certains cas des plans des bâtiments dans leur zone d’intervention.

On peut également envisager une autre approche : que les opérateurs des lieux recevant du public se chargent de la contribution sur OpenStreetMap. Cela présente plusieurs avantages :

  • Les opérateurs n’ont pas à diffuser leurs plans d’évacuation sous licence ouverte. La question de la propriété intellectuelle de ces plans ne se pose plus. De plus, l’opérateur garde la main sur les données diffusées (uniquement les espaces ouverts au public par exemple).
  • Chaque opérateur est au fait des changements qui ont lieu dans son bâtiment. Il sera plus simple de réaliser les mises à jour rapidement et garantir un bon suivi des données dans OpenStreetMap.
  • Il sera plus simple d’arriver rapidement à une couverture globale. Plutôt que la communauté de bénévoles se charge seule de l’ajout de ce type de données, chaque opérateur se charge de son établissement. De la même manière que le bénévole connaît bien sa rue, l’opérateur connaît bien son établissement et sera plus à même de le détailler rapidement.

Dans cette logique, la communauté et les professionnels autour d’OpenStreetMap doivent se mobiliser pour sensibiliser ces acteurs à cette thématique. Toutefois, les opérateurs de lieux recevant du public seront plus sensibles si la chaîne d’outils est complète et cohérente, sur la même logique que pour les contributeurs bénévoles.

En conclusion

Depuis les débuts de la cartographie d’intérieur sur OpenStreetMap en 2011, la communauté a largement progressé. Nous nous sommes dotés d’outils pour rendre possible l’ajout de ces données dans la base. Les premières initiatives à large échelle ont permis d’obtenir des retours concrets et pragmatiques sur la méthodologie. Il nous reste encore plusieurs étapes avant de devenir la base de référence en intérieur :

  • Améliorer nos outils, à la fois pour les contributeurs et les réutilisateurs
  • Lever les flous juridiques autour des plans d’évacuation des bâtiments
  • Embarquer dans l’aventure les gestionnaires de lieux recevant du public
La communauté sait y faire pour relever des défis de taille !

Mais ces défis ne doivent pas nous effrayer : en 15 ans, OSM a su s’imposer comme la base de données géographique de référence pour l’extérieur. Faisons la même chose pour l’intérieur des bâtiments 😉

Pic4Review : photos de rues et données ouvertes

Pic4Review est un éditeur facilitant la contribution à la carte collaborative OpenStreetMap. Il propose de renseigner des informations sur des objets géolocalisés à partir de photos de rues libres de droits. Lancé fin 2017, il a permis à des centaines de contributeurs d’améliorer la description de centaines de milliers d’objets à travers le monde. Le principe est simple : vous participez à des missions thématiques sur une zone donnée, et pour chaque objet les photos disponibles sont présentées. Cela vous permet de répondre facilement à une question posée.

Exemple de mission pour renseigner le type de marqueur signalant un gazoduc.

Au départ, l’outil se concentrait sur la mise à jour d’objets existants côté OpenStreetMap. La nouvelle version publiée le 2 avril 2019 permet désormais de créer de nouveaux points, et ainsi compléter la base OpenStreetMap.

Intégrer les détections automatiques d’objets

La collecte et mise à disposition de photos de rues n’est pas un sujet récent. Deux fournisseurs de photos ont cependant changé la donne : Mapillary et OpenStreetCam. Ces deux initiatives ont pour objectif de mettre à disposition des photos de rues du monde entier, sous licence libre. Au-delà des photos, les équipes travaillent à la détection et l’extraction automatique des objets visibles sur les photos. On pense en particulier aux panneaux routiers, mais cela concerne également marquages au sol, mobilier urbain, équipements techniques….

Détections automatiques de panneaux routiers (source : Mapillary)

Les localisations de ces objets sont intéressantes, mais comme ils sont détectés automatiquement, il peut y avoir quelques erreurs (objets confondus, pas d’objets…). Et par ailleurs, ces objets sont stockés dans des bases de données indépendantes. Pourtant, il serait plus intéressant de les rendre disponibles au sein de cette base commune qu’est OpenStreetMap.

Pour intégrer ces données tout en vérifiant leur pertinence, on s’appuie sur une validation humaine. Pic4Review facilite ce processus, et propose désormais de valider l’intégration des détections issues de Mapillary dans OpenStreetMap.

Intégration des détections de bornes incendies

Pour le contributeur c’est très simple : on se rend sur la page de la mission, et on visualise un premier objet. On vérifie sa présence sur les photos, sa bonne localisation à l’aide de la carte (on peut déplacer si besoin) et on valide l’intégration. Plutôt simple, non ?

Pour l’instant, une vingtaine de catégories d’objets sont disponibles : bornes incendies, poteaux électriques, boîtes aux lettres, panneaux routiers… Et d’autres seront ajoutées dans le futur.

Intégrer des données ouvertes (avec Osmose)

Osmose est un outil de la communauté OpenStreetMap permettant d’identifier de potentielles améliorations dans les données (nom mal écrit, rue isolée, description incohérente…). Il permet également la mise en relation de jeux de données ouvertes avec OpenStreetMap. Plusieurs types de données sont disponibles : points de recyclage, parkings à vélos, pharmacies, postes électriques… Les données manquantes côté OpenStreetMap sont rendues visibles sur une carte et proposées aux contributeurs.

Données ouvertes à intégrer sur différents sujets (il y a de quoi s’occuper !)

Sur le même principe que les détections automatiques, l’utilisation de photos pour vérifier et intégrer ces données a du sens. C’est pour cela que Pic4Review permet de facilement intégrer les données ouvertes listées par Osmose.

Mission d’intégration des postes électriques Enedis via Osmose et Pic4Review

Ici encore, la tâche est très simple pour le contributeur : on vérifie les photos, et on valide l’intégration si l’objet est visible. Rien de plus facile, cela rend possible l’ajout de dizaines d’objets très rapidement.

Lancez-vous !

Envie de lancer une mission sur votre zone de prédilection ? C’est simple : cliquez sur « Créer une mission » dans le bandeau d’en-tête de la page, choisissez « Créer à partir d’un modèle », choisissez le type de mission et la zone, et c’est parti !

Pour les contributeurs plus expérimentés, il est également possible de créer une mission complètement paramétrable. Créez votre mission « À partir de zéro », et vous accédez à l’outil complet pour définir une mission. Choisissez une source de données et une zone, ajoutez des détails sur les attendus de la mission, et validez ! Un peu plus long à mettre en place, mais vous avez le choix sur l’ensemble des configurations.

En résumé, Pic4Review facilite désormais l’ajout de données ouvertes structurées à OpenStreetMap. Les développements futurs auront pour objectif de faciliter davantage l’intégration de jeux de données ouverts, par exemple issus de portails open data de collectivités. À noter que l’outil étant libre, il peut être utilisé également dans des contextes d’enrichissement de bases de données privées au sein d’une entreprise / administration (contactez-moi pour en savoir plus).

Pour aller plus loin

Envie d’en savoir plus ? De contribuer au développement ? Voici quelques liens utiles :