some perf improvements
1
ex1.ssc
1
ex2.ssc
1
ex3.ssc
1
ex4.ssc
1
ex5.ssc
1
ex6.ssc
1
ex7.ssc
1
ex8.ssc
1
ex9.ssc
|
Before Width: | Height: | Size: 79 KiB After Width: | Height: | Size: 66 KiB |
|
Before Width: | Height: | Size: 87 KiB After Width: | Height: | Size: 86 KiB |
|
Before Width: | Height: | Size: 77 KiB After Width: | Height: | Size: 74 KiB |
|
Before Width: | Height: | Size: 86 KiB After Width: | Height: | Size: 82 KiB |
|
Before Width: | Height: | Size: 107 KiB After Width: | Height: | Size: 97 KiB |
|
Before Width: | Height: | Size: 89 KiB After Width: | Height: | Size: 78 KiB |
|
|
@ -103,7 +103,8 @@ def main() -> None:
|
|||
})
|
||||
|
||||
# Save plots only for certain iterations to save time
|
||||
if idx % 20 == 0 or idx == pf.max_iterations - 1:
|
||||
# if idx % 20 == 0 or idx == pf.max_iterations - 1:
|
||||
if False:
|
||||
# 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)
|
||||
|
|
|
|||
|
Before Width: | Height: | Size: 88 KiB After Width: | Height: | Size: 88 KiB |
|
Before Width: | Height: | Size: 78 KiB After Width: | Height: | Size: 51 KiB |
|
|
@ -28,7 +28,7 @@ class CollisionEngine:
|
|||
'dynamic_tree', 'dynamic_obj_ids', 'dynamic_grid', '_dynamic_id_counter',
|
||||
'metrics', '_dynamic_tree_dirty', '_dynamic_net_ids_array', '_inv_grid_cell_size',
|
||||
'_static_bounds_array', '_static_is_rect_array', '_locked_nets',
|
||||
'_static_raw_tree', '_static_raw_obj_ids'
|
||||
'_static_raw_tree', '_static_raw_obj_ids', '_dynamic_bounds_array'
|
||||
)
|
||||
|
||||
def __init__(
|
||||
|
|
@ -72,6 +72,7 @@ class CollisionEngine:
|
|||
self._dynamic_id_counter = 0
|
||||
self._dynamic_tree_dirty = True
|
||||
self._dynamic_net_ids_array = numpy.array([], dtype='<U32')
|
||||
self._dynamic_bounds_array = numpy.array([], dtype=numpy.float64).reshape(0, 4)
|
||||
self._locked_nets: set[str] = set()
|
||||
|
||||
self.metrics = {
|
||||
|
|
@ -135,6 +136,7 @@ class CollisionEngine:
|
|||
geoms = [self.dynamic_dilated[i] for i in ids]
|
||||
self.dynamic_tree = STRtree(geoms)
|
||||
self.dynamic_obj_ids = numpy.array(ids, dtype=numpy.int32)
|
||||
self._dynamic_bounds_array = numpy.array([g.bounds for g in geoms])
|
||||
nids = [self.dynamic_geometries[obj_id][0] for obj_id in self.dynamic_obj_ids]
|
||||
self._dynamic_net_ids_array = numpy.array(nids, dtype='<U32')
|
||||
self._dynamic_tree_dirty = False
|
||||
|
|
@ -191,20 +193,29 @@ class CollisionEngine:
|
|||
self._ensure_static_tree()
|
||||
if self.static_tree is None: return False
|
||||
|
||||
# In sparse A*, result.dilated_geometry is buffered by C/2.
|
||||
# static_dilated is also buffered by C/2.
|
||||
# Total separation = C. Correct for waveguide-waveguide and waveguide-obstacle?
|
||||
# Actually, if result.geometry is width Wi, then dilated is Wi + C.
|
||||
# Wait, result.dilated_geometry is buffered by self._self_dilation = C/2.
|
||||
# So dilated poly is Wi + C.
|
||||
# Obstacle dilated by C/2 is Wo + C.
|
||||
# Intersection means dist < (Wi+C)/2 + (Wo+C)/2? No.
|
||||
# Let's keep it simple:
|
||||
# result.geometry is the REAL waveguide polygon (width Wi).
|
||||
# dilated_geometry is buffered by C/2.
|
||||
# static_dilated is buffered by C/2.
|
||||
# Intersecting them means dist < C. This is correct!
|
||||
# 1. Fast total bounds check
|
||||
tb = result.total_bounds
|
||||
s_bounds = self._static_bounds_array
|
||||
possible_total = (tb[0] < s_bounds[:, 2]) & (tb[2] > s_bounds[:, 0]) & \
|
||||
(tb[1] < s_bounds[:, 3]) & (tb[3] > s_bounds[:, 1])
|
||||
|
||||
if not numpy.any(possible_total):
|
||||
return False
|
||||
|
||||
# 2. Per-polygon AABB check
|
||||
bounds_list = result.bounds
|
||||
any_possible = False
|
||||
for b in bounds_list:
|
||||
possible = (b[0] < s_bounds[:, 2]) & (b[2] > s_bounds[:, 0]) & \
|
||||
(b[1] < s_bounds[:, 3]) & (b[3] > s_bounds[:, 1])
|
||||
if numpy.any(possible):
|
||||
any_possible = True
|
||||
break
|
||||
|
||||
if not any_possible:
|
||||
return False
|
||||
|
||||
# 3. Real geometry check (Triggers Lazy Evaluation)
|
||||
test_geoms = result.dilated_geometry if result.dilated_geometry else result.geometry
|
||||
for i, poly in enumerate(result.geometry):
|
||||
hits = self.static_tree.query(test_geoms[i], predicate='intersects')
|
||||
|
|
@ -215,15 +226,20 @@ class CollisionEngine:
|
|||
return False
|
||||
|
||||
def check_move_congestion(self, result: ComponentResult, net_id: str) -> int:
|
||||
if result.total_dilated_bounds is None: return 0
|
||||
tb = result.total_dilated_bounds
|
||||
if tb is None: return 0
|
||||
self._ensure_dynamic_grid()
|
||||
if not self.dynamic_grid: return 0
|
||||
b = result.total_dilated_bounds; cs = self.grid_cell_size
|
||||
|
||||
cs_inv = self._inv_grid_cell_size
|
||||
gx_min, gy_min = int(tb[0] * cs_inv), int(tb[1] * cs_inv)
|
||||
gx_max, gy_max = int(tb[2] * cs_inv), int(tb[3] * cs_inv)
|
||||
|
||||
any_possible = False
|
||||
dynamic_grid = self.dynamic_grid
|
||||
dynamic_geometries = self.dynamic_geometries
|
||||
for gx in range(int(b[0]/cs), int(b[2]/cs)+1):
|
||||
for gy in range(int(b[1]/cs), int(b[3]/cs)+1):
|
||||
for gx in range(gx_min, gx_max + 1):
|
||||
for gy in range(gy_min, gy_max + 1):
|
||||
cell = (gx, gy)
|
||||
if cell in dynamic_grid:
|
||||
for obj_id in dynamic_grid[cell]:
|
||||
|
|
@ -232,14 +248,40 @@ class CollisionEngine:
|
|||
if any_possible: break
|
||||
if any_possible: break
|
||||
if not any_possible: return 0
|
||||
|
||||
self.metrics['congestion_tree_queries'] += 1
|
||||
self._ensure_dynamic_tree()
|
||||
if self.dynamic_tree is None: return 0
|
||||
|
||||
# 1. Fast total bounds check (LAZY SAFE)
|
||||
tb = result.total_dilated_bounds
|
||||
d_bounds = self._dynamic_bounds_array
|
||||
possible_total = (tb[0] < d_bounds[:, 2]) & (tb[2] > d_bounds[:, 0]) & \
|
||||
(tb[1] < d_bounds[:, 3]) & (tb[3] > d_bounds[:, 1])
|
||||
|
||||
# Filter by net_id (important for negotiated congestion)
|
||||
valid_hits = (self._dynamic_net_ids_array != net_id)
|
||||
if not numpy.any(possible_total & valid_hits):
|
||||
return 0
|
||||
|
||||
# 2. Per-polygon AABB check using query on geometries (LAZY triggering)
|
||||
# We only trigger evaluation if total bounds intersect with other nets.
|
||||
geoms_to_test = result.dilated_geometry if result.dilated_geometry else result.geometry
|
||||
res_indices, tree_indices = self.dynamic_tree.query(geoms_to_test, predicate='intersects')
|
||||
if tree_indices.size == 0: return 0
|
||||
|
||||
if tree_indices.size == 0:
|
||||
return 0
|
||||
|
||||
# Filter out self-overlaps (from same net)
|
||||
hit_net_ids = numpy.take(self._dynamic_net_ids_array, tree_indices)
|
||||
return int(numpy.sum(hit_net_ids != net_id))
|
||||
valid_geoms_hits = (hit_net_ids != net_id)
|
||||
if not numpy.any(valid_geoms_hits):
|
||||
return 0
|
||||
|
||||
# 3. Real geometry check (Only if AABBs intersect with other nets)
|
||||
# We already have hits from STRtree which are accurate for polygons too.
|
||||
# But wait, query(..., predicate='intersects') ALREADY does real check!
|
||||
return int(numpy.sum(valid_geoms_hits))
|
||||
|
||||
def _is_in_safety_zone(self, geometry: Polygon, obj_id: int, start_port: Port | None, end_port: Port | None) -> bool:
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -25,18 +25,20 @@ def snap_search_grid(value: float, snap_size: float = SEARCH_GRID_SNAP_UM) -> fl
|
|||
class ComponentResult:
|
||||
"""
|
||||
Standard container for generated move geometry and state.
|
||||
Supports Lazy Evaluation for translation to improve performance.
|
||||
"""
|
||||
__slots__ = (
|
||||
'geometry', 'dilated_geometry', 'proxy_geometry', 'actual_geometry', 'dilated_actual_geometry',
|
||||
'end_port', 'length', 'move_type', 'bounds', 'dilated_bounds',
|
||||
'total_bounds', 'total_dilated_bounds', '_t_cache', '_total_geom_list', '_offsets', '_coords_cache'
|
||||
'_geometry', '_dilated_geometry', '_proxy_geometry', '_actual_geometry', '_dilated_actual_geometry',
|
||||
'end_port', 'length', 'move_type', '_bounds', '_dilated_bounds',
|
||||
'_total_bounds', '_total_dilated_bounds', '_t_cache', '_total_geom_list', '_offsets', '_coords_cache',
|
||||
'_base_result', '_offset', '_lazy_evaluated', 'rel_gx', 'rel_gy', 'rel_go'
|
||||
)
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
geometry: list[Polygon],
|
||||
end_port: Port,
|
||||
length: float,
|
||||
geometry: list[Polygon] | None = None,
|
||||
end_port: Port | None = None,
|
||||
length: float = 0.0,
|
||||
dilated_geometry: list[Polygon] | None = None,
|
||||
proxy_geometry: list[Polygon] | None = None,
|
||||
actual_geometry: list[Polygon] | None = None,
|
||||
|
|
@ -45,26 +47,66 @@ class ComponentResult:
|
|||
move_type: str = 'Unknown',
|
||||
_total_geom_list: list[Polygon] | None = None,
|
||||
_offsets: list[int] | None = None,
|
||||
_coords_cache: numpy.ndarray | None = None
|
||||
_coords_cache: numpy.ndarray | None = None,
|
||||
_base_result: ComponentResult | None = None,
|
||||
_offset: list[float] | None = None,
|
||||
snap_size: float = SEARCH_GRID_SNAP_UM,
|
||||
rel_gx: int | None = None,
|
||||
rel_gy: int | None = None,
|
||||
rel_go: int | None = None
|
||||
) -> None:
|
||||
self.geometry = geometry
|
||||
self.dilated_geometry = dilated_geometry
|
||||
self.proxy_geometry = proxy_geometry
|
||||
self.actual_geometry = actual_geometry
|
||||
self.dilated_actual_geometry = dilated_actual_geometry
|
||||
self.end_port = end_port
|
||||
self.length = length
|
||||
self.move_type = move_type
|
||||
self._t_cache = {}
|
||||
|
||||
self._base_result = _base_result
|
||||
self._offset = _offset
|
||||
self._lazy_evaluated = False
|
||||
|
||||
if rel_gx is not None:
|
||||
self.rel_gx = rel_gx
|
||||
self.rel_gy = rel_gy
|
||||
self.rel_go = rel_go
|
||||
elif end_port:
|
||||
self.rel_gx = int(round(end_port.x / snap_size))
|
||||
self.rel_gy = int(round(end_port.y / snap_size))
|
||||
self.rel_go = int(round(end_port.orientation / 1.0))
|
||||
else:
|
||||
self.rel_gx = 0; self.rel_gy = 0; self.rel_go = 0
|
||||
|
||||
if _base_result is not None:
|
||||
# Lazy Mode
|
||||
self._geometry = None
|
||||
self._dilated_geometry = None
|
||||
self._proxy_geometry = None
|
||||
self._actual_geometry = None
|
||||
self._dilated_actual_geometry = None
|
||||
|
||||
# Bounds are computed on demand
|
||||
self._bounds = None
|
||||
self._dilated_bounds = None
|
||||
self._total_bounds = None
|
||||
self._total_dilated_bounds = None
|
||||
|
||||
# No need to copy large arrays if we reference base
|
||||
else:
|
||||
# Eager Mode (Base Component)
|
||||
self._geometry = geometry
|
||||
self._dilated_geometry = dilated_geometry
|
||||
self._proxy_geometry = proxy_geometry
|
||||
self._actual_geometry = actual_geometry
|
||||
self._dilated_actual_geometry = dilated_actual_geometry
|
||||
|
||||
if _total_geom_list is not None and _offsets is not None:
|
||||
self._total_geom_list = _total_geom_list
|
||||
self._offsets = _offsets
|
||||
self._coords_cache = _coords_cache
|
||||
else:
|
||||
# Flatten everything for fast vectorized translate
|
||||
gl = list(geometry)
|
||||
o = [len(geometry)]
|
||||
gl = []
|
||||
if geometry: gl.extend(geometry)
|
||||
o = [len(gl)]
|
||||
if dilated_geometry: gl.extend(dilated_geometry)
|
||||
o.append(len(gl))
|
||||
if proxy_geometry: gl.extend(proxy_geometry)
|
||||
|
|
@ -74,25 +116,114 @@ class ComponentResult:
|
|||
if dilated_actual_geometry: gl.extend(dilated_actual_geometry)
|
||||
self._total_geom_list = gl
|
||||
self._offsets = o
|
||||
self._coords_cache = shapely.get_coordinates(gl)
|
||||
self._coords_cache = shapely.get_coordinates(gl) if gl else None
|
||||
|
||||
if not skip_bounds:
|
||||
self.bounds = shapely.bounds(geometry)
|
||||
self.total_bounds = numpy.array([
|
||||
numpy.min(self.bounds[:, 0]), numpy.min(self.bounds[:, 1]),
|
||||
numpy.max(self.bounds[:, 2]), numpy.max(self.bounds[:, 3])
|
||||
if not skip_bounds and geometry:
|
||||
self._bounds = shapely.bounds(geometry)
|
||||
self._total_bounds = numpy.array([
|
||||
numpy.min(self._bounds[:, 0]), numpy.min(self._bounds[:, 1]),
|
||||
numpy.max(self._bounds[:, 2]), numpy.max(self._bounds[:, 3])
|
||||
])
|
||||
if dilated_geometry is not None:
|
||||
self.dilated_bounds = shapely.bounds(dilated_geometry)
|
||||
self.total_dilated_bounds = numpy.array([
|
||||
numpy.min(self.dilated_bounds[:, 0]), numpy.min(self.dilated_bounds[:, 1]),
|
||||
numpy.max(self.dilated_bounds[:, 2]), numpy.max(self.dilated_bounds[:, 3])
|
||||
self._dilated_bounds = shapely.bounds(dilated_geometry)
|
||||
self._total_dilated_bounds = numpy.array([
|
||||
numpy.min(self._dilated_bounds[:, 0]), numpy.min(self._dilated_bounds[:, 1]),
|
||||
numpy.max(self._dilated_bounds[:, 2]), numpy.max(self._dilated_bounds[:, 3])
|
||||
])
|
||||
else:
|
||||
self.dilated_bounds = None
|
||||
self.total_dilated_bounds = None
|
||||
self._dilated_bounds = None
|
||||
self._total_dilated_bounds = None
|
||||
else:
|
||||
self._bounds = None
|
||||
self._total_bounds = None
|
||||
self._dilated_bounds = None
|
||||
self._total_dilated_bounds = None
|
||||
|
||||
def translate(self, dx: float, dy: float) -> ComponentResult:
|
||||
def _ensure_evaluated(self) -> None:
|
||||
if self._base_result is None or self._lazy_evaluated:
|
||||
return
|
||||
|
||||
# Perform Translation
|
||||
dx, dy = self._offset
|
||||
# Base uses its own coords cache
|
||||
base_coords = self._base_result._coords_cache
|
||||
if base_coords is None:
|
||||
self._lazy_evaluated = True
|
||||
return
|
||||
|
||||
new_coords = base_coords + [dx, dy]
|
||||
|
||||
# Translate ALL geometries at once
|
||||
new_total_arr = shapely.set_coordinates(list(self._base_result._total_geom_list), new_coords)
|
||||
new_total = new_total_arr.tolist()
|
||||
|
||||
o = self._base_result._offsets
|
||||
self._geometry = new_total[:o[0]]
|
||||
self._dilated_geometry = new_total[o[0]:o[1]] if self._base_result._dilated_geometry is not None else None
|
||||
self._proxy_geometry = new_total[o[1]:o[2]] if self._base_result._proxy_geometry is not None else None
|
||||
self._actual_geometry = new_total[o[2]:o[3]] if self._base_result._actual_geometry is not None else None
|
||||
self._dilated_actual_geometry = new_total[o[3]:] if self._base_result._dilated_actual_geometry is not None else None
|
||||
|
||||
self._lazy_evaluated = True
|
||||
|
||||
@property
|
||||
def geometry(self) -> list[Polygon]:
|
||||
self._ensure_evaluated()
|
||||
return self._geometry
|
||||
|
||||
@property
|
||||
def dilated_geometry(self) -> list[Polygon] | None:
|
||||
self._ensure_evaluated()
|
||||
return self._dilated_geometry
|
||||
|
||||
@property
|
||||
def proxy_geometry(self) -> list[Polygon] | None:
|
||||
self._ensure_evaluated()
|
||||
return self._proxy_geometry
|
||||
|
||||
@property
|
||||
def actual_geometry(self) -> list[Polygon] | None:
|
||||
self._ensure_evaluated()
|
||||
return self._actual_geometry
|
||||
|
||||
@property
|
||||
def dilated_actual_geometry(self) -> list[Polygon] | None:
|
||||
self._ensure_evaluated()
|
||||
return self._dilated_actual_geometry
|
||||
|
||||
@property
|
||||
def bounds(self) -> numpy.ndarray:
|
||||
if self._bounds is None:
|
||||
if self._base_result is not None:
|
||||
dx, dy = self._offset
|
||||
self._bounds = self._base_result.bounds + [dx, dy, dx, dy]
|
||||
return self._bounds
|
||||
|
||||
@property
|
||||
def total_bounds(self) -> numpy.ndarray:
|
||||
if self._total_bounds is None:
|
||||
if self._base_result is not None:
|
||||
dx, dy = self._offset
|
||||
self._total_bounds = self._base_result.total_bounds + [dx, dy, dx, dy]
|
||||
return self._total_bounds
|
||||
|
||||
@property
|
||||
def dilated_bounds(self) -> numpy.ndarray | None:
|
||||
if self._dilated_bounds is None:
|
||||
if self._base_result is not None and self._base_result.dilated_bounds is not None:
|
||||
dx, dy = self._offset
|
||||
self._dilated_bounds = self._base_result.dilated_bounds + [dx, dy, dx, dy]
|
||||
return self._dilated_bounds
|
||||
|
||||
@property
|
||||
def total_dilated_bounds(self) -> numpy.ndarray | None:
|
||||
if self._total_dilated_bounds is None:
|
||||
if self._base_result is not None and self._base_result.total_dilated_bounds is not None:
|
||||
dx, dy = self._offset
|
||||
self._total_dilated_bounds = self._base_result.total_dilated_bounds + [dx, dy, dx, dy]
|
||||
return self._total_dilated_bounds
|
||||
|
||||
def translate(self, dx: float, dy: float, rel_gx: int | None = None, rel_gy: int | None = None, rel_go: int | None = None) -> ComponentResult:
|
||||
"""
|
||||
Create a new ComponentResult translated by (dx, dy).
|
||||
"""
|
||||
|
|
@ -102,44 +233,27 @@ class ComponentResult:
|
|||
if (dxr, dyr) in self._t_cache:
|
||||
return self._t_cache[(dxr, dyr)]
|
||||
|
||||
# FASTEST TRANSLATE
|
||||
new_coords = self._coords_cache + [dx, dy]
|
||||
new_total_arr = shapely.set_coordinates(list(self._total_geom_list), new_coords)
|
||||
new_total = new_total_arr.tolist()
|
||||
|
||||
o = self._offsets
|
||||
new_geom = new_total[:o[0]]
|
||||
new_dil = new_total[o[0]:o[1]] if self.dilated_geometry is not None else None
|
||||
new_proxy = new_total[o[1]:o[2]] if self.proxy_geometry is not None else None
|
||||
new_actual = new_total[o[2]:o[3]] if self.actual_geometry is not None else None
|
||||
new_dil_actual = new_total[o[3]:] if self.dilated_actual_geometry is not None else None
|
||||
|
||||
new_port = Port(self.end_port.x + dx, self.end_port.y + dy, self.end_port.orientation)
|
||||
|
||||
# Fast bypass of __init__
|
||||
res = self.__class__.__new__(self.__class__)
|
||||
res.geometry = new_geom
|
||||
res.dilated_geometry = new_dil
|
||||
res.proxy_geometry = new_proxy
|
||||
res.actual_geometry = new_actual
|
||||
res.dilated_actual_geometry = new_dil_actual
|
||||
res.end_port = new_port
|
||||
res.length = self.length
|
||||
res.move_type = self.move_type
|
||||
res._t_cache = {}
|
||||
res._total_geom_list = new_total
|
||||
res._offsets = o
|
||||
res._coords_cache = new_coords
|
||||
|
||||
db = [dx, dy, dx, dy]
|
||||
res.bounds = self.bounds + db
|
||||
res.total_bounds = self.total_bounds + db
|
||||
if self.dilated_bounds is not None:
|
||||
res.dilated_bounds = self.dilated_bounds + db
|
||||
res.total_dilated_bounds = self.total_dilated_bounds + db
|
||||
# LAZY TRANSLATE
|
||||
if self._base_result:
|
||||
base = self._base_result
|
||||
current_offset = self._offset
|
||||
new_offset = [current_offset[0] + dx, current_offset[1] + dy]
|
||||
else:
|
||||
res.dilated_bounds = None
|
||||
res.total_dilated_bounds = None
|
||||
base = self
|
||||
new_offset = [dx, dy]
|
||||
|
||||
res = ComponentResult(
|
||||
end_port=new_port,
|
||||
length=self.length,
|
||||
move_type=self.move_type,
|
||||
_base_result=base,
|
||||
_offset=new_offset,
|
||||
rel_gx=rel_gx,
|
||||
rel_gy=rel_gy,
|
||||
rel_go=rel_go
|
||||
)
|
||||
|
||||
self._t_cache[(dxr, dyr)] = res
|
||||
return res
|
||||
|
|
@ -205,7 +319,7 @@ class Straight:
|
|||
dilated_geom = [Polygon(poly_points_dil)]
|
||||
|
||||
# For straight segments, geom IS the actual geometry
|
||||
return ComponentResult(geometry=geom, end_port=end_port, length=actual_length, dilated_geometry=dilated_geom, actual_geometry=geom, dilated_actual_geometry=dilated_geom, move_type='Straight')
|
||||
return ComponentResult(geometry=geom, end_port=end_port, length=actual_length, dilated_geometry=dilated_geom, actual_geometry=geom, dilated_actual_geometry=dilated_geom, move_type='Straight', snap_size=snap_size)
|
||||
|
||||
|
||||
def _get_num_segments(radius: float, angle_deg: float, sagitta: float = 0.01) -> int:
|
||||
|
|
@ -432,7 +546,8 @@ class Bend90:
|
|||
proxy_geometry=proxy_geom,
|
||||
actual_geometry=arc_polys,
|
||||
dilated_actual_geometry=dilated_actual_geom,
|
||||
move_type='Bend90'
|
||||
move_type='Bend90',
|
||||
snap_size=snap_size
|
||||
)
|
||||
|
||||
|
||||
|
|
@ -485,7 +600,7 @@ class SBend:
|
|||
if abs(theta) < 1e-9:
|
||||
# De-generate to straight
|
||||
actual_len = numpy.sqrt(local_dx**2 + local_dy**2)
|
||||
return Straight.generate(start_port, actual_len, width, snap_to_grid=False, dilation=dilation)
|
||||
return Straight.generate(start_port, actual_len, width, snap_to_grid=False, dilation=dilation, snap_size=snap_size)
|
||||
|
||||
denom = (2 * (1 - numpy.cos(theta)))
|
||||
if abs(denom) < 1e-9:
|
||||
|
|
@ -496,7 +611,7 @@ class SBend:
|
|||
# Limit radius to prevent giant arcs
|
||||
if actual_radius > 100000.0:
|
||||
actual_len = numpy.sqrt(local_dx**2 + local_dy**2)
|
||||
return Straight.generate(start_port, actual_len, width, snap_to_grid=False, dilation=dilation)
|
||||
return Straight.generate(start_port, actual_len, width, snap_to_grid=False, dilation=dilation, snap_size=snap_size)
|
||||
|
||||
direction = 1 if local_dy > 0 else -1
|
||||
c1_angle = rad_start + direction * numpy.pi / 2
|
||||
|
|
@ -546,5 +661,6 @@ class SBend:
|
|||
proxy_geometry=proxy_geom,
|
||||
actual_geometry=arc_polys,
|
||||
dilated_actual_geometry=dilated_actual_geom,
|
||||
move_type='SBend'
|
||||
move_type='SBend',
|
||||
snap_size=snap_size
|
||||
)
|
||||
|
|
|
|||