科研 Skill
城市路网OSMnx分析
osmnx-urban
Analyzes urban street networks with OSMnx: network statistics, centrality, isochrone/walkability, and multi-city comparison. Use for street-network or walkability research.
SKILL.md
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
from shapely.geometry import Point, Polygon, MultiPolygon
from scipy.spatial import cKDTree
warnings.filterwarnings("ignore", category=FutureWarning)
# Configure OSMnx caching (avoids redundant API calls)
ox.settings.use_cache = True
ox.settings.cache_folder = "osmnx_cache"
ox.settings.log_console = False
# ---------------------------------------------------------------------------
# 1. Download Street Network
# ---------------------------------------------------------------------------
def get_city_network(
place_name: str,
network_type: str = "walk",
simplify: bool = True,
retain_all: bool = False,
custom_filter: Optional[str] = None,
) -> nx.MultiDiGraph:
"""
Download an OSM street network for a named place or area.
Parameters
----------
place_name : str
Geocodable place name, e.g. 'Manhattan, New York, USA' or
'Amsterdam, Netherlands'. OSMnx uses Nominatim for geocoding.
network_type : str
Type of network edges to include:
- 'walk' : pedestrian-accessible streets and paths
- 'drive' : driveable roads (no pedestrian-only ways)
- 'bike' : cyclable edges
- 'all' : all OSM ways (including private)
- 'all_public': all publicly accessible ways
simplify : bool
If True (default), simplify the graph topology by removing nodes of
degree 2 (intermediate nodes on straight roads). Keeps only true
intersections and dead-ends.
retain_all : bool
If True, retain all subgraphs including disconnected components.
Default False (keeps only the largest strongly connected component).
custom_filter : str, optional
Custom OSM filter string, e.g.
'["highway"~"motorway|trunk|primary"]'.
Returns
-------
nx.MultiDiGraph
Projected (UTM) street network graph. Node attributes include
'x', 'y' (UTM coords) and 'lat', 'lon' (WGS84). Edge attributes
include 'length' (metres), 'highway', 'oneway', 'maxspeed', etc.
Examples
--------
>>> G = get_city_network("Barcelona, Spain", network_type="walk")
>>> G_drive = get_city_network("Seoul, South Korea", network_type="drive")
"""
if custom_filter:
G = ox.graph_from_place(
place_name, retain_all=retain_all,
simplify=simplify, custom_filter=custom_filter,
)
else:
G = ox.graph_from_place(
place_name, network_type=network_type,
retain_all=retain_all, simplify=simplify,
)
G = ox.project_graph(G)
return G
def get_network_from_point(
lat: float,
lon: float,
dist: int = 1000,
network_type: str = "walk",
) -> nx.MultiDiGraph:
"""
Download a network within ``dist`` metres of a lat/lon point.
Useful when a named place is ambiguous or too large.
"""
G = ox.graph_from_point((lat, lon), dist=dist, network_type=network_type)
return ox.project_graph(G)
def save_network(G: nx.MultiDiGraph, path: Union[str, Path]) -> None:
"""Save a graph to a GraphML file for later reuse."""
ox.save_graphml(G, str(path))
print(f"Saved network to {path}")
def load_network(path: Union[str, Path]) -> nx.MultiDiGraph:
"""Load a previously saved GraphML network."""
return ox.load_graphml(str(path))
# ---------------------------------------------------------------------------
# 2. Network Statistics
# ---------------------------------------------------------------------------
def compute_network_stats(
G: nx.MultiDiGraph,
extended: bool = True,
) -> Dict:
"""
Compute a comprehensive set of network statistics.
Parameters
----------
G : nx.MultiDiGraph
Projected OSMnx street network.
extended : bool
If True, compute additional circuity and intersection density metrics.
These are slower for large networks.
Returns
-------
dict with keys (subset):
n - number of nodes (intersections + dead-ends)
m - number of edges (street segments)
k_avg - average node degree
edge_length_total - total street length (m)
edge_length_avg - mean edge length (m)
street_density - km of street per km² of convex hull
intersection_density- intersections per km²
circuity_avg - ratio actual/straight-line distance (1.0 = perfect grid)
self_loop_proportion- fraction of edges that are self-loops
clean_intersection_count - count of true intersections (degree >= 3)
Examples
--------
>>> G = get_city_network("Vienna, Austria")
>>> stats = compute_network_stats(G)
>>> print(f"Avg circuity: {stats['circuity_avg']:.3f}")
"""
basic = ox.basic_stats(G)
stats = {
"n": basic["n"],
"m": basic["m"],
"k_avg": basic["k_avg"],
"edge_length_total_km": basic["edge_length_total"] / 1000,
"edge_length_avg_m": basic["edge_length_avg"],
"streets_per_node_avg": basic["streets_per_node_avg"],
"intersection_count": basic.get("intersection_count", np.nan),
}
if extended:
area_km2 = ox.project_graph(G) # already projected
# Compute convex hull area from node positions
nodes_gdf, _ = ox.graph_to_gdfs(G)
hull = nodes_gdf.unary_union.convex_hull
area_km2 = hull.area / 1e6
stats["area_km2"] = round(area_km2, 4)
if area_km2 > 0:
stats["street_density_km_per_km2"] = round(
stats["edge_length_total_km"] / area_km2, 2
)
stats["node_density_per_km2"] = round(stats["n"] / area_km2, 1)
# Circuity
try:
stats["circuity_avg"] = round(
ox.circuity_avg(G), 4
)
except Exception:
stats["circuity_avg"] = np.nan
# Self-loops
self_loops = sum(1 for u, v, _ in G.edges if u == v)
stats["self_loop_proportion"] = round(self_loops / max(G.number_of_edges(), 1), 4)
return stats
# ---------------------------------------------------------------------------
# 3. Centrality Analysis
# ---------------------------------------------------------------------------
def compute_centrality(
G: nx.MultiDiGraph,
measures: List[str] = None,
weight: str = "length",
) -> pd.DataFrame:
"""
Compute node-level centrality measures on the street network.
Parameters
----------
G : nx.MultiDiGraph
Projected network. For large cities, use a subgraph or coarsen first.
measures : list of str, optional
Centrality measures to compute. Defaults to
['betweenness', 'closeness', 'pagerank', 'degree'].
weight : str
Edge attribute to use as weight ('length' for distance-weighted).
Returns
-------
pd.DataFrame
One row per node (indexed by OSM node ID), columns for each measure.
Merged with node lat/lon for spatial plotting.
Notes
-----
Betweenness centrality is O(n * m) and can be slow for networks with
> 10,000 nodes. Use ``nx.betweenness_centrality`` with ``k`` argument
for approximation on large networks.
"""
if measures is None:
measures = ["betweenness", "closeness", "pagerank", "degree"]
# Convert to undirected for symmetric centrality
G_undirected = G.to_undirected()
nodes_gdf, _ = ox.graph_to_gdfs(G)
results = {"osmid": list(G.nodes())}
if "degree" in measures:
deg = dict(G.degree(weight=weight))
results["degree"] = [deg.get(n, 0) for n in G.nodes()]
if "betweenness" in measures:
n_nodes = G.number_of_nodes()
k_approx = min(n_nodes, 500) if n_nodes > 1000 else None
bc = nx.betweenness_centrality(
G_undirected, weight=weight, normalized=True, k=k_approx, seed=42
)
results["betweenness"] = [bc.get(n, 0) for n in G.nodes()]
if "closeness" in measures:
cc = nx.closeness_centrality(G_undirected, distance=weight)
results["closeness"] = [cc.get(n, 0) for n in G.nodes()]
if "pagerank" in measures:
pr = nx.pagerank(G, weight=weight, alpha=0.85)
results["pagerank"] = [pr.get(n, 0) for n in G.nodes()]
df = pd.DataFrame(results).set_index("osmid")
# Merge spatial coordinates
df = df.join(nodes_gdf[["lat", "lon", "geometry"]])
return df
# ---------------------------------------------------------------------------
# 4. Isochrone / Walkability Analysis
# ---------------------------------------------------------------------------
def get_isochrone(
G: nx.MultiDiGraph,
center_node: int,
travel_time_min: Union[float, List[float]],
speed_kph: float = 4.8,
) -> gpd.GeoDataFrame:
"""
Generate isochrone polygon(s) — the area reachable within a given travel
time by walking (or cycling / driving) from a centre node.
Parameters
----------
G : nx.MultiDiGraph
Projected network. Must have 'length' edge attributes (metres).
center_node : int
OSM node ID of the origin.
travel_time_min : float or list of float
Travel time threshold(s) in minutes. Multiple values produce
concentric isochrone rings.
speed_kph : float
Travel speed in km/h. Default 4.8 km/h ≈ average walking speed.
Returns
-------
gpd.GeoDataFrame
One row per travel time threshold, with columns:
'travel_time_min', 'geometry' (polygon in projected CRS).
"""
if isinstance(travel_time_min, (int, float)):
travel_time_min = [travel_time_min]
travel_time_min = sorted(travel_time_min, reverse=True)
speed_m_per_min = speed_kph * 1000 / 60
records = []
for t in travel_time_min:
max_dist = t * speed_m_per_min
subgraph = nx.ego_graph(G, center_node, radius=max_dist,
distance="length", undirected=True)
node_points = [
Point(data["x"], data["y"])
for _, data in subgraph.nodes(data=True)
]
if len(node_points) < 3:
continue
from shapely.ops import unary_union
region = gpd.GeoSeries(node_points).buffer(max_dist * 0.05)
iso_poly = unary_union(region).convex_hull
records.append({
"travel_time_min": t,
"n_reachable_nodes": len(subgraph.nodes),
"geometry": iso_poly,
})
crs = G.graph.get("crs", "EPSG:3857")
return gpd.GeoDataFrame(records, crs=crs)
# ---------------------------------------------------------------------------
# 5. Nearest Node
# ---------------------------------------------------------------------------
def find_nearest_node(
G: nx.MultiDiGraph,
lat: float,
lon: float,
) -> Tuple[int, float]:
"""
Find the nearest graph node to a given WGS84 coordinate.
Parameters
----------
G : nx.MultiDiGraph
Projected network.
lat : float
Latitude (WGS84).
lon : float
Longitude (WGS84).
Returns
-------
tuple : (node_id, distance_metres)
"""
node_id, dist = ox.distance.nearest_nodes(G, X=lon, Y=lat, return_dist=True)
return node_id, dist
# ---------------------------------------------------------------------------
# 6. Multi-City Comparison
# ---------------------------------------------------------------------------
def compare_cities_stats(
places_list: List[str],
network_type: str = "walk",
cache_dir: str = "city_networks",
) -> pd.DataFrame:
"""
Download networks and compute comparable statistics for multiple cities.
Parameters
----------
places_list : list of str
List of geocodable place names.
network_type : str
Network type (consistent across all cities for fair comparison).
cache_dir : str
Directory to cache downloaded GraphML files.
Returns
-------
pd.DataFrame
One row per city, columns = network statistics.
"""
cache_path = Path(cache_dir)
cache_path.mkdir(exist_ok=True)
rows = []
for place in places_list:
safe_name = place.replace(", ", "_").replace(" ", "_")
graphml_file = cache_path / f"{safe_name}_{network_type}.graphml"
print(f"Processing: {place}")
if graphml_file.exists():
G = load_network(graphml_file)
else:
try:
G = get_city_network(place, network_type=network_type)
save_network(G, graphml_file)
except Exception as e:
print(f" WARNING: failed to download {place}: {e}")
continue
stats = compute_network_stats(G, extended=True)
stats["city"] = place
rows.append(stats)
df = pd.DataFrame(rows).set_index("city")
return df
Example 1: Walkability Comparison of 5 City Downtowns
Download walking networks for five downtown areas, compute network statistics and circuity, and produce a comparative bar chart and spider plot.
"""
example_city_walkability.py
---------------------------
Compare pedestrian street network characteristics for five world cities.
Uses OSMnx to download 1-km radius walking networks around each city centre.
"""
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import osmnx as ox
import networkx as nx
from osmnx_urban import (
get_network_from_point,
compute_network_stats,
get_isochrone,
find_nearest_node,
)
# City centres (lat, lon, label)
CITIES = [
(40.7580, -73.9855, "Midtown Manhattan"),
(48.8566, 2.3522, "Paris (1st arr.)"),
(35.6762, 139.6503, "Shinjuku, Tokyo"),
(-33.8688, 151.2093, "Sydney CBD"),
(37.7749, -122.4194, "San Francisco"),
]
RADIUS_M = 1000 # 1-km radius around each centre
WALK_SPEED_KPH = 4.8 # km/h walking speed
stats_rows = []
isochrone_areas = {}
for lat, lon, label in CITIES:
print(f"\nDownloading: {label} ...")
G = get_network_from_point(lat, lon, dist=RADIUS_M, network_type="walk")
stats = compute_network_stats(G, extended=True)
stats["city"] = label
stats_rows.append(stats)
# 10-minute and 5-minute isochrones from city centre
centre_node, _ = find_nearest_node(G, lat, lon)
iso_gdf = get_isochrone(G, centre_node, travel_time_min=[5, 10],
speed_kph=WALK_SPEED_KPH)
if not iso_gdf.empty:
iso_10 = iso_gdf[iso_gdf["travel_time_min"] == 10]
if not iso_10.empty:
area_ha = iso_10.geometry.area.values[0] / 10000 # m² -> ha
isochrone_areas[label] = area_ha
else:
isochrone_areas[label] = np.nan
df = pd.DataFrame(stats_rows).set_index("city")
df["walkable_area_10min_ha"] = pd.Series(isochrone_areas)
print("\n=== Network Statistics Summary ===")
display_cols = [
"n", "m", "edge_length_avg_m", "circuity_avg",
"street_density_km_per_km2", "node_density_per_km2",
"walkable_area_10min_ha",
]
print(df[display_cols].round(2).to_string())
# ---- Visualisation 1: Bar chart comparison ----
fig, axes = plt.subplots(2, 3, figsize=(16, 10))
metrics = [
("circuity_avg", "Avg Circuity (lower = more grid-like)"),
("street_density_km_per_km2", "Street Density (km / km²)"),
("node_density_per_km2", "Intersection Density (/ km²)"),
("edge_length_avg_m", "Avg Block Length (m)"),
("walkable_area_10min_ha", "10-min Walkable Area (ha)"),
("streets_per_node_avg", "Streets per Intersection"),
]
colors = plt.cm.Set2(np.linspace(0, 1, len(df)))
for ax, (col, label) in zip(axes.flat, metrics):
vals = df[col].values
bars = ax.bar(range(len(df)), vals, color=colors)
ax.set_xticks(range(len(df)))
ax.set_xticklabels(df.index, rotation=20, ha="right", fontsize=8)
ax.set_title(label, fontsize=10)
ax.set_ylabel(col.split("_")[0])
# Annotate bar tops
for bar, v in zip(bars, vals):
if not np.isnan(v):
ax.text(bar.get_x() + bar.get_width() / 2, bar.get_height() * 1.01,
f"{v:.1f}", ha="center", va="bottom", fontsize=7)
fig.suptitle("Pedestrian Street Network Comparison — 1 km Radius from City Centre",
fontsize=13, y=1.01)
fig.tight_layout()
fig.savefig("city_walkability_comparison.png", dpi=150, bbox_inches="tight")
print("\nSaved: city_walkability_comparison.png")
plt.show()
# ---- Visualisation 2: Network maps for all cities ----
fig2, axes2 = plt.subplots(1, 5, figsize=(25, 5))
for ax, (lat, lon, label) in zip(axes2, CITIES):
G_plot = get_network_from_point(lat, lon, dist=RADIUS_M, network_type="walk")
ox.plot_graph(
G_plot, ax=ax,
node_size=0, edge_color="#333333", edge_linewidth=0.5,
bgcolor="white", show=False, close=False,
)
ax.set_title(label, fontsize=9)
fig2.suptitle("Walking Network Layouts — 1 km Radius", fontsize=12)
fig2.tight_layout()
fig2.savefig("city_network_maps.png", dpi=150, bbox_inches="tight")
print("Saved: city_network_maps.png")
plt.show()
Example 2: Betweenness Centrality Map and Key Intersections
Download a city street network, compute betweenness centrality for all nodes, identify the most central intersections, and produce a colour-scaled map.
"""
example_betweenness_centrality.py
----------------------------------
Identify the most central intersections in a neighbourhood using
betweenness centrality and visualise the result as a colour-coded node map.
"""
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import matplotlib.colors as mcolors
import osmnx as ox
import networkx as nx
import geopandas as gpd
from osmnx_urban import (
get_city_network,
compute_centrality,
find_nearest_node,
)
# ---- 1. Download network ----
PLACE = "Williamsburg, Brooklyn, New York, USA"
print(f"Downloading network: {PLACE}")
G = get_city_network(PLACE, network_type="walk", simplify=True)
print(f"Network: {G.number_of_nodes()} nodes, {G.number_of_edges()} edges")
# ---- 2. Compute centrality measures ----
print("Computing centrality (betweenness approximation k=300) ...")
cent_df = compute_centrality(
G, measures=["betweenness", "closeness", "pagerank", "degree"],
weight="length",
)
# ---- 3. Identify top 10 most central intersections ----
# Filter to proper intersections (degree >= 3)
intersections = cent_df[cent_df["degree"] >= 3].copy()
top10 = intersections.nlargest(10, "betweenness")
print("\n=== Top 10 Most Central Intersections ===")
print(f"{'Rank':<5} {'Node ID':<12} {'Betweenness':>12} {'Lat':>10} {'Lon':>10}")
print("-" * 52)
for rank, (node_id, row) in enumerate(top10.iterrows(), 1):
print(f"{rank:<5} {node_id:<12} {row['betweenness']:>12.6f} "
f"{row['lat']:>10.5f} {row['lon']:>10.5f}")
# ---- 4. Colour-coded betweenness map ----
nodes_gdf, edges_gdf = ox.graph_to_gdfs(G)
nodes_gdf = nodes_gdf.join(cent_df[["betweenness", "closeness", "pagerank"]])
# Normalise betweenness for colour mapping
bc_vals = nodes_gdf["betweenness"].fillna(0).values
bc_norm = (bc_vals - bc_vals.min()) / (bc_vals.max() - bc_vals.min() + 1e-12)
cmap = cm.plasma
node_colors = [cmap(v) for v in bc_norm]
node_sizes = 2 + bc_norm * 30 # scale size by centrality
fig, ax = plt.subplots(figsize=(14, 12))
# Plot edges first (grey background)
edges_gdf.plot(ax=ax, color="#cccccc", linewidth=0.5, alpha=0.7)
# Plot nodes, coloured by betweenness
sc = ax.scatter(
nodes_gdf.geometry.x, nodes_gdf.geometry.y,
c=bc_vals, cmap="plasma", s=node_sizes,
alpha=0.85, linewidths=0,
norm=mcolors.PowerNorm(gamma=0.4, vmin=0, vmax=bc_vals.max()),
)
# Mark top-10 intersections
top_nodes = nodes_gdf.loc[top10.index]
ax.scatter(
top_nodes.geometry.x, top_nodes.geometry.y,
c="white", s=80, edgecolors="black", linewidths=1.5, zorder=5,
label="Top-10 intersections",
)
for i, (nid, row) in enumerate(top10.iterrows(), 1):
nrow = nodes_gdf.loc[nid]
ax.annotate(
str(i),
xy=(nrow.geometry.x, nrow.geometry.y),
xytext=(5, 5), textcoords="offset points",
fontsize=7, color="white", fontweight="bold",
)
cbar = fig.colorbar(sc, ax=ax, orientation="vertical", pad=0.01, shrink=0.7)
cbar.set_label("Betweenness Centrality", fontsize=11)
ax.legend(loc="upper left", fontsize=9)
ax.set_title(f"Street Network Betweenness Centrality\n{PLACE}", fontsize=13)
ax.set_axis_off()
fig.tight_layout()
fig.savefig("betweenness_centrality_map.png", dpi=150, bbox_inches="tight")
print("\nSaved: betweenness_centrality_map.png")
plt.show()
# ---- 5. Closeness vs betweenness scatter ----
fig2, ax2 = plt.subplots(figsize=(8, 6))
sample = cent_df.sample(min(2000, len(cent_df)), random_state=42)
sc2 = ax2.scatter(
sample["closeness"], sample["betweenness"],
c=sample["pagerank"], cmap="viridis",
s=8, alpha=0.6,
)
ax2.scatter(
top10["closeness"], top10["betweenness"],
c="red", s=60, zorder=5, label="Top-10 (betweenness)",
)
fig2.colorbar(sc2, ax=ax2, label="PageRank")
ax2.set_xlabel("Closeness Centrality")
ax2.set_ylabel("Betweenness Centrality")
ax2.set_title("Centrality Measures Comparison\n(coloured by PageRank)")
ax2.legend()
fig2.tight_layout()
fig2.savefig("centrality_scatter.png", dpi=150)
print("Saved: centrality_scatter.png")
plt.show()
POI Extraction
"""
poi_extraction.py
-----------------
Extract Points of Interest (POIs) from OpenStreetMap for a place,
compute nearest-POI distances for each street node, and assess
amenity accessibility.
"""
import osmnx as ox
import geopandas as gpd
import pandas as pd
import numpy as np
from scipy.spatial import cKDTree
from osmnx_urban import get_city_network, find_nearest_node
def get_pois(
place_name: str,
amenity_types: list = None,
) -> gpd.GeoDataFrame:
"""
Download POIs (amenity nodes/ways) for a place from OpenStreetMap.
Parameters
----------
place_name : str
Nominatim geocodable place name.
amenity_types : list of str, optional
OSM amenity tags to retrieve, e.g. ['school', 'hospital', 'cafe'].
If None, retrieves all amenity features.
Returns
-------
gpd.GeoDataFrame with columns including 'name', 'amenity', 'geometry'.
"""
tags = {"amenity": amenity_types if amenity_types else True}
gdf = ox.features_from_place(place_name, tags=tags)
# Keep only point geometries (centroids for polygon amenities)
gdf["geometry"] = gdf.geometry.centroid
return gdf[gdf.geometry.geom_type == "Point"].reset_index()
def nearest_poi_distance(
G,
pois: gpd.GeoDataFrame,
) -> pd.Series:
"""
For each network node, compute the Euclidean distance to the nearest POI.
Parameters
----------
G : nx.MultiDiGraph
Projected network.
pois : gpd.GeoDataFrame
Projected POI GeoDataFrame (same CRS as G).
Returns
-------
pd.Series indexed by node ID, values = distance in metres.
"""
nodes_gdf, _ = ox.graph_to_gdfs(G)
node_coords = np.column_stack([nodes_gdf.geometry.x, nodes_gdf.geometry.y])
poi_proj = pois.to_crs(nodes_gdf.crs)
poi_coords = np.column_stack([poi_proj.geometry.x, poi_proj.geometry.y])
tree = cKDTree(poi_coords)
distances, _ = tree.query(node_coords)
return pd.Series(distances, index=nodes_gdf.index, name="dist_to_nearest_poi_m")
# Usage example
if __name__ == "__main__":
PLACE = "Prenzlauer Berg, Berlin, Germany"
G = get_city_network(PLACE, network_type="walk")
pois = get_pois(PLACE, amenity_types=["cafe", "restaurant", "bakery"])
print(f"Found {len(pois)} food/drink POIs in {PLACE}")
# Reproject POIs to match network CRS
pois_proj = pois.to_crs(G.graph["crs"])
distances = nearest_poi_distance(G, pois_proj)
print(f"\nDistance to nearest cafe/restaurant/bakery:")
print(f" Median: {distances.median():.0f} m")
print(f" Mean: {distances.mean():.0f} m")
print(f" Max: {distances.max():.0f} m")
pct_within_200m = (distances < 200).mean() * 100
print(f" Nodes within 200m of food POI: {pct_within_200m:.1f}%")
Routing Example
"""
routing_example.py
------------------
Compute the shortest path between two points and plot it on the street network.
"""
import osmnx as ox
import networkx as nx
import matplotlib.pyplot as plt
from osmnx_urban import get_city_network, find_nearest_node
def shortest_path_map(
G,
origin_lat: float,
origin_lon: float,
dest_lat: float,
dest_lon: float,
weight: str = "length",
output_path: str = "route_map.png",
) -> dict:
"""
Find and visualise the shortest path between two coordinates.
"""
orig_node, orig_dist = find_nearest_node(G, origin_lat, origin_lon)
dest_node, dest_dist = find_nearest_node(G, dest_lat, dest_lon)
route = nx.shortest_path(G, orig_node, dest_node, weight=weight)
route_length = sum(
G[u][v][0].get("length", 0) for u, v in zip(route[:-1], route[1:])
)
fig, ax = ox.plot_graph_route(
G, route,
route_linewidth=4, route_color="firebrick",
node_size=0, bgcolor="white", edge_color="#cccccc",
edge_linewidth=0.5,
show=False, close=False,
figsize=(12, 10),
)
ax.set_title(f"Shortest Path — {route_length:.0f} m", fontsize=12)
fig.savefig(output_path, dpi=150, bbox_inches="tight")
print(f"Route saved: {output_path}")
plt.show()
return {
"origin_node": orig_node,
"dest_node": dest_node,
"route_nodes": route,
"route_length_m": route_length,
"n_turns": len(route) - 1,
}
Tips and Best Practices
- Caching: Always enable
ox.settings.use_cache = True. Re-downloading large city networks wastes time and is inconsiderate to the Overpass API. - Rate limiting: For batch jobs over many cities, add a small sleep between requests
(
ox.settings.overpass_rate_limit = True) or use a local Overpass instance. - Graph projection: OSMnx returns graphs in WGS84 by default. Call
ox.project_graph(G)to reproject to the local UTM zone before computing distances, areas, or buffers. - Simplification:
simplify=Trueremoves intermediate nodes (degree-2 nodes along straight roads). Usesimplify=Falseonly when you need every OSM node for attribute access or fine-grained routing. - Large networks: For cities with >100,000 nodes, use
kapproximation in betweenness centrality (e.g.k=500) to keep runtime under a minute. - Network type: Use
network_type="walk"for pedestrian accessibility analysis. For cycling infrastructure studies, use"bike"to include cycle paths. - Reproducibility: Save downloaded networks with
ox.save_graphmland commit to DVC or store in object storage. OSM data changes daily.
References
- Boeing, G. (2017). OSMnx: New methods for acquiring, constructing, analysing, and visualising complex street networks. Computers, Environment and Urban Systems, 65, 126–139.
- Boeing, G. (2019). Urban spatial order: street network orientation, configuration, and entropy. Applied Network Science, 4, 67.
- OpenStreetMap contributors. OpenStreetMap. https://www.openstreetmap.org
- NetworkX documentation: https://networkx.org
- OSMnx documentation: https://osmnx.readthedocs.io
示例提示词
帮我用OSMnx计算这座城市路网的中心性和步行可达范围。
所属插件
安装该插件会一并获得同领域的 58 个 Skill / MCP。
同插件的其他科研 Skill
- Mesa社会主体建模Builds Mesa agent-based models of opinion dynamics, segregation, social contagion, and network diffusion. Use when simulating emergent social behavior from agent rules.
- Mesa3主体建模引擎Builds agent-based models with the Mesa 3 AgentSet API, cell spaces, and batch_run sweeps for segregation, diffusion, and cooperation. Use for a Mesa 3.x ABM build or debug.
- 观察数据因果推断Estimates causal effects with DiD, IV, RDD, panel fixed effects, and propensity scores via statsmodels, linearmodels, DoWhy, and EconML. Use for observational or quasi-experimental causal estimation.
- 效应量元分析Pools effect sizes across studies with fixed/random-effects models, heterogeneity stats, forest/funnel plots, and publication-bias tests. Use for a systematic review’s quantitative synthesis.
- 缺失数据插补处理Handles missing data by naming the MCAR/MAR/MNAR mechanism, then applying multiple imputation (MICE) or FIML instead of single imputation. Use when a dataset has missing values to treat.
- 多层线性混合模型Fits mixed-effects/multilevel models (random slopes, ICC, GLMMs) for nested or longitudinal data via statsmodels, bambi, or R lme4/brms. Use for grouped data with within- vs between-cluster questions.
- 定性比较分析QCARuns crisp-, multi-value, and fuzzy-set Qualitative Comparative Analysis via R’s QCA package. Use for configurational or necessary/sufficient-condition research.
- 质性编码与主题分析Builds codebooks and computes intercoder reliability (Krippendorff’s alpha, kappa) for thematic or content coding, including human-vs-LLM double coding. Use when coding text or reporting reliability.
- 社会网络结构分析Computes network centrality, community detection, and ERGM inferential models matched to the research question via networkx/igraph. Use for social-network analysis beyond basic visualization.
- 社科研究设计把关Routes a study to its research design (experiment, quasi-experiment, observational, qualitative) and pins the identifying assumption first. Use when choosing a study design.
- 社科推论结论审核Audits inferential claims against the design before publication: unwarranted causal language, p-value/CI misreadings, and multiple-comparison issues. Use when checking a results section.
- 量表测量质量把关Checks that a scale’s reliability, validity, and measurement invariance are established before trusting or comparing it across groups. Use when adopting or reporting a survey instrument.
- 社科研究流程总控Coordinates a study through design, measurement, sampling, analysis, and inference gates with a shared Design Passport. Use for an end-to-end methodology review of a whole study.
- 质性研究可信度把关Gates qualitative trustworthiness before write-up: positionality, credibility, transferability, dependability, confirmability per Lincoln and Guba. Use before writing ethnographic findings.
- 抽样方法与样本量把关Checks that the sampling frame, method, and size match the inference paradigm before data collection. Use when planning recruitment or judging sample generalization.
- 复杂抽样调查分析Analyzes complex-sample survey data with design-based inference: weights, strata, PSUs, and calibration via Python svy or R survey/srvyr. Use for weighted surveys like GSS, ANES, or DHS.
- 文本数据定量分析Analyzes text as social-science data with topic modeling, embeddings, and validated dictionary or classification methods. Use for computational text analysis beyond a keyword count.
- 政策议题框架分析Runs anthropological framing and metaphor analysis on contested-policy documents, producing actor-attributed CSVs for NVivo import. Use for policy-framing or metaphor-analysis coding.
- 跨国比较政治分析Merges QoG, Polity5, and Freedom House data and runs cross-sectional OLS with fixed effects and regime classification. Use for comparative political-institution research.
- 计算社会学方法Covers social-media data collection, bot detection, network homophily, echo-chamber analysis, and conjoint survey experiments. Use for large-scale digital-trace sociology research.
- 冲突事件数据分析Downloads ACLED/UCDP conflict data and runs spatio-temporal clustering, conflict-onset logit panels, and fatality estimation. Use for quantitative armed-conflict research.
- 联合分析调查实验Designs conjoint survey experiments and estimates AMCEs via OLS, marginal means, and respondent-level heterogeneity. Use when designing or analyzing a choice-based conjoint experiment.
- 统计方法教学规范Defines the baseline statistical teaching and reproducibility standards shared across this analysis skill family. Use as the methodology reference other skills in the family build on.
- 人口统计方法分析Computes life tables, Leslie-matrix population projections, Lee-Carter mortality forecasts, and Kitagawa decomposition. Use for formal demographic analysis of mortality or population structure.
常见问题
城市路网OSMnx分析能做什么?
Analyzes urban street networks with OSMnx: network statistics, centrality, isochrone/walkability, and multi-city comparison. Use for street-network or walkability research。
如何安装城市路网OSMnx分析?
在科搭 Codar 左侧点击「插件」,在「组件」页签搜索「城市路网OSMnx分析」并安装;在 Claude Code 或 Codex 中可以发送本页的安装提示词,或下载 Skill 包后解压到 ~/.claude/skills 或 ~/.codex/skills。
城市路网OSMnx分析需要哪些权限?
该科研 Skill没有声明额外权限;执行具体操作时仍由 Agent 按自身规则请求确认。
城市路网OSMnx分析经过官方审核吗?
是。SpeedSkills 收录的每个版本都会记录内容摘要与权限声明,当前版本已通过安全审核。