Refactor: Remove AStarRouter, introduce AStarContext/AStarMetrics

examples/01_simple_route.py

@@ -2,7 +2,7 @@ from shapely.geometry import Polygon
 
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarRouter
+from inire.router.astar import AStarContext, AStarMetrics, route_astar
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
@@ -27,8 +27,8 @@ def main() -> None:
     danger_map.precompute([obstacle])
 
     evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
-    router = AStarRouter(evaluator, snap_size=1.0, bend_radii=[10.0])
-    pf = PathFinder(router, evaluator)
+    context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0])
+    pf = PathFinder(context)
 
     # 2. Define Netlist
     # Route from (10, 10) to (90, 50)

examples/02_congestion_resolution.py

@@ -1,6 +1,6 @@
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarRouter
+from inire.router.astar import AStarContext, AStarMetrics, route_astar
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
@@ -17,8 +17,8 @@ def main() -> None:
     danger_map.precompute([])
 
     evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
-    router = AStarRouter(evaluator, snap_size=1.0, bend_radii=[10.0])
-    pf = PathFinder(router, evaluator)
+    context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0])
+    pf = PathFinder(context)
 
     # 2. Define Netlist
     # Three nets that all converge on the same central area.
@@ -32,7 +32,7 @@ def main() -> None:
 
     # 3. Route with Negotiated Congestion
     # We increase the base penalty to encourage faster divergence
-    pf = PathFinder(router, evaluator, base_congestion_penalty=1000.0)
+    pf = PathFinder(context, base_congestion_penalty=1000.0)
     results = pf.route_all(netlist, net_widths)
 
     # 4. Check Results

examples/03_locked_paths.py

@@ -2,7 +2,7 @@ from shapely.geometry import Polygon
 
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarRouter
+from inire.router.astar import AStarContext, AStarMetrics, route_astar
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
@@ -19,8 +19,9 @@ def main() -> None:
     danger_map.precompute([])
 
     evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
-    router = AStarRouter(evaluator, snap_size=1.0, bend_radii=[10.0])
-    pf = PathFinder(router, evaluator)
+    context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0])
+    metrics = AStarMetrics()
+    pf = PathFinder(context, metrics)
 
     # 2. Add a 'Pre-routed' net and lock it
     # Net 'fixed' goes right through the middle
@@ -28,7 +29,7 @@ def main() -> None:
     fixed_target = Port(90, 50, 0)
     
     print("Routing initial net...")
-    res_fixed = router.route(fixed_start, fixed_target, net_width=2.0)
+    res_fixed = route_astar(fixed_start, fixed_target, net_width=2.0, context=context, metrics=metrics)
     
     if res_fixed:
         # 3. Lock this net! It now behaves like a static obstacle

examples/04_sbends_and_radii.py

@@ -1,6 +1,6 @@
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarRouter
+from inire.router.astar import AStarContext, route_astar
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
@@ -8,7 +8,7 @@ from inire.utils.visualization import plot_routing_results
 
 
 def main() -> None:
-    print("Running Example 04: S-Bends and Multiple Radii...")
+    print("Running Example 04: SBends and Radii Strategy...")
 
     # 1. Setup Environment
     bounds = (0, 0, 100, 100)
@@ -16,45 +16,33 @@ def main() -> None:
     danger_map = DangerMap(bounds=bounds)
     danger_map.precompute([])
 
-    # 2. Configure Router
-    evaluator = CostEvaluator(
-        engine,
-        danger_map,
-        unit_length_cost=1.0,
-        bend_penalty=10.0,
-        sbend_penalty=20.0,
-    )
-
-    router = AStarRouter(
+    evaluator = CostEvaluator(engine, danger_map, bend_penalty=200.0, sbend_penalty=400.0)
+    
+    # Define a custom router with multiple SBend radii and specific offsets
+    context = AStarContext(
         evaluator,
-        node_limit=50000,
         snap_size=1.0,
-        bend_radii=[10.0, 30.0],
-        sbend_offsets=[5.0], # Use a simpler offset
-        bend_penalty=10.0,
-        sbend_penalty=20.0,
-        snap_to_target_dist=50.0, # Large snap range
+        bend_radii=[20.0, 50.0],
+        sbend_radii=[5.0, 10.0, 50.0],
+        sbend_offsets=[2.0, 5.0, 10.0, 20.0, 50.0]
     )
+    pf = PathFinder(context)
 
-    pf = PathFinder(router, evaluator)
+    # 2. Define Netlist
+    # High-density parallel nets with varying offsets
+    netlist = {}
+    for i in range(10):
+        # Starts at x=50, y=50+i*10. Targets at x=450, y=60+i*10.
+        # This forces small vertical jogs (SBends)
+        netlist[f"net_{i}"] = (Port(50, 50 + i * 10, 0), Port(450, 55 + i * 10, 0))
+    
+    net_widths = {nid: 2.0 for nid in netlist}
 
-    # 3. Define Netlist
-    # start (10, 50), target (60, 55) -> 5um offset
-    netlist = {
-        "sbend_only": (Port(10, 50, 0), Port(60, 55, 0)),
-        "multi_radii": (Port(10, 10, 0), Port(90, 90, 0)),
-    }
-    net_widths = {"sbend_only": 2.0, "multi_radii": 2.0}
+    # 3. Route
+    print(f"Routing {len(netlist)} nets with custom SBend strategy...")
+    results = pf.route_all(netlist, net_widths, shuffle_nets=True)
 
-    # 4. Route
-    results = pf.route_all(netlist, net_widths)
-
-    # 5. Check Results
-    for nid, res in results.items():
-        status = "Success" if res.is_valid else "Failed"
-        print(f"{nid}: {status}, collisions={res.collisions}")
-
-    # 6. Visualize
+    # 4. Visualize
     fig, ax = plot_routing_results(results, [], bounds, netlist=netlist)
     fig.savefig("examples/04_sbends_and_radii.png")
     print("Saved plot to examples/04_sbends_and_radii.png")

examples/05_orientation_stress.py

@@ -1,6 +1,6 @@
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarRouter
+from inire.router.astar import AStarContext, route_astar
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
@@ -8,7 +8,7 @@ from inire.utils.visualization import plot_routing_results
 
 
 def main() -> None:
-    print("Running Example 05: Orientation Stress Test...")
+    print("Running Example 05: Orientation Stress...")
 
     # 1. Setup Environment
     bounds = (0, 0, 200, 200)
@@ -16,9 +16,9 @@ def main() -> None:
     danger_map = DangerMap(bounds=bounds)
     danger_map.precompute([])
 
-    evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
-    router = AStarRouter(evaluator, snap_size=1.0, bend_radii=[10.0])
-    pf = PathFinder(router, evaluator)
+    evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0)
+    context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0])
+    pf = PathFinder(context)
 
     # 2. Define Netlist: Complex orientation challenges
     netlist = {
@@ -29,15 +29,10 @@ def main() -> None:
     net_widths = {nid: 2.0 for nid in netlist}
 
     # 3. Route
-    print("Routing complex orientation nets...")
+    print("Routing nets with complex orientation combinations...")
     results = pf.route_all(netlist, net_widths)
 
-    # 4. Check Results
-    for nid, res in results.items():
-        status = "Success" if res.is_valid else "Failed"
-        print(f"  {nid}: {status}")
-
-    # 5. Visualize
+    # 4. Visualize
     fig, ax = plot_routing_results(results, [], bounds, netlist=netlist)
     fig.savefig("examples/05_orientation_stress.png")
     print("Saved plot to examples/05_orientation_stress.png")

examples/06_bend_collision_models.py

@@ -2,7 +2,7 @@ from shapely.geometry import Polygon
 
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarRouter
+from inire.router.astar import AStarContext, AStarMetrics, route_astar
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
@@ -33,26 +33,26 @@ def main() -> None:
     evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
 
     # Scenario 1: Standard 'arc' model (High fidelity)
-    router_arc = AStarRouter(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type="arc")
+    context_arc = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type="arc")
     netlist_arc = {"arc_model": (Port(10, 120, 0), Port(90, 140, 90))}
 
     # Scenario 2: 'bbox' model (Conservative axis-aligned box)
-    router_bbox = AStarRouter(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type="bbox")
+    context_bbox = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type="bbox")
     netlist_bbox = {"bbox_model": (Port(10, 70, 0), Port(90, 90, 90))}
 
     # Scenario 3: 'clipped_bbox' model (Balanced)
-    router_clipped = AStarRouter(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type="clipped_bbox", bend_clip_margin=1.0)
+    context_clipped = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type="clipped_bbox", bend_clip_margin=1.0)
     netlist_clipped = {"clipped_model": (Port(10, 20, 0), Port(90, 40, 90))}
 
     # 2. Route each scenario
     print("Routing Scenario 1 (Arc)...")
-    res_arc = PathFinder(router_arc, evaluator, use_tiered_strategy=False).route_all(netlist_arc, {"arc_model": 2.0})
+    res_arc = PathFinder(context_arc, use_tiered_strategy=False).route_all(netlist_arc, {"arc_model": 2.0})
 
     print("Routing Scenario 2 (BBox)...")
-    res_bbox = PathFinder(router_bbox, evaluator, use_tiered_strategy=False).route_all(netlist_bbox, {"bbox_model": 2.0})
+    res_bbox = PathFinder(context_bbox, use_tiered_strategy=False).route_all(netlist_bbox, {"bbox_model": 2.0})
 
     print("Routing Scenario 3 (Clipped BBox)...")
-    res_clipped = PathFinder(router_clipped, evaluator, use_tiered_strategy=False).route_all(netlist_clipped, {"clipped_model": 2.0})
+    res_clipped = PathFinder(context_clipped, use_tiered_strategy=False).route_all(netlist_clipped, {"clipped_model": 2.0})
 
     # 3. Combine results for visualization
     all_results = {**res_arc, **res_bbox, **res_clipped}

examples/07_large_scale_routing.py

@@ -2,7 +2,7 @@ import numpy as np
 import time
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarRouter
+from inire.router.astar import AStarContext, AStarMetrics, route_astar
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
@@ -29,8 +29,9 @@ def main() -> None:
 
     evaluator = CostEvaluator(engine, danger_map, greedy_h_weight=1.5, unit_length_cost=0.1, bend_penalty=100.0, sbend_penalty=400.0, congestion_penalty=100.0)
 
-    router = AStarRouter(evaluator, node_limit=2000000, snap_size=5.0, bend_radii=[50.0], sbend_radii=[50.0])
-    pf = PathFinder(router, evaluator, max_iterations=15, base_congestion_penalty=100.0, congestion_multiplier=1.4)
+    context = AStarContext(evaluator, node_limit=2000000, snap_size=5.0, bend_radii=[50.0], sbend_radii=[50.0])
+    metrics = AStarMetrics()
+    pf = PathFinder(context, metrics, max_iterations=15, base_congestion_penalty=100.0, congestion_multiplier=1.4)
 
     # 2. Define Netlist
     netlist = {}
@@ -57,7 +58,7 @@ def main() -> None:
     def iteration_callback(idx, current_results):
         successes = sum(1 for r in current_results.values() if r.is_valid)
         total_collisions = sum(r.collisions for r in current_results.values())
-        total_nodes = pf.router.metrics['nodes_expanded']
+        total_nodes = metrics.nodes_expanded
 
         # Identify Hotspots
         hotspots = {}
@@ -71,17 +72,18 @@ def main() -> None:
                     # Check what it overlaps with
                     overlaps = engine.dynamic_index.intersection(poly.bounds)
                     for other_obj_id in overlaps:
-                        other_nid, other_poly = engine.dynamic_geometries[other_obj_id]
-                        if other_nid != nid:
-                            if poly.intersects(other_poly):
-                                # Record hotspot
-                                cx, cy = poly.centroid.x, poly.centroid.y
-                                grid_key = (int(cx/20)*20, int(cy/20)*20)
-                                hotspots[grid_key] = hotspots.get(grid_key, 0) + 1
+                        if other_obj_id in engine.dynamic_geometries:
+                            other_nid, other_poly = engine.dynamic_geometries[other_obj_id]
+                            if other_nid != nid:
+                                if poly.intersects(other_poly):
+                                    # Record hotspot
+                                    cx, cy = poly.centroid.x, poly.centroid.y
+                                    grid_key = (int(cx/20)*20, int(cy/20)*20)
+                                    hotspots[grid_key] = hotspots.get(grid_key, 0) + 1
 
-                                # Record pair
-                                pair = tuple(sorted((nid, other_nid)))
-                                overlap_matrix[pair] = overlap_matrix.get(pair, 0) + 1
+                                    # Record pair
+                                    pair = tuple(sorted((nid, other_nid)))
+                                    overlap_matrix[pair] = overlap_matrix.get(pair, 0) + 1
 
         print(f"  Iteration {idx} finished. Successes: {successes}/{len(netlist)}, Collisions: {total_collisions}")
         if overlap_matrix:
@@ -129,7 +131,7 @@ def main() -> None:
                  fig_d.savefig(f"examples/07_iteration_{idx:02d}_density.png")
                  plt.close(fig_d)
 
-        pf.router.reset_metrics()
+        metrics.reset_per_route()
 
     import cProfile, pstats
     profiler = cProfile.Profile()
@@ -173,9 +175,9 @@ def main() -> None:
     plot_danger_map(danger_map, ax=ax)
 
     # Overlay Expanded Nodes from last routed net (as an example)
-    if pf.router.last_expanded_nodes:
-        print(f"Plotting {len(pf.router.last_expanded_nodes)} expanded nodes for the last net...")
-        plot_expanded_nodes(pf.router.last_expanded_nodes, ax=ax, color='blue', alpha=0.1)
+    if metrics.last_expanded_nodes:
+        print(f"Plotting {len(metrics.last_expanded_nodes)} expanded nodes for the last net...")
+        plot_expanded_nodes(metrics.last_expanded_nodes, ax=ax, color='blue', alpha=0.1)
 
     fig.savefig("examples/07_large_scale_routing.png")
     print("Saved plot to examples/07_large_scale_routing.png")

examples/08_custom_bend_geometry.py

@@ -2,7 +2,7 @@ from shapely.geometry import Polygon
 
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarRouter
+from inire.router.astar import AStarContext, AStarMetrics, route_astar
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
@@ -19,8 +19,9 @@ def main() -> None:
     danger_map.precompute([])
 
     evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
-    router = AStarRouter(evaluator, snap_size=1.0, bend_radii=[10.0])
-    pf = PathFinder(router, evaluator)
+    context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0])
+    metrics = AStarMetrics()
+    pf = PathFinder(context, metrics)
 
     # 2. Define Netlist
     netlist = {
@@ -39,8 +40,9 @@ def main() -> None:
     
     print("Routing with custom collision model...")
     # Override bend_collision_type with a literal Polygon
-    router_custom = AStarRouter(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type=custom_poly)
-    results_custom = PathFinder(router_custom, evaluator, use_tiered_strategy=False).route_all(
+    context_custom = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type=custom_poly)
+    metrics_custom = AStarMetrics()
+    results_custom = PathFinder(context_custom, metrics_custom, use_tiered_strategy=False).route_all(
         {"custom_model": netlist["custom_bend"]}, {"custom_model": 2.0}
     )
 

examples/09_unroutable_best_effort.py

@@ -1,6 +1,6 @@
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarRouter
+from inire.router.astar import AStarContext, AStarMetrics
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
@@ -28,10 +28,11 @@ def main() -> None:
 
     evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
     # Use a low node limit to fail faster
-    router = AStarRouter(evaluator, node_limit=2000, snap_size=1.0, bend_radii=[10.0])
+    context = AStarContext(evaluator, node_limit=2000, snap_size=1.0, bend_radii=[10.0])
+    metrics = AStarMetrics()
     
-    # Enable partial path return
-    pf = PathFinder(router, evaluator)
+    # Enable partial path return (handled internally by PathFinder calling route_astar with return_partial=True)
+    pf = PathFinder(context, metrics)
 
     # 2. Define Netlist: start outside, target inside the cage
     netlist = {