OSMnx vs Pyrosm performance benchmarks for routing Jump to heading#

Routing graph generation from OpenStreetMap PBF extracts is a critical throughput bottleneck in production GIS ETL pipelines. OSMnx provides a high-level, NetworkX-native interface optimized for spatial analysis and rapid prototyping. Pyrosm is a Cython-backed library that wraps libosmium and exposes data as GeoDataFrames, making it faster for raw ingestion but requiring more manual graph assembly. This benchmark isolates graph construction, attribute normalization, and shortest-path computation to establish production-ready configurations for mapping engineers and Python ETL developers operating within Parsing & Tag Normalization Workflows.

PBF Parsing Architecture Jump to heading#

Pyrosm (v0.6.2+) wraps libosmium via Cython extensions, reading PBF files into GeoDataFrames backed by Apache Arrow arrays. For regional extracts, Pyrosm reads the entire file in a single pass and materializes a GeoDataFrame per feature type. It does not stream arbitrary byte offsets; it parses the full PBF sequentially via the underlying osmium C++ bindings. Peak memory is substantially lower than OSMnx because Pyrosm avoids constructing an in-memory NetworkX graph until explicitly requested.

OSMnx (v2.0+) uses overpass API queries or local file parsing via pyosmium, constructs a networkx.MultiDiGraph with topology simplification applied automatically. The conversion pipeline calls ox.simplify_graph(), which merges degree-2 nodes at O(N) cost. For routing applications, the primary performance constraints are tag filtering, boolean coercion, and NetworkX’s dictionary-based adjacency storage. Applying OSMnx Graph Conversion Techniques reduces peak RAM when disabling permissive tag retention and applying post-construction edge contraction.

Graph Construction & Routing Implementation Jump to heading#

Routing execution requires explicit weight assignment. Precomputing travel_time as length / (maxspeed_clean * 0.2778) avoids repeated division during Dijkstra/A* execution and prevents division-by-zero errors when maxspeed is null. Memory fragmentation typically occurs during ox.simplify_graph() when intersecting nodes exceed 500k; applying ox.remove_isolated_nodes() prior to simplification stabilizes heap allocation.

import osmnx as ox
import networkx as nx

def build_routing_graph(pbf_path: str) -> nx.MultiDiGraph:
    """Build a speed-weighted routing graph from a local PBF file."""
    G = ox.graph_from_xml(pbf_path, simplify=True, retain_all=False)
    G = ox.add_edge_speeds(G)           # imputes missing maxspeed from highway type
    G = ox.add_edge_travel_times(G)     # length / speed → travel_time seconds
    return G

When the extract is too large for in-memory OSMnx parsing, use Pyrosm to produce the GeoDataFrames and feed them to ox.graph_from_gdfs:

from pyrosm import OSM

def build_graph_via_pyrosm(pbf_path: str) -> nx.MultiDiGraph:
    osm = OSM(pbf_path)
    nodes, edges = osm.get_network(network_type="driving", nodes=True)
    G = ox.graph_from_gdfs(nodes, edges)
    G = ox.add_edge_speeds(G)
    G = ox.add_edge_travel_times(G)
    return G

Value Standardization & Regex Cleaning Jump to heading#

Raw OSM tags exhibit high entropy across municipal boundaries. maxspeed values frequently contain unit suffixes ("50 mph", "50;70", "variable"), while oneway attributes use values like "yes", "1", -1, and "no". Production pipelines must enforce deterministic value standardization before graph serialization. The following pattern isolates numeric velocity while discarding conditional routing tags:

import re

speed_pattern = re.compile(r"^(\d+(?:\.\d+)?)(?:\s*(?:km/h|kmh|kph))?$", re.IGNORECASE)

Batch attribute mapping should coerce missing or malformed entries to None rather than 0 to prevent division-by-zero errors during travel-time calculation. Cross-region tag harmonization requires a lookup table mapping regional conventions (e.g., maxspeed:variable in Germany vs maxspeed=none in the United States) to a unified float schema. A fallback chain (raw value → regex match → highway-class default) keeps routing weights mathematically valid even when upstream OSM data is incomplete.

Error Handling in Large OSM Extracts Jump to heading#

PBF corruption, incomplete relation closures, and malformed multipolygon geometries can crash synchronous parsers. Pre-validate files with osmium fileinfo -e extract.osm.pbf before starting a long pipeline run. For OSMnx, wrap graph_from_xml in a try/except and catch ValueError exceptions that arise from degenerate geometries. For Pyrosm, get_network() returns None for empty results; always guard against that before calling graph_from_gdfs.

When memory pressure exceeds 90% RSS, switching from networkx.DiGraph to igraph or rustworkx adjacency structures can sustain routing queries without triggering kernel OOM kills. igraph in particular stores adjacency as contiguous C arrays and can handle multi-million-edge graphs in under 2 GB.

Benchmark Matrix & Production Configurations Jump to heading#

Testing environment: Ubuntu 22.04 LTS, AMD EPYC 7763 (64-core), 128 GB DDR4, Python 3.11.7, NetworkX 3.2.1. Extract: us-california-latest.osm.pbf (4.1 GB). Routing workload: 10,000 randomized origin-destination pairs using A* with travel_time weights.

Pyrosm dominates ingestion speed and memory footprint, making it the preferred first stage for continental-scale ETL. OSMnx excels in out-of-the-box topology simplification and impedance calculation. For production routing, the optimal architecture chains Pyrosm’s fast parsing with OSMnx’s graph_from_gdfs and add_edge_speeds/add_edge_travel_times helpers.

Refer to the official Pyrosm documentation for reader configurations and the OSMnx documentation for graph simplification parameters. Routing weight validation should align with OpenStreetMap tagging guidelines to ensure regulatory compliance across jurisdictions.