Add node-specific tolerances to intersection consolidation

osmnx/simplification.py

@@ -9,10 +9,11 @@
 import geopandas as gpd
 import networkx as nx
 import numpy as np
-from shapely import LineString
-from shapely import MultiPolygon
-from shapely import Point
-from shapely import Polygon
+import pandas as pd
+from shapely.geometry import LineString
+from shapely.geometry import MultiPolygon
+from shapely.geometry import Point
+from shapely.geometry import Polygon
 
 from . import convert
 from . import stats
@@ -446,7 +447,7 @@
 def consolidate_intersections(
     G: nx.MultiDiGraph,
     *,
-    tolerance: float = 10,
+    tolerance: float | dict[int, float] = 10,
     rebuild_graph: bool = True,
     dead_ends: bool = False,
     reconnect_edges: bool = True,
@@ -463,6 +464,11 @@
     Note `tolerance` represents a per-node buffering radius: for example, to
     consolidate nodes within 10 meters of each other, use `tolerance=5`.
 
+    It's also possible to specify difference tolerances for each node. This can
+    be done by adding an attribute to each node with contains the tolerance, and
+    passing the name of that argument as tolerance_attribute argument. If a node
+    does not have a value in the tolerance_attribute, the default tolerance is used.
+
     When `rebuild_graph` is False, it uses a purely geometric (and relatively
     fast) algorithm to identify "geometrically close" nodes, merge them, and
     return the merged intersections' centroids. When `rebuild_graph` is True,
@@ -487,7 +493,8 @@
         A projected graph.
     tolerance
         Nodes are buffered to this distance (in graph's geometry's units) and
-        subsequent overlaps are dissolved into a single node.
+        subsequent overlaps are dissolved into a single node. Can be a float
+        value or a dictionary mapping node IDs to individual tolerance values.
     rebuild_graph
         If True, consolidate the nodes topologically, rebuild the graph, and
         return as MultiDiGraph. Otherwise, consolidate the nodes geometrically
@@ -547,7 +554,10 @@
     return _merge_nodes_geometric(G, tolerance).centroid
 
 
-def _merge_nodes_geometric(G: nx.MultiDiGraph, tolerance: float) -> gpd.GeoSeries:
+def _merge_nodes_geometric(
+    G: nx.MultiDiGraph,
+    tolerance: float | dict[int, float],
+) -> gpd.GeoSeries:
     """
     Geometrically merge nodes within some distance of each other.
 
@@ -558,14 +568,29 @@
     tolerance
         Buffer nodes to this distance (in graph's geometry's units) then merge
         overlapping polygons into a single polygon via unary union operation.
+        Can be a float value or a dictionary mapping node IDs to individual
+        tolerance values.
 
     Returns
     -------
     merged
         The merged overlapping polygons of the buffered nodes.
     """
-    # buffer nodes GeoSeries then get unary union to merge overlaps
-    merged = convert.graph_to_gdfs(G, edges=False)["geometry"].buffer(tolerance).unary_union
+    gdf_nodes = convert.graph_to_gdfs(G, edges=False)
+
+    if isinstance(tolerance, dict):
+        # Create a Series of tolerances, reindexed to match the nodes
+        tolerances = pd.Series(tolerance).reindex(gdf_nodes.index)
+        # Buffer nodes to the specified distance
+        buffered_geoms = gdf_nodes.geometry.buffer(tolerances)
+        # Replace POLYGON EMPTY with original geometries if buffer distance was effectively zero or missing
+        buffered_geoms = buffered_geoms.fillna(gdf_nodes["geometry"])
+    else:
+        # Buffer nodes to the specified distance
+        buffered_geoms = gdf_nodes.geometry.buffer(tolerance)
+
+    # Merge overlapping geometries into a single geometry
+    merged = buffered_geoms.unary_union
 
     # if only a single node results, make it iterable to convert to GeoSeries
     merged = MultiPolygon([merged]) if isinstance(merged, Polygon) else merged
@@ -574,7 +599,7 @@
 
 def _consolidate_intersections_rebuild_graph(  # noqa: C901,PLR0912,PLR0915
     G: nx.MultiDiGraph,
-    tolerance: float,
+    tolerance: float | dict[int, float],
     reconnect_edges: bool,  # noqa: FBT001
     node_attr_aggs: dict[str, Any] | None,
 ) -> nx.MultiDiGraph:
@@ -599,7 +624,8 @@
         A projected graph.
     tolerance
         Nodes are buffered to this distance (in graph's geometry's units) and
-        subsequent overlaps are dissolved into a single node.
+        subsequent overlaps are dissolved into a single node. Can be a float
+        value or a dictionary mapping node IDs to individual tolerance values.
     reconnect_edges
         If True, reconnect edges (and their geometries) to the consolidated
         nodes in rebuilt graph, and update the edge length attributes. If
@@ -625,7 +651,9 @@
     # STEP 1
     # buffer nodes to passed-in distance and merge overlaps. turn merged nodes
     # into gdf and get centroids of each cluster as x, y
-    node_clusters = gpd.GeoDataFrame(geometry=_merge_nodes_geometric(G, tolerance))
+    node_clusters = gpd.GeoDataFrame(
+        geometry=_merge_nodes_geometric(G, tolerance),
+    )
     centroids = node_clusters.centroid
     node_clusters["x"] = centroids.x
     node_clusters["y"] = centroids.y