schematic: redistribute stagger groups, fix power symbol Y-flip, lower min_group

Three fixes:
1. IC groups with stagger fans are now vertically redistributed so they
   don't overlap. After staggering, each group's bounding box is computed
   (IC + all dependent parts), sorted by Y, and shifted apart with margin.
2. Power symbol angle mapping swaps U/D to account for Y-axis flip between
   SKiDL internal coords (Y-up) and KiCad schematic coords (Y-down).
3. Stagger min_group lowered from 3 to 2, so smaller ICs like optocouplers
   get T-junction treatment.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: lfyysh

src/skidl/tools/kicad9/gen_schematic.py

@@ -620,17 +620,16 @@ def _snap_two_pin_parts(node):
     _stagger_tjunctions(node, node_part_ids, snapped, occupied_pins)
 
 
-def _stagger_tjunctions(node, node_part_ids, snapped, occupied_pins, min_group=3):
+def _stagger_tjunctions(node, node_part_ids, snapped, occupied_pins, min_group=2):
     """Detect repeating T-junction patterns and stagger parts outward from IC.
 
     A T-junction occurs when 2+ two-pin parts share a signal net with the same
     IC pin. When 3+ IC pins on the same IC have the same fan-out count, it's a
     repeating pattern. Parts are rearranged so each pin's group steps further
     from the IC body, with all parts extending perpendicular.
 
-    Also moves the pass-1 snapped part from its overlapping position to the
-    staggered position, and records junction wires on node._tjunction_wires
-    for sexp_schematic to render.
+    After staggering, IC groups are vertically redistributed so their stagger
+    fans don't overlap.
     """
     perp_map = {"R": "D", "L": "U", "U": "R", "D": "L"}
     anti_perp = {"U": "D", "D": "U", "L": "R", "R": "L"}
@@ -679,6 +678,9 @@ def _stagger_tjunctions(node, node_part_ids, snapped, occupied_pins, min_group=3
     junction_wires = getattr(node, "_tjunction_wires", [])
     suppressed_pins = set()
 
+    # Collect stagger group metadata for redistribution pass.
+    stagger_groups = []
+
     for ic_id, pin_entries in ic_groups.items():
         fanout_counts = [len(pl) for _, pl in pin_entries]
         dominant = max(set(fanout_counts), key=fanout_counts.count)
@@ -707,10 +709,10 @@ def _stagger_tjunctions(node, node_part_ids, snapped, occupied_pins, min_group=3
                     max_span = max(max_span, span)
         step_size = max(100, int(max_span) + 50)
 
-        def _pin_sort_key(entry):
+        def _pin_sort_key(entry, _ic_part=ic_part, _ic_dir=ic_dir):
             ic_pin = entry[0]
-            w = ic_pin.pt * ic_part.tx
-            if ic_dir in ("L", "R"):
+            w = ic_pin.pt * _ic_part.tx
+            if _ic_dir in ("L", "R"):
                 return w.y
             return w.x
 
@@ -720,6 +722,9 @@ def _pin_sort_key(entry):
         anti = anti_perp.get(perp_dir, perp_dir)
         extend_dirs = [perp_dir, anti] if parts_per_pin >= 2 else [perp_dir]
 
+        group_parts = []
+        group_wires = []
+
         for pin_idx, (ic_pin, parts_list) in enumerate(matching):
             ic_pin_world = ic_pin.pt * ic_part.tx
 
@@ -737,15 +742,109 @@ def _pin_sort_key(entry):
                 )
                 snapped.add(id(part))
                 suppressed_pins.add(id(my_pin))
+                group_parts.append(part)
 
-            junction_wires.append(
+            group_wires.append(
                 (ic_pin_world.x, ic_pin_world.y, ox, oy)
             )
 
+        stagger_groups.append({
+            "ic_part": ic_part,
+            "parts": group_parts,
+            "wires": group_wires,
+            "ic_dir": ic_dir,
+            "n_pins": len(matching),
+            "step_size": step_size,
+        })
+
+    # Redistribute IC groups vertically so stagger fans don't overlap.
+    if len(stagger_groups) > 1:
+        _redistribute_stagger_groups(stagger_groups, node, snapped)
+
+    for grp in stagger_groups:
+        junction_wires.extend(grp["wires"])
+
     node._tjunction_wires = junction_wires
     node._tjunction_suppressed_pins = suppressed_pins
 
 
+def _redistribute_stagger_groups(groups, node, snapped):
+    """Shift IC groups vertically so their stagger fans don't overlap."""
+
+    for grp in groups:
+        _collect_ic_dependents(grp, node, snapped)
+
+    def _group_bbox(grp):
+        all_parts = [grp["ic_part"]] + grp["all_deps"]
+        min_y = float("inf")
+        max_y = float("-inf")
+
+        for part in all_parts:
+            for pin in part.pins:
+                w = pin.pt * part.tx
+                min_y = min(min_y, w.y)
+                max_y = max(max_y, w.y)
+
+        return min_y, max_y
+
+    groups.sort(key=lambda g: _group_bbox(g)[0])
+
+    margin = 200
+    prev_max_y = None
+
+    for grp in groups:
+        min_y, max_y = _group_bbox(grp)
+
+        if prev_max_y is not None and min_y < prev_max_y + margin:
+            shift = (prev_max_y + margin) - min_y
+            _shift_group(grp, 0, shift)
+            min_y += shift
+            max_y += shift
+
+        prev_max_y = max_y
+
+
+def _collect_ic_dependents(grp, node, snapped):
+    """Find all snapped 2-pin parts connected to this IC (not just stagger parts)."""
+    ic = grp["ic_part"]
+    ic_id = id(ic)
+    deps = set(id(p) for p in grp["parts"])
+    deps.add(ic_id)
+
+    for part in node.parts:
+        if id(part) in deps or id(part) not in snapped:
+            continue
+        if not _is_two_pin_part(part):
+            continue
+        for pin in part.pins:
+            net = getattr(pin, "net", None)
+            if not net:
+                continue
+            for net_pin in net.pins:
+                if net_pin.part is ic:
+                    deps.add(id(part))
+                    break
+            if id(part) in deps:
+                break
+
+    grp["all_deps"] = [p for p in node.parts if id(p) in deps and p is not ic]
+
+
+def _shift_group(grp, dx, dy):
+    """Shift an IC and all its dependent parts by (dx, dy)."""
+    vec = Point(dx, dy)
+    all_parts = [grp["ic_part"]] + grp["all_deps"]
+    shifted_ids = set()
+    for part in all_parts:
+        if id(part) not in shifted_ids:
+            part.tx = part.tx.move(vec)
+            shifted_ids.add(id(part))
+    grp["wires"] = [
+        (x1 + dx, y1 + dy, x2 + dx, y2 + dy)
+        for (x1, y1, x2, y2) in grp["wires"]
+    ]
+
+
 def _stub_all_non_explicit(circuit):
     """Stub all nets that weren't explicitly set by the user (labels-only fallback).
 

src/skidl/tools/kicad9/sexp_schematic.py

@@ -258,15 +258,15 @@ def _power_symbol_to_sexp(pin, net_name, tx):
     y = _round_mm(pt.y)
 
     # Rotate the power symbol so its graphical part points AWAY from the
-    # component, in the same direction as the pin.  At angle=0, ground-type
-    # symbols (GND, GNDA, etc.) have bars pointing down; supply-type symbols
-    # (VCC, +5V, etc.) have arrows/bars pointing up.
+    # component.  calc_pin_dir returns directions in SKiDL's internal coords
+    # (Y-up), but KiCad schematics use Y-down, so U and D are swapped.
+    # At angle=0: GND bars point down, supply arrows point up (KiCad convention).
     pin_dir = calc_pin_dir(pin)
     _is_gnd = any(g in net_name.upper() for g in ("GND", "VSS", "EARTH"))
     if _is_gnd:
-        angle = {"D": 0, "U": 180, "R": 270, "L": 90}.get(pin_dir, 0)
+        angle = {"U": 0, "D": 180, "R": 270, "L": 90}.get(pin_dir, 0)
     else:
-        angle = {"U": 0, "D": 180, "R": 90, "L": 270}.get(pin_dir, 0)
+        angle = {"D": 0, "U": 180, "R": 90, "L": 270}.get(pin_dir, 0)
 
     lib_id = f"power:{net_name}"
     inst_uuid = _gen_uuid(f"pwr:{net_name}:{x}:{y}:{_pwr_counter[0]}")