code/refine_offset.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
refine_offset.py —— 固定 M 后的单参数偏移精修

为什么要单独一步：align_flow 在每个窗口里同时拟合「偏移 + 2x2 映射 M」，共 5 个
自由度。20260821 那一轮跑着游戏自己的昼夜循环和天气，30 秒窗口内光照本身在变，
相位相关会去锁光照图案而不是几何位移，5 个自由度足够把噪声拟合得很像样
（实测 R2 只有 0.15，解出的增益 10.2/3.1 明显是错的）。

但 M 是**相机投影**，是游戏的固有属性，不随 session 变：两轮是同一个游戏、
同一分辨率、同一「刚性跟随」相机。20260823 那轮环境钉死 Day/Clear，光照不变，
测出来干净（R2=0.79，横向增益换算到 832 画幅 = 27.55 px/世界单位）。
所以这里把 M 钉死成那个值，只剩偏移一个自由度。

同时把标量相关换成**矢量**相关：用 M 把日志速度投影成预期的屏幕速度，再与实测
光流做二维内积。光照伪影产生的位移与玩家运动方向无关，矢量相关会自然把它压掉，
标量的 |v| 相关做不到这一点。

另外把映射从 2x2 扩成 3x2，加入世界 y（高度）：2.5D 斜视角下上下坡本身就会改变
屏幕纵向位移（旧交付报告里的「坡地项 dy_px ≈ -23·dy_world」）。只用 (x,z) 拟合时
这部分方差会被错误地摊到 dz 的系数上，把纵向增益系统性拟低。
"""
from __future__ import annotations

import argparse
import json
import os

import numpy as np

import align_flow as AF


def vec_xcorr(vx, vy, px, py, fps, lag_max):
    """二维矢量互相关：sum(v · p) 随位移的变化。"""
    def norm(a, b):
        s = np.sqrt((a ** 2 + b ** 2).mean()) + 1e-9
        return a / s, b / s
    vx, vy = norm(vx - vx.mean(), vy - vy.mean())
    px, py = norm(px - px.mean(), py - py.mean())
    K = int(lag_max * fps)
    ks = np.arange(-K, K + 1)
    sc = np.empty(ks.size, np.float64)
    for i, k in enumerate(ks):
        a0, a1 = max(0, k), vx.size + min(0, k)
        b0, b1 = max(0, -k), px.size + min(0, -k)
        sc[i] = (vx[a0:a1] * px[b0:b1] + vy[a0:a1] * py[b0:b1]).mean()
    j = int(np.argmax(sc))
    sub = 0.0
    if 0 < j < sc.size - 1:
        d = sc[j - 1] - 2 * sc[j] + sc[j + 1]
        if abs(d) > 1e-12:
            sub = 0.5 * (sc[j - 1] - sc[j + 1]) / d
    return float((ks[j] + sub) / fps), float(sc[j])


def fit_M(args, sid):
    """在最干净的 session 上解 3x2 世界→屏幕映射（先用已知偏移把两侧对齐）。"""
    d = os.path.join(args.logs, sid)
    st = np.load(os.path.join(d, "state.npz")); o = np.argsort(st["vt"])
    vt, x, z = AF.dedupe_time(st["vt"][o], st["x"][o].astype(np.float64),
                              st["z"][o].astype(np.float64))
    yv = np.interp(vt, st["vt"][o], st["y"][o].astype(np.float64))
    wx, wy, wz = np.gradient(x, vt), np.gradient(yv, vt), np.gradient(z, vt)
    lum = np.load(os.path.join(d, "lum.npz")); mean = lum["mean"]; fps = float(lum["fps"])
    events = json.load(open(os.path.join(d, "events.json"), encoding="utf-8"))
    fj = json.load(open(os.path.join(d, "align_flow.json"), encoding="utf-8"))
    vid = os.path.join(args.raw, sid, "video.mp4")
    rng = np.random.default_rng(args.seed + 1)
    rows_A, rows_Y = [], []
    for seg in fj["segments"]:
        if seg.get("offset_flow") is None:
            continue
        off = seg["offset_flow"]
        for t0 in AF.pick_windows(mean, fps, events, 16, args.dur,
                                  seg["vt_lo"], seg["vt_hi"], rng):
            fr = AF.decode_window(vid, t0, args.dur)
            if fr is None:
                continue
            vx, vy_, _ = AF.flow_series(fr)
            grid = t0 + (np.arange(vx.size) + AF.STRIDE / 2) / fps - off
            A = np.stack([np.interp(grid, vt, wx), np.interp(grid, vt, wy),
                          np.interp(grid, vt, wz)], 1)
            sp = np.hypot(A[:, 0], A[:, 2])
            m = (sp > 0.8) & (sp < AF.SPEED_CAP)
            if m.sum() > 100:
                rows_A.append(A[m]); rows_Y.append(np.stack([vx, vy_], 1)[m])
    A = np.concatenate(rows_A); Y = np.concatenate(rows_Y)
    Mr, *_ = np.linalg.lstsq(A, Y, rcond=None)
    r2 = 1.0 - (Y - A @ Mr).var() / Y.var()
    k = (1280.0 / AF.PW) * 30.0 / AF.STRIDE
    print(f"[M 拟合] {sid}: {A.shape[0]:,} 个样本，R2 = {r2:.3f}")
    return Mr * k


def main():
    ap = argparse.ArgumentParser(description="固定 M 的偏移精修")
    ap.add_argument("--raw", default="/data/zhiyangdeng/EYBXROAM")
    ap.add_argument("--logs", default="/data/zhiyangdeng/data_eybx/logs")
    ap.add_argument("--sessions", nargs="*", default=None)
    ap.add_argument("--m_from", default="20260823_201942_753",
                    help="M 取自哪个 session（环境钉死那轮最干净）")
    ap.add_argument("--n_win", type=int, default=60)
    ap.add_argument("--dur", type=float, default=25.0)
    ap.add_argument("--lag_max", type=float, default=8.0)
    ap.add_argument("--min_peak", type=float, default=0.15)
    ap.add_argument("--seed", type=int, default=11)
    args = ap.parse_args()

    # ---- 在最干净的 session 上重解 3x2 的 M（含高度项）----
    M = fit_M(args, args.m_from)
    gx = abs(M[0, 0]) * 832 / 1280; gy = abs(M[2, 1]) * 480 / 720
    slope = M[1, 1] * 480 / 720
    print(f"M 取自 {args.m_from}：832x480 画幅下 横 {gx:.2f} / 纵 {gy:.2f} px/世界单位"
          f"  gx/gy={gx/gy:.2f}   坡地项 dy_px = {slope:+.1f}·dy_world")
    print(f"符号：世界 +x -> 屏幕 {'左' if M[0,0]<0 else '右'}，"
          f"世界 +z -> 屏幕 {'下' if M[2,1]>0 else '上'}\n")
    # M_px1280 是「px@1280/s per 世界单位/s」；光流量出来的是 px@PW/STRIDE帧，换算回去
    k = (1280.0 / AF.PW) * 30.0 / AF.STRIDE
    Mraw = M / k

    sessions = args.sessions or sorted(
        d for d in os.listdir(args.logs) if os.path.isdir(os.path.join(args.logs, d)))
    for sid in sessions:
        d = os.path.join(args.logs, sid)
        st = np.load(os.path.join(d, "state.npz")); o = np.argsort(st["vt"])
        vt, x, z = AF.dedupe_time(st["vt"][o], st["x"][o].astype(np.float64),
                                  st["z"][o].astype(np.float64))
        yy = np.interp(vt, st["vt"][o], st["y"][o].astype(np.float64))
        wx, wy, wz = np.gradient(x, vt), np.gradient(yy, vt), np.gradient(z, vt)
        lum = np.load(os.path.join(d, "lum.npz")); mean = lum["mean"]; fps = float(lum["fps"])
        events = json.load(open(os.path.join(d, "events.json"), encoding="utf-8"))
        aw = json.load(open(os.path.join(d, "align.json"), encoding="utf-8"))
        vid = os.path.join(args.raw, sid, "video.mp4")
        rng = np.random.default_rng(args.seed)
        print(f"== {sid}", flush=True)
        out = []
        for seg in aw["segments"]:
            lo, hi = seg["vt_lo"], seg["vt_hi"]
            if hi - lo < 4 * args.dur:
                continue
            wins = AF.pick_windows(mean, fps, events, args.n_win, args.dur, lo, hi, rng)
            lags, peaks = [], []
            for t0 in wins:
                fr = AF.decode_window(vid, t0, args.dur)
                if fr is None:
                    continue
                vx, vy, _ = AF.flow_series(fr)
                grid = t0 + (np.arange(vx.size) + AF.STRIDE / 2) / fps
                lwx = np.clip(np.interp(grid, vt, wx), -AF.SPEED_CAP, AF.SPEED_CAP)
                lwz = np.clip(np.interp(grid, vt, wz), -AF.SPEED_CAP, AF.SPEED_CAP)
                lwy = np.clip(np.interp(grid, vt, wy), -AF.SPEED_CAP, AF.SPEED_CAP)
                px = Mraw[0, 0] * lwx + Mraw[1, 0] * lwy + Mraw[2, 0] * lwz  # 预期屏幕速度
                py = Mraw[0, 1] * lwx + Mraw[1, 1] * lwy + Mraw[2, 1] * lwz
                if np.hypot(px, py).std() < 0.3 or np.hypot(vx, vy).std() < 0.3:
                    continue
                lag, pk = vec_xcorr(vx, vy, px, py, fps, args.lag_max)
                if pk < args.min_peak:
                    continue
                lags.append(lag); peaks.append(pk)
            if not lags:
                print(f"   vt {lo:.0f}–{hi:.0f}: 没有可用窗口"); continue
            L = np.array(lags); P = np.array(peaks)
            # 用峰值加权的中位（高峰值窗口更可信）
            order = np.argsort(L); Ls, Ps = L[order], P[order]
            c = np.cumsum(Ps); wmed = float(Ls[np.searchsorted(c, c[-1] / 2)])
            print(f"   vt {lo:9.0f}–{hi:9.0f}:  offset = {wmed:+.3f} s   "
                  f"[p25 {np.percentile(L,25):+.3f} / p75 {np.percentile(L,75):+.3f}]  "
                  f"矢量峰值中位 {np.median(P):.3f}  n={len(L)}/{len(wins)}", flush=True)
            out.append(dict(vt_lo=lo, vt_hi=hi, offset_refined=wmed,
                            offset_xcorr=seg["offset"], n=len(L),
                            peak_median=float(np.median(P)),
                            lags=[float(v) for v in L]))
        with open(os.path.join(d, "refine_offset.json"), "w", encoding="utf-8") as fh:
            json.dump(dict(session=sid, M_px1280=M.tolist(), m_from=args.m_from,
                           convention="video_t = log_vt + offset", segments=out),
                      fh, ensure_ascii=False, indent=1)
    print("DONE")


if __name__ == "__main__":
    main()