@huaqiu/dsh-kicad 0.5.1 → 0.5.2

package/skills/pcb-initial-placement/scripts/placement_config.example.json

@@ -0,0 +1,116 @@
+{
+ "_comment": [
+  "Phase-1 placement config for the KiCad 'video' demo board (312x106.7 mm PCI card).",
+  "This is the worked example behind the pcb-initial-placement skill: every number here",
+  "was derived from the board's own geometry (see references/algorithm.md).",
+  "Copy it, replace the modules/anchors/fixed entries with your own board's facts,",
+  "and run: pack.py -> verify_placement.py -> apply_via_ipc.py"
+ ],
+
+ "board": "video.kicad_pcb",
+ "grid_mm": 0.635,
+ "gap_mm": 0.3,
+ "big_part_area_mm2": 40.0,
+ "radius_schedule_mm": [30, 45, 65, 90, 130, 200],
+ "module_order": ["M1", "M4", "M5", "M6", "M3", "M2"],
+
+ "fixed": {
+  "BUS1": {"pad": "A1", "at": [95.25, 160.195], "rot": 0,
+           "_comment": "PCI card-edge fingers: pin A1 sits on the board edge, so the whole connector is derived from the Edge.Cuts geometry"},
+
+  "P1": {"x": 58.0, "y": 63.0, "rot": 180, "_comment": "BNC bracket connector, body overhangs the left edge x=53.594"},
+  "P2": {"x": 58.0, "y": 74.4, "rot": 180},
+  "P3": {"x": 58.0, "y": 85.8, "rot": 180},
+  "P8": {"x": 58.0, "y": 97.2, "rot": 180},
+  "J4": {"x": 68.154, "y": 137.0, "rot": 90,
+         "_comment": "DB9; footprint is EdgePinOffset14.56mm so origin x = 53.594 + 14.56"},
+
+  "U10": {"x": 80.25, "y": 73.0, "rot": 0, "_comment": "video decoder, next to the BNC inputs"},
+  "U8":  {"x": 113.9, "y": 74.3, "rot": 0, "_comment": "RAMDAC"},
+  "U9":  {"x": 111.25, "y": 107.0, "rot": 0, "_comment": "encoder"},
+  "U20": {"x": 69.9, "y": 100.0, "rot": 0, "_comment": "video encoder"},
+
+  "U11": {"x": 116.25, "y": 138.5, "rot": 0, "_comment": "PCI controller, hugging the card edge"},
+  "U24": {"x": 152.25, "y": 138.5, "rot": 0, "_comment": "main FPGA, 47 nets to U11"},
+  "U23": {"x": 184.25, "y": 127.25, "rot": 90},
+  "U22": {"x": 205.8, "y": 124.65, "rot": 0, "_comment": "SIMM controller, 32 nets to every socket"},
+  "U2":  {"x": 179.0, "y": 143.9, "rot": 90},
+
+  "U3": {"x": 221.5, "y": 123.0, "rot": 0, "_comment": "SIMM data-bus buffers, lined up beside the bank"},
+  "U4": {"x": 234.5, "y": 123.0, "rot": 0},
+  "U5": {"x": 247.5, "y": 123.0, "rot": 0},
+  "U6": {"x": 260.5, "y": 123.0, "rot": 0},
+
+  "U12": {"x": 189.494, "y": 61.2,  "rot": 180, "_comment": "SIMM bank: 2 columns x 4 rows, 14.5 mm row pitch (0.571 in)"},
+  "U13": {"x": 189.494, "y": 74.7,  "rot": 180},
+  "U14": {"x": 189.494, "y": 88.2,  "rot": 180},
+  "U15": {"x": 189.494, "y": 101.7, "rot": 180},
+  "U16": {"x": 307.634, "y": 61.2,  "rot": 180},
+  "U17": {"x": 307.634, "y": 74.7,  "rot": 180},
+  "U18": {"x": 307.634, "y": 88.2,  "rot": 180},
+  "U19": {"x": 307.634, "y": 101.7, "rot": 180}
+ },
+
+ "keepouts": [
+  {"rect": [131.594, 105.1, 247.494, 115.8],
+   "why": "SIMM modules lean towards +y once inserted and cover the space below row 4; keep the tilt volume clear of copper-side parts"},
+  {"rect": [249.734, 105.1, 365.634, 115.8],
+   "why": "same for the second SIMM column"}
+ ],
+
+ "priority": ["RR1", "RR2", "RR3", "RR4", "RR5", "RR6", "RR7", "RR8",
+              "X1", "X2", "U1", "U7", "U21", "CV1", "POT1", "U20"],
+
+ "modules": {
+  "M1": {
+   "title": "板边连接器 bracket connectors",
+   "anchors": [[79.0, 137.0], [58.0, 62.0], [58.0, 80.0], [58.0, 99.0]],
+   "members": ["J4", "P1", "P2", "P3", "P8",
+               "R22", "R23", "R24", "R39", "R40", "R41", "R42", "R43", "R44",
+               "R45", "R46", "R47", "C3", "C4", "C59"]
+  },
+  "M2": {
+   "title": "PCI 总线接口 PCI bus interface",
+   "anchors": [[116.25, 138.5], [158.1, 158.4], [240.0, 123.0]],
+   "members": ["BUS1", "U11", "U1", "U3", "U4", "U5", "U6",
+               "RR1", "RR2", "RR3", "RR4", "RR5", "RR6",
+               "R5", "R6", "R7", "R28", "R29", "C68", "C69",
+               "W1", "W2", "W3", "W4", "W5", "C9", "C11", "C17", "C27", "C31"]
+  },
+  "M3": {
+   "title": "图形逻辑 FPGA",
+   "anchors": [[152.25, 138.5], [179.0, 143.9], [184.25, 127.25],
+               [205.8, 124.65], [177.0, 120.0]],
+   "members": ["U24", "U23", "U22", "U21", "U2", "U7",
+               "RR7", "RR8", "R1", "R13", "R21", "R26", "R30", "R31", "R32",
+               "R33", "R34", "C23", "C49", "C50", "C63", "D6", "P4", "P5",
+               "P9", "P10", "P11", "P12", "X1", "C10", "C15", "C18", "C19",
+               "C20", "C21", "R48"]
+  },
+  "M4": {
+   "title": "视频输入解码 video capture",
+   "anchors": [[80.25, 73.0], [68.0, 100.0]],
+   "members": ["U10", "X2", "C1", "C2", "C5", "C6", "C7", "C8", "C12", "C13",
+               "C14", "C16", "C62", "C65", "C66", "D1", "D2", "D3", "D4",
+               "L1", "L2", "L3", "L4", "L6", "R2", "R3", "R12", "R14", "R19",
+               "R20", "R25", "R27", "R35", "Q1", "Q2", "Q3", "CV1", "POT1",
+               "C47", "C55"]
+  },
+  "M5": {
+   "title": "视频输出 RAMDAC+encoder",
+   "anchors": [[113.9, 74.3], [111.25, 107.0], [69.9, 100.0]],
+   "members": ["U8", "U9", "U20", "X3", "C32", "C33", "C34", "C35", "C36",
+               "C39", "C40", "C41", "C42", "C43", "C44", "C45", "C48", "C51",
+               "C52", "C54", "C58", "C60", "C61", "C64", "L5", "R4", "R8",
+               "R9", "R10", "R11", "R15", "R16", "R17", "R18", "R36", "R37",
+               "R38", "C22", "C24", "C25", "C26", "C28", "C29", "C30", "C37",
+               "C46", "C53"]
+  },
+  "M6": {
+   "title": "帧缓存 frame buffer SIMM",
+   "anchors": [[189.5, 83.0], [307.6, 83.0], [255.0, 125.0]],
+   "members": ["U12", "U13", "U14", "U15", "U16", "U17", "U18", "U19",
+               "C38", "C56", "C57", "C67", "C70", "C71", "C72", "C73"]
+  }
+ }
+}

package/skills/pcb-initial-placement/scripts/placement_view.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""Render a placement plan as a module-coloured SVG plan view + evaluation panel.
+
+    python placement_view.py --geometry geometry.json --plan placement_plan.json
+    # -> <placement dir>/placement_view.svg
+
+This is the picture a reviewer opens first, and it is deliberately self-contained:
+standard library only, no KiCad, no browser, no rasteriser, so it can be produced on
+any machine that got as far as running the packer.
+
+What it draws
+-------------
+* the real board outline from Edge.Cuts, filled, so the board shape (notches, tabs,
+  rounded corners) is visible rather than a bounding box;
+* every keep-out registered in the plan, hatched, with its reason in the panel - the
+  tilt volume of a socket or the antenna clear zone is a decision, not noise;
+* every courtyard rectangle tinted by the module that owns it, labelled once it is
+  big enough on screen to carry text, with fixed/anchor parts drawn at full opacity
+  so a reviewer can separate *decisions* from *consequences*;
+* each module's anchor points, drawn as crosses in the module colour.
+
+The panel underneath carries the numbers that decide whether the plan is acceptable -
+occupancy, per-module area, and the hard gates.  The canvas is sized from the content
+that actually exists, so a board with 14 modules or 5 keep-outs does not run its text
+off the bottom edge.
+
+The gates shown here are for DISPLAY: the authoritative check is
+``verify_placement.py``, which computes the same quantities from the same inputs
+without sharing the packer's code.  If the two ever disagree, believe
+verify_placement.py.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime
+import json
+import math
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import projpaths  # noqa: E402
+
+#: Palette for up to 12 modules; assigned in sorted module order so the same board
+#: always produces the same colours run to run.
+PALETTE = ["#2e8b57", "#c0392b", "#8e44ad", "#e67e22", "#2471a3", "#16a085",
+           "#7f8c8d", "#34495e", "#b7950b", "#a04000", "#1a5276", "#7d3c98"]
+UNASSIGNED = "#95a5a6"
+FONT = "DejaVu Sans, Segoe UI, Microsoft YaHei, Arial, sans-serif"
+ROW_H = 18
+LEGEND_COL_PX = 330
+PANEL_HEAD_PX = 72
+
+
+def esc(s):
+    return (str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;"))
+
+
+def rect_of(geo_ref, pose):
+    """Courtyard rectangle in board coordinates (KiCad Y down => clockwise turn)."""
+    x0, y0, x1, y1 = geo_ref["bbox_local"]
+    t = math.radians(pose["rot"])
+    c, s = math.cos(t), math.sin(t)
+    pts = [(lx * c + ly * s, -lx * s + ly * c) for lx in (x0, x1) for ly in (y0, y1)]
+    return (pose["x"] + min(p[0] for p in pts), pose["y"] + min(p[1] for p in pts),
+            pose["x"] + max(p[0] for p in pts), pose["y"] + max(p[1] for p in pts))
+
+
+def poly_area(poly):
+    a = 0.0
+    n = len(poly)
+    for i in range(n):
+        x0, y0 = poly[i]
+        x1, y1 = poly[(i + 1) % n]
+        a += x0 * y1 - x1 * y0
+    return abs(a) / 2.0
+
+
+def inside_poly(poly, x, y):
+    r, n = False, len(poly)
+    for i in range(n):
+        x0, y0 = poly[i]
+        x1, y1 = poly[(i + 1) % n]
+        if (y0 > y) != (y1 > y) and x < x0 + (y - y0) * (x1 - x0) / (y1 - y0):
+            r = not r
+    return r
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--geometry", required=True)
+    ap.add_argument("--plan", required=True)
+    ap.add_argument("--config", help="optional placement_config.json; only used to "
+                                     "recover module titles/keep-outs if the plan lacks them")
+    ap.add_argument("--out", help="SVG to write (default <placement dir>/placement_view.svg)")
+    ap.add_argument("--scale", type=float,
+                    help="pixels per mm; default auto-fits the board to --target-width-px")
+    ap.add_argument("--title", help="override the drawing title")
+    ap.add_argument("--target-width-px", type=float, default=1500.0)
+    projpaths.add_outdir(ap)
+    args = ap.parse_args()
+
+    geom = json.load(open(args.geometry, encoding="utf-8-sig"))
+    plan = json.load(open(args.plan, encoding="utf-8-sig"))
+    cfg = json.load(open(args.config, encoding="utf-8-sig")) if args.config else {}
+
+    geo = {g["ref"]: g for g in geom["footprints"]}
+    pos = plan["positions"]
+    poly = [tuple(p) for p in geom["outline"]]
+    fixed = set(plan.get("fixed", []))
+    keepouts = plan.get("keepouts") or cfg.get("keepouts") or []
+    titles = dict(plan.get("module_titles") or {})
+    for m, spec in (cfg.get("modules") or {}).items():
+        titles.setdefault(m, spec.get("title", m))
+
+    modules = plan.get("modules") or {m: s.get("members", [])
+                                      for m, s in (cfg.get("modules") or {}).items()}
+    mod_of = {}
+    for m, members in modules.items():
+        for r in members:
+            mod_of[r] = m
+    order = sorted(modules)
+    color = {m: PALETTE[i % len(PALETTE)] for i, m in enumerate(order)}
+
+    bx0 = min(p[0] for p in poly)
+    bx1 = max(p[0] for p in poly)
+    by0 = min(p[1] for p in poly)
+    by1 = max(p[1] for p in poly)
+    bw, bh = bx1 - bx0, by1 - by0
+
+    S = args.scale or max(1.5, min(14.0, args.target_width_px / max(bw, 1e-6)))
+    PAD = 34
+    plan_w = bw * S + 2 * PAD
+    plan_h = bh * S + 2 * PAD
+
+    # ---- geometry of every part, and the display metrics -------------------
+    R = {r: rect_of(geo[r], p) for r, p in pos.items() if r in geo}
+    refs = sorted(R)
+
+    overlaps = []
+    for i in range(len(refs)):
+        a = refs[i]
+        ax0, ay0, ax1, ay1 = R[a]
+        for j in range(i + 1, len(refs)):
+            b = refs[j]
+            bxx0, byy0, bxx1, byy1 = R[b]
+            if ax0 < bxx1 and bxx0 < ax1 and ay0 < byy1 and byy0 < ay1:
+                overlaps.append((a, b))
+
+    off_board = []
+    for r in refs:
+        x0, y0, x1, y1 = R[r]
+        out = tot = 0
+        for k in range(12):
+            px = x0 + (x1 - x0) * ((k % 4) / 3.0)
+            py = y0 + (y1 - y0) * ((k // 4) / 2.0)
+            tot += 1
+            if not inside_poly(poly, px, py):
+                out += 1
+        if out:
+            off_board.append((r, out / tot))
+
+    board_area = poly_area(poly)
+    court_area = sum((R[r][2] - R[r][0]) * (R[r][3] - R[r][1]) for r in refs)
+    density = 100.0 * court_area / board_area if board_area else 0.0
+
+    mod_area, mod_count = {}, {}
+    for r in refs:
+        m = mod_of.get(r, "?")
+        mod_area[m] = mod_area.get(m, 0.0) + (R[r][2] - R[r][0]) * (R[r][3] - R[r][1])
+        mod_count[m] = mod_count.get(m, 0) + 1
+
+    weak = sorted({(g["ref"], g["bbox_src"]) for g in geom["footprints"]
+                   if g.get("bbox_src") not in (None, "courtyard")})
+
+    # ---- panel content, counted BEFORE the canvas is sized -----------------
+    legend = [(m, mod_count.get(m, 0),
+               100.0 * mod_area.get(m, 0.0) / board_area if board_area else 0.0)
+              for m in order]
+    unassigned = sorted(set(refs) - set(mod_of))
+    if unassigned:
+        legend.append(("(unassigned)", len(unassigned), 0.0))
+
+    rows = [
+        ("footprints on board / placed", "%d / %d" % (len(geo), len(pos)), "#222"),
+        ("fixed anchors / algorithm-placed",
+         "%d / %d" % (len(fixed), len(pos) - len(fixed)), "#222"),
+        ("board size / area", "%.1f x %.1f mm / %.0f mm2" % (bw, bh, board_area), "#222"),
+        ("courtyard area / density", "%.0f mm2 / %.1f%%" % (court_area, density),
+         "#c0392b" if density > 75 else "#1e8449"),
+        ("courtyard overlap pairs",
+         "%d%s" % (len(overlaps), " PASS" if not overlaps else " FAIL"),
+         "#1e8449" if not overlaps else "#c0392b"),
+        ("parts off the board",
+         "%d%s" % (len(off_board), " PASS" if not off_board else " REVIEW"),
+         "#1e8449" if not off_board else "#b7950b"),
+        ("unplaced by the packer", "%d" % len(plan.get("unplaced") or []),
+         "#222" if not plan.get("unplaced") else "#c0392b"),
+        ("keep-outs registered", "%d" % len(keepouts), "#222"),
+    ]
+    if weak:
+        rows.append(("courtyard stand-ins / no geometry",
+                     "%d / %d" % (len(weak), sum(1 for w in weak if w[1] == "none")),
+                     "#b7950b"))
+
+    notes = []
+    if overlaps:
+        notes.append(("overlapping: %s" % ", ".join("%s/%s" % p for p in overlaps[:6]),
+                      "#c0392b"))
+    if off_board:
+        notes.append(("off-board: %s" % ", ".join("%s %.0f%%" % (r, f * 100)
+                                                  for r, f in off_board[:6]), "#b7950b"))
+    for i, ko in enumerate(keepouts):
+        notes.append(("keep-out %d: %s" % (i + 1, (ko.get("why") or "")[:110]), "#c0392b"))
+
+    # legend columns, then the canvas that fits them
+    per_col = max(1, min(len(legend), 12))
+    ncol = max(1, -(-len(legend) // per_col))
+    legend_w = ncol * LEGEND_COL_PX
+    mx = PAD + legend_w + 16
+    body_rows = max(per_col, len(rows) + len(notes) + 1)
+    panel_h = PANEL_HEAD_PX + body_rows * ROW_H + 28
+    W = max(plan_w, mx + 520.0)
+    H = plan_h + panel_h
+
+    def tx(x):
+        return PAD + (x - bx0) * S
+
+    def ty(y):
+        return PAD + (y - by0) * S
+
+    title = args.title or ("%s - Phase-1 initial placement: courtyard occupancy by module"
+                           % geom.get("board", "board"))
+
+    o = ['<?xml version="1.0" encoding="UTF-8"?>',
+         '<svg xmlns="http://www.w3.org/2000/svg" width="%.0f" height="%.0f" '
+         'viewBox="0 0 %.0f %.0f" font-family="%s">' % (W, H, W, H, FONT),
+         '<defs><pattern id="hatch" width="8" height="8" patternUnits="userSpaceOnUse" '
+         'patternTransform="rotate(45)">'
+         '<rect width="8" height="8" fill="#fdecea"/>'
+         '<line x1="0" y1="0" x2="0" y2="8" stroke="#c0392b" stroke-width="2.4"/>'
+         '</pattern></defs>',
+         '<rect width="100%" height="100%" fill="#fbfbfb"/>']
+
+    o.append('<polygon points="%s" fill="#eef3f7" stroke="#1a1a1a" stroke-width="2.5"/>'
+             % " ".join("%.1f,%.1f" % (tx(px), ty(py)) for px, py in poly))
+
+    for ko in keepouts:
+        x0, y0, x1, y1 = ko["rect"]
+        o.append('<rect x="%.1f" y="%.1f" width="%.1f" height="%.1f" fill="url(#hatch)" '
+                 'stroke="#c0392b" stroke-width="1.4" stroke-dasharray="5,3"/>'
+                 % (tx(x0), ty(y0), (x1 - x0) * S, (y1 - y0) * S))
+
+    # big parts first, so a small part's label is never buried under a big rectangle
+    for ref in sorted(refs, key=lambda r: -((R[r][2] - R[r][0]) * (R[r][3] - R[r][1]))):
+        x0, y0, x1, y1 = R[ref]
+        fx, fy = tx(x0), ty(y0)
+        w, h = (x1 - x0) * S, (y1 - y0) * S
+        col = color.get(mod_of.get(ref), UNASSIGNED)
+        is_fixed = ref in fixed
+        o.append('<rect x="%.1f" y="%.1f" width="%.1f" height="%.1f" fill="%s" '
+                 'fill-opacity="%.2f" stroke="%s" stroke-width="%.1f" rx="1.5"/>'
+                 % (fx, fy, w, h, col, 0.85 if is_fixed else 0.5,
+                    "#111" if is_fixed else col, 1.2 if is_fixed else 0.6))
+        if w >= 34 and h >= 15:
+            o.append('<text x="%.1f" y="%.1f" font-size="10" fill="#111" '
+                     'text-anchor="middle">%s</text>'
+                     % (fx + w / 2, fy + h / 2 + 3.5, esc(ref)))
+
+    anchors = plan.get("anchors") or {}
+    for m in order:
+        for ax, ay in anchors.get(m, []):
+            o.append('<path d="M %.1f %.1f l 7 7 m 0 -7 l -7 7" stroke="%s" '
+                     'stroke-width="2.2" fill="none"/>'
+                     % (tx(ax) - 3.5, ty(ay) - 3.5, color.get(m, "#111")))
+
+    bar_mm = 10.0 if bw > 60 else 20.0
+    while bar_mm * S < 60:
+        bar_mm *= 2
+    bxp, byp = PAD + 6, plan_h - PAD - 8
+    o.append('<line x1="%.1f" y1="%.1f" x2="%.1f" y2="%.1f" stroke="#111" stroke-width="3"/>'
+             % (bxp, byp, bxp + bar_mm * S, byp))
+    o.append('<text x="%.1f" y="%.1f" font-size="12" fill="#111">%g mm</text>'
+             % (bxp + bar_mm * S + 8, byp + 4, bar_mm))
+
+    # ---- panel -------------------------------------------------------------
+    def text(x, y, s, size=12, fill="#222", weight="normal", anchor="start"):
+        o.append('<text x="%.1f" y="%.1f" font-size="%d" font-weight="%s" fill="%s" '
+                 'text-anchor="%s">%s</text>'
+                 % (x, y, size, weight, fill, anchor, esc(s)))
+
+    head_y = plan_h + 26
+    o.append('<line x1="0" y1="%.1f" x2="%.0f" y2="%.1f" stroke="#ccc" stroke-width="1"/>'
+             % (plan_h, W, plan_h))
+    text(PAD, head_y, title, 17, "#111", "bold")
+    text(PAD, head_y + 20,
+         "%s | generated %s | display metrics only - the gate is verify_placement.py"
+         % (geom.get("board", ""), datetime.datetime.now().strftime("%Y-%m-%d %H:%M")),
+         11, "#555")
+
+    top = plan_h + PANEL_HEAD_PX
+    text(PAD, top, "modules", 13, "#111", "bold")
+    for i, (m, n, share) in enumerate(legend):
+        col_i, row_i = divmod(i, per_col)
+        lx = PAD + col_i * LEGEND_COL_PX
+        ly = top + ROW_H * (row_i + 1)
+        col = color.get(m, UNASSIGNED)
+        o.append('<rect x="%.1f" y="%.1f" width="12" height="12" fill="%s" '
+                 'fill-opacity="0.6" stroke="%s"/>' % (lx, ly - 10, col, col))
+        text(lx + 17, ly, "%s  %s  (%d, %.1f%%)" % (m, titles.get(m, ""), n, share), 11)
+
+    text(mx, top, "evaluation panel", 13, "#111", "bold")
+    my = top + ROW_H
+    for label, value, col in rows:
+        text(mx, my, "%s:" % label, 11, "#555")
+        text(mx + 250, my, value, 11, col, "bold")
+        my += ROW_H
+    my += 4
+    for note, col in notes:
+        text(mx, my, note, 10, col)
+        my += 15
+
+    o.append("</svg>")
+
+    out_path = projpaths.resolve_out(args.out, "placement_view.svg",
+                                     refs=(args.geometry, args.plan), outdir=args.outdir)
+    with open(out_path, "w", encoding="utf-8") as fh:
+        fh.write("\n".join(o) + "\n")
+
+    print("wrote %s  (%.0f x %.0f px, %.2f px/mm)" % (out_path, W, H, S))
+    print("modules %d | parts %d | fixed %d | density %.1f%% | overlaps %d | off-board %d"
+          % (len(order), len(pos), len(fixed), density, len(overlaps), len(off_board)))
+    if weak:
+        print("stand-in courtyards (name these in the report): %s"
+              % ", ".join("%s=%s" % w for w in weak[:12]))
+
+
+if __name__ == "__main__":
+    main()

package/skills/pcb-initial-placement/scripts/pose_table.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""Turn a placement plan into the hand-off pose table (CSV).
+
+    python pose_table.py --geometry geometry.json --plan placement_plan.json
+    # -> <placement dir>/placement_pose_table.csv   (override with --out / --outdir)
+
+Columns: module, ref, value, footprint, origin_x_mm, origin_y_mm, rotation_deg,
+courtyard_w_mm, courtyard_h_mm, center_x_mm, center_y_mm, source
+``source`` is ``fixed`` for anchors the config pinned and ``placed`` otherwise, so a
+reviewer can tell decisions from consequences.  Written UTF-8 with BOM so Excel
+opens the Chinese module names correctly.
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import math
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import projpaths  # noqa: E402
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--geometry", required=True)
+    ap.add_argument("--plan", required=True)
+    ap.add_argument("--out", help="CSV to write "
+                                  "(default <placement dir>/placement_pose_table.csv)")
+    projpaths.add_outdir(ap)
+    args = ap.parse_args()
+
+    out_path = projpaths.resolve_out(args.out, "placement_pose_table.csv",
+                                     refs=(args.geometry, args.plan),
+                                     outdir=args.outdir)
+
+    geo = {g["ref"]: g
+           for g in json.load(open(args.geometry, encoding="utf-8-sig"))["footprints"]}
+    plan = json.load(open(args.plan, encoding="utf-8-sig"))
+    pos = plan["positions"]
+    fixed = set(plan.get("fixed", []))
+    order = list(plan["modules"].keys())
+
+    rows = []
+    for mod in order:
+        for ref in plan["modules"][mod]:
+            if ref not in pos:
+                continue
+            p = pos[ref]
+            x0, y0, x1, y1 = geo[ref]["bbox_local"]
+            t = math.radians(p["rot"])
+            c, s = math.cos(t), math.sin(t)
+            pts = [(lx * c + ly * s, -lx * s + ly * c) for lx in (x0, x1) for ly in (y0, y1)]
+            xs = [q[0] for q in pts]
+            ys = [q[1] for q in pts]
+            rows.append({
+                "module": mod, "ref": ref, "value": geo[ref]["value"],
+                "footprint": geo[ref]["libid"],
+                "origin_x_mm": "%.3f" % p["x"], "origin_y_mm": "%.3f" % p["y"],
+                "rotation_deg": "%.4g" % (p["rot"] % 360),
+                "courtyard_w_mm": "%.2f" % (max(xs) - min(xs)),
+                "courtyard_h_mm": "%.2f" % (max(ys) - min(ys)),
+                "center_x_mm": "%.2f" % (p["x"] + (min(xs) + max(xs)) / 2),
+                "center_y_mm": "%.2f" % (p["y"] + (min(ys) + max(ys)) / 2),
+                "source": "fixed" if ref in fixed else "placed",
+            })
+
+    cols = ["module", "ref", "value", "footprint", "origin_x_mm", "origin_y_mm",
+            "rotation_deg", "courtyard_w_mm", "courtyard_h_mm",
+            "center_x_mm", "center_y_mm", "source"]
+    with open(out_path, "w", encoding="utf-8-sig", newline="") as fh:
+        w = csv.DictWriter(fh, fieldnames=cols)
+        w.writeheader()
+        w.writerows(rows)
+    print("wrote %s (%d rows)" % (out_path, len(rows)))
+    by_module = {}
+    for r in rows:
+        by_module[r["module"]] = by_module.get(r["module"], 0) + 1
+    print("per module:", by_module)
+
+
+if __name__ == "__main__":
+    main()