osmnx-urban

name	osmnx-urban
description	Urban street network analysis with OSMnx: network statistics, centrality, isochrone/walkability analysis, POI extraction, and multi-city comparisons.
tags	["osmnx","urban-science","street-network","walkability","networkx","openstreetmap"]
version	1.0.0
authors	[{"name":"awesome-rosetta-skills contributors","github":"@awesome-rosetta-skills"}]
license	MIT
platforms	["claude-code","codex","gemini-cli","cursor"]
dependencies	["osmnx>=1.9.0","networkx>=3.1.0","numpy>=1.24.0","pandas>=2.0.0","geopandas>=0.14.0","matplotlib>=3.7.0","shapely>=2.0.0","scipy>=1.11.0"]
last_updated	2026-03-17

OSMnx Urban Street Network Analysis Skill

This skill covers the complete workflow for downloading, analysing, and visualising urban street networks using OSMnx — a Python package that retrieves OpenStreetMap data and models it as directed NetworkX graphs. The skill includes network statistics, centrality measures, isochrone generation for walkability assessment, point-of-interest (POI) extraction, routing, and systematic multi-city comparisons.

Urban morphology shapes how people move, access services, and experience cities. Street network analysis provides quantitative metrics that underpin urban planning, transport modelling, and public health research.

---

Setup

pip install osmnx networkx numpy pandas geopandas matplotlib shapely scipy
# On conda:
# conda install -c conda-forge osmnx

OSMnx fetches data from the Overpass API (OpenStreetMap). No API key is required, but heavy use should respect the Overpass rate limits by caching graphs locally.

---

Core Functions

"""
osmnx_urban.py
--------------
Core utilities for urban street network analysis with OSMnx and NetworkX.
"""

from __future__ import annotations

import warnings
import json
from pathlib import Path
from typing import Dict, List, Optional, Tuple, Union

import numpy as np
import pandas as pd
import geopandas as gpd
import networkx as nx
import osmnx as ox
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import matplotlib.colors as mcolors
 shapely.geometry  Point, Polygon, MultiPolygon
 scipy.spatial  cKDTree

warnings.filterwarnings(, category=FutureWarning)


ox.settings.use_cache = 
ox.settings.cache_folder = 
ox.settings.log_console = 






 () -> nx.MultiDiGraph:
    
     custom_filter:
        G = ox.graph_from_place(
            place_name, retain_all=retain_all,
            simplify=simplify, custom_filter=custom_filter,
        )
    :
        G = ox.graph_from_place(
            place_name, network_type=network_type,
            retain_all=retain_all, simplify=simplify,
        )
    G = ox.project_graph(G)
     G


 () -> nx.MultiDiGraph:
    
    G = ox.graph_from_point((lat, lon), dist=dist, network_type=network_type)
     ox.project_graph(G)


 () -> :
    
    ox.save_graphml(G, (path))
    ()


 () -> nx.MultiDiGraph:
    
     ox.load_graphml((path))






 () -> :
    
    basic = ox.basic_stats(G)
    stats = {
        : basic[],
        : basic[],
        : basic[],
        : basic[] / ,
        : basic[],
        : basic[],
        : basic.get(, np.nan),
    }

     extended:
        area_km2 = ox.project_graph(G)  
        
        nodes_gdf, _ = ox.graph_to_gdfs(G)
        hull = nodes_gdf.unary_union.convex_hull
        area_km2 = hull.area / 

        stats[] = (area_km2, )
         area_km2 > :
            stats[] = (
                stats[] / area_km2, 
            )
            stats[] = (stats[] / area_km2, )

        
        :
            stats[] = (
                ox.circuity_avg(G), 
            )
         Exception:
            stats[] = np.nan

        
        self_loops = (  u, v, _  G.edges  u == v)
        stats[] = (self_loops / (G.number_of_edges(), ), )

     stats






 () -> pd.DataFrame:
    
     measures  :
        measures = [, , , ]

    
    G_undirected = G.to_undirected()
    nodes_gdf, _ = ox.graph_to_gdfs(G)

    results = {: (G.nodes())}

       measures:
        deg = (G.degree(weight=weight))
        results[] = [deg.get(n, )  n  G.nodes()]

       measures:
        n_nodes = G.number_of_nodes()
        k_approx = (n_nodes, )  n_nodes >   
        bc = nx.betweenness_centrality(
            G_undirected, weight=weight, normalized=, k=k_approx, seed=
        )
        results[] = [bc.get(n, )  n  G.nodes()]

       measures:
        cc = nx.closeness_centrality(G_undirected, distance=weight)
        results[] = [cc.get(n, )  n  G.nodes()]

       measures:
        pr = nx.pagerank(G, weight=weight, alpha=)
        results[] = [pr.get(n, )  n  G.nodes()]

    df = pd.DataFrame(results).set_index()

    
    df = df.join(nodes_gdf[[, , ]])
     df






 () -> gpd.GeoDataFrame:
    
     (travel_time_min, (, )):
        travel_time_min = [travel_time_min]

    travel_time_min = (travel_time_min, reverse=)
    speed_m_per_min = speed_kph *  / 
    records = []

     t  travel_time_min:
        max_dist = t * speed_m_per_min
        subgraph = nx.ego_graph(G, center_node, radius=max_dist,
                                distance=, undirected=)
        node_points = [
            Point(data[], data[])
             _, data  subgraph.nodes(data=)
        ]
         (node_points) < :
            
         shapely.ops  unary_union
        region = gpd.GeoSeries(node_points).buffer(max_dist * )
        iso_poly = unary_union(region).convex_hull

        records.append({
            : t,
            : (subgraph.nodes),
            : iso_poly,
        })

    crs = G.graph.get(, )
     gpd.GeoDataFrame(records, crs=crs)






 () -> [, ]:
    
    node_id, dist = ox.distance.nearest_nodes(G, X=lon, Y=lat, return_dist=)
     node_id, dist






 () -> pd.DataFrame:
    
    cache_path = Path(cache_dir)
    cache_path.mkdir(exist_ok=)
    rows = []

     place  places_list:
        safe_name = place.replace(, ).replace(, )
        graphml_file = cache_path / 

        ()
         graphml_file.exists():
            G = load_network(graphml_file)
        :
            :
                G = get_city_network(place, network_type=network_type)
                save_network(G, graphml_file)
             Exception  e:
                ()
                

        stats = compute_network_stats(G, extended=)
        stats[] = place
        rows.append(stats)

    df = pd.DataFrame(rows).set_index()
     df