# -*- coding: utf-8 -*-
u"""R2 刀片 PCB（M4）：板框 + 分区参考 + 摆位常量。

    /c/Python314/python .claude/r2/pcb_blade.py            # 只算 + 自检
    /c/Python314/python .claude/r2/pcb_blade.py --outline  # 画/重画板框（幂等）
    /c/Python314/python .claude/r2/pcb_blade.py --verify   # 读回校验板框 + 挖槽区域
    /c/Python314/python .claude/r2/pcb_blade.py --slots    # 只重画两条排线槽（layer 12 填充）

## 坐标系

**板左下角 = (0, 0)，x 向右、y 向上**（EasyEDA PCB 里 y 向上为正，见方案 §22.5）。
这正好是方案 §3.1 那张分区图的坐标，图里的数可以直接抄。

```
y 76 ┬──────────────────────────────────┬──────────────┐
     │                                  │  功率列 26mm  │
     │   小米8 主板 67.09 × 44.66         │  Buck/L/Cin  │
y 29 ┼──── 接口边 ───────────────────────┤  eFuse/Rs    │
     │ 服务带 18mm  C60/TP/EDL/BM24/K1~4 │  INA/PCA9555 │
y 11 ┼──────────────────────────────────┴──────────────┤
     │ 金手指区 11mm（槽体 ~9mm 要让开，这一带不许放件）  │
y  0 ┴───────────────── 板边（卡边）─────────────────────┘
     x 0   3 ──── 手机主板 ──── 70.09   72 ─ 功率列 ─ 98
```

## 板框的底边是**断开**的

金手指的防呆缺口画在封装 `EDGE-64P-P1.00_PCIE-X4-GF` 的板框层里（方案 §22.3），
所以这里画的底边必须在缺口口部让开一段：断点 x 由 `fp_edge.notch_mouth()` + `J1_X` 算出，
**不要手抄**。两段拼起来才是一个闭合板框；拼不上 DRC 会报开口。

## ⛔ 不用 pcb_PrimitiveArc

实测（方案 §22.4）：`pcb_PrimitiveArc.create()` 在**封装编辑器里画得出但读不回、删不掉**，
在 **PCB 文档里干脆什么都不画**（返回值仍然是成功的）。⇒ 四角 R2 用折线近似，
弦高误差 < 0.01 mm。
"""
import io
import json
import math
import os
import sys

sys.stdout.reconfigure(encoding='utf-8')
HERE = os.path.dirname(os.path.abspath(__file__))
# ⚠ 顺序不能反：`.claude` 下有同名的 R1 脚本（pcb_pour / pcb_rules / pcb_place），
#   先插 .claude 再插 HERE 的话，`import pcb_pour` 会拿到 R1 那一份，
#   而且**不报错**，只在调到 R2 专有的函数时才炸。
sys.path.insert(0, os.path.dirname(HERE))
sys.path.insert(0, HERE)
from eda import run                                              # noqa: E402
import fp_edge                                                   # noqa: E402

PCB = '3b9c4e39c8d164db'         # BLADE-PCB
MIL = fp_edge.MIL

# ── 板框（mm，出处 方案 §3.1）─────────────────────────────────────────
BW, BH = 98.0, 76.0
CORNER_R = 2.0
CORNER_SEG = 8                   # 每个 R2 圆角用几段折线
OUTLINE_W = 0.15

# 金手指阵列中心。**居中**：刀片 98 宽、插槽体只有 39，居中让两侧悬臂等长
# （左边是手机主板、右边是功率列，两头都不轻）。⚠ 底板的 5 个插槽必须按同一个数摆。
J1_X, J1_Y, J1_ROT = BW / 2.0, 0.0, 0

# ── 小米8 主板的落点 + 定位孔（板级事实，摆位/布线/铺铜都从这里取）────────
# 主板 67.09 × 44.66，长边水平、**接口边（v=0，J600/J1401/侧键都在上面）朝下**。
PHONE_ORG = (3.0, 29.0)
PHONE_WH = (67.09, 44.66)

# ⛔ **主板定位孔**。整个 §3.2 的高度预算 / §21.1 的槽距结论都建立在
#    「螺丝把主板压在刀片上、螺柱间隙 1.0 mm」（R1 §22.3e 的中框式焊盘）之上 ——
#    没有这几个孔，`K1~K4` 那四个裸铜盘就没有压力，整套接触方式不成立。
#    孔位是实测值（`.claude/mi8_mech.json` 的 `holes`，u/v 本体坐标）。
# 直径沿用 R1 已经定稿的一组（`pcb2_place.py`）：
#    主板自己的孔 **Φ2.0**（用户卡尺）⇒ 配 **M1.6 尼龙立柱**（M2 螺杆塞 Φ2.0 没余量），
#    刀片这一侧是螺钉过孔，取 M1.6 的通孔 **Φ1.8 NPTH**。
# ⚠ R1 载板上 `H5` 没打（撞 EDL 座），**刀片上七个孔全都够得开**（实测最近焊盘 3.06 mm
#    是 H1 到 K2），所以七个全打。
HOLE_D = 1.8
HOLE_KEEP = 2.2                  # 螺钉头避让（M1.6 尼龙螺钉头 Ø3.2 + 余量）
HOLE_VIA_KEEP = 1.5              # 孔到过孔/铜的最小中心距（孔半径 0.9 + 过孔半径 0.3 + 净距）


def phone_holes():
    u"""{名字: (x, y)}，刀片坐标。"""
    m = json.load(io.open(os.path.join(os.path.dirname(HERE), 'mi8_mech.json'),
                          encoding='utf-8'))
    return {k: (round(PHONE_ORG[0] + u, 3), round(PHONE_ORG[1] + v, 3))
            for k, (u, v) in m['holes'].items()}


# ── 排线穿板槽（2026-09-09 用户拍板：屏蔽窗去掉、器件全到 B 面、给两条排线开槽）──
# ⛔ **屏蔽罩避让窗已删**。它是「屏蔽罩轮廓没实测所以全挖」的保守项，而 R1 §22.3e 的
#    定稿是「载板不挖空：用户实测贴合面元件全低于 1 mm」。去掉之后 L2 地平面整块、
#    板子恢复刚度，B 面手机投影 67×44 全部可放件（高度预算见 pcb_place.H_B_*）。
#
# **排线走法**（照搬 R1 `pcb2_place.SLOTS`，2026-09-06 实测排线：电池 8×38、尾插 18×55）：
#   J600/J1401 在主板朝上那一面 → 朝接口边（y=29）走 → 翻过板边落到刀片 A 面
#   → 到接口边外侧 2.7 mm 的槽 → 穿板 → **U 形折回，贴着 B 面往 +y 走**到手机投影下方的
#   `J5` / `J4`。折回是绕 x 轴翻 180°：x 不变、y 镜像 —— 而立创底层正是「先 y 镜像再转」
#   （方案 §25.3），所以 `J5`/`J4` 在底层 **rot 0** 就是对的（R1 §25.16 v4 同一结论）。
# ⚠ 槽是 **layer 12 (MULTI) 的填充 = 挖槽区域**（`pcb_PrimitiveFill`），不是板框内环。
#    DRC 认它（「挖槽区域 到 导线」），内层铺铜也会给它让反焊盘。
# ⚠ J1401 的 x 取设计文档 §22.3b 的**本体中心 53.58**（±0.3），不是 `mi8_mech.json`
#    `contacts_up.J1401 = 48.76` —— 那是座子西端（两者差 4.82 ≈ 半本体 6.1 − 1.3）。
#    TP1204/1205 两份数据吻合到 0.1，说明坐标系相同、只是 J1401 取的点不同。
#    按 53.58 定，尾插车道西沿 47.6 正好让开 H4 螺钉头 (44.9 + 2.2)，与 R1 自洽。
J600_U = 23.77                   # 电池座中心（两份数据一致；§22.3b 标 ±2，槽放宽到 12）
J1401_U = 53.58                  # 尾插座本体中心（§22.3b，±0.3）
SLOT_Y = (24.8, 27.8)            # 槽的 y 区间：接口边外侧 1.2~4.2，中心离边 2.7（R1 同）
SLOT_W = {'BAT': 12.0, 'TAIL': 20.0}     # 排线 8 / 18，各留余量
FLEX_W = {'BAT': 8.0, 'TAIL': 18.0}
SLOT_R = 1.0                     # 槽内圆角（铣刀半径，嘉立创内槽最小 R0.5）


def flex_x():
    u"""两条排线的中心 x（刀片坐标）。"""
    return {'BAT': round(PHONE_ORG[0] + J600_U, 3), 'TAIL': round(PHONE_ORG[0] + J1401_U, 3)}


def flex_slots():
    u"""{名字: (x0, y0, x1, y1)}，刀片坐标，铣穿。"""
    out = {}
    for k, cx in flex_x().items():
        w = SLOT_W[k]
        out[k] = (round(cx - w / 2, 3), SLOT_Y[0], round(cx + w / 2, 3), SLOT_Y[1])
    return out


def mill_cuts():
    u"""板上全部铣穿的内槽 [(x0,y0,x1,y1)] —— 布线 / 铺铜 / 摆位都从这里取障碍。"""
    return list(flex_slots().values())


def slot_check():
    u"""槽不许啃到螺钉孔避让圈，两条槽之间要留肋，槽不许进手机投影。"""
    bad = []
    for k, w in flex_slots().items():
        for hn, (hx, hy) in phone_holes().items():
            dx = max(w[0] - hx, 0.0, hx - w[2])
            dy = max(w[1] - hy, 0.0, hy - w[3])
            if math.hypot(dx, dy) < HOLE_KEEP:
                bad.append(u'槽 %s 离螺钉孔 %s 只有 %.2f < %.1f' % (k, hn, math.hypot(dx, dy), HOLE_KEEP))
        if w[3] > PHONE_ORG[1]:
            bad.append(u'槽 %s 顶 %.1f 进了手机投影（接口边 %.1f）' % (k, w[3], PHONE_ORG[1]))
        if w[1] < ZONES['finger'][3] + 1.0:
            bad.append(u'槽 %s 底 %.1f 压到金手指区' % (k, w[1]))
    s = flex_slots()
    rib = s['TAIL'][0] - s['BAT'][2]
    if rib < 3.0:
        bad.append(u'两槽之间只剩 %.1f mm 肋（要 >= 3）' % rib)
    return bad


# 分区（只是参考矩形，画在文档层，摆位脚本从这里取）
ZONES = {
    'finger':  (0.0, 0.0, BW, 11.0),          # 金手指区：不许放件（槽体 ~9mm）
    'service': (0.0, 11.0, 72.0, 29.0),       # 服务带：C60 / TP / EDL / BM24 / K1~K4
    'phone':   (3.0, 29.0, 3 + 67.09, 29.0 + 44.66),   # 小米8 主板投影
    'power':   (72.0, 11.0, BW, BH),          # 功率列
}


def corner(cx, cy, a0, a1):
    u"""圆角折线点列（角度 deg，逆时针）。"""
    pts = []
    for k in range(CORNER_SEG + 1):
        a = math.radians(a0 + (a1 - a0) * k / CORNER_SEG)
        pts.append((cx + CORNER_R * math.cos(a), cy + CORNER_R * math.sin(a)))
    return pts


def outline_pts():
    u"""板框点列（逆时针，从底边左端 (r,0) 起，回到 (r,0) 闭合）。

    ⚠ 相邻重合点必须去掉：圆角的首点和前一条直边的终点是同一个点，留着就会生成
    一条**零长度线段**，编辑器会静默把它吃掉（下发 41 段读回 37 段），
    于是「读回条数 != 期望」变成一个没完没了的假警报。这正是 CLAUDE.md 里
    原理图那条「零长度导线」坑的 PCB 版。
    """
    r = CORNER_R
    pts = [(r, 0.0), (BW - r, 0.0)]
    pts += corner(BW - r, r, 270, 360)             # 右下
    pts += [(BW, BH - r)]
    pts += corner(BW - r, BH - r, 0, 90)           # 右上
    pts += [(r, BH)]
    pts += corner(r, BH - r, 90, 180)              # 左上
    pts += [(0.0, r)]
    pts += corner(r, r, 180, 270)                  # 左下，收回 (r,0)
    out = [pts[0]]
    for q in pts[1:]:
        if abs(q[0] - out[-1][0]) > 1e-9 or abs(q[1] - out[-1][1]) > 1e-9:
            out.append(q)
    assert abs(out[0][0] - out[-1][0]) < 1e-9 and abs(out[0][1] - out[-1][1]) < 1e-9,         u'板框点列没有闭合'
    return out


def notch_break():
    u"""底边要断开的区间（板坐标 mm）。"""
    ml, mr = fp_edge.notch_mouth()
    return round(J1_X + ml, 4), round(J1_X + mr, 4)


def segments():
    u"""板框全部线段。底边在缺口口部断开。"""
    pts = outline_pts()
    segs = []
    for a, b in zip(pts, pts[1:]):
        segs.append((a[0], a[1], b[0], b[1]))
    # 第一段是底边 (r,0)->(BW-r,0)，切成两段
    bl, br = notch_break()
    x0, y0, x1, y1 = segs[0]
    assert (y0, y1) == (0.0, 0.0) and x0 < bl < br < x1, u'底边不是第一段或断点跑出去了'
    segs[0:1] = [(x0, 0.0, bl, 0.0), (br, 0.0, x1, 0.0)]
    # ⚠ 排线槽**不在这里**：它们是 layer 12 的填充（挖槽区域），见 push_slots()
    return segs


def notch_pts():
    u"""缺口的点列（板坐标），**自左向右**：口部左 → 导入角 → 左壁 → 顶半圆 → 右壁 → 口部右。

    几何仍然只有 `fp_edge` 一个出处，这里只做「封装坐标 + J1_X」的平移和顺序调整。
    """
    hw = fp_edge.NOTCH_W / 2.0
    ml, mr = notch_break()
    cx = J1_X + fp_edge.NOTCH_CX
    top = fp_edge.NOTCH_D - hw
    pts = [(ml, 0.0), (cx - hw, fp_edge.LEAD_IN), (cx - hw, top)]
    for k in range(fp_edge.ARC_SEG, -1, -1):          # 半圆从左（π）走到右（0）
        a = math.pi * k / fp_edge.ARC_SEG
        pts.append((cx + hw * math.cos(a), top + hw * math.sin(a)))
    pts += [(cx + hw, fp_edge.LEAD_IN), (mr, 0.0)]
    out = [pts[0]]
    for q in pts[1:]:
        if abs(q[0] - out[-1][0]) > 1e-9 or abs(q[1] - out[-1][1]) > 1e-9:
            out.append(q)
    return out


def outline_polygon():
    u"""**一条闭合折线**的完整板框点列：圆角矩形 + 底边中间的金手指防呆缺口。

    ⛔ 为什么不用 `segments()` 那 37 段线（2026-09-09，M7）：
    `pcb_PrimitiveLine` 在嘉立创里是**导线（铜）**，不是图形线 —— 选中它属性面板写的是
    「导线」，还带网络 / 网络长度，`图层` 那一格 `data-value=11` 但**显示是空的**
    （下拉里只有铜层，板框层不在选项里）。渲染成品红、DRC 也不报，
    所以四道几何校验全过，而**客户端根本不把它当板框**：
    自动布线一路弹「请先绘制板框！」。板框要用 `pcb_PrimitivePolyline`（折线）画。
    """
    pts = outline_pts()                                # 闭合，第一段是底边 (r,0)->(BW-r,0)
    bl, br = notch_break()
    assert pts[0][1] == 0.0 and pts[1][1] == 0.0 and pts[0][0] < bl < br < pts[1][0],         u'底边不是第一段或断点跑出去了'
    return [pts[0]] + notch_pts() + list(pts[1:])


def polygon_src(pts):
    u"""点列 -> pcb_MathPolygon.createPolygon 的源数组（mil，显式闭合）。"""
    a = [mil(pts[0][0]), mil(pts[0][1])]
    for q in pts[1:]:
        a += ['L', mil(q[0]), mil(q[1])]
    if pts[0] != pts[-1]:
        a += ['L', mil(pts[0][0]), mil(pts[0][1])]
    return a


def rrect_pts(x0, y0, x1, y1, r, seg=6):
    u"""圆角矩形闭合点列。内槽必须圆角：铣刀下不去直角，嘉立创内槽最小 R0.5。"""
    pts = []
    for cx, cy, a0 in ((x1 - r, y0 + r, 270), (x1 - r, y1 - r, 0),
                       (x0 + r, y1 - r, 90), (x0 + r, y0 + r, 180)):
        for k in range(seg + 1):
            a = math.radians(a0 + 90.0 * k / seg)
            pts.append((cx + r * math.cos(a), cy + r * math.sin(a)))
    out = [pts[0]]
    for q in pts[1:]:
        if abs(q[0] - out[-1][0]) > 1e-9 or abs(q[1] - out[-1][1]) > 1e-9:
            out.append(q)
    out.append(out[0])
    return out


def selfcheck():
    bl, br = notch_break()
    assert round(br - bl, 4) == 2.9, (bl, br)
    # 金手指必须整个落在板内，且不侵占服务带
    for pin in ('A1', 'A32'):
        x, y, w, h = fp_edge.pad_geom(pin)
        ax = J1_X + x
        assert 0.5 < ax < BW - 0.5, u'%s 跑出板外: x=%.2f' % (pin, ax)
    top = fp_edge.EDGE_CLR + fp_edge.LONG_L
    assert top < ZONES['finger'][3], u'手指顶到服务带'
    assert fp_edge.NOTCH_D < ZONES['finger'][3], u'缺口比金手指区还深'
    # 分区不许互相重叠（除了 finger/service 只共边）
    z = ZONES
    assert z['service'][3] == z['phone'][1] == 29.0
    assert z['phone'][2] <= z['power'][0], u'手机投影压进功率列'
    assert z['service'][2] <= z['power'][0], u'服务带压进功率列'
    assert z['phone'][3] <= BH, u'手机投影超出板顶'
    bad = slot_check()
    assert not bad, u'排线槽校核不过: %s' % bad
    return True


def call(js, timeout=180):
    r = run(js, timeout=timeout)
    if not r.get('success'):
        raise RuntimeError(json.dumps(r, ensure_ascii=False)[:800])
    return r['result']


def mil(v):
    return round(v * MIL, 4)


def push_outline():
    u"""画板框：**一条闭合折线**（`pcb_PrimitivePolyline`），含金手指缺口。

    顺带把层 11 上遗留的**导线**全删掉 —— M4b~M6 一直是用 `pcb_PrimitiveLine`
    画的，那是铜，客户端不认（见 `outline_polygon()` 的说明）。
    """
    src = polygon_src(outline_polygon())
    js = ("await eda.dmt_EditorControl.openDocument('%s');" % PCB +
          "await new Promise(r=>setTimeout(r,2500));" +
          "const oldL = (await eda.pcb_PrimitiveLine.getAll()||[]).filter(l=>l.layer===11)"
          ".map(l=>l.primitiveId).filter(i=>i.length<=20);" +
          "if (oldL.length) await eda.pcb_PrimitiveLine.delete(oldL);" +
          "const oldP = (await eda.pcb_PrimitivePolyline.getAll()||[])"
          ".filter(p=>p.getState_Layer()===11).map(p=>p.getState_PrimitiveId());" +
          "if (oldP.length) await eda.pcb_PrimitivePolyline.delete(oldP);" +
          "const poly = await eda.pcb_MathPolygon.createPolygon(%s);" % json.dumps(src) +
          "const r = await eda.pcb_PrimitivePolyline.create('', 11, poly, %s);" % mil(OUTLINE_W) +
          "await eda.pcb_Document.save();" +
          "return {delLine: oldL.length, delPoly: oldP.length, made: !!r,"
          " now: (await eda.pcb_PrimitivePolyline.getAll()||[])"
          ".filter(p=>p.getState_Layer()===11).length};")
    r = call(js, timeout=300)
    print(u'板框折线: 建 %s（删旧导线 %d / 旧折线 %d）；层 11 上现有折线 %d 条'
          % (u'成功' if r['made'] else u'失败', r['delLine'], r['delPoly'], r['now']))
    if not r['made'] or r['now'] != 1:
        raise SystemExit(u'!! 板框没画成')
    return r


PUSH_SLOTS_JS = u"""
await eda.dmt_EditorControl.openDocument('%s');
await new Promise(r=>setTimeout(r,2500));
const S = %s;
let del = 0;
for (const f of await eda.pcb_PrimitiveFill.getAll())
  if (f.getState_Layer() === 12) { await eda.pcb_PrimitiveFill.delete(f.getState_PrimitiveId()); del++; }
let made = 0, fail = [];
for (const [name, src] of S) {
  const poly = await eda.pcb_MathPolygon.createPolygon(src);
  const r = await eda.pcb_PrimitiveFill.create(12, poly);
  if (r) made++; else fail.push(name);
}
await eda.pcb_Document.save();
const now = (await eda.pcb_PrimitiveFill.getAll()).filter(f => f.getState_Layer() === 12).length;
return {del, made, fail, now};
"""


def slot_src(x0, y0, x1, y1):
    u"""圆角矩形 -> pcb_MathPolygon 的点列源（mil，显式闭合）。照抄 R1 pcb2_place.slot_poly。"""
    pts = rrect_pts(x0, y0, x1, y1, SLOT_R)
    a = [mil(pts[0][0]), mil(pts[0][1])]
    for p in pts[1:]:
        a += ['L', mil(p[0]), mil(p[1])]
    return a


def push_slots():
    S = [[k, slot_src(*w)] for k, w in sorted(flex_slots().items())]
    r = call(PUSH_SLOTS_JS % (PCB, json.dumps(S)), timeout=300)
    print(u'排线槽（layer 12 挖槽区域）: 建 %d / 失败 %s（删旧 %d）；板上现有 %d 个'
          % (r['made'], r['fail'] or u'无', r['del'], r['now']))
    for k, w in sorted(flex_slots().items()):
        print(u'   %-5s x %.2f~%.2f  y %.2f~%.2f  (%.1f × %.1f，排线 %.0f 宽)'
              % (k, w[0], w[2], w[1], w[3], w[2] - w[0], w[3] - w[1], FLEX_W[k]))
    if r['now'] != len(S):
        raise SystemExit(u'!! 槽没建全')
    return r


def verify():
    u"""读回板框折线，逐点和 `outline_polygon()` 对账 + 校验闭合与外接矩形。"""
    r = call("await eda.dmt_EditorControl.openDocument('%s');"
             "await new Promise(r=>setTimeout(r,2000));"
             "const ps = (await eda.pcb_PrimitivePolyline.getAll()||[])"
             ".filter(p=>p.getState_Layer()===11);"
             "const line11 = (await eda.pcb_PrimitiveLine.getAll()||[])"
             ".filter(l=>l.layer===11).length;"
             "const fills = (await eda.pcb_PrimitiveFill.getAll()).filter(f=>f.getState_Layer()===12).length;"
             "return {n: ps.length, poly: ps.length ? ps[0].getState_Polygon() : null,"
             " line11, fills};" % PCB, timeout=180)
    bad = []
    if r['n'] != 1:
        bad.append(u'层 11 上有 %d 条折线（应为 1 条）' % r['n'])
    # ⚠ 层 11 上**允许**留 16 条导线：那是 J1 金手指封装内部的缺口线（fp_edge 画的），
    #   删不掉也不必删 —— 板框已经由折线自己闭合，它们只是重复的图形。
    if r['line11'] not in (0, 16):
        bad.append(u'层 11 上还有 %d 条导线（只该剩 J1 封装那 16 条或 0 条）' % r['line11'])
    if r['fills'] != len(flex_slots()):
        bad.append(u'layer 12 挖槽区域 %d 个 != %d' % (r['fills'], len(flex_slots())))
    pts = []
    src = r['poly']
    if isinstance(src, dict):
        src = src.get('pointArr') or src.get('points') or src.get('polygon') or src
    if isinstance(src, list):
        i, cur = 0, None
        while i < len(src):
            if src[i] == 'L' or src[i] == 'l':
                i += 1
                continue
            if isinstance(src[i], (int, float)) and i + 1 < len(src) and isinstance(src[i + 1], (int, float)):
                pts.append((src[i] / MIL, src[i + 1] / MIL))
                i += 2
            else:
                i += 1
    want = outline_polygon()
    if pts:
        xs = [p[0] for p in pts]
        ys = [p[1] for p in pts]
        if abs(min(xs)) > 0.01 or abs(max(xs) - BW) > 0.01 or            abs(min(ys)) > 0.01 or abs(max(ys) - BH) > 0.01:
            bad.append(u'板框外接矩形 %.2f~%.2f x %.2f~%.2f != 0~%.1f x 0~%.1f'
                       % (min(xs), max(xs), min(ys), max(ys), BW, BH))
        if abs(pts[0][0] - pts[-1][0]) > 0.01 or abs(pts[0][1] - pts[-1][1]) > 0.01:
            bad.append(u'折线首尾不重合：%s vs %s' % (pts[0], pts[-1]))
        if abs(len(pts) - len(want)) > 1:
            bad.append(u'点数 %d != %d' % (len(pts), len(want)))
        print(u'读回板框折线 1 条 / %d 点，外接 %.2f~%.2f x %.2f~%.2f；'
              u'层 11 遗留导线 %d 条；挖槽区域 %d 个'
              % (len(pts), min(xs), max(xs), min(ys), max(ys), r['line11'], r['fills']))
    else:
        bad.append(u'读不回折线点列（原始值 %s）' % str(r['poly'])[:120])
    if bad:
        print(u'[X] 校验不过:')
        for b in bad:
            print(u'   ' + b)
    else:
        print(u'[OK] 板框是一条闭合折线（缺口在里面），外接矩形对上，挖槽区域齐')
    return bad


PUSH_HOLES_JS = u"""
await eda.dmt_EditorControl.openDocument('%s');
await new Promise(r=>setTimeout(r,2500));
const H = %s, D = %s;
for (const p of await eda.pcb_PrimitivePad.getAll()) {
  const num = p.getState_PadNumber();
  if (typeof num === 'string' && /^H[1-7]$/.test(num))
    await eda.pcb_PrimitivePad.delete(p.getState_PrimitiveId());
}
let k = 0;
for (const [name, x, y] of H) {
  // layer 12 = 多层；metallization=false ⇒ NPTH。参数位序照抄 R1 pcb2_place.py
  await eda.pcb_PrimitivePad.create(12, name, x, y, 0, ['ELLIPSE', D, D], '',
                                    ['ROUND', D], 0, 0, 0, false);
  k++;
}
await eda.pcb_Document.save();
return {made: k, now: (await eda.pcb_PrimitivePad.getAll())
          .filter(p => /^H[1-7]$/.test(String(p.padNumber))).length};
"""


def push_holes():
    hs = phone_holes()
    arr = [[k, round(v[0] * MIL, 4), round(v[1] * MIL, 4)] for k, v in sorted(hs.items())]
    r = call(PUSH_HOLES_JS % (PCB, json.dumps(arr), round(HOLE_D * MIL, 4)), timeout=300)
    print(u'主板定位孔: 下发 %d 个 / 读回 %d 个，NPTH Φ%.1f（⚠ 必须配 M1.6 尼龙立柱）'
          % (r['made'], r['now'], HOLE_D))
    return r


if __name__ == '__main__':
    selfcheck()
    if '--holes' in sys.argv:
        push_holes()
        for k, v in sorted(phone_holes().items()):
            print(u'  %-3s (%6.2f, %6.2f)' % (k, v[0], v[1]))
        sys.exit(0)
    bl, br = notch_break()
    print(u'刀片 %.0f x %.0f，四角 R%.1f；金手指中心 x=%.2f' % (BW, BH, CORNER_R, J1_X))
    print(u'底边断点: %.2f ~ %.2f（缺口口部）' % (bl, br))
    print(u'金手指跨度: x %.2f ~ %.2f，指顶 y=%.2f，缺口顶 y=%.2f'
          % (J1_X + fp_edge.PIN_X['A1'] - fp_edge.FW / 2,
             J1_X + fp_edge.PIN_X['A32'] + fp_edge.FW / 2,
             fp_edge.EDGE_CLR + fp_edge.LONG_L, fp_edge.NOTCH_D))
    for k, z in ZONES.items():
        print(u'  %-8s x %6.2f~%6.2f  y %6.2f~%6.2f' % (k, z[0], z[2], z[1], z[3]))
    for k, w in sorted(flex_slots().items()):
        print(u'  槽 %-5s x %6.2f~%6.2f  y %6.2f~%6.2f' % (k, w[0], w[2], w[1], w[3]))
    if '--outline' in sys.argv:
        push_outline()
        push_slots()
        verify()
    elif '--slots' in sys.argv:
        push_slots()
        verify()
    elif '--verify' in sys.argv:
        verify()