jan/inire
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

clean up magic numbers, enable arbitrary gridding, add cache invalidatino

Browse source
This commit is contained in:
Jan Petykiewicz 2026-03-26 20:22:17 -07:00
commit 519dd48131
19 changed files with 574 additions and 358 deletions
Download patch file Download diff file Expand all files Collapse all files

51
examples/01_simple_route.py
View file

@ -1,8 +1,6 @@
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
@ -13,43 +11,44 @@ def main() -> None:
print("Running Example 01: Simple Route...")
# 1. Setup Environment
# Define the routing area bounds (minx, miny, maxx, maxy)
# We define a 100um x 100um routing area
bounds = (0, 0, 100, 100)
# Clearance of 2.0um between waveguides
engine = CollisionEngine(clearance=2.0)
# Precompute DangerMap for heuristic speedup
danger_map = DangerMap(bounds=bounds)
danger_map.precompute([]) # No obstacles yet
# 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, bend_penalty=50.0, sbend_penalty=150.0)
# 2. Configure Router
evaluator = CostEvaluator(engine, danger_map)
context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0])
pf = PathFinder(context)
metrics = AStarMetrics()
pf = PathFinder(context, metrics)
# 2. Define Netlist
# Route from (10, 10) to (90, 50)
# The obstacle at y=20-40 blocks the direct path.
# 3. Define Netlist
# Start at (10, 50) pointing East (0 deg)
# Target at (90, 50) pointing East (0 deg)
netlist = {
"simple_net": (Port(10, 10, 0), Port(90, 50, 0)),
"net1": (Port(10, 50, 0), Port(90, 50, 0)),
}
net_widths = {"simple_net": 2.0}
net_widths = {"net1": 2.0}
# 3. Route
# 4. Route
results = pf.route_all(netlist, net_widths)
# 4. Check Results
if results["simple_net"].is_valid:
# 5. Check Results
res = results["net1"]
if res.is_valid:
print("Success! Route found.")
print(f"Path collisions: {results['simple_net'].collisions}")
print(f"Path collisions: {res.collisions}")
else:
print("Failed to route.")
print("Failed to find route.")
# 5. Visualize
fig, ax = plot_routing_results(results, [obstacle], bounds, netlist=netlist)
# 6. Visualize
# plot_routing_results takes a dict of RoutingResult objects
fig, ax = plot_routing_results(results, [], bounds)
fig.savefig("examples/01_simple_route.png")
print("Saved plot to examples/01_simple_route.png")

28
examples/02_congestion_resolution.py
View file

@ -1,6 +1,6 @@
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
@ -10,39 +10,37 @@ from inire.utils.visualization import plot_routing_results
def main() -> None:
print("Running Example 02: Congestion Resolution (Triple Crossing)...")
# 1. Setup Environment (Open space)
# 1. Setup Environment
bounds = (0, 0, 100, 100)
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, snap_size=1.0, bend_radii=[10.0])
pf = PathFinder(context)
# 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])
metrics = AStarMetrics()
pf = PathFinder(context, metrics, base_congestion_penalty=1000.0)
# 2. Define Netlist
# Three nets that all converge on the same central area.
# Negotiated Congestion must find non-overlapping paths for all of them.
# Three nets that must cross each other in a small area
netlist = {
"horizontal": (Port(10, 50, 0), Port(90, 50, 0)),
"vertical_up": (Port(45, 10, 90), Port(45, 90, 90)),
"vertical_down": (Port(55, 90, 270), Port(55, 10, 270)),
}
net_widths = dict.fromkeys(netlist, 2.0)
net_widths = {nid: 2.0 for nid in netlist}
# 3. Route with Negotiated Congestion
# We increase the base penalty to encourage faster divergence
pf = PathFinder(context, base_congestion_penalty=1000.0)
# 3. Route
# PathFinder uses Negotiated Congestion to resolve overlaps iteratively
results = pf.route_all(netlist, net_widths)
# 4. Check Results
all_valid = all(r.is_valid for r in results.values())
all_valid = all(res.is_valid for res in results.values())
if all_valid:
print("Success! Congestion resolved for all nets.")
else:
print("Some nets failed or have collisions.")
for nid, res in results.items():
print(f" {nid}: valid={res.is_valid}, collisions={res.collisions}")
print("Failed to resolve congestion for some nets.")
# 5. Visualize
fig, ax = plot_routing_results(results, [], bounds, netlist=netlist)

BIN
examples/03_locked_paths.png
View file

Binary file not shown.
Side by side Swipe Overlay

Before

Width:  |  Height:  |  Size: 70 KiB

After

Width:  |  Height:  |  Size: 67 KiB

Before After
Before After

49
examples/03_locked_paths.py
View file

@ -1,8 +1,6 @@
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
@ -13,49 +11,34 @@ def main() -> None:
print("Running Example 03: Locked Paths...")
# 1. Setup Environment
bounds = (0, 0, 100, 100)
bounds = (0, -50, 100, 50)
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)
evaluator = CostEvaluator(engine, danger_map)
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
fixed_start = Port(10, 50, 0)
fixed_target = Port(90, 50, 0)
# 2. Route Net A and 'Lock' it
# Net A is a straight path blocking the direct route for Net B
print("Routing initial net...")
res_fixed = route_astar(fixed_start, fixed_target, net_width=2.0, context=context, metrics=metrics)
netlist_a = {"netA": (Port(10, 0, 0), Port(90, 0, 0))}
results_a = pf.route_all(netlist_a, {"netA": 2.0})
if res_fixed:
# 3. Lock this net! It now behaves like a static obstacle
geoms = [comp.geometry[0] for comp in res_fixed]
engine.add_path("locked_net", geoms)
engine.lock_net("locked_net")
print("Initial net locked as static obstacle.")
# Update danger map to reflect the new static obstacle
danger_map.precompute(list(engine.static_geometries.values()))
# 4. Route a new net that must detour around the locked one
netlist = {
"detour_net": (Port(50, 10, 90), Port(50, 90, 90)),
}
net_widths = {"detour_net": 2.0}
# Locking prevents Net A from being removed or rerouted during NC iterations
engine.lock_net("netA")
print("Initial net locked as static obstacle.")
# 3. Route Net B (forced to detour)
print("Routing detour net around locked path...")
results = pf.route_all(netlist, net_widths)
netlist_b = {"netB": (Port(50, -20, 90), Port(50, 20, 90))}
results_b = pf.route_all(netlist_b, {"netB": 2.0})
# 5. Visualize
# Add the locked net back to results for display
from inire.router.pathfinder import RoutingResult
display_results = {**results, "locked_net": RoutingResult("locked_net", res_fixed or [], True, 0)}
fig, ax = plot_routing_results(display_results, list(engine.static_geometries.values()), bounds, netlist=netlist)
# 4. Visualize
results = {**results_a, **results_b}
fig, ax = plot_routing_results(results, [], bounds)
fig.savefig("examples/03_locked_paths.png")
print("Saved plot to examples/03_locked_paths.png")

56
examples/04_sbends_and_radii.py
View file

@ -1,6 +1,6 @@
from inire.geometry.collision import CollisionEngine
from inire.geometry.primitives import Port
from inire.router.astar import AStarContext, 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
@ -8,7 +8,7 @@ from inire.utils.visualization import plot_routing_results
def main() -> None:
print("Running Example 04: SBends and Radii Strategy...")
print("Running Example 04: S-Bends and Multiple Radii...")
# 1. Setup Environment
bounds = (0, 0, 100, 100)
@ -16,33 +16,45 @@ def main() -> None:
danger_map = DangerMap(bounds=bounds)
danger_map.precompute([])
evaluator = CostEvaluator(engine, danger_map, bend_penalty=200.0, sbend_penalty=400.0)
# Define a custom router with multiple SBend radii and specific offsets
# 2. Configure Router
evaluator = CostEvaluator(
engine,
danger_map,
unit_length_cost=1.0,
bend_penalty=10.0,
sbend_penalty=20.0,
)
context = AStarContext(
evaluator,
node_limit=50000,
snap_size=1.0,
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]
bend_radii=[10.0, 30.0],
sbend_offsets=[5.0], # Use a simpler offset
bend_penalty=10.0,
sbend_penalty=20.0,
)
pf = PathFinder(context)
# 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}
metrics = AStarMetrics()
pf = PathFinder(context, metrics)
# 3. Route
print(f"Routing {len(netlist)} nets with custom SBend strategy...")
results = pf.route_all(netlist, net_widths, shuffle_nets=True)
# 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}
# 4. Visualize
# 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
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")

27
examples/05_orientation_stress.py
View file

@ -1,6 +1,6 @@
from inire.geometry.collision import CollisionEngine
from inire.geometry.primitives import Port
from inire.router.astar import AStarContext, 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
@ -8,7 +8,7 @@ from inire.utils.visualization import plot_routing_results
def main() -> None:
print("Running Example 05: Orientation Stress...")
print("Running Example 05: Orientation Stress Test...")
# 1. Setup Environment
bounds = (0, 0, 200, 200)
@ -17,22 +17,29 @@ def main() -> None:
danger_map.precompute([])
evaluator = CostEvaluator(engine, danger_map, bend_penalty=50.0)
context = AStarContext(evaluator, snap_size=1.0, bend_radii=[10.0])
pf = PathFinder(context)
context = AStarContext(evaluator, snap_size=5.0, bend_radii=[20.0])
metrics = AStarMetrics()
pf = PathFinder(context, metrics)
# 2. Define Netlist: Complex orientation challenges
# 2. Define Netlist
# Challenging orientation combinations
netlist = {
"u_turn": (Port(50, 100, 0), Port(30, 100, 180)),
"loop": (Port(150, 50, 90), Port(150, 40, 90)),
"zig_zag": (Port(20, 20, 0), Port(180, 180, 0)),
"u_turn": (Port(50, 50, 0), Port(50, 70, 180)),
"loop": (Port(100, 100, 90), Port(100, 80, 270)),
"zig_zag": (Port(20, 150, 0), Port(180, 150, 0)),
}
net_widths = {nid: 2.0 for nid in netlist}
# 3. Route
print("Routing nets with complex orientation combinations...")
print("Routing complex orientation nets...")
results = pf.route_all(netlist, net_widths)
# 4. Visualize
# 4. Check Results
for nid, res in results.items():
status = "Success" if res.is_valid else "Failed"
print(f" {nid}: {status}")
# 5. 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")

4
examples/06_bend_collision_models.py
View file

@ -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 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
@ -59,8 +59,6 @@ def main() -> None:
all_netlists = {**netlist_arc, **netlist_bbox, **netlist_clipped}
# 4. Visualize
# Note: plot_routing_results will show the 'collision geometry' used by the router
# since that's what's stored in res.path[i].geometry
fig, ax = plot_routing_results(all_results, obstacles, bounds, netlist=all_netlists)
fig.savefig("examples/06_bend_collision_models.png")
print("Saved plot to examples/06_bend_collision_models.png")

4
examples/07_large_scale_routing.py
View file

@ -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 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
@ -141,7 +141,7 @@ def main() -> None:
t1 = time.perf_counter()
profiler.disable()
# ... (rest of the code)
# Final stats
stats = pstats.Stats(profiler).sort_stats('tottime')
stats.print_stats(20)
print(f"Routing took {t1-t0:.4f}s")