User:Didier2020/Correction Batiment chevauchants

From OpenStreetMap Wiki
Jump to: navigation, search

merci a osmose pour osmsax.py et a Bruno Cortial qui m'a inspiré

Les bâtiments chevauchants sont détectés par Osmose

Les 21 septembre 2012, l'"explosion" des erreurs est due à la nouvelle analyse Osmose: interstice

Langage et modules utilisés

  • Linux et Python
  • Le langage est Python, car la lecture des données OSM se fait grâce a OsmSax.py (un module d'Osmose disponible sur gitorious)
  • Shapely permet de manipuler les objets géométrique
  • Rtree est un index spatial et permet ici de rechercher tous les bâtiments aux abords
  • le script est déposé https://gitorious.org/building4osm

Principe de correction des bâtiments chevauchants par calcul d'intersection

  • Télécharger les données OSM

Utilisation de https://github.com/werner2101/python-osm/blob/master/src/osm/multipolygon.py pour créer un fichier JOSM vide d'une commune

  • depuis les modification OSMF redaction account, validation JOSM puis purger les nodes orphelins
  • Première lecture du fichier OSM, et ajout de tags temporaires pour marquer les ways (contenant le tag building) qu'il ne faut pas traiter : chevauchements trop importants, polygone non valide (ayant moins de 3 nodes, se coupant ou non fermé)
  • Pour tous les bâtiments
    • recherche de tous les bâtiments aux abords
    • vérification s'ils se chevauchent (layer identique, pas de mapping indoor, pas de bâtiment qu'il ne faut pas traiter)
      • Calcul des deux nouvelles surfaces, vérification que la correction est valide
      • Ajout d'un tag temporaire sur les 2 ways et modification de la description des ways
      • Ajout des nouveaux noeuds
  • Écriture du fichier corrigé
  • Avec JOSM
    • corrections manuelles des ways ayant le tag temporaire identifiant une erreur
    • suppression des tags temporaires
    • grâce à la validation JOSM, suppression des nodes non utilisés

Correction par projection

Projection orthogonale d'un point sur un segment. Cela corrige les intersections et les interstices. Cela correspond avec JOSM aux touches L (alignement) et J (joindre).

Un peu de théorie:

  • Comprendre les modèles dimentionnels des objets de-9im
  • utilisation de shapely

Problèmes rencontrés

Pour la correction par intersection

  • Définir ce qui est corrigeable automatiquement ou pas:
    • pas de traitement des relations bâtiments (surfaces complexes)
    • filtrer les types d'intersections : utilisation de Python-Shapely avec le filtre de-9im "212101212","212111212"
    • critère de (non)correction : z1 et z2 étant les surfaces (m²) des bâtiments
      • (z1+z2) * (1-taux) < z1Uz2 < (z1+z2) * (1+taux)
      • (100+100) * 0.95 < 101 < (100+100) * 1.05 -> ne pas corriger
      • (80+20) * 0.95 < 101 < (80+20) * 1.05
      • (80+20) * 0.95 < 98 < (80+20) * 1.05
  • Les corrections génèrent des polygones invalides:
    • c'était dû a la précision des coordonnées. Un polygone corrigé (sans arrondi des coordonnées) devenait incorrect après upload (arrondi à 7 décimales).
    • Conversion des flottants en texte, arrondi à 7 caractères après le point, puis conversion en flottant à chaque correction.
  • Le traitement était trop long
    • Le script initial était une double boucle sur tous les ways. Pour chaque way, vérifier sur tous les way s'il y a une intersection.
    • Utilisation de rtree afin de ne faire une recherche qu'aux abords du way (par bbox du way).
  • Shapely permet de travailler avec des objets graphiques. Quand on modifie un objet, comment réattribuer le numéro de node existant ou en attribuer un nouveau ? Utilisation de tables de correspondance (id du node, coordonnées) et (coordonnées, id du node).
  • quel bâtiment modifier ?
    • le bâtiment contenant plus de points que l'autre aura des nodes en plus, l'autre aura sa surface réduite, et des nodes seront à supprimer dans JOSM (validator).
    • si le nombre de points est égal, c'est celui qui a la plus grande surface.
  • utilisation de plusieurs méthode pour corriger les intersections (s1 et s2 étant les deux bâtiments)
    • méthode 1
      • i1=s2.difference(s1)
      • i2=s2.intersection(s1)
      • i3=s1.difference(s2)
      • i4=i1.union(i2)
      • nouveau s1 = i3
      • nouveau s2 = i4
    • méthode 2
      • i2=s2.difference(s1)
      • nouveau s1 = s1 (inchangé)
      • nouveau s2 = i2

Pour la correction par projection orthogonale

  • Optimisation : utilisation de rtree afin de ne faire une recherche qu'aux abords d'un segment du way (par bbox du segment)
  • critère de (non) correction: distance entre un node et un segment : 0.5e-6
  • La correction génère des dupes nodes: fusionner les nodes et modifier la description des ways
  • La correction génère des polygones invalides : fusionner les nodes et modifier la description des ways

Utilisation d'Osmose

J'utilise des analyses Osmose (osmose.openstreetmap.fr) spécifiques afin de détecter des erreurs avant d'uploader les données. Un script Python lit les fichiers xml des erreurs, et ajoute un tag temporaire dans les fichiers pour pouvoir les corriger dans JOSM ; par exemple, la fusion des bâtiments morcelés.


Comment corriger tous les cas de chevauchements

  • ce que le script ne sait pas faire : aligner deux murs qui ne sont pas parallèles
  • JOSM avec les touches j l g ...