trim down

examples/01_simple_route.py

@@ -23,7 +23,7 @@ def main() -> None:
 
     # 2. Configure Router
     evaluator = CostEvaluator(engine, danger_map)
-    context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0])
+    context = AStarContext(evaluator, bend_radii=[10.0])
     metrics = AStarMetrics()
     pf = PathFinder(context, metrics)
 

examples/02_congestion_resolution.py

@@ -18,7 +18,7 @@ def main() -> None:
 
     # Configure a router with high congestion penalties
     evaluator = CostEvaluator(engine, danger_map, greedy_h_weight=1.5, bend_penalty=50.0, sbend_penalty=150.0)
-    context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0], sbend_radii=[10.0])
+    context = AStarContext(evaluator, bend_radii=[10.0], sbend_radii=[10.0])
     metrics = AStarMetrics()
     pf = PathFinder(context, metrics, base_congestion_penalty=1000.0)
 

examples/03_locked_paths.py

@@ -17,7 +17,7 @@ def main() -> None:
     danger_map.precompute([])
 
     evaluator = CostEvaluator(engine, danger_map)
-    context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0])
+    context = AStarContext(evaluator, bend_radii=[10.0])
     metrics = AStarMetrics()
     pf = PathFinder(context, metrics)
 

examples/04_sbends_and_radii.py

@@ -28,7 +28,6 @@ def main() -> None:
     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,

examples/05_orientation_stress.py

@@ -17,7 +17,7 @@ def main() -> None:
     danger_map.precompute([])
 
     evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0)
-    context = AStarContext(evaluator, snap_size=5.0, bend_radii=[20.0])
+    context = AStarContext(evaluator, bend_radii=[20.0])
     metrics = AStarMetrics()
     pf = PathFinder(context, metrics)
 

examples/06_bend_collision_models.py

@@ -33,15 +33,15 @@ def main() -> None:
     evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
 
     # Scenario 1: Standard 'arc' model (High fidelity)
-    context_arc = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type="arc")
+    context_arc = AStarContext(evaluator, 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)
-    context_bbox = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type="bbox")
+    context_bbox = AStarContext(evaluator, 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)
-    context_clipped = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type="clipped_bbox", bend_clip_margin=1.0)
+    context_clipped = AStarContext(evaluator, 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

examples/07_large_scale_routing.py

@@ -10,7 +10,7 @@ from inire.utils.visualization import plot_routing_results, plot_danger_map, plo
 from shapely.geometry import box
 
 def main() -> None:
-    print("Running Example 07: Fan-Out (10 Nets, 50um Radius, 5um Grid)...")
+    print("Running Example 07: Fan-Out (10 Nets, 50um Radius)...")
 
     # 1. Setup Environment
     bounds = (0, 0, 1000, 1000)
@@ -29,7 +29,7 @@ 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)
 
-    context = AStarContext(evaluator, node_limit=2000000, snap_size=5.0, bend_radii=[50.0], sbend_radii=[50.0])
+    context = AStarContext(evaluator, node_limit=2000000, 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)
 
@@ -44,8 +44,8 @@ def main() -> None:
     end_y_pitch = 800.0 / (num_nets - 1)
 
     for i in range(num_nets):
-        sy = round((start_y_base + i * 10.0) / 5.0) * 5.0
-        ey = round((end_y_base + i * end_y_pitch) / 5.0) * 5.0
+        sy = int(round(start_y_base + i * 10.0))
+        ey = int(round(end_y_base + i * end_y_pitch))
         netlist[f"net_{i:02d}"] = (Port(start_x, sy, 0), Port(end_x, ey, 0))
 
     net_widths = {nid: 2.0 for nid in netlist}
@@ -60,39 +60,8 @@ def main() -> None:
         total_collisions = sum(r.collisions for r in current_results.values())
         total_nodes = metrics.nodes_expanded
 
-        # Identify Hotspots
-        hotspots = {}
-        overlap_matrix = {} # (net_a, net_b) -> count
-
-        for nid, res in current_results.items():
-            if not res.path:
-                continue
-            for comp in res.path:
-                for poly in comp.geometry:
-                    # Check what it overlaps with
-                    overlaps = engine.dynamic_index.intersection(poly.bounds)
-                    for other_obj_id in overlaps:
-                        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
-
         print(f"  Iteration {idx} finished. Successes: {successes}/{len(netlist)}, Collisions: {total_collisions}")
-        if overlap_matrix:
-            top_pairs = sorted(overlap_matrix.items(), key=lambda x: x[1], reverse=True)[:3]
-            print(f"  Top Conflicts: {top_pairs}")
-        if hotspots:
-            top_hotspots = sorted(hotspots.items(), key=lambda x: x[1], reverse=True)[:3]
-            print(f"  Top Hotspots: {top_hotspots}")
-
+        
         # Adaptive Greediness: Decay from 1.5 to 1.1 over 10 iterations
         new_greedy = max(1.1, 1.5 - ((idx + 1) / 10.0) * 0.4)
         evaluator.greedy_h_weight = new_greedy
@@ -104,46 +73,12 @@ def main() -> None:
             'Congestion': total_collisions,
             'Nodes': total_nodes
         })
-
-        # Save plots only for certain iterations to save time
-#        if idx % 20 == 0 or idx == pf.max_iterations - 1:
-        if True:
-            # Save a plot of this iteration's result
-            fig, ax = plot_routing_results(current_results, obstacles, bounds, netlist=netlist)
-            plot_danger_map(danger_map, ax=ax)
-
-            # Overlay failures: show where they stopped
-            for nid, res in current_results.items():
-                if not res.is_valid and res.path:
-                    last_p = res.path[-1].end_port
-                    target_p = netlist[nid][1]
-                    dist = abs(last_p.x - target_p.x) + abs(last_p.y - target_p.y)
-                    ax.scatter(last_p.x, last_p.y, color='red', marker='x', s=100)
-                    ax.text(last_p.x, last_p.y, f" {nid} (rem: {dist:.0f}um)", color='red', fontsize=8)
-
-            fig.savefig(f"examples/07_iteration_{idx:02d}.png")
-            import matplotlib.pyplot as plt
-            plt.close(fig)
-
-            # Plot Expansion Density if data is available
-            if pf.accumulated_expanded_nodes:
-                 fig_d, ax_d = plot_expansion_density(pf.accumulated_expanded_nodes, bounds)
-                 fig_d.savefig(f"examples/07_iteration_{idx:02d}_density.png")
-                 plt.close(fig_d)
-
         metrics.reset_per_route()
 
-    import cProfile, pstats
-    profiler = cProfile.Profile()
-    profiler.enable()
     t0 = time.perf_counter()
     results = pf.route_all(netlist, net_widths, store_expanded=True, iteration_callback=iteration_callback, shuffle_nets=True, seed=42)
     t1 = time.perf_counter()
-    profiler.disable()
 
-    # Final stats
-    stats = pstats.Stats(profiler).sort_stats('tottime')
-    stats.print_stats(20)
     print(f"Routing took {t1-t0:.4f}s")
 
     # 4. Check Results
@@ -157,28 +92,15 @@ def main() -> None:
     print(f"\nFinal: Routed {success_count}/{len(netlist)} nets successfully.")
 
     for nid, res in results.items():
-        target_p = netlist[nid][1]
         if not res.is_valid:
-            last_p = res.path[-1].end_port if res.path else netlist[nid][0]
-            dist = abs(last_p.x - target_p.x) + abs(last_p.y - target_p.y)
-            print(f"  FAILED: {nid} (Stopped {dist:.1f}um from target)")
+            print(f"  FAILED: {nid}, collisions={res.collisions}")
         else:
-            types = [move.move_type for move in res.path]
-            from collections import Counter
-            counts = Counter(types)
-            print(f"  {nid}: {len(res.path)} segments, {dict(counts)}")
+            print(f"  {nid}: SUCCESS")
 
     # 5. Visualize
     fig, ax = plot_routing_results(results, obstacles, bounds, netlist=netlist)
-
-    # Overlay Danger Map
     plot_danger_map(danger_map, ax=ax)
 
-    # Overlay Expanded Nodes from last routed net (as an example)
-    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

@@ -19,7 +19,7 @@ def main() -> None:
     danger_map.precompute([])
 
     evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
-    context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0], sbend_radii=[])
+    context = AStarContext(evaluator, bend_radii=[10.0], sbend_radii=[])
     metrics = AStarMetrics()
     pf = PathFinder(context, metrics)
 
@@ -40,7 +40,7 @@ def main() -> None:
 
     print("Routing with custom collision model...")
     # Override bend_collision_type with a literal Polygon
-    context_custom = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0], bend_collision_type=custom_poly, sbend_radii=[])
+    context_custom = AStarContext(evaluator, bend_radii=[10.0], bend_collision_type=custom_poly, sbend_radii=[])
     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

@@ -8,51 +8,49 @@ from inire.utils.visualization import plot_routing_results
 from shapely.geometry import box
 
 def main() -> None:
-    print("Running Example 09: Best-Effort (Unroutable Net)...")
+    print("Running Example 09: Best-Effort Under Tight Search Budget...")
 
     # 1. Setup Environment
     bounds = (0, 0, 100, 100)
     engine = CollisionEngine(clearance=2.0)
-    
-    # Create a 'cage' that completely blocks the target
-    cage = [
-        box(70, 30, 75, 70), # Left wall
-        box(70, 70, 95, 75), # Top wall
-        box(70, 25, 95, 30), # Bottom wall
+
+    # A small obstacle cluster keeps the partial route visually interesting.
+    obstacles = [
+        box(35, 35, 45, 65),
+        box(55, 35, 65, 65),
     ]
-    for obs in cage:
+    for obs in obstacles:
         engine.add_static_obstacle(obs)
 
     danger_map = DangerMap(bounds=bounds)
-    danger_map.precompute(cage)
+    danger_map.precompute(obstacles)
 
     evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
-    # Use a low node limit to fail faster
-    context = AStarContext(evaluator, node_limit=2000, snap_size=1.0, bend_radii=[10.0])
+    # Keep the search budget intentionally tiny so the router returns a partial path.
+    context = AStarContext(evaluator, node_limit=3, bend_radii=[10.0])
     metrics = AStarMetrics()
-    
-    # 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
+    pf = PathFinder(context, metrics, warm_start=None)
+
+    # 2. Define Netlist: reaching the target requires additional turns the search budget cannot afford.
     netlist = {
-        "trapped_net": (Port(10, 50, 0), Port(85, 50, 0)),
+        "budget_limited_net": (Port(10, 50, 0), Port(85, 60, 180)),
     }
-    net_widths = {"trapped_net": 2.0}
+    net_widths = {"budget_limited_net": 2.0}
 
     # 3. Route
-    print("Routing net into a cage (should fail and return partial)...")
+    print("Routing with a deliberately tiny node budget (should return a partial path)...")
     results = pf.route_all(netlist, net_widths)
 
     # 4. Check Results
-    res = results["trapped_net"]
-    if not res.is_valid:
-        print(f"Net failed to route as expected. Partial path length: {len(res.path)} segments.")
+    res = results["budget_limited_net"]
+    if not res.reached_target:
+        print(f"Target not reached as expected. Partial path length: {len(res.path)} segments.")
     else:
-        print("Wait, it found a way in? Check the cage geometry!")
+        print("The route unexpectedly reached the target. Increase difficulty or reduce the node budget further.")
 
     # 5. Visualize
-    fig, ax = plot_routing_results(results, cage, bounds, netlist=netlist)
+    fig, ax = plot_routing_results(results, obstacles, bounds, netlist=netlist)
     fig.savefig("examples/09_unroutable_best_effort.png")
     print("Saved plot to examples/09_unroutable_best_effort.png")