1.2 风格向量与风格距离矩阵

#!/usr/bin/env python3
# file: sim/st01_distance.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/st01_distance.py
"""卷三 1.2 风格向量与风格距离矩阵（S 层）。

读只读真源 config/sp16_themes.json：五维风格向量（与 1.1 同式），再用**声明权重**
[2,2,1,3,3] 算 6×6 加权 L1 距离矩阵（整数 ×10，逐位一致）。判据是
distinguishableFloor10：任意两主题距离必须严格大于它，「同源但可区分」才成立。

摘要串（canonical）与卷二 16.2 同式：主题顺序 + 逐主题向量，再接 15 对距离；
故两卷各自独立复算，digest 应逐位相同。产出 out/st01_distance.json + .svg 热力图。
"""
import hashlib
import itertools
import json
import os
import sys
import xml.etree.ElementTree as ET

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
THEMES = os.path.join(ROOT, "config/sp16_themes.json")
OUT = os.path.join(ROOT, "out")
ROLES = ["accent", "bg", "ink", "surface"]


def luma709(c):
    return (2126 * c[0] + 7152 * c[1] + 722 * c[2]) // 10000


def median_int(xs):
    s = sorted(xs)
    n = len(s)
    return s[n // 2] if n % 2 else (s[n // 2 - 1] + s[n // 2]) // 2


def sat_permille(c):
    mx = max(c)
    return 0 if mx == 0 else (mx - min(c)) * 1000 // mx


def hue_deg(c):
    mx, mn = max(c), min(c)
    d = mx - mn
    if d == 0:
        return None
    h = (60 * (c[1] - c[2]) / d if mx == c[0]
         else 60 * ((c[2] - c[0]) / d + 2) if mx == c[1]
         else 60 * ((c[0] - c[1]) / d + 4))
    return int(h % 360)


def style_vector(t):
    cols = [t["tokens"][k] for k in ROLES]
    hues = [h for h in (hue_deg(c) for c in cols) if h is not None]
    span = (max(hues) - min(hues)) if len(hues) >= 2 else 0
    luma = median_int([luma709(c) for c in cols])
    return [luma * 1000 // 255, sum(sat_permille(c) for c in cols) // len(cols),
            span * 1000 // 360, int(t["strokePermille"]), int(t["detailPermille"])]


def dist10(a, b, w):
    """五维加权 L1 的整数均值再 ×10 取整 → 整数类，逐位一致。"""
    return (sum(wi * abs(x - y) for wi, x, y in zip(w, a, b)) * 10) // sum(w)


def main():
    cfg = json.load(open(THEMES, encoding="utf-8"))
    w, floor10 = cfg["weights"], cfg["distinguishableFloor10"]
    names = [t["id"] for t in cfg["themes"]]
    vecs = {t["id"]: style_vector(t) for t in cfg["themes"]}
    matrix = [[0 if a == b else dist10(vecs[a], vecs[b], w) for b in names] for a in names]
    flat = [(names[i], names[j], dist10(vecs[names[i]], vecs[names[j]], w))
            for i in range(len(names)) for j in range(i + 1, len(names))]
    lo = min(flat, key=lambda r: r[2])
    hi = max(flat, key=lambda r: r[2])
    below = [f"{a}/{b}:{d}" for a, b, d in flat if d <= floor10]
    parts = [f"{n}:{','.join(map(str, vecs[n]))}" for n in names]
    parts += [f"{a}>{b}:{d}" for a, b, d in flat]
    canon = ";".join(parts)
    digest = hashlib.sha256(canon.encode("utf-8")).hexdigest()[:16]
    report = {"project": cfg["project"], "order": names, "dims": cfg["dims"], "weights": w,
              "distinguishableFloor10": floor10, "vectors": {n: vecs[n] for n in names},
              "matrix": matrix, "minPair": {"a": lo[0], "b": lo[1], "d": lo[2]},
              "maxPair": {"a": hi[0], "b": hi[1], "d": hi[2]}, "belowFloor": below,
              "headroom": lo[2] - floor10, "pairCount": len(flat),
              "canonical": canon, "digest": digest}
    os.makedirs(OUT, exist_ok=True)
    with open(os.path.join(OUT, "st01_distance.json"), "w", encoding="utf-8") as f:
        json.dump(report, f, ensure_ascii=False, indent=2, sort_keys=True)
        f.write("\n")
    write_svg(names, matrix, os.path.join(OUT, "st01_distance.svg"))
    print(f"themes={len(names)} pairs={len(flat)} floor10={floor10} below={len(below)}")
    print(f"min={lo[0]}/{lo[1]}={lo[2]} max={hi[0]}/{hi[1]}={hi[2]} headroom={lo[2] - floor10}")
    print(f"digest={digest}")
    print("wrote out/st01_distance.json out/st01_distance.svg")
    return 0


def write_svg(names, matrix, path):
    """6×6 热力图：色越暖（红）越不像，越冷（蓝）越像；对角为 0。"""
    n, cell = len(names), 58
    W = H = 110 + n * cell
    svg = ET.Element("svg", {"xmlns": "http://www.w3.org/2000/svg", "width": str(W),
                             "height": str(H), "viewBox": f"0 0 {W} {H}", "role": "img"})
    ET.SubElement(svg, "rect", {"width": str(W), "height": str(H), "fill": "#111827"})
    mx = max(max(r) for r in matrix) or 1
    for i, a in enumerate(names):
        ET.SubElement(svg, "text", {"x": "8", "y": str(96 + i * cell), "fill": "#cbd5e1",
                                    "font-family": "monospace", "font-size": "10"}).text = a
        for j, b in enumerate(names):
            d = matrix[i][j]
            t = d / mx  # 0 冷 → 1 暖
            r = int(59 + t * 180)
            g = int(130 - t * 80)
            bl = int(246 - t * 170)
            x, y = 90 + j * cell, 74 + i * cell
            ET.SubElement(svg, "rect", {"x": str(x), "y": str(y), "width": str(cell - 3),
                                        "height": str(cell - 3), "rx": "3",
                                        "fill": f"#{r:02x}{g:02x}{bl:02x}"})
            ET.SubElement(svg, "text", {"x": str(x + 6), "y": str(y + 32), "fill": "#0b1220",
                                        "font-family": "monospace", "font-size": "11"}).text = str(d)
    for j, b in enumerate(names):
        ET.SubElement(svg, "text", {"x": str(96 + j * cell), "y": "62", "fill": "#cbd5e1",
                                    "font-family": "monospace", "font-size": "10"}).text = b[:9]
    tree = ET.ElementTree(svg)
    ET.indent(tree, space="  ")
    tree.write(path, encoding="utf-8", xml_declaration=True)


if __name__ == "__main__":
    sys.exit(main())

themes=6 pairs=15 floor10=800 below=0
min=lowpoly/cozy-clean=1002 max=retro-cyber/cozy-clean=3794 headroom=202
digest=fa04e9418d9f3c2c
wrote out/st01_distance.json out/st01_distance.svg

// file: core/src/st01/distance.ts
// tier: P
// verify: node --test 'core/test/st01_*.test.ts'
// 1.2 风格距离矩阵的 TS 内核：五维加权 L1 的整数均值再 ×10，逐位一致；6×6 矩阵与
// canonical 摘要串（主题顺序 + 逐主题向量 + 15 对距离）与 Python 侧同式，故两卷 digest
// 可对拍。距离是整数类，跨语言「逐位一致」；这里没有任何浮点。
import { FULL_DIMS, dist10 } from "./style.ts";

export type Vec = number[];

/** 五维加权 L1 距离 ×10（整数类，逐位一致）。 */
export function styleDistance(a: Vec, b: Vec, weights: number[]): number {
  return dist10(a, b, weights, FULL_DIMS);
}

/** 6×6 对称矩阵：对角为 0，其余为 styleDistance ×10。 */
export function distanceMatrix(names: string[], vecs: Record<string, Vec>, weights: number[]): number[][] {
  return names.map((a) => names.map((b) => (a === b ? 0 : styleDistance(vecs[a], vecs[b], weights))));
}

/** 15 对无序对（i<j，按 names 顺序）。 */
export function pairs(names: string[], vecs: Record<string, Vec>, weights: number[]): { a: string; b: string; d: number }[] {
  const out: { a: string; b: string; d: number }[] = [];
  for (let i = 0; i < names.length; i += 1) {
    for (let j = i + 1; j < names.length; j += 1) {
      out.push({ a: names[i], b: names[j], d: styleDistance(vecs[names[i]], vecs[names[j]], weights) });
    }
  }
  return out;
}

/** canonical 摘要串：与 sim/st01_distance.py 逐字同式（`;` 连接，无空白）。 */
export function canonical(order: string[], vecs: Record<string, Vec>, flat: { a: string; b: string; d: number }[]): string {
  const parts = order.map((n) => `${n}:${vecs[n].join(",")}`);
  for (const r of flat) parts.push(`${r.a}>${r.b}:${r.d}`);
  return parts.join(";");
}

✔ 6×6 距离矩阵：整数 ×10 与 Python 逐位一致 (0.931875ms)
✔ 最近/最远一对与下限余量：与 Python 一致 (0.171875ms)
✔ 同源可区分：15 对全部严格高于下限，越界集合为空 (0.082958ms)
✔ canonical 摘要 + sha256 指纹：跨语言逐位一致，并锚定跨卷指纹 (0.365084ms)
✔ 负例：把两个主题调成同一向量，距离为 0 必被下限拦下 (0.089958ms)
ℹ tests 16
ℹ pass 16
ℹ fail 0