| |
| |
| """ |
| 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() |
|
|
| |
| 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") |
| |
| 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() |
|
|
