initial pass on examples

examples/01_simple_route.py

@@ -0,0 +1,58 @@
+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.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 main() -> None:
+    print("Running Example 01: Simple Route...")
+
+    # 1. Setup Environment
+    # Define the routing area bounds (minx, miny, maxx, maxy)
+    bounds = (0, 0, 100, 100)
+
+    engine = CollisionEngine(clearance=2.0)
+    danger_map = DangerMap(bounds=bounds)
+
+    # Add a simple rectangular obstacle
+    obstacle = Polygon([(30, 20), (70, 20), (70, 40), (30, 40)])
+    engine.add_static_obstacle(obstacle)
+
+    # Precompute the danger map (distance field) for heuristics
+    danger_map.precompute([obstacle])
+
+    evaluator = CostEvaluator(engine, danger_map)
+    router = AStarRouter(evaluator)
+    pf = PathFinder(router, evaluator)
+
+    # 2. Define Netlist
+    # Route from (10, 10) to (90, 50)
+    # The obstacle at y=20-40 blocks the direct path.
+    netlist = {
+        "simple_net": (Port(10, 10, 0), Port(90, 50, 0)),
+    }
+    net_widths = {"simple_net": 2.0}
+
+    # 3. Route
+    results = pf.route_all(netlist, net_widths)
+
+    # 4. Check Results
+    if results["simple_net"].is_valid:
+        print("Success! Route found.")
+        print(f"Path collisions: {results['simple_net'].collisions}")
+    else:
+        print("Failed to route.")
+
+    # 5. Visualize
+    fig, ax = plot_routing_results(results, [obstacle], bounds)
+    fig.savefig("examples/simple_route.png")
+    print("Saved plot to examples/simple_route.png")
+
+
+if __name__ == "__main__":
+    main()

examples/02_congestion_resolution.py

@@ -0,0 +1,54 @@
+
+from inire.geometry.collision import CollisionEngine
+from inire.geometry.primitives import Port
+from inire.router.astar import AStarRouter
+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 main() -> None:
+    print("Running Example 02: Congestion Resolution (Crossing)...")
+
+    # 1. Setup Environment (Open space)
+    bounds = (0, 0, 100, 100)
+    engine = CollisionEngine(clearance=2.0)
+    danger_map = DangerMap(bounds=bounds)
+    danger_map.precompute([])
+
+    evaluator = CostEvaluator(engine, danger_map)
+    router = AStarRouter(evaluator)
+    pf = PathFinder(router, evaluator)
+
+    # 2. Define Netlist
+    # Two nets that MUST cross.
+    # Since crossings are illegal in single-layer routing, one net must detour around the other.
+    netlist = {
+        "horizontal": (Port(10, 50, 0), Port(90, 50, 0)),
+        "vertical": (Port(50, 10, 90), Port(50, 90, 90)),
+    }
+    net_widths = {"horizontal": 2.0, "vertical": 2.0}
+
+    # 3. Route with Negotiated Congestion
+    # We increase the base penalty to encourage faster divergence
+    pf.base_congestion_penalty = 500.0
+    results = pf.route_all(netlist, net_widths)
+
+    # 4. Check Results
+    all_valid = all(r.is_valid for r in results.values())
+    if all_valid:
+        print("Success! Congestion resolved (one net detoured).")
+    else:
+        print("Some nets failed or have collisions.")
+        for nid, res in results.items():
+            print(f"  {nid}: valid={res.is_valid}, collisions={res.collisions}")
+
+    # 5. Visualize
+    fig, ax = plot_routing_results(results, [], bounds)
+    fig.savefig("examples/congestion.png")
+    print("Saved plot to examples/congestion.png")
+
+
+if __name__ == "__main__":
+    main()

examples/03_locked_paths.py

@@ -0,0 +1,76 @@
+
+from inire.geometry.collision import CollisionEngine
+from inire.geometry.primitives import Port
+from inire.router.astar import AStarRouter
+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 main() -> None:
+    print("Running Example 03: Locked Paths (Incremental Routing)...")
+
+    # 1. Setup Environment
+    bounds = (0, 0, 100, 100)
+    engine = CollisionEngine(clearance=2.0)
+    danger_map = DangerMap(bounds=bounds)
+    danger_map.precompute([]) # No initial obstacles
+
+    evaluator = CostEvaluator(engine, danger_map)
+    router = AStarRouter(evaluator)
+    pf = PathFinder(router, evaluator)
+
+    # 2. Phase 1: Route a "Critical" Net
+    # This net gets priority and takes the best path.
+    netlist_phase1 = {
+        "critical_net": (Port(10, 50, 0), Port(90, 50, 0)),
+    }
+    print("Phase 1: Routing critical_net...")
+    results1 = pf.route_all(netlist_phase1, {"critical_net": 3.0}) # Wider trace
+
+    if not results1["critical_net"].is_valid:
+        print("Error: Phase 1 failed.")
+        return
+
+    # 3. Lock the Critical Net
+    # This converts the dynamic path into a static obstacle in the collision engine.
+    print("Locking critical_net...")
+    engine.lock_net("critical_net")
+
+    # Update danger map to reflect the new obstacle (optional but recommended for heuristics)
+    # Extract polygons from result
+    path_polys = [p for comp in results1["critical_net"].path for p in comp.geometry]
+    danger_map.precompute(path_polys)
+
+    # 4. Phase 2: Route a Secondary Net
+    # This net must route *around* the locked critical_net.
+    # Start and end points force a crossing path if it were straight.
+    netlist_phase2 = {
+        "secondary_net": (Port(50, 10, 90), Port(50, 90, 90)),
+    }
+
+    print("Phase 2: Routing secondary_net around locked path...")
+    results2 = pf.route_all(netlist_phase2, {"secondary_net": 2.0})
+
+    if results2["secondary_net"].is_valid:
+        print("Success! Secondary net routed around locked path.")
+    else:
+        print("Failed to route secondary net.")
+
+    # 5. Visualize
+    # Combine results for plotting
+    all_results = {**results1, **results2}
+
+    # Note: 'critical_net' is now in engine.static_obstacles internally,
+    # but for visualization we plot it from the result object to see it clearly.
+    # We pass an empty list for 'static_obstacles' to plot_routing_results
+    # because we want to see the path colored, not grayed out as an obstacle.
+
+    fig, ax = plot_routing_results(all_results, [], bounds)
+    fig.savefig("examples/locked.png")
+    print("Saved plot to examples/locked.png")
+
+
+if __name__ == "__main__":
+    main()