more fixes and refactoring

examples/06_bend_collision_models.py

@@ -2,21 +2,44 @@ from shapely.geometry import Polygon
 
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarContext, AStarMetrics
+from inire.router.astar import AStarContext
 from inire.router.cost import CostEvaluator
 from inire.router.danger_map import DangerMap
 from inire.router.pathfinder import PathFinder
 from inire.utils.visualization import plot_routing_results
 
 
+def _route_scenario(
+    bounds: tuple[float, float, float, float],
+    obstacles: list[Polygon],
+    bend_collision_type: str,
+    netlist: dict[str, tuple[Port, Port]],
+    widths: dict[str, float],
+    *,
+    bend_clip_margin: float = 10.0,
+) -> dict[str, object]:
+    engine = CollisionEngine(clearance=2.0)
+    for obstacle in obstacles:
+        engine.add_static_obstacle(obstacle)
+
+    danger_map = DangerMap(bounds=bounds)
+    danger_map.precompute(obstacles)
+    evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
+    context = AStarContext(
+        evaluator,
+        bend_radii=[10.0],
+        bend_collision_type=bend_collision_type,
+        bend_clip_margin=bend_clip_margin,
+    )
+    return PathFinder(context, use_tiered_strategy=False).route_all(netlist, widths)
+
+
 def main() -> None:
     print("Running Example 06: Bend Collision Models...")
 
     # 1. Setup Environment
     # Give room for 10um bends near the edges
     bounds = (-20, -20, 170, 170)
-    engine = CollisionEngine(clearance=2.0)
-    danger_map = DangerMap(bounds=bounds)
 
     # Create three scenarios with identical obstacles
     # We'll space them out vertically
@@ -25,34 +48,26 @@ def main() -> None:
     obs_clipped = Polygon([(40, 10), (60, 10), (60, 30), (40, 30)])
 
     obstacles = [obs_arc, obs_bbox, obs_clipped]
-    for obs in obstacles:
-        engine.add_static_obstacle(obs)
-    danger_map.precompute(obstacles)
-
-    # We'll run three separate routers since collision_type is a router-level config
-    evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
-
-    # Scenario 1: Standard 'arc' model (High fidelity)
-    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, 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, 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(context_arc, use_tiered_strategy=False).route_all(netlist_arc, {"arc_model": 2.0})
+    res_arc = _route_scenario(bounds, obstacles, "arc", netlist_arc, {"arc_model": 2.0})
 
     print("Routing Scenario 2 (BBox)...")
-    res_bbox = PathFinder(context_bbox, use_tiered_strategy=False).route_all(netlist_bbox, {"bbox_model": 2.0})
+    res_bbox = _route_scenario(bounds, obstacles, "bbox", netlist_bbox, {"bbox_model": 2.0})
 
     print("Routing Scenario 3 (Clipped BBox)...")
-    res_clipped = PathFinder(context_clipped, use_tiered_strategy=False).route_all(netlist_clipped, {"clipped_model": 2.0})
+    res_clipped = _route_scenario(
+        bounds,
+        obstacles,
+        "clipped_bbox",
+        netlist_clipped,
+        {"clipped_model": 2.0},
+        bend_clip_margin=1.0,
+    )
 
     # 3. Combine results for visualization
     all_results = {**res_arc, **res_bbox, **res_clipped}

examples/08_custom_bend_geometry.py

@@ -2,26 +2,27 @@ from shapely.geometry import Polygon
 
 from inire.geometry.collision import CollisionEngine
 from inire.geometry.primitives import Port
-from inire.router.astar import AStarContext, AStarMetrics, route_astar
+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
 from inire.utils.visualization import plot_routing_results
 
 
+def _route_with_context(
+    context: AStarContext,
+    metrics: AStarMetrics,
+    netlist: dict[str, tuple[Port, Port]],
+    net_widths: dict[str, float],
+) -> dict[str, object]:
+    return PathFinder(context, metrics, use_tiered_strategy=False).route_all(netlist, net_widths)
+
+
 def main() -> None:
     print("Running Example 08: Custom Bend Geometry...")
 
     # 1. Setup Environment
     bounds = (0, 0, 150, 150)
-    engine = CollisionEngine(clearance=2.0)
-    danger_map = DangerMap(bounds=bounds)
-    danger_map.precompute([])
-
-    evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
-    context = AStarContext(evaluator, bend_radii=[10.0], sbend_radii=[])
-    metrics = AStarMetrics()
-    pf = PathFinder(context, metrics)
 
     # 2. Define Netlist
     netlist = {
@@ -29,22 +30,26 @@ def main() -> None:
     }
     net_widths = {"custom_bend": 2.0}
 
+    def build_context(bend_collision_type: object = "arc") -> tuple[AStarContext, AStarMetrics]:
+        engine = CollisionEngine(clearance=2.0)
+        danger_map = DangerMap(bounds=bounds)
+        danger_map.precompute([])
+        evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0, sbend_penalty=150.0)
+        return AStarContext(evaluator, bend_radii=[10.0], bend_collision_type=bend_collision_type, sbend_radii=[]), AStarMetrics()
+
     # 3. Route with standard arc first
     print("Routing with standard arc...")
-    results_std = pf.route_all(netlist, net_widths)
+    context_std, metrics_std = build_context()
+    results_std = _route_with_context(context_std, metrics_std, netlist, net_widths)
 
-    # 4. Define a custom 'trapezoid' bend model
-    # (Just for demonstration - we override the collision model during search)
-    # Define a custom centered 20x20 box
-    custom_poly = Polygon([(-10, -10), (10, -10), (10, 10), (-10, 10)])
+    # 4. Define a custom Manhattan 90-degree bend proxy in bend-local coordinates.
+    # The polygon origin is the bend center. It is mirrored for CW bends and
+    # rotated with the bend orientation before being translated into place.
+    custom_poly = Polygon([(0, -11), (11, -11), (11, 0), (9, 0), (9, -9), (0, -9)])
 
-    print("Routing with custom collision model...")
-    # Override bend_collision_type with a literal Polygon
-    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}
-    )
+    print("Routing with custom bend geometry...")
+    context_custom, metrics_custom = build_context(custom_poly)
+    results_custom = _route_with_context(context_custom, metrics_custom, {"custom_model": netlist["custom_bend"]}, {"custom_model": 2.0})
 
     # 5. Visualize
     all_results = {**results_std, **results_custom}

examples/README.md

@@ -18,7 +18,9 @@ Demonstrates the Negotiated Congestion algorithm handling multiple intersecting
 `inire` supports multiple collision models for bends, allowing a trade-off between search speed and geometric accuracy:
 *   **Arc**: High-fidelity geometry (Highest accuracy).
 *   **BBox**: Simple axis-aligned bounding box (Fastest search).
-*   **Clipped BBox**: A balanced model that clips the corners of the AABB to better fit the arc (Optimal performance).
+*   **Clipped BBox**: A balanced 8-point conservative polygonal approximation of the arc (Optimal performance).
+
+Example 08 also demonstrates a custom polygonal bend geometry. Custom polygons are defined in bend-local coordinates around the bend center, mirrored for CW bends, and rotated with the bend orientation before being placed. The example uses a 6-point Manhattan 90-degree bend with the same width as the normal waveguide, and that polygon now serves as both the routed geometry and the search-time collision shape.
 
 ![Custom Bend Geometry](08_custom_bend_geometry.png)