| |
| |
| """ |
| align.py —— 把日志时间轴钉到视频时间轴 |
| |
| 约定（全流水线统一）： video_t = log_vt + offset(log_vt) |
| |
| 为什么需要这一步：视频是恒定 30 fps 的连续时间轴，日志的 vt 是墙钟算出来的。 |
| 只要 OBS 掉过帧，两者就永久错开，而且是「台阶」不是「漂移」。体检阶段发现 |
| 20260823 在 4 h 附近掉了约 4 秒画面，该 session 有 75% 的素材动作与画面错开 |
| 约 130 帧 —— 拿去训 action-conditioned 模型等于教模型「按下 W 之后 4 秒画面才动」。 |
| 所以这一步必须在任何切片之前跑，并且要自己测、不能照抄常数。 |
| |
| 信号：传送窗口在视频里是「掉黑 → 加载页（一张逐帧完全不动的静止图）→ 落地」。 |
| 于是构造两条 0/1 轨道再做互相关： |
| 日志轨 = t 落在某个 [roam_leg_end, roam_leg_start] 区间内 |
| 视频轨 = 该帧「暗」(mean<DARK) 或「静止」(与前帧差<STILL) |
| 互相关峰值的位移就是 offset。不假设 leg_end 到掉黑之间的固定延迟 —— 那个 |
| 延迟本身是被测量的对象之一，假设进去就会把系统误差算进 offset。 |
| |
| 产出 <out>/<session>/align.json： |
| offset_global, 分块估计, 台阶位置, 分段常数映射 segments=[[vt_lo, vt_hi, offset]] |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
|
|
| import numpy as np |
|
|
| DARK = 10.0 |
| STILL = 0.05 |
| GRID_HZ = 10.0 |
| LAG_MAX = 12.0 |
| LAG_STEP = 0.05 |
|
|
|
|
| def load(logs_dir: str, sid: str): |
| d = os.path.join(logs_dir, sid) |
| lum = np.load(os.path.join(d, "lum.npz")) |
| with open(os.path.join(d, "events.json"), encoding="utf-8") as fh: |
| events = json.load(fh) |
| return lum, events |
|
|
|
|
| def teleport_windows(events) -> list[tuple[float, float]]: |
| """按 leg 配对 roam_leg_end -> 下一个 roam_leg_start，得到传送窗口（日志时间）。""" |
| ends = [e for e in events if e.get("ev") == "roam_leg_end"] |
| starts = [e for e in events if e.get("ev") == "roam_leg_start"] |
| starts_vt = np.array([s["vt"] for s in starts], np.float64) |
| order = np.argsort(starts_vt) |
| starts_vt = starts_vt[order] |
| out = [] |
| for e in ends: |
| ve = e["vt"] |
| j = np.searchsorted(starts_vt, ve, side="left") |
| if j < starts_vt.size: |
| vs = float(starts_vt[j]) |
| if vs - ve < 120.0: |
| out.append((float(ve), vs)) |
| return out |
|
|
|
|
| def build_tracks(lum, windows, t_max: float): |
| fps = float(lum["fps"]) |
| mean, diff = lum["mean"], lum["diff"] |
| n = mean.size |
| vt_frame = np.arange(n) / fps |
|
|
| vid_flag = (mean < DARK) | (np.nan_to_num(diff, nan=1e9) < STILL) |
| grid = np.arange(0, t_max, 1.0 / GRID_HZ) |
| idx = np.clip((grid * fps).astype(np.int64), 0, n - 1) |
| vid = vid_flag[idx].astype(np.float32) |
|
|
| log = np.zeros(grid.size, np.float32) |
| for a, b in windows: |
| i0 = int(max(a, 0) * GRID_HZ) |
| i1 = int(min(b, t_max) * GRID_HZ) |
| if i1 > i0: |
| log[i0:i1] = 1.0 |
| return grid, vid, log, vt_frame |
|
|
|
|
| def xcorr_lag(vid: np.ndarray, log: np.ndarray, lo: int, hi: int): |
| """在 [lo, hi) 这段栅格上搜索使两条轨道最吻合的位移（返回秒 + 峰值分数曲线）。""" |
| seg_log = log[lo:hi] |
| if seg_log.sum() < 5: |
| return None, None, None |
| lags = np.arange(-LAG_MAX, LAG_MAX + 1e-9, LAG_STEP) |
| scores = np.empty(lags.size, np.float32) |
| lo_c = np.clip(lo, 0, vid.size) |
| for i, L in enumerate(lags): |
| sh = int(round(L * GRID_HZ)) |
| a = lo_c + sh |
| b = a + (hi - lo) |
| if a < 0 or b > vid.size: |
| scores[i] = -1.0 |
| continue |
| v = vid[a:b] |
| |
| inter = float(np.minimum(v, seg_log).sum()) |
| union = float(np.maximum(v, seg_log).sum()) |
| scores[i] = inter / union if union > 0 else -1.0 |
| k = int(np.argmax(scores)) |
| return float(lags[k]), float(scores[k]), (lags, scores) |
|
|
|
|
| def refine_step(block_lag, block_mid, tol=0.3): |
| """分块 offset -> 分段常数。找到唯一（或多个）台阶的位置。""" |
| ok = [(m, l) for m, l in zip(block_mid, block_lag) if l is not None] |
| if not ok: |
| return [], [] |
| mids = np.array([m for m, _ in ok]) |
| lags = np.array([l for _, l in ok]) |
| segs = [] |
| s0 = 0 |
| for i in range(1, len(lags)): |
| if abs(lags[i] - np.median(lags[s0:i])) > tol: |
| segs.append((s0, i)) |
| s0 = i |
| segs.append((s0, len(lags))) |
| out = [(float(mids[a]), float(mids[b - 1]), float(np.median(lags[a:b])), int(b - a)) |
| for a, b in segs] |
| return out, (mids, lags) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(description="日志↔视频时间轴对齐") |
| ap.add_argument("--logs", default="/data/zhiyangdeng/data_eybx/logs") |
| ap.add_argument("--sessions", nargs="*", default=None) |
| ap.add_argument("--block_s", type=float, default=1800.0, help="分块估计的块长（秒）") |
| 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: |
| print(f"== {sid}") |
| lum, events = load(args.logs, sid) |
| fps = float(lum["fps"]) |
| t_max = lum["mean"].size / fps |
| wins = teleport_windows(events) |
| print(f" 传送窗口 {len(wins)} 个 · 视频 {t_max/3600:.2f} h @ {fps:.4f} fps") |
|
|
| grid, vid, log, _ = build_tracks(lum, wins, t_max) |
| g_lag, g_score, _ = xcorr_lag(vid, log, 0, grid.size) |
| print(f" 全局 offset = {g_lag:+.3f} s (重合度 {g_score:.3f})") |
|
|
| step = int(args.block_s * GRID_HZ) |
| blk_lag, blk_mid, blk_score = [], [], [] |
| for lo in range(0, grid.size, step): |
| hi = min(lo + step, grid.size) |
| L, S, _ = xcorr_lag(vid, log, lo, hi) |
| blk_lag.append(L); blk_score.append(S) |
| blk_mid.append(float(grid[lo] + (grid[min(hi, grid.size - 1)] - grid[lo]) / 2)) |
| for m, L, S in zip(blk_mid, blk_lag, blk_score): |
| tag = f"{L:+.3f} s (重合度 {S:.3f})" if L is not None else "样本不足" |
| print(f" vt {m/3600:5.2f} h : {tag}") |
|
|
| segs, _ = refine_step(blk_lag, blk_mid) |
| print(" 分段常数：") |
| for a, b, L, n in segs: |
| print(f" vt {a:9.1f} – {b:9.1f} s offset {L:+.3f} s ({n} 块)") |
|
|
| out = dict(session=sid, convention="video_t = log_vt + offset", |
| fps=fps, video_hours=t_max / 3600, n_teleports=len(wins), |
| dark_thresh=DARK, still_thresh=STILL, |
| offset_global=g_lag, score_global=g_score, |
| blocks=[dict(mid_vt=m, offset=L, score=S) |
| for m, L, S in zip(blk_mid, blk_lag, blk_score)], |
| segments=[dict(vt_lo=a, vt_hi=b, offset=L, n_blocks=n) for a, b, L, n in segs]) |
| with open(os.path.join(args.logs, sid, "align.json"), "w", encoding="utf-8") as fh: |
| json.dump(out, fh, ensure_ascii=False, indent=1) |
| print("DONE") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
