Lattice-Vault：棋盘格与数字巨龙

#!/usr/bin/env python3
"""从 BIP39「冷钱包雕版」棋盘格图里读出 12 个助记词索引。

棋盘格是 12×12 的圆点阵：横轴权重 2048/1024/…/2/1，纵轴行号 1~12，
实心圆 = 1、空心圆 = 0。每行读成一个 12 bit 数，减去 1 才是 BIP39 词索引
（雕版是 1-based 的：index 0 也要刻一格，否则分不清「没刻」和「0 号词」）。
12 个索引各取 11 bit 拼成 132 bit = Entropy(128 bit) + 校验位(4 bit)，
校验位应等于 SHA256(Entropy) 的头 4 bit —— 脚本用它自证读对了没有。

依赖：numpy, pillow
用法：
    python read_grid.py 谜面图.jpg
    python read_grid.py 谜面图.jpg --x0 899.5 --y0 459.5 --step 120 --win 20
"""
import argparse
import hashlib
import sys

import numpy as np
from PIL import Image

GRID = 12


def line_centers(dark, axis):
    """找出棋盘上「每 4 列/行一组」的分组粗线中心"""
    proj = dark.sum(axis=1) if axis == 0 else dark.sum(axis=0)
    limit = (dark.shape[1] if axis == 0 else dark.shape[0]) * 0.4
    idx = np.where(proj > limit)[0]
    out, start, prev = [], None, None
    for i in idx:
        if start is None:
            start = prev = i
            continue
        if i > prev + 5:
            out.append((start + prev) / 2)
            start = i
        prev = i
    if start is not None:
        out.append((start + prev) / 2)
    return out


def calibrate(path):
    """只用分组线推格距；原点由第一条线外推半格（线的渲染宽度会引入偏差，故留 --x0 可覆盖）"""
    a = np.array(Image.open(path).convert("L")).astype(np.int32)
    dark = a < 128
    rows, cols = line_centers(dark, 0), line_centers(dark, 1)
    if len(rows) < 2 or len(cols) < 2:
        sys.exit("✗ 没找到棋盘的分组线，请用 --x0/--y0/--step 手工指定")
    ystep = float(np.median(np.diff(rows)) / 4)
    xstep = float(np.median(np.diff(cols)) / 4)
    # 第 0 行/列的圆心：第一条分组线在格子的边界上，圆心在它 + 半格处
    y0 = rows[0] + ystep / 2
    x0 = cols[0] + xstep / 2
    return a, x0, y0, xstep, ystep


def read_bits(a, x0, y0, xstep, ystep, win):
    h = win // 2
    m = np.zeros((GRID, GRID), dtype=int)
    for j in range(GRID):
        for i in range(GRID):
            cx = int(round(x0 + xstep * i))
            cy = int(round(y0 + ystep * j))
            patch = a[cy - h:cy + h, cx - h:cx + h]
            m[j, i] = 1 if patch.mean() < 128 else 0
    return m


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("image")
    ap.add_argument("--x0", type=float, default=None, help="第 0 列圆心 x")
    ap.add_argument("--y0", type=float, default=None, help="第 0 行圆心 y")
    ap.add_argument("--step", type=float, default=None, help="格距（横纵相同）")
    ap.add_argument("--win", type=int, default=20, help="采样窗口边长")
    args = ap.parse_args()

    a, x0, y0, xstep, ystep = calibrate(args.image)
    x0 = args.x0 if args.x0 is not None else x0
    y0 = args.y0 if args.y0 is not None else y0
    if args.step:
        xstep = ystep = args.step

    m = read_bits(a, x0, y0, xstep, ystep, args.win)
    print(f"网格: x0={x0:.1f} y0={y0:.1f} step={xstep:.2f}")
    print()
    for j in range(GRID):
        print("  行%2d  %s  %s" % (j + 1, "".join("●" if v else "·" for v in m[j]),
                                   "".join(str(v) for v in m[j])))

    vals = [int("".join(str(v) for v in m[j]), 2) for j in range(GRID)]
    idx = [v - 1 for v in vals]
    print()
    print("  12bit 刻度值:", vals)
    print("  词索引(减1) :", idx)
    if any(not (0 <= i < 2048) for i in idx):
        sys.exit("✗ 有索引越界，说明读错了（可能列序反了或采样偏了）")

    bits = "".join(f"{i:011b}" for i in idx)
    ent = f"{int(bits[:128], 2):032X}"
    ck = bits[128:]
    want = f"{int(hashlib.sha256(bytes.fromhex(ent)).hexdigest()[0], 16):04b}"
    print("  Entropy(hex) :", ent)
    print("  末 4 bit     :", ck, "| SHA256(Entropy) 前 4 bit:", want,
          "->", "✓ 读法自洽（这是一份合法 BIP39 助记词）" if ck == want else "✗ 不自洽，读错了")


if __name__ == "__main__":
    main()