code/align_flow.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
align_flow.py —— 用画面全局光流做无偏对齐 + 解世界→屏幕映射

为什么必须做这一步：
  · align.py 用「传送窗口 vs 画面变黑」，能可靠抓出台阶，但绝对值里混进了
    「leg_end 事件 → 引擎真正切黑」的固定延迟，不是纯时间轴偏移。
  · 逐帧亮度差(diff)与速度的相关太弱（实测峰值 0.08），画面变化被内容主导。
  · 唯一没有可假设常数的信号对，是同一时刻的两个观测：
        日志侧 = 玩家世界速度 (x,z)
        视频侧 = 画面全局位移（相机刚性跟随玩家 ⇒ 背景反向平移）
    互相关峰值就是纯粹的 offset。

两个必须做对的细节（第一版都栽在这）：
  1. 分辨率/时间基线：玩家 2.4 m/s、增益约 27.5 px/世界单位@1280宽，
     换算到 128 px 宽、逐帧比，位移只有 0.22 px —— 整数峰的相位相关分辨不出来。
     这里用 480 px 宽 + 6 帧（0.2 s）时间基线，位移约 5 px，再做抛物线亚像素。
  2. 状态日志有重复时间戳，np.gradient 会除零把速度污染成 nan，必须先去重。

产出 <out>/<session>/align_flow.json：每个分段的 offset + 2x2 世界→屏幕映射 M。
M 决定「moving up」对应哪个世界方向 —— 动作词表的符号是实测的，不是猜的。
"""
from __future__ import annotations

import argparse
import json
import os
import subprocess

import numpy as np

PW, PH = 480, 270
FB = PW * PH
STRIDE = 3                 # 时间基线（帧）；实测 3 帧时互相关峰值最高
SPEED_CAP = 12.0           # m/s，玩家跑动上限；超过的都是瞬移尖峰


def decode_window(path: str, t0: float, dur: float):
    cmd = ["ffmpeg", "-v", "error", "-ss", f"{t0:.3f}", "-t", f"{dur:.3f}", "-i", path,
           "-vf", f"scale={PW}:{PH}:flags=bicubic,format=gray",
           "-f", "rawvideo", "-pix_fmt", "gray", "-"]
    raw = subprocess.run(cmd, capture_output=True).stdout
    n = len(raw) // FB
    if n < STRIDE + 8:
        return None
    return np.frombuffer(raw[:n * FB], np.uint8).reshape(n, PH, PW).astype(np.float32)


def _subpix(r, iy, ix):
    """在峰值邻域做抛物线插值，拿到亚像素位移。"""
    def par(m, c, p):
        d = m - 2 * c + p
        return 0.0 if abs(d) < 1e-9 else 0.5 * (m - p) / d
    H, W = r.shape
    dy = par(r[(iy - 1) % H, ix], r[iy, ix], r[(iy + 1) % H, ix])
    dx = par(r[iy, (ix - 1) % W], r[iy, ix], r[iy, (ix + 1) % W])
    return dx, dy


def flow_series(frames: np.ndarray):
    """对每个 i 比较 frame[i] 与 frame[i+STRIDE]，返回屏幕上玩家的移动速度 (px/基线)。"""
    win = np.outer(np.hanning(PH), np.hanning(PW)).astype(np.float32)
    F = np.fft.rfft2(frames * win)                     # 缓存所有帧的 FFT
    n = F.shape[0] - STRIDE
    vx = np.zeros(n, np.float32); vy = np.zeros(n, np.float32); pk = np.zeros(n, np.float32)
    for i in range(n):
        R = F[i] * np.conj(F[i + STRIDE])
        m = np.abs(R)
        R = np.where(m > 1e-12, R / m, 0)
        r = np.fft.irfft2(R, s=(PH, PW))
        iy, ix = np.unravel_index(np.argmax(r), r.shape)
        sx, sy = _subpix(r, iy, ix)
        dx = ix + sx; dy = iy + sy
        if dx > PW / 2: dx -= PW
        if dy > PH / 2: dy -= PH
        # 画面往左退 = 玩家往右走，所以取反
        vx[i], vy[i] = -dx, -dy
        pk[i] = r[iy, ix]
    return vx, vy, pk


def dedupe_time(vt, x, z):
    keep = np.concatenate([[True], np.diff(vt) > 1e-6])
    return vt[keep], x[keep], z[keep]


def xcorr(a, b, fps, lag_max):
    """返回使 a 与 b 最吻合的位移（秒，正 = a 落后于 b）+ 峰值。"""
    a = (a - a.mean()) / (a.std() + 1e-9)
    b = (b - b.mean()) / (b.std() + 1e-9)
    K = int(lag_max * fps)
    ks = np.arange(-K, K + 1)
    sc = np.array([np.dot(a[max(0, k):a.size + min(0, k)],
                          b[max(0, -k):b.size + min(0, -k)]) / (a.size - abs(k)) for k in ks])
    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 pick_windows(lum, fps, events, n_win, dur, t_lo, t_hi, rng):
    tel = np.array(sorted(float(e["vt"]) for e in events
                          if e.get("ev") in ("roam_leg_end", "roam_leg_start")))
    out, tries = [], 0
    while len(out) < n_win and tries < n_win * 400:
        tries += 1
        t = rng.uniform(t_lo, max(t_lo + 1, t_hi - dur))
        if tel.size:
            j = np.searchsorted(tel, t)
            near = tel[max(j - 2, 0):j + 3]
            if np.any((near > t - 25) & (near < t + dur + 25)):
                continue
        i0, i1 = int(t * fps), int((t + dur) * fps)
        if i1 >= lum.size or lum[i0:i1].mean() < 18:
            continue
        if any(abs(t - o) < dur * 1.5 for o in out):
            continue
        out.append(t)
    return sorted(out)


def main():
    ap = argparse.ArgumentParser(description="光流对齐 + 世界→屏幕映射")
    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("--n_win", type=int, default=24)
    ap.add_argument("--dur", type=float, default=45.0)
    ap.add_argument("--lag_max", type=float, default=8.0)
    ap.add_argument("--min_peak", type=float, default=0.25,
                    help="互相关峰值低于此的窗口丢掉（画面太静/太暗，测不出运动）")
    ap.add_argument("--seed", type=int, default=7)
    args = ap.parse_args()

    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 = dedupe_time(st["vt"][o], st["x"][o].astype(np.float64),
                               st["z"][o].astype(np.float64))
        wx, wz = np.gradient(x, 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"))
        align = 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)

        results = []
        for seg in align["segments"]:
            lo, hi = seg["vt_lo"], seg["vt_hi"]
            if hi - lo < 4 * args.dur:
                continue
            wins = pick_windows(mean, fps, events, args.n_win, args.dur, lo, hi, rng)
            print(f"   分段 vt {lo:.0f}–{hi:.0f} s（互相关估计 {seg['offset']:+.2f} s）："
                  f"{len(wins)} 个窗口", flush=True)
            lags, peaks, maps, r2s = [], [], [], []
            for t0 in wins:
                fr = decode_window(vid, t0, args.dur)
                if fr is None:
                    continue
                vx, vy, _ = flow_series(fr)
                grid = t0 + (np.arange(vx.size) + STRIDE / 2) / fps
                sv = np.hypot(vx, vy)
                sl = np.hypot(np.interp(grid, vt, wx), np.interp(grid, vt, wz))
                # 位移日志里有瞬移尖峰（np.gradient 在跳变处给出上万 m/s），
                # 归一化后整条信号会被单个尖峰压平 —— 必须先钳位再相关。
                sl = np.clip(sl, 0.0, SPEED_CAP)
                sv = np.clip(sv, 0.0, np.percentile(sv, 99.5) + 1e-6)
                if sv.std() < 0.3 or sl.std() < 0.2:
                    continue
                lag, pk = xcorr(sv, sl, fps, args.lag_max)
                if pk < args.min_peak:
                    continue
                lags.append(lag); peaks.append(pk)
                # 对齐后解 [vx,vy] = [wx,wz] @ M
                A = np.stack([np.interp(grid - lag, vt, wx),
                              np.interp(grid - lag, vt, wz)], 1)
                Y = np.stack([vx, vy], 1)
                m = (np.hypot(A[:, 0], A[:, 1]) > 0.8) & (np.hypot(A[:, 0], A[:, 1]) < SPEED_CAP)
                if m.sum() > 100:
                    M, *_ = np.linalg.lstsq(A[m], Y[m], rcond=None)
                    r2 = 1.0 - (Y[m] - A[m] @ M).var() / max(Y[m].var(), 1e-9)
                else:
                    M, r2 = np.full((2, 2), np.nan), 0.0
                maps.append(M); r2s.append(float(r2))   # 与 lags 一一对应，供自洽性筛选
            if not lags:
                print("     没有可用窗口"); continue
            lags = np.array(lags); peaks_a = np.array(peaks)
            # M 自洽性筛选：M 是整个 session 的相机参数，不随时间变。某个窗口拟合出的
            # M 明显偏离中位数，说明它拟合的是噪声而不是真实运动，它给的 lag 也不可信。
            if len(maps) == len(lags) and len(maps) >= 4:
                Ms = np.stack(maps)
                Mmed = np.nanmedian(Ms, 0)
                scale = np.abs(np.array([M[0, 0] for M in Ms]) / (Mmed[0, 0] + 1e-9))
                keep = np.isfinite(scale) & (scale > 0.7) & (scale < 1.4)
                if keep.sum() >= 3:
                    print(f"     M 自洽性筛选：{len(lags)} -> {int(keep.sum())} 个窗口")
                    lags = lags[keep]; peaks_a = peaks_a[keep]
                    maps = [m for m, k in zip(maps, keep) if k]
                    r2s = [r for r, k in zip(r2s, keep) if k]
            peaks = list(peaks_a)
            med = float(np.median(lags))
            print(f"     offset(光流) = {med:+.3f} s  "
                  f"[p25 {np.percentile(lags,25):+.3f} / p75 {np.percentile(lags,75):+.3f}]"
                  f"  峰值中位 {np.median(peaks):.2f}  n={len(lags)}")
            Mm = None
            if maps:
                Mm = np.median(np.stack(maps), 0)
                # px@PWxPH per (世界单位/s) -> 换算成 px@1280 per 世界单位
                k = (1280.0 / PW) * fps / STRIDE
                gx = abs(Mm[0, 0] * k) * (832.0 / 1280.0)
                gy = abs(Mm[1, 1] * k) * (480.0 / 720.0)
                print(f"     世界→屏幕 M = [[{Mm[0,0]*k:+7.2f} {Mm[0,1]*k:+7.2f}]"
                      f" [{Mm[1,0]*k:+7.2f} {Mm[1,1]*k:+7.2f}]] px@1280宽/世界单位")
                print(f"     换算到 832x480 画幅：横 {gx:.1f} / 纵 {gy:.1f} px/世界单位"
                      f"  (gx/gy={gx/max(gy,1e-9):.2f})   R2 中位 {np.nanmedian(r2s):.3f}")
            results.append(dict(vt_lo=lo, vt_hi=hi, offset_xcorr=seg["offset"],
                                offset_flow=med, peak_median=float(np.median(peaks)),
                                n=len(lags), lags=[float(v) for v in lags],
                                M_px1280=(Mm * (1280.0 / PW) * fps / STRIDE).tolist()
                                if Mm is not None else None,
                                r2_median=float(np.median(r2s)) if r2s else None))
        with open(os.path.join(d, "align_flow.json"), "w", encoding="utf-8") as fh:
            json.dump(dict(session=sid, convention="video_t = log_vt + offset",
                           proj_wh=[PW, PH], stride=STRIDE, segments=results),
                      fh, ensure_ascii=False, indent=1)
    print("DONE")


if __name__ == "__main__":
    main()