title

Algorithmes OSMnx pour visualiser et analyser le réseau routier des principales villes françaises en modélisant les réseaux de transport, en calculant les statistiques et l'orientation moyenne avec les données d'OpenStreetMap et de l'API GoogleMaps.

87% des trajets s’effectuent sur les routes. Élément essentiel du maillage territorial, pour cette raison, nous étudierons le nouveaux algorithmes comme OSMnx nous présentent une série d'indicateurs qui aident à définir la logique spatiale et l'ordre urbain, révélant l'ordre et le désordre des rues, ainsi que les meilleures stratégies pour la dynamique du transport d'une ville. Dans cette opportunité, nous explorerons la ville de Paris en utilisant les données d'OpenStreetMap et OSMnx dans une première occasion de connaître le réseau routier et d'exécuter une modélisation des itinéraires basée sur les distances et l'impédance et enfin d'appliquer l'indicateur d'orientation des villes afin de quantifier la façon dont les réseaux routiers dans les villes françaises suivent une logique d’ordonnancement géométrique d’une grille unique ou son schéma est hétérogène.

Les ressources:

1.- Données de l'API OpenStreetMap pour télécharger des données depuis le réseau routier.

2.- Données Google Maps API pour télécharger les données d'altitude et les associer au réseau routier, pour développer notre modèle d'impédances, défini par la différence d'altitude des itinéraires.

3.- Appliquer l'algorithme OSMnx pour développer les modèles et définir les directions cardinales des axes routiers.

Sources

In [1]:
from api import APIKey 
import networkx as nx
import numpy as np
import osmnx as ox
import matplotlib.pyplot as plt
import pandas as pd
%matplotlib inline
import datetime
import pandas as pd
weight_by_length = False
ox.__version__
ox.config(log_console=True, use_cache=True)
ox.__version__
Out[1]:
'0.11.4'
In [2]:
# Nous extrayons les données associées à Paris
place = 'Paris'
place_query = {'city':'Paris', 'state':'Paris', 'country':'France'}
G = ox.graph_from_place(place_query, network_type='drive')
In [3]:
# Nous consultons les données de chaque nœud routier extrait à l'aide des données de l'API Google Elevation
G = ox.add_node_elevations(G, api_key=APIKey)
G = ox.add_edge_grades(G)

Nous calculons les variations de la pente du réseau routier

Nous utilisons les nœuds pour définir le réseau et nous prenons uniquement les valeurs uniques pour éviter de dupliquer les données et enfin calculer les valeurs de pourcentage de pente.

In [4]:
edge_grades = [data['grade_abs'] for u, v, k, data in ox.get_undirected(G).edges(keys=True, data=True)]
In [5]:
avg_grade = np.mean(edge_grades)
print('Pente moyenne du réseau routier à Paris  {} is {:.1f}%'.format(place, avg_grade*100))

med_grade = np.median(edge_grades)
print('Pente médiane du réseau routier à Paris {} is {:.1f}%'.format(place, med_grade*100))
Pente moyenne du réseau routier à Paris  Paris is 1.5%
Pente médiane du réseau routier à Paris Paris is 1.0%

Nous voyons qu'en moyenne la ville de Paris a une condition idéale pour le développement d'une infrastructure pour Ciclovia, maintenant nous allons visualiser le réseau développant un modèle d'impédance en raison de l'état des distances et de la différence d'altitude.

Visualiser les nœuds routiers et leur altitude

Ce sont les valeurs du violet de basse altitude et celles du jaune de plus haute altitude.

In [6]:
G_proj = ox.project_graph(G)
In [7]:
nc = ox.get_node_colors_by_attr(G_proj, 'elevation', cmap='plasma', num_bins=20)
fig, ax = ox.plot_graph(G_proj, fig_height=6, node_color=nc, node_size=12, node_zorder=2, edge_color='#dddddd')

Les valeurs d'altitude sont intégrées au réseau routier français pour visualiser notre modèle d'impédance

In [8]:
# Nous cartographions le réseau routier avec les valeurs d'altitude téléchargées
ec = ox.get_edge_colors_by_attr(G_proj, 'grade_abs', cmap='plasma', num_bins=100)
fig, ax = ox.plot_graph(G_proj, fig_height=6, edge_color=ec, edge_linewidth=0.8, node_size=0)

Nous exécutons le modèle d'impédance définissant un itinéraire pour calculer l'itinéraire le plus court et l'itinéraire avec la pente la plus basse

In [9]:
# sélectionnez un nœud d'origine et de destination et un cadre de sélection autour d'eux
origin = ox.get_nearest_node(G, (48.826955,2.366481))
destination = ox.get_nearest_node(G, (48.890483,2.337470))
bbox = ox.bbox_from_point((48.859661,2.333608), distance=5000, project_utm=True)
In [10]:
# Nous définissons notre modèle en fonction des variations de distance et de pente
def impedance(length, grade):
    penalty = grade ** 2
    return length * penalty


for u, v, k, data in G_proj.edges(keys=True, data=True):
    data['impedance'] = impedance(data['length'], data['grade_abs'])
    data['rise'] = data['length'] * data['grade']

Itinéraire le plus court:

In [14]:
route_by_length = nx.shortest_path(G_proj, source=origin, target=destination, weight='length')
fig, ax = ox.plot_graph_route(G_proj, route_by_length, bbox=bbox, node_size=0)