nearxos/kicad-mcp-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: switch get_wire_connections to exact IU matching throughout

Browse Source 
Remove the 0.5mm query tolerance in favour of exact integer-unit matching
on all coordinate lookups (seed, label bridging, pin matching), mirroring
KiCad's own connectivity algorithm. Callers must supply exact wire endpoint
coordinates (e.g. from list_schematic_wires).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Eugene Mikhantyev
2026-03-14 17:16:57 +00:00
parent 8414784b78
commit 018f4a278d
2 changed files with 90 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
python/commands/wire_connectivity.py
View File

@@ -14,7 +14,6 @@ from commands.pin_locator import PinLocator
logger = logging.getLogger('kicad_interface')
_IU_PER_MM = 10000 # KiCad schematic internal units per millimeter
_QUERY_TOLERANCE_IU = 5000 # 0.5 mm in IU — for user-supplied query points
def _to_iu(x_mm: float, y_mm: float) -> Tuple[int, int]:
@@ -67,29 +66,78 @@ def _build_adjacency(
return adjacency, iu_to_wires
def _parse_virtual_connections(schematic, schematic_path):
"""Return virtual connectivity from net labels and power symbols.
Returns a tuple of:
- point_to_label: Dict[Tuple[int,int], str] — IU position → label name
- label_to_points: Dict[str, List[Tuple[int,int]]] — label name → list of IU positions
"""
point_to_label: Dict[Tuple[int, int], str] = {}
label_to_points: Dict[str, List[Tuple[int, int]]] = {}
if hasattr(schematic, "label"):
for label in schematic.label:
try:
if not hasattr(label, "value"):
continue
name = label.value
if not hasattr(label, "at") or not hasattr(label.at, "value"):
continue
coords = label.at.value
pt = _to_iu(float(coords[0]), float(coords[1]))
point_to_label[pt] = name
label_to_points.setdefault(name, []).append(pt)
except Exception as e:
logger.warning(f"Error parsing net label: {e}")
if hasattr(schematic, "symbol"):
locator = PinLocator()
for symbol in schematic.symbol:
try:
if not hasattr(symbol, "property") or not hasattr(symbol.property, "Reference"):
continue
ref = symbol.property.Reference.value
if not ref.startswith("#PWR"):
continue
if ref.startswith("_TEMPLATE"):
continue
if not hasattr(symbol.property, "Value"):
continue
name = symbol.property.Value.value
all_pins = locator.get_all_symbol_pins(Path(schematic_path), ref)
if not all_pins or "1" not in all_pins:
continue
pin_data = all_pins["1"]
pt = _to_iu(float(pin_data[0]), float(pin_data[1]))
point_to_label[pt] = name
label_to_points.setdefault(name, []).append(pt)
except Exception as e:
logger.warning(f"Error parsing power symbol: {e}")
return point_to_label, label_to_points
def _find_connected_wires(
x_mm: float,
y_mm: float,
all_wires: List[List[Tuple[int, int]]],
iu_to_wires: Dict[Tuple[int, int], Set[int]],
adjacency: List[Set[int]],
point_to_label: Optional[Dict[Tuple[int, int], str]] = None,
label_to_points: Optional[Dict[str, List[Tuple[int, int]]]] = None,
) -> Tuple:
"""BFS from query point. Returns (visited wire indices, net IU points) or (None, None).
Uses _QUERY_TOLERANCE_IU for the seed step because user-supplied coordinates
may be imprecise. Wire-to-wire matching inside _build_adjacency is exact.
Requires query point (x_mm, y_mm) to be exactly on a wire endpoint (exact IU match).
"""
query_iu = _to_iu(x_mm, y_mm)
# Find seed wires: any wire whose endpoint is within _QUERY_TOLERANCE_IU of the query
seed_indices: Set[int] = set()
for iu_pt, wire_indices in iu_to_wires.items():
if (abs(iu_pt[0] - query_iu[0]) <= _QUERY_TOLERANCE_IU and
abs(iu_pt[1] - query_iu[1]) <= _QUERY_TOLERANCE_IU):
seed_indices.update(wire_indices)
if not seed_indices:
# Find seed wires: exact IU match on the query endpoint
seed_set = iu_to_wires.get(query_iu)
if not seed_set:
return (None, None)
seed_indices: Set[int] = set(seed_set)
# BFS flood-fill using pre-compiled adjacency
visited: Set[int] = set(seed_indices)
@@ -98,6 +146,7 @@ def _find_connected_wires(
for i in seed_indices:
net_points.update(all_wires[i])
seen_labels: Set[str] = set()
while queue:
wire_idx = queue.pop()
for neighbor_idx in adjacency[wire_idx]:
@@ -106,6 +155,20 @@ def _find_connected_wires(
queue.append(neighbor_idx)
net_points.update(all_wires[neighbor_idx])
if point_to_label and label_to_points:
for pt in all_wires[wire_idx]:
label_name = point_to_label.get(pt)
if label_name and label_name not in seen_labels:
seen_labels.add(label_name)
for other_pt in label_to_points.get(label_name, []):
if other_pt == pt:
continue
for idx in iu_to_wires.get(other_pt, set()):
if idx not in visited:
visited.add(idx)
queue.append(idx)
net_points.update(all_wires[idx])
return (visited, net_points)
@@ -114,21 +177,13 @@ def _find_pins_on_net(
schematic_path,
schematic,
) -> List[Dict]:
"""Find component pins that land on net points.
Uses exact IU matching with a ±_PIN_TOLERANCE_IU neighbourhood to guard
against floating-point round-trip differences between wire and pin coordinates.
"""Find component pins that land on net points using exact IU matching.
Returns a list of {"component": ref, "pin": pin_num} dicts.
"""
def _on_net(px_mm: float, py_mm: float) -> bool:
pin_iu = _to_iu(px_mm, py_mm)
if pin_iu in net_points:
return True
x, y = pin_iu
return ((x+1, y) in net_points or (x-1, y) in net_points or
(x, y+1) in net_points or (x, y-1) in net_points)
return _to_iu(px_mm, py_mm) in net_points
locator = PinLocator()
pins = []
@@ -158,12 +213,15 @@ def _find_pins_on_net(
def get_wire_connections(schematic, schematic_path: str, x_mm: float, y_mm: float) -> Optional[Dict]:
"""Find all component pins reachable from a point via connected wires.
"""Find all component pins reachable from a point via connected wires, net labels, and power symbols.
The query point (x_mm, y_mm) must be within _QUERY_TOLERANCE_IU (0.5 mm) of
a wire endpoint or junction. Interior (mid-segment) points are not matched —
The query point (x_mm, y_mm) must be exactly on a wire endpoint or junction (exact IU match).
Interior (mid-segment) points are not matched —
use wire endpoint coordinates obtained from the schematic data.
Net labels and power symbols are traversed: wires on the same named net are
treated as connected even when they are not geometrically adjacent.
Returns dict with keys:
- "pins": list of {"component": str, "pin": str}
- "wires": list of {"start": {"x", "y"}, "end": {"x", "y"}} in mm
@@ -175,7 +233,13 @@ def get_wire_connections(schematic, schematic_path: str, x_mm: float, y_mm: floa
adjacency, iu_to_wires = _build_adjacency(all_wires)
visited, net_points = _find_connected_wires(x_mm, y_mm, all_wires, iu_to_wires, adjacency)
point_to_label, label_to_points = _parse_virtual_connections(schematic, schematic_path)
visited, net_points = _find_connected_wires(
x_mm, y_mm, all_wires, iu_to_wires, adjacency,
point_to_label=point_to_label,
label_to_points=label_to_points,
)
if visited is None:
return None