# From Road Network to Graph#

This section contains a non-exhaustive list of operations on geospatial data that you should familiarize yourself with. More information can be found by consulting the Tools and Python Libraries page or the respective libary’s API documentation.

## Creating a Graph from a named place#

Mathematically speaking, a graph can be represented by $$G$$, where

$$G=(V,E)$$

For a graph $$G$$, vertices are represented by $$V$$, and edges by $$E$$.

Each edge is a tuple $$(v,w)$$, where

$$w$$, $$v \in V$$

Weight can be added as a third component to the edge tuple.

In other words, graphs consist of 3 sets:

• vertices/nodes

• edges

• a set representing relations between vertices and edges

The nodes represent intersections, and the edges represent the roads themselves. A route is a sequence of edges connecting the origin node to the destination node.

osmnx can convert a text descriptor of a place into a networkx graph. Let’s use the University of Toronto as an example:

import osmnx

place_name = "University of Toronto"

# networkx graph of the named place

# Plot the graphs
osmnx.plot_graph(graph,figsize=(10,10)) (<Figure size 1000x1000 with 1 Axes>, <AxesSubplot:>)


The graph shows edges and nodes of the road network surrouding the University of Toronto’s St. George (downtown Toronto) campus. While it may look visually interesting, it extends a bit too far off campus, and lacks the context of the street names and other geographic features. Let’s restrict the scope of the network to 500 meters around the university, and use a folium map as a baselayer. We will discuss more about folium later in this section.

graph = osmnx.graph_from_address(place_name, dist=300)
osmnx.folium.plot_graph_folium(graph)

Make this Notebook Trusted to load map: File -> Trust Notebook

Suppose you want to get from one location to another on this campus.

Starting at the King Edward VII Equestrian Statue near Queen’s Park, you need to cut across the campus to attend a lecture at the Bahen Centre for Information Technology. Later in this section, you will see how you can calculate the shortest path between these two points.

For now, let’s plot these two locations on the map using ipyleaflet:

from ipyleaflet import *

# UofT main building
center=(43.662643, -79.395689)
# King Edward VII Equestrian Statue
source_point = (43.664527, -79.392442)
# Bahen Centre for Information Technology at UofT
destination_point = (43.659659, -79.397669)

m = Map(center=center, zoom=15)
m


Notice that the way we create maps in ipyleaflet is different from folium. For the latter, the code is as follows:

import folium
m = folium.Map(location=center, zoom_start=15)
m

Make this Notebook Trusted to load map: File -> Trust Notebook

## Extracting Graph Information#

Various properties of the graph can be examined, such as the graph type, edge (road) types, CRS projection, etc.

### Graph Type#

type(graph)

networkx.classes.multidigraph.MultiDiGraph


Note

You can read more about MultiDiGraph here.

### Edges and Nodes#

We can extract the nodes and edges of the graph as separate structures.

nodes, edges = osmnx.graph_to_gdfs(graph)


y x highway street_count geometry
osmid
21631731 43.664076 -79.398440 traffic_signals 4 POINT (-79.39844 43.66408)
24959527 43.664436 -79.396904 NaN 3 POINT (-79.39690 43.66444)
24959528 43.664687 -79.395701 NaN 3 POINT (-79.39570 43.66469)
24959535 43.663497 -79.400045 traffic_signals 4 POINT (-79.40004 43.66350)
24959542 43.665940 -79.401019 stop 3 POINT (-79.40102 43.66594)
edges.head(5)

osmid lanes name highway maxspeed oneway reversed length geometry access service width tunnel
u v key
21631731 389678033 0 277878927 3 St George Street tertiary 30 False True 12.829 LINESTRING (-79.39844 43.66408, -79.39840 43.6... NaN NaN NaN NaN
389678008 0 327452916 3 St George Street tertiary 30 False True 12.667 LINESTRING (-79.39844 43.66408, -79.39848 43.6... NaN NaN NaN NaN
389677903 0 10334990 3 Hoskin Avenue tertiary NaN False True 10.351 LINESTRING (-79.39844 43.66408, -79.39839 43.6... NaN NaN NaN NaN
389677893 0 126742589 3 Harbord Street tertiary 40 False True 14.564 LINESTRING (-79.39844 43.66408, -79.39847 43.6... NaN NaN NaN NaN
24959527 389678004 0 77720372 2 Devonshire Place residential 30 False False 8.867 LINESTRING (-79.39690 43.66444, -79.39694 43.6... NaN NaN NaN NaN

We can further drill down to examine each individual node or edge.

# Rendering the 2nd node
list(graph.nodes(data=True))

(24959527, {'y': 43.6644357, 'x': -79.3969038, 'street_count': 3})

# Rendering the 1st edge
list(graph.edges(data=True))

(21631731,
389678033,
{'osmid': 277878927,
'lanes': '3',
'name': 'St George Street',
'highway': 'tertiary',
'maxspeed': '30',
'oneway': False,
'reversed': True,
'length': 12.829})


### Street Types#

Street types can also be retrieved for the graph:

print(edges['highway'].value_counts())

footway                       898
service                        90
residential                    58
tertiary                       54
[footway, steps]               21
unclassified                   15
living_street                  14
pedestrian                     10
[footway, service]              4
steps                           4
[steps, footway]                3
secondary                       2
[footway, steps, corridor]      2
[footway, service, steps]       1
[steps, service, footway]       1
Name: highway, dtype: int64


### GeoDataFrame to MultiDiGraph#

GeoDataFrames can be easily converted back to MultiDiGraphs by using osmnx.graph_from_gdfs.

new_graph = osmnx.graph_from_gdfs(nodes,edges)
osmnx.plot_graph(new_graph,figsize=(10,10)) (<Figure size 1000x1000 with 1 Axes>, <AxesSubplot:>)


### Calculating Network Statistics#

We can see some basic statistics of our graph using osmnx.basic_stats.

osmnx.basic_stats(graph)

{'n': 421,
'm': 1177,
'k_avg': 5.59144893111639,
'edge_length_total': 32953.49499999998,
'edge_length_avg': 27.997871707731505,
'streets_per_node_avg': 3.02375296912114,
'streets_per_node_counts': {0: 0, 1: 62, 2: 1, 3: 228, 4: 126, 5: 3, 6: 1},
'streets_per_node_proportions': {0: 0.0,
1: 0.14726840855106887,
2: 0.0023752969121140144,
3: 0.5415676959619953,
4: 0.2992874109263658,
5: 0.007125890736342043,
6: 0.0023752969121140144},
'intersection_count': 359,
'street_length_total': 16663.342,
'street_segment_count': 594,
'street_length_avg': 28.05276430976431,
'circuity_avg': 1.0287183227563486,
'self_loop_proportion': 0.0}


We can also see the circuity average. Circuity average is the sum of edge lengths divided by the sum of straight line distances. It produces a metric > 1 that indicates how “direct” the network is (i.e. how much more distance is required when travelling via the graph as opposed to walking in a straight line).

# osmnx expects an undirected graph
undir = graph.to_undirected()
osmnx.stats.circuity_avg(undir)

1.0287183227563486


### Extended and Density Stats#

Density-based statistics requires knowing the area of the graph. To do this, the convex hull of the graph is required.

convex_hull = edges.unary_union.convex_hull
convex_hull import pandas
area = convex_hull.area
stats = osmnx.basic_stats(graph, area=area)
extended_stats = osmnx.extended_stats(graph,ecc=True,cc=True)
stats.update(extended_stats)

# Show the data in a pandas Series for better formatting
pandas.Series(stats)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Input In , in <cell line: 4>()
2 area = convex_hull.area
3 stats = osmnx.basic_stats(graph, area=area)
----> 4 extended_stats = osmnx.extended_stats(graph,ecc=True,cc=True)
5 stats.update(extended_stats)
7 # Show the data in a pandas Series for better formatting

AttributeError: module 'osmnx' has no attribute 'extended_stats'


Warning

extended_stats has already been deprecated from osmnx. In the absence of an alternative, you can access these metrics directly through networkx.

### CRS Projection#

You can also look at the projection of the graph. To find out more about projections, check out this section. Additionally, you can also reproject the graph to a different CRS.

edges.crs

<Geographic 2D CRS: EPSG:4326>
Name: WGS 84
Axis Info [ellipsoidal]:
- Lat[north]: Geodetic latitude (degree)
- Lon[east]: Geodetic longitude (degree)
Area of Use:
- name: World.
- bounds: (-180.0, -90.0, 180.0, 90.0)
Datum: World Geodetic System 1984 ensemble
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich

merc_edges = edges.to_crs(epsg=3857)
merc_edges.crs

<Projected CRS: EPSG:3857>
Name: WGS 84 / Pseudo-Mercator
Axis Info [cartesian]:
- X[east]: Easting (metre)
- Y[north]: Northing (metre)
Area of Use:
- name: World between 85.06°S and 85.06°N.
- bounds: (-180.0, -85.06, 180.0, 85.06)
Coordinate Operation:
- name: Popular Visualisation Pseudo-Mercator
- method: Popular Visualisation Pseudo Mercator
Datum: World Geodetic System 1984 ensemble
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich


### Shortest Path Analysis#

Let’s revisit our trip across campus from the statue in Queen’s Park to our lecture hall at the Bahen centre.

To calculate the shortest path, we first need to find the closest nodes on the network to our starting and ending locations.

import geopandas

X = [source_point, destination_point]
Y = [source_point, destination_point]
closest_nodes = osmnx.distance.nearest_nodes(graph,X,Y)

# Get the rows from the Node GeoDataFrame
closest_rows = nodes.loc[closest_nodes]

# Put the two nodes into a GeoDataFrame
od_nodes = geopandas.GeoDataFrame(closest_rows, geometry='geometry', crs=nodes.crs)
od_nodes

y x highway street_count geometry
osmid
390545921 43.665132 -79.394109 NaN 3 POINT (-79.39411 43.66513)
239055725 43.660783 -79.397878 NaN 3 POINT (-79.39788 43.66078)

Let’s find and plot the shortest route now!

import networkx

shortest_route = networkx.shortest_path(G=graph,source=closest_nodes,target=closest_nodes, weight='length')
print(shortest_route)

[390545921, 60654129, 60654119, 389678001, 389678002, 2143434369, 390550470, 127289393, 8277128565, 8277128566, 4920594801, 3996671922, 80927418, 7967019552, 127275360, 80927426, 2143468197, 2143468182, 55808564, 55808527, 130170945, 389677905, 389678182, 389677906, 50885141, 389678180, 1258706668, 2143436407, 1258706673, 2143402269, 2143402268, 1258706670, 239055725]

osmnx.plot_graph_route(graph,shortest_route,figsize=(15,15)) (<Figure size 1080x1080 with 1 Axes>, <AxesSubplot:>)


Now let’s try visualizing this on a leaflet map. We’ll use the ipyleaflet library for this. Graphs rendered in ipyleaflet tend to be very slow when there are many nodes. For this reason, the code will fall back to folium if there are more than 1,500 nodes in the graph (this particular graph should have ~1,090 nodes).

Let’s make a map that shows the above route, with both starting and ending nodes shows as markers.

import ipyleaflet
import networkx

def draw_route(G, route, zoom=15):
if len(G)>=1500:
# Too many nodes to use ipyleaflet
return osmnx.plot_route_folium(G=G,route=route)

# Calculate the center node of the graph
# This used to be accessible from extended_stats, but now we have to do it manually with a undirected graph in networkx
undir = G.to_undirected()
length_func = networkx.single_source_dijkstra_path_length
sp = {source: dict(length_func(undir, source, weight="length")) for source in G.nodes}
eccentricity = networkx.eccentricity(undir,sp=sp)
center = networkx.center(undir,e=eccentricity)

# Create the leaflet map and center it around the center of our graph
G_gdfs = osmnx.graph_to_gdfs(G)
nodes_frame = G_gdfs
ways_frame = G_gdfs
center_node = nodes_frame.loc[center]
location = [center_node.y,center_node.x]
m = ipyleaflet.Map(center=location, zoom=zoom)

# Get our starting and ending nodes
start_node = nodes_frame.loc[route]
end_node = nodes_frame.loc[route[-1]]
start_xy = [start_node.y, start_node.x]
end_xy = [end_node.y,end_node.x]

# Add both nodes as markers

for u,v in zip(route[0:],route[1:]):
try:
x,y = (ways_frame.query(f'u == {u} and v == {v}').to_dict('list')['geometry']).coords.xy
except:
x,y = (ways_frame.query(f'u == {v} and v == {u}').to_dict('list')['geometry']).coords.xy

points = map(list, [*zip([*y],[*x])])
ant_path = ipyleaflet.AntPath(
locations = [*points],
dash_array=[1, 10],
delay=1000,
color='#7590ba',
pulse_color='#3f6fba'
)

return m
draw_route(graph, shortest_route)


## Retrieve buildings from named place#

Just like our graph above, we can also retrieve all the building footprints of a named place.

# Retrieve the building footprint, project it to match our previous graph, and plot it.
buildings = buildings.to_crs(edges.crs)
osmnx.plot_footprints(buildings) (<Figure size 576x576 with 1 Axes>, <AxesSubplot:>)


Now that we have the building footprints for the campus, let’s plot that shortest route again.

First, get the nodes from the shortest route, create a geometry from it, and then visualize building footprints, street network, and shortest route all on one plot.

from shapely.geometry import LineString

# Nodes of our shortest path
route_nodes = nodes.loc[shortest_route]

# Convert the nodes into a line geometry
route_line = LineString(list(route_nodes.geometry.values))

# Create a GeoDataFrame from the line
route_geom = geopandas.GeoDataFrame([[route_line]], geometry='geometry', crs=edges.crs, columns=['geometry'])

# Plot edges and nodes
ax = edges.plot(linewidth=0.75, color='gray', figsize=(15,15))
ax = nodes.plot(ax=ax, markersize=2, color='gray') 