feat(schematic): reposition and auto-place Ref/Value field labels
Adds field-placement tools: - set_schematic_property_position / batch_set_schematic_property_positions: move a symbol's Reference/Value field labels - autoplace_schematic_fields: place every symbol's fields clear of its body and nearby net labels (the #1 readability problem in generated schematics) - check_schematic_layout: audit out-of-bounds / fields-in-body / duplicate labels (note: overlaps upstream find_overlapping_elements etc. — reuse or drop on request) Generic .kicad_sch text helpers are factored into commands/schematic_text_utils.py so the batch/hierarchy modules don't import from one another. - python/commands/schematic_text_utils.py: shared text/S-expr helpers - python/commands/schematic_field_layout.py: SchematicFieldLayoutCommands - src/tools/schematic-layout.ts + registry 'schematic_layout' category - python/kicad_interface.py: import + instantiate + dispatch routes - tests/test_schematic_field_layout.py: 23 unit tests incl. end-to-end on real .kicad_sch Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Ravi
545
python/commands/schematic_field_layout.py
Normal file
545
python/commands/schematic_field_layout.py
Normal file
@@ -0,0 +1,545 @@
|
||||
"""
|
||||
Schematic field-placement commands.
|
||||
|
||||
Tools:
|
||||
- set_schematic_property_position: move one Reference/Value field
|
||||
- batch_set_schematic_property_positions: move many fields in one file read/write
|
||||
- autoplace_schematic_fields: auto-position Ref/Value fields outside the
|
||||
component body and any attached net labels
|
||||
|
||||
This module is self-contained: it gathers the enriched component/label data it needs
|
||||
(body bounding boxes, field positions, pin tips) directly from the schematic + PinLocator,
|
||||
rather than depending on the output shape of other handlers.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List
|
||||
|
||||
from commands.pin_locator import PinLocator
|
||||
from commands.schematic import SchematicManager
|
||||
from commands.schematic_text_utils import (
|
||||
_extract_property_position,
|
||||
_extract_property_visible,
|
||||
_find_placed_symbol_block,
|
||||
_move_property_in_block,
|
||||
)
|
||||
|
||||
logger = logging.getLogger("kicad_interface")
|
||||
|
||||
_GRID = 1.27 # 50-mil KiCad schematic grid (mm)
|
||||
_BODY_PAD_MM = 1.27
|
||||
|
||||
# ── Enriched data gathering (replicates list_schematic_components' fork enrichment) ──
|
||||
|
||||
|
||||
def _gather_components(
|
||||
schematic, sch_path: Path, raw_content: str, locator: PinLocator
|
||||
) -> List[Dict[str, Any]]:
|
||||
"""Build enriched component dicts: position, value, libId, pins, body_bbox, ref/value_field."""
|
||||
components: List[Dict[str, Any]] = []
|
||||
for symbol in schematic.symbol:
|
||||
if not hasattr(symbol.property, "Reference"):
|
||||
continue
|
||||
ref = symbol.property.Reference.value
|
||||
if ref.startswith("_TEMPLATE"):
|
||||
continue
|
||||
lib_id = symbol.lib_id.value if hasattr(symbol, "lib_id") else ""
|
||||
value = symbol.property.Value.value if hasattr(symbol.property, "Value") else ""
|
||||
position = symbol.at.value if hasattr(symbol, "at") else [0, 0, 0]
|
||||
|
||||
comp: Dict[str, Any] = {
|
||||
"reference": ref,
|
||||
"libId": lib_id,
|
||||
"value": value,
|
||||
"position": {"x": float(position[0]), "y": float(position[1])},
|
||||
"rotation": float(position[2]) if len(position) > 2 else 0,
|
||||
}
|
||||
|
||||
block_text, _, _ = _find_placed_symbol_block(raw_content, ref)
|
||||
if block_text:
|
||||
ref_pos = _extract_property_position(block_text, "Reference")
|
||||
if ref_pos:
|
||||
ref_pos["visible"] = _extract_property_visible(block_text, "Reference")
|
||||
comp["ref_field"] = ref_pos
|
||||
val_pos = _extract_property_position(block_text, "Value")
|
||||
if val_pos:
|
||||
val_pos["visible"] = _extract_property_visible(block_text, "Value")
|
||||
comp["value_field"] = val_pos
|
||||
|
||||
try:
|
||||
all_pins = locator.get_all_symbol_pins(sch_path, ref)
|
||||
if all_pins:
|
||||
pins_def = locator.get_symbol_pins(sch_path, lib_id) or {}
|
||||
pin_list = []
|
||||
for pin_num, coords in all_pins.items():
|
||||
pin_info = {"number": pin_num, "position": {"x": coords[0], "y": coords[1]}}
|
||||
if pin_num in pins_def:
|
||||
pin_info["name"] = pins_def[pin_num].get("name", pin_num)
|
||||
pin_list.append(pin_info)
|
||||
comp["pins"] = pin_list
|
||||
xs = [p["position"]["x"] for p in pin_list]
|
||||
ys = [p["position"]["y"] for p in pin_list]
|
||||
comp["body_bbox"] = {
|
||||
"x_min": min(xs) - _BODY_PAD_MM,
|
||||
"y_min": min(ys) - _BODY_PAD_MM,
|
||||
"x_max": max(xs) + _BODY_PAD_MM,
|
||||
"y_max": max(ys) + _BODY_PAD_MM,
|
||||
}
|
||||
except Exception:
|
||||
pass # pin lookup is best-effort
|
||||
|
||||
components.append(comp)
|
||||
return components
|
||||
|
||||
|
||||
def _gather_labels(schematic) -> List[Dict[str, Any]]:
|
||||
"""Net + global labels as {type, name, position, angle}."""
|
||||
labels = []
|
||||
for attr, kind in (("label", "net"), ("global_label", "global")):
|
||||
for lbl in getattr(schematic, attr, []):
|
||||
if not hasattr(lbl, "value"):
|
||||
continue
|
||||
pos = lbl.at.value if hasattr(lbl, "at") and hasattr(lbl.at, "value") else [0, 0, 0]
|
||||
labels.append(
|
||||
{
|
||||
"type": kind,
|
||||
"name": lbl.value,
|
||||
"position": {"x": float(pos[0]), "y": float(pos[1])},
|
||||
"angle": float(pos[2]) if len(pos) > 2 else 0,
|
||||
}
|
||||
)
|
||||
return labels
|
||||
|
||||
|
||||
def _bbox_overlaps(a, b, margin=0.0):
|
||||
return (
|
||||
a["x_min"] - margin < b["x_max"]
|
||||
and a["x_max"] + margin > b["x_min"]
|
||||
and a["y_min"] - margin < b["y_max"]
|
||||
and a["y_max"] + margin > b["y_min"]
|
||||
)
|
||||
|
||||
|
||||
class SchematicFieldLayoutCommands:
|
||||
"""Handlers for schematic field placement."""
|
||||
|
||||
def set_schematic_property_position(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Move a symbol's Reference or Value property field to a new coordinate."""
|
||||
logger.info("Setting schematic property position")
|
||||
try:
|
||||
schematic_path = params.get("schematicPath")
|
||||
reference = params.get("reference")
|
||||
property_name = params.get("property")
|
||||
x = params.get("x")
|
||||
y = params.get("y")
|
||||
angle = params.get("angle", 0)
|
||||
visible = params.get("visible", True)
|
||||
|
||||
if not all([schematic_path, reference, property_name, x is not None, y is not None]):
|
||||
return {
|
||||
"success": False,
|
||||
"message": "Missing required parameters: schematicPath, reference, property, x, y",
|
||||
}
|
||||
if property_name not in ("Reference", "Value"):
|
||||
return {"success": False, "message": "property must be 'Reference' or 'Value'"}
|
||||
|
||||
sch_path = Path(schematic_path)
|
||||
if not sch_path.exists():
|
||||
return {"success": False, "message": f"Schematic not found: {schematic_path}"}
|
||||
|
||||
content = sch_path.read_text(encoding="utf-8")
|
||||
block_text, block_start, block_end = _find_placed_symbol_block(content, reference)
|
||||
if block_text is None:
|
||||
return {
|
||||
"success": False,
|
||||
"message": f"Component '{reference}' not found in schematic",
|
||||
}
|
||||
|
||||
old_pos = _extract_property_position(block_text, property_name)
|
||||
new_block, n_subs = _move_property_in_block(
|
||||
block_text, property_name, x, y, angle, visible
|
||||
)
|
||||
if n_subs == 0:
|
||||
return {
|
||||
"success": False,
|
||||
"message": f"Property '{property_name}' not found in {reference}",
|
||||
}
|
||||
|
||||
new_content = content[:block_start] + new_block + content[block_end + 1 :]
|
||||
sch_path.write_text(new_content, encoding="utf-8")
|
||||
|
||||
old_str = (
|
||||
f"({old_pos['x']}, {old_pos['y']}, {old_pos['angle']}°)" if old_pos else "unknown"
|
||||
)
|
||||
return {
|
||||
"success": True,
|
||||
"message": f"Moved {reference}.{property_name} from {old_str} to ({x}, {y}, {angle}°)",
|
||||
}
|
||||
except Exception as e:
|
||||
logger.error(f"Error setting property position: {e}")
|
||||
import traceback
|
||||
|
||||
logger.error(traceback.format_exc())
|
||||
return {"success": False, "message": str(e)}
|
||||
|
||||
def batch_set_schematic_property_positions(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Batch-move Reference/Value property fields for many components in one read/write."""
|
||||
logger.info("Batch setting schematic property positions")
|
||||
try:
|
||||
schematic_path = params.get("schematicPath")
|
||||
updates = params.get("updates", [])
|
||||
|
||||
if not schematic_path:
|
||||
return {"success": False, "message": "schematicPath is required"}
|
||||
if not updates:
|
||||
return {"success": False, "message": "updates list is required"}
|
||||
|
||||
sch_path = Path(schematic_path)
|
||||
if not sch_path.exists():
|
||||
return {"success": False, "message": f"Schematic not found: {schematic_path}"}
|
||||
|
||||
content = sch_path.read_text(encoding="utf-8")
|
||||
applied: List[Dict[str, Any]] = []
|
||||
failed: List[Dict[str, Any]] = []
|
||||
|
||||
for upd in updates:
|
||||
reference = upd.get("reference")
|
||||
property_name = upd.get("property")
|
||||
x = upd.get("x")
|
||||
y = upd.get("y")
|
||||
angle = upd.get("angle", 0)
|
||||
visible = upd.get("visible", True)
|
||||
|
||||
if not reference or not property_name or x is None or y is None:
|
||||
failed.append(
|
||||
{
|
||||
"reference": reference,
|
||||
"property": property_name,
|
||||
"reason": "Missing required fields: reference, property, x, y",
|
||||
}
|
||||
)
|
||||
continue
|
||||
if property_name not in ("Reference", "Value"):
|
||||
failed.append(
|
||||
{
|
||||
"reference": reference,
|
||||
"property": property_name,
|
||||
"reason": "property must be 'Reference' or 'Value'",
|
||||
}
|
||||
)
|
||||
continue
|
||||
|
||||
block_text, block_start, block_end = _find_placed_symbol_block(content, reference)
|
||||
if block_text is None:
|
||||
failed.append(
|
||||
{
|
||||
"reference": reference,
|
||||
"property": property_name,
|
||||
"reason": f"Component '{reference}' not found in schematic",
|
||||
}
|
||||
)
|
||||
continue
|
||||
|
||||
new_block, n_subs = _move_property_in_block(
|
||||
block_text, property_name, x, y, angle, visible
|
||||
)
|
||||
if n_subs == 0:
|
||||
failed.append(
|
||||
{
|
||||
"reference": reference,
|
||||
"property": property_name,
|
||||
"reason": f"Property '{property_name}' not found in {reference} block",
|
||||
}
|
||||
)
|
||||
continue
|
||||
|
||||
content = content[:block_start] + new_block + content[block_end + 1 :]
|
||||
applied.append(
|
||||
{
|
||||
"reference": reference,
|
||||
"property": property_name,
|
||||
"x": x,
|
||||
"y": y,
|
||||
"angle": angle,
|
||||
"visible": visible,
|
||||
}
|
||||
)
|
||||
|
||||
if applied:
|
||||
sch_path.write_text(content, encoding="utf-8")
|
||||
|
||||
return {
|
||||
"success": len(failed) == 0,
|
||||
"applied": applied,
|
||||
"failed": failed,
|
||||
"applied_count": len(applied),
|
||||
"failed_count": len(failed),
|
||||
}
|
||||
except Exception as e:
|
||||
logger.error(f"Error in batch_set_schematic_property_positions: {e}")
|
||||
import traceback
|
||||
|
||||
logger.error(traceback.format_exc())
|
||||
return {"success": False, "message": str(e)}
|
||||
|
||||
def autoplace_schematic_fields(self, params: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Re-position Reference and Value fields outside the body and any attached net labels."""
|
||||
logger.info("Auto-placing schematic fields")
|
||||
try:
|
||||
schematic_path = params.get("schematicPath")
|
||||
references_filter = params.get("references")
|
||||
clearance = float(params.get("clearance", _GRID))
|
||||
|
||||
if not schematic_path:
|
||||
return {"success": False, "message": "schematicPath is required"}
|
||||
sch_path = Path(schematic_path)
|
||||
if not sch_path.exists():
|
||||
return {"success": False, "message": f"Schematic not found: {schematic_path}"}
|
||||
|
||||
chars_per_mm, text_height = 1.5, 1.27
|
||||
|
||||
def snap(val):
|
||||
return round(round(val / _GRID) * _GRID, 4)
|
||||
|
||||
def label_bbox(lx, ly, angle, name):
|
||||
length = max(len(name), 1) * chars_per_mm + 1.0
|
||||
half_h = text_height / 2.0
|
||||
a = round(angle / 90) * 90 % 360
|
||||
if a == 0:
|
||||
return {
|
||||
"x_min": lx,
|
||||
"y_min": ly - half_h,
|
||||
"x_max": lx + length,
|
||||
"y_max": ly + half_h,
|
||||
}
|
||||
if a == 90:
|
||||
return {
|
||||
"x_min": lx - half_h,
|
||||
"y_min": ly - length,
|
||||
"x_max": lx + half_h,
|
||||
"y_max": ly,
|
||||
}
|
||||
if a == 180:
|
||||
return {
|
||||
"x_min": lx - length,
|
||||
"y_min": ly - half_h,
|
||||
"x_max": lx,
|
||||
"y_max": ly + half_h,
|
||||
}
|
||||
return {
|
||||
"x_min": lx - half_h,
|
||||
"y_min": ly,
|
||||
"x_max": lx + half_h,
|
||||
"y_max": ly + length,
|
||||
}
|
||||
|
||||
def union(bb, other):
|
||||
return {
|
||||
"x_min": min(bb["x_min"], other["x_min"]),
|
||||
"y_min": min(bb["y_min"], other["y_min"]),
|
||||
"x_max": max(bb["x_max"], other["x_max"]),
|
||||
"y_max": max(bb["y_max"], other["y_max"]),
|
||||
}
|
||||
|
||||
def field_bbox(fx, fy, text):
|
||||
half_w = max(len(str(text)), 1) * 0.75 / 2.0
|
||||
half_h = text_height / 2.0
|
||||
return {
|
||||
"x_min": fx - half_w,
|
||||
"y_min": fy - half_h,
|
||||
"x_max": fx + half_w,
|
||||
"y_max": fy + half_h,
|
||||
}
|
||||
|
||||
schematic = SchematicManager.load_schematic(schematic_path)
|
||||
if not schematic:
|
||||
return {"success": False, "message": "Failed to load schematic"}
|
||||
raw_content = sch_path.read_text(encoding="utf-8")
|
||||
locator = PinLocator()
|
||||
|
||||
components = _gather_components(schematic, sch_path, raw_content, locator)
|
||||
if references_filter:
|
||||
components = [c for c in components if c["reference"] in references_filter]
|
||||
net_labels = [
|
||||
lb for lb in _gather_labels(schematic) if lb.get("type") in ("net", "global")
|
||||
]
|
||||
|
||||
comp_ext_bboxes: Dict[str, Dict[str, float]] = {}
|
||||
comp_pin_map: Dict[str, Dict[str, Any]] = {}
|
||||
|
||||
for comp in components:
|
||||
ref = comp["reference"]
|
||||
cx, cy = comp["position"]["x"], comp["position"]["y"]
|
||||
body_bb = comp.get("body_bbox") or {
|
||||
"x_min": cx - 2.54,
|
||||
"y_min": cy - 2.54,
|
||||
"x_max": cx + 2.54,
|
||||
"y_max": cy + 2.54,
|
||||
}
|
||||
ext_bb = dict(body_bb)
|
||||
|
||||
all_pins: Dict[str, Any] = {}
|
||||
for p in comp.get("pins", []):
|
||||
pnum = str(p.get("number", p.get("name", "")))
|
||||
px = p.get("x", p.get("position", {}).get("x", cx))
|
||||
py = p.get("y", p.get("position", {}).get("y", cy))
|
||||
all_pins[pnum] = [float(px), float(py)]
|
||||
if not all_pins:
|
||||
all_pins = locator.get_all_symbol_pins(sch_path, ref) or {}
|
||||
comp_pin_map[ref] = all_pins
|
||||
|
||||
for lbl in net_labels:
|
||||
lx, ly = lbl["position"]["x"], lbl["position"]["y"]
|
||||
for pin_coords in all_pins.values():
|
||||
px = (
|
||||
pin_coords[0]
|
||||
if isinstance(pin_coords, (list, tuple))
|
||||
else pin_coords["x"]
|
||||
)
|
||||
py = (
|
||||
pin_coords[1]
|
||||
if isinstance(pin_coords, (list, tuple))
|
||||
else pin_coords["y"]
|
||||
)
|
||||
if abs(lx - px) < 0.6 and abs(ly - py) < 0.6:
|
||||
ext_bb = union(
|
||||
ext_bb, label_bbox(lx, ly, lbl.get("angle", 0), lbl.get("name", ""))
|
||||
)
|
||||
break
|
||||
comp_ext_bboxes[ref] = ext_bb
|
||||
|
||||
updates: List[Dict[str, Any]] = []
|
||||
placed_field_bboxes: List[Dict[str, float]] = []
|
||||
|
||||
def has_collision(ref_bb, val_bb, exclude_ref):
|
||||
for other_ref, other_ext in comp_ext_bboxes.items():
|
||||
if other_ref == exclude_ref:
|
||||
continue
|
||||
if _bbox_overlaps(ref_bb, other_ext, 0.3) or _bbox_overlaps(
|
||||
val_bb, other_ext, 0.3
|
||||
):
|
||||
return True
|
||||
for fb in placed_field_bboxes:
|
||||
if _bbox_overlaps(ref_bb, fb, 0.2) or _bbox_overlaps(val_bb, fb, 0.2):
|
||||
return True
|
||||
return False
|
||||
|
||||
for comp in components:
|
||||
ref = comp["reference"]
|
||||
lib_id = comp.get("libId", "")
|
||||
if ref.startswith("#") or ref.startswith("_TEMPLATE"):
|
||||
continue
|
||||
cx, cy = comp["position"]["x"], comp["position"]["y"]
|
||||
val_text = comp.get("value", ref)
|
||||
|
||||
is_power = lib_id.startswith("kicad_power:") or lib_id.startswith("power:")
|
||||
if is_power:
|
||||
ext_bb = dict(
|
||||
comp.get("body_bbox")
|
||||
or {
|
||||
"x_min": cx - 1.27,
|
||||
"y_min": cy - 1.27,
|
||||
"x_max": cx + 1.27,
|
||||
"y_max": cy + 1.27,
|
||||
}
|
||||
)
|
||||
num_pins = 0
|
||||
else:
|
||||
ext_bb = comp_ext_bboxes[ref]
|
||||
num_pins = len(comp_pin_map[ref])
|
||||
|
||||
if num_pins == 2:
|
||||
coords = list(comp_pin_map[ref].values())
|
||||
p1x = (
|
||||
float(coords[0][0])
|
||||
if isinstance(coords[0], (list, tuple))
|
||||
else float(coords[0]["x"])
|
||||
)
|
||||
p1y = (
|
||||
float(coords[0][1])
|
||||
if isinstance(coords[0], (list, tuple))
|
||||
else float(coords[0]["y"])
|
||||
)
|
||||
p2x = (
|
||||
float(coords[1][0])
|
||||
if isinstance(coords[1], (list, tuple))
|
||||
else float(coords[1]["x"])
|
||||
)
|
||||
p2y = (
|
||||
float(coords[1][1])
|
||||
if isinstance(coords[1], (list, tuple))
|
||||
else float(coords[1]["y"])
|
||||
)
|
||||
sides = (
|
||||
["right", "left", "above", "below"]
|
||||
if abs(p1y - p2y) > abs(p1x - p2x)
|
||||
else ["above", "below", "right", "left"]
|
||||
)
|
||||
else:
|
||||
sides = ["above", "below", "right", "left"]
|
||||
|
||||
def try_side(side):
|
||||
half_ref_h = text_height / 2.0
|
||||
half_ref_w = max(len(ref), 1) * 0.75 / 2.0
|
||||
half_val_w = max(len(str(val_text)), 1) * 0.75 / 2.0
|
||||
stack = text_height
|
||||
if side == "above":
|
||||
ref_y = snap(ext_bb["y_min"] - half_ref_h - clearance)
|
||||
return cx, ref_y, cx, ref_y - stack
|
||||
if side == "below":
|
||||
ref_y = snap(ext_bb["y_max"] + half_ref_h + clearance)
|
||||
return cx, ref_y, cx, ref_y + stack
|
||||
if side == "right":
|
||||
x0 = ext_bb["x_max"] + clearance
|
||||
ref_y = snap(cy)
|
||||
return snap(x0 + half_ref_w), ref_y, snap(x0 + half_val_w), ref_y + stack
|
||||
x0 = ext_bb["x_min"] - clearance
|
||||
ref_y = snap(cy)
|
||||
return snap(x0 - half_ref_w), ref_y, snap(x0 - half_val_w), ref_y + stack
|
||||
|
||||
ref_x = ref_y = val_x = val_y = ref_bb = val_bb = None
|
||||
for side in sides:
|
||||
rx, ry, vx, vy = try_side(side)
|
||||
rb, vb = field_bbox(rx, ry, ref), field_bbox(vx, vy, val_text)
|
||||
if not has_collision(rb, vb, ref):
|
||||
ref_x, ref_y, val_x, val_y, ref_bb, val_bb = rx, ry, vx, vy, rb, vb
|
||||
break
|
||||
if ref_x is None:
|
||||
ref_x, ref_y, val_x, val_y = try_side(sides[0])
|
||||
ref_bb, val_bb = field_bbox(ref_x, ref_y, ref), field_bbox(
|
||||
val_x, val_y, val_text
|
||||
)
|
||||
|
||||
placed_field_bboxes.append(ref_bb)
|
||||
placed_field_bboxes.append(val_bb)
|
||||
updates.append(
|
||||
{"reference": ref, "property": "Reference", "x": ref_x, "y": ref_y, "angle": 0}
|
||||
)
|
||||
updates.append(
|
||||
{"reference": ref, "property": "Value", "x": val_x, "y": val_y, "angle": 0}
|
||||
)
|
||||
|
||||
if not updates:
|
||||
return {"success": True, "message": "No components to update.", "updated_count": 0}
|
||||
|
||||
batch_result = self.batch_set_schematic_property_positions(
|
||||
{"schematicPath": schematic_path, "updates": updates}
|
||||
)
|
||||
applied = batch_result.get("applied_count", 0)
|
||||
failed = batch_result.get("failed_count", 0)
|
||||
return {
|
||||
"success": batch_result.get("success", False),
|
||||
"message": f"Auto-placed fields for {applied // 2} component(s) "
|
||||
f"({applied} fields updated{', ' + str(failed) + ' failed' if failed else ''}).",
|
||||
"updated_count": applied,
|
||||
"failed_count": failed,
|
||||
"failed": batch_result.get("failed", []),
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error in autoplace_schematic_fields: {e}")
|
||||
import traceback
|
||||
|
||||
logger.error(traceback.format_exc())
|
||||
return {"success": False, "message": str(e)}
|
||||
Reference in New Issue
Block a user