Street Networks with OSMnx

Real-world street networks encode the spatial structure of cities. Using OSMnx, we can download actual OpenStreetMap data, convert it to NetworkX graphs, and compute network metrics that reveal fundamental properties of urban form -- from grid cities to organic medieval layouts.

1. Street Networks as Graphs

A street network is naturally represented as a graph $G = (V, E)$ where:

Nodes $V$: intersections and dead-ends
Edges $E$: street segments connecting intersections

For a directed graph (one-way streets), the adjacency matrix $\mathbf{A}$ has entries:

$$A_{ij} = \begin{cases} 1 & \text{if edge } (i, j) \in E \\ 0 & \text{otherwise} \end{cases}$$

OSMnx (Boeing, 2017) automates downloading OpenStreetMap data and constructing the primal graph representation. It handles:

Simplification: merging degree-2 nodes into single edges
Projection: converting lat/lon to local planar coordinates (UTM)
Topology cleaning: removing self-loops and parallel edges
Directionality: preserving one-way street information

2. Fundamental Network Metrics

Several metrics characterise the structure of a street network:

Node Degree

The degree $k_i$ of node $i$ counts its edges (streets meeting at that intersection):

$$k_i = \sum_j A_{ij}, \qquad \bar{k} = \frac{1}{|V|}\sum_i k_i = \frac{2|E|}{|V|}$$

Grid cities (e.g., Manhattan) have $\bar{k} \approx 4$; suburban cul-de-sac networks have $\bar{k} \approx 2.5$.

Betweenness Centrality

Measures how often a node lies on shortest paths between other nodes:

$$C_B(v) = \sum_{s \neq v \neq t} \frac{\sigma_{st}(v)}{\sigma_{st}}$$

where $\sigma_{st}$ is the total number of shortest paths from $s$ to $t$, and $\sigma_{st}(v)$ is how many pass through $v$. High-betweenness nodes are critical for network flow -- removing them causes maximum disruption.

Network Density

The proportion of possible edges that actually exist:

$$\rho = \frac{|E|}{|V|(|V|-1)/2}$$

Street networks are extremely sparse: $\rho \ll 1$because each intersection connects to only a handful of streets.

Circuity

The ratio of network distance to Euclidean distance:

$$\text{circuity} = \frac{1}{|P|}\sum_{(s,t) \in P} \frac{d_{\text{network}}(s,t)}{d_{\text{Euclidean}}(s,t)}$$

Perfect grids have circuity $\approx 1.27$ (the expected Manhattan distance ratio); winding medieval layouts can reach $> 1.5$.

3. Degree Distribution and Urban Form

The degree distribution $P(k)$ reveals the planning philosophy of a city. Unlike social networks (which are scale-free with $P(k) \sim k^{-\gamma}$), street networks are narrowly distributed:

$$P(k) \approx \begin{cases} \text{peaked at } k=3,4 & \text{grid cities} \\ \text{peaked at } k=1,3 & \text{suburban/cul-de-sac} \\ \text{broad, } k=3\text{--}6 & \text{organic/medieval} \end{cases}$$

The proportion of 4-way intersections ($k = 4$) versus 3-way T-junctions ($k = 3$) is a strong indicator of grid planning. Boeing (2019) found that $P(k=4)/P(k=3)$ ranges from ~0.1 in suburban sprawl to ~2.0 in planned grid cities.

4. Python: Network Analysis with Synthetic Graph

We generate a synthetic street network (grid + random perturbation to mimic a real city) and compute all key metrics. This demonstrates the analysis pipeline that would be applied to real OSMnx data.

Street Network Analysis: Metrics and Visualisation

Python

script.py130 lines

import numpy as np
import matplotlib.pyplot as plt
import networkx as nx

np.random.seed(42)

# --- Build a synthetic street network (perturbed grid) ---
grid_size = 15
G = nx.grid_2d_graph(grid_size, grid_size)

# Convert to regular graph with positions
pos = {}
for node in G.nodes():
    # Add small random perturbation to mimic organic layout
    pos[node] = (node[0] + 0.15 * np.random.randn(),
                 node[1] + 0.15 * np.random.randn())

# Add some diagonal shortcuts (mimicking real cities)
for _ in range(25):
    i, j = np.random.randint(0, grid_size - 1, 2)
    n1 = (i, j)
    n2 = (i + 1, j + 1)
    if n1 in G.nodes() and n2 in G.nodes():
        G.add_edge(n1, n2)

# Remove some edges randomly (mimicking dead ends, parks)
edges_to_remove = []
for e in list(G.edges()):
    if np.random.random() < 0.08:
        edges_to_remove.append(e)
G.remove_edges_from(edges_to_remove)

# Keep only largest connected component
largest_cc = max(nx.connected_components(G), key=len)
G = G.subgraph(largest_cc).copy()
pos = {n: pos[n] for n in G.nodes()}

# --- Compute metrics ---
n_nodes = G.number_of_nodes()
n_edges = G.number_of_edges()
degrees = [d for _, d in G.degree()]
avg_degree = np.mean(degrees)
density = nx.density(G)

# Betweenness centrality
bc = nx.betweenness_centrality(G)
bc_values = list(bc.values())

# Clustering coefficient
clustering = nx.average_clustering(G)

# Average shortest path (sample for speed)
if nx.is_connected(G):
    sample_nodes = list(G.nodes())[:50]
    path_lengths = []
    for s in sample_nodes:
        lengths = nx.single_source_shortest_path_length(G, s)
        path_lengths.extend(lengths.values())
    avg_path = np.mean(path_lengths)
else:
    avg_path = float('nan')

# --- Degree distribution ---
degree_counts = {}
for d in degrees:
    degree_counts[d] = degree_counts.get(d, 0) + 1

# --- Plot ---
fig, axes = plt.subplots(2, 2, figsize=(14, 12))

# Top left: Network with betweenness centrality coloring
ax = axes[0, 0]
bc_arr = np.array([bc[n] for n in G.nodes()])
node_colors = plt.cm.YlGn(bc_arr / bc_arr.max())
nx.draw_networkx_edges(G, pos, ax=ax, edge_color='#334155', width=0.8, alpha=0.6)
nx.draw_networkx_nodes(G, pos, ax=ax, node_size=30, node_color=bc_arr,
                       cmap=plt.cm.YlGn, vmin=0, vmax=bc_arr.max())
ax.set_title('Street Network (colored by betweenness)', fontsize=12, color='white')
ax.set_aspect('equal')
ax.tick_params(colors='white')

# Top right: Degree distribution
ax = axes[0, 1]
ks = sorted(degree_counts.keys())
counts = [degree_counts[k] / n_nodes for k in ks]
ax.bar(ks, counts, color='#10b981', edgecolor='#064e3b', alpha=0.8)
ax.set_xlabel('Degree k', fontsize=12, color='white')
ax.set_ylabel('P(k)', fontsize=12, color='white')
ax.set_title('Degree Distribution', fontsize=12, color='white')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2, axis='y')

# Bottom left: Betweenness distribution
ax = axes[1, 0]
ax.hist(bc_values, bins=40, color='#06b6d4', edgecolor='#0e7490', alpha=0.8, density=True)
ax.set_xlabel('Betweenness Centrality', fontsize=12, color='white')
ax.set_ylabel('Density', fontsize=12, color='white')
ax.set_title('Betweenness Centrality Distribution', fontsize=12, color='white')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2)

# Bottom right: Summary statistics
ax = axes[1, 1]
ax.axis('off')
stats_text = f"""Network Statistics
{'='*35}
Nodes:              {n_nodes}
Edges:              {n_edges}
Average degree:     {avg_degree:.2f}
Network density:    {density:.4f}
Clustering coeff:   {clustering:.4f}
Avg path length:    {avg_path:.2f}
Max betweenness:    {max(bc_values):.4f}
P(k=3):            {degree_counts.get(3,0)/n_nodes:.3f}
P(k=4):            {degree_counts.get(4,0)/n_nodes:.3f}
4-way/3-way ratio:  {degree_counts.get(4,0)/(degree_counts.get(3,0)+1e-10):.3f}"""

ax.text(0.1, 0.9, stats_text, transform=ax.transAxes, fontsize=12,
        verticalalignment='top', fontfamily='monospace', color='#10b981',
        bbox=dict(boxstyle='round', facecolor='#0f172a', edgecolor='#10b981', alpha=0.8))
ax.set_title('Summary', fontsize=12, color='white')

fig.patch.set_facecolor('#0f172a')
for ax_row in axes:
    for ax in ax_row:
        ax.set_facecolor('#0f172a')
plt.tight_layout()
plt.savefig('output.png', dpi=130, bbox_inches='tight', facecolor='#0f172a')
plt.show()
print(f"Network: {n_nodes} nodes, {n_edges} edges, avg degree {avg_degree:.2f}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

5. Patterns Across Cities

Comparative analysis of street networks reveals systematic differences in urban form:

Grid cities (Manhattan, Barcelona): high proportion of 4-way intersections, low circuity (~1.3), regular degree distribution peaked at $k=4$
Organic cities (London, Tokyo): broader degree distribution, higher circuity (~1.5), more 3-way intersections
Suburban networks: many dead-ends ($k=1$), tree-like structure, very high circuity, low connectivity

The orientation entropy of a network measures how uniformly street bearings are distributed. For a grid city with streets aligned to cardinal directions, the bearing distribution has four sharp peaks and low entropy. For organic cities, bearings are more uniformly distributed with higher entropy.

← Part VI Overview Spectral Analysis →