code/budget.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
budget.py —— 逐秒打标 + 时长预算 + 可用片段（cutlist）

全流程只对时间轴动手：不裁画面、不改分辨率、不做逐帧曝光调整。
所有「变干净」都靠丢掉整段时间实现，留下来的每一帧都是原始像素。

打标优先级（同一秒只算一次，所以各类时长可直接相加）：
    损坏 › 传送窗口 › 卡住/空闲 › 低照度 › 干净

拍板过的决策（体检 → 交付两轮的最终值）：
    D1 卡住   只丢「连续 ≥2s」的卡住，不是全丢。短卡住会把连续素材劈成两半，
              而「发了移动指令 + 画面不动」本身正是 world model 要学的碰撞。
    D2 低照度 帧均值 < 6 丢掉（度量必须是 lum_scan 的 64x36 bicubic，换度量阈值就不是这个 6）
    D5 传送   固定余量 [leg_end-1.0s, leg_start+1.5s]

切段：可用区间还要在下列位置断开，段内才允许切训练片段
    · >1s 的日志采样空洞（对不上动作真值）
    · 相邻采样位移 >20 m（未被 leg 事件覆盖的瞬移）
    · 区域被整体排除（白模缺陷区）

产出 <out>/<session>/：
    labels.npz     逐秒标签（0..5，见 LABELS）
    segments.json  可用片段 [{seg_id, vt_lo, vt_hi, video_lo, video_hi, region, leg, ...}]
    budget.json    时长预算表 + 各判据的命中统计
"""
from __future__ import annotations

import argparse
import json
import os

import numpy as np

LABELS = ["clean", "corrupt", "transition", "stuck", "dark", "idle"]
L_CLEAN, L_CORRUPT, L_TRANS, L_STUCK, L_DARK, L_IDLE = range(6)

# --- 判据常数 ---
TRANS_PRE = 1.0          # leg_end 前余量
TRANS_POST = 1.5         # leg_start 后余量
STUCK_WIN = 1.0          # 卡住判定窗口（秒）
STUCK_DIST = 0.5         # 窗口内位移阈值（米）
STUCK_MIN_RUN = 2.0      # D1：只丢连续 ≥2s 的卡住
DARK_THRESH = 6.0        # D2
JUMP_M = 20.0            # 瞬移断点
GAP_S = 1.0              # 日志空洞断点
CLIP_FPS = 16.0
CLIP_FRAMES = 81
CLIP_STRIDE = 84
MIN_SEG_S = CLIP_FRAMES / CLIP_FPS      # 段短于一个 clip 就没用

# 白模缺陷区：目检确认整片无贴图，直接整区排除
EXCLUDE_REGIONS = {"phalenChurch", "MountainPassCaveB"}

# 视频尾部损坏：s1 被强杀时文件写了一半，最后约 16 s 取不出帧
VIDEO_END_CAP = {"20260821_190601_787": 124356.0}


def load_session(logs: str, sid: str):
    d = os.path.join(logs, sid)
    st = np.load(os.path.join(d, "state.npz"))
    ip = np.load(os.path.join(d, "input.npz"))
    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)
    with open(os.path.join(d, "regions.json"), encoding="utf-8") as fh:
        regions = json.load(fh)
    # 只读 finalize_offsets.py 产出的权威映射；align.json / align_flow.json 是中间结果
    align_p = os.path.join(d, "offsets.json")
    align = json.load(open(align_p, encoding="utf-8")) if os.path.exists(align_p) else None
    return st, ip, lum, events, regions, align


def offset_fn(align):
    """分段常数 offset：video_t = log_vt + offset(log_vt)。"""
    if align is None:
        return lambda vt: np.zeros_like(np.asarray(vt, np.float64))
    segs = align["segments"]
    los = np.array([s["vt_lo"] for s in segs], np.float64)
    offs = np.array([s["offset"] for s in segs], np.float64)

    def f(vt):
        vt = np.asarray(vt, np.float64)
        i = np.clip(np.searchsorted(los, vt, side="right") - 1, 0, len(offs) - 1)
        return offs[i]
    return f


def sorted_state(st):
    o = np.argsort(st["vt"])
    return {k: st[k][o] for k in st.files}


def rolling_disp(vt, x, z, win_s):
    """每个采样点在 ±win/2 窗口内的位移（米）。"""
    n = vt.size
    half = win_s / 2.0
    lo = np.searchsorted(vt, vt - half, side="left")
    hi = np.clip(np.searchsorted(vt, vt + half, side="right") - 1, 0, n - 1)
    return np.hypot(x[hi] - x[lo], z[hi] - z[lo]), lo, hi


def runs_of(mask):
    """布尔数组 -> [(i0, i1)) 的 True 区间。"""
    if mask.size == 0:
        return []
    d = np.diff(mask.astype(np.int8))
    starts = list(np.flatnonzero(d == 1) + 1)
    ends = list(np.flatnonzero(d == -1) + 1)
    if mask[0]:
        starts.insert(0, 0)
    if mask[-1]:
        ends.append(mask.size)
    return list(zip(starts, ends))


def teleport_windows(events):
    ends = [e for e in events if e.get("ev") == "roam_leg_end"]
    starts = sorted((e for e in events if e.get("ev") == "roam_leg_start"),
                    key=lambda e: e["vt"])
    svt = np.array([s["vt"] for s in starts], np.float64)
    out = []
    for e in ends:
        ve = float(e["vt"])
        j = np.searchsorted(svt, ve, side="left")
        vs = float(svt[j]) if j < svt.size else ve + 10.0
        if vs - ve > 120.0:
            vs = ve + 10.0                      # 异常长的窗口，按典型长度保守切
        out.append((ve, vs))
    return out


def leg_of(events, vt):
    """每个采样点属于哪个 leg（roam_leg_start 之后、对应 roam_leg_end 之前）。"""
    starts = sorted(((float(e["vt"]), int(e.get("leg", -1)))
                     for e in events if e.get("ev") == "roam_leg_start"), key=lambda t: t[0])
    if not starts:
        return np.full(vt.size, -1, np.int32)
    svt = np.array([s[0] for s in starts], np.float64)
    sid = np.array([s[1] for s in starts], np.int32)
    i = np.clip(np.searchsorted(svt, vt, side="right") - 1, 0, sid.size - 1)
    out = sid[i]
    out[vt < svt[0]] = -1
    return out


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("--dark", type=float, default=DARK_THRESH)
    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}")
        st, ip, lum, events, regions, align = load_session(args.logs, sid)
        st = sorted_state(st)
        vt, x, z, rg = st["vt"], st["x"].astype(np.float64), st["z"].astype(np.float64), st["rg"]
        n = vt.size
        off = offset_fn(align)
        vid_t = vt + off(vt)                      # 每个采样点对应的视频时间
        fps = float(lum["fps"])
        mean = lum["mean"]
        nfr = mean.size
        vend = VIDEO_END_CAP.get(sid, nfr / fps)

        # 输入按时间最近邻对到状态采样
        ivt = ip["vt"]; o = np.argsort(ivt)
        ivt, mag = ivt[o], ip["mag"][o].astype(np.float64)
        j = np.clip(np.searchsorted(ivt, vt), 0, ivt.size - 1)
        j2 = np.clip(j - 1, 0, ivt.size - 1)
        pick = np.where(np.abs(ivt[j] - vt) <= np.abs(ivt[j2] - vt), j, j2)
        mv_mag = mag[pick]
        mv_ok = np.abs(ivt[pick] - vt) < 0.5      # 对不上输入的采样点不判 stuck/idle

        # 每个采样点代表的时长
        step = np.clip(np.diff(vt, append=vt[-1]), 0, 1.0)

        # ---- 判据 ----
        lab = np.full(n, L_CLEAN, np.int8)

        # 损坏：日志空洞（>1s 无采样）本身不占时长，但视频尾损坏要整段剔除
        corrupt = vid_t >= vend
        # 区域整体排除（白模缺陷区）
        excl_idx = {i for i, r in enumerate(regions) if r in EXCLUDE_REGIONS}
        excluded = np.isin(rg, list(excl_idx)) if excl_idx else np.zeros(n, bool)
        corrupt_true = corrupt.copy()
        corrupt |= excluded

        # 传送窗口（在视频时间轴上判定）
        trans = np.zeros(n, bool)
        for a, b in teleport_windows(events):
            va = a + float(off(np.array([a]))[0]) - TRANS_PRE
            vb = b + float(off(np.array([b]))[0]) + TRANS_POST
            trans |= (vid_t >= va) & (vid_t <= vb)

        # 卡住 / 空闲
        disp, _, _ = rolling_disp(vt, x, z, STUCK_WIN)
        stuck_raw = mv_ok & (mv_mag > 0.0) & (disp < STUCK_DIST)
        idle = mv_ok & (mv_mag <= 0.0)
        # D1：只保留连续 ≥2s 的卡住
        stuck = np.zeros(n, bool)
        for i0, i1 in runs_of(stuck_raw):
            if vt[i1 - 1] - vt[i0] >= STUCK_MIN_RUN:
                stuck[i0:i1] = True

        # 低照度（D2）
        fi = np.clip(np.round(vid_t * fps).astype(np.int64), 0, nfr - 1)
        lum_at = mean[fi]
        dark = lum_at < args.dark

        # 优先级覆盖
        lab[dark] = L_DARK
        lab[idle] = L_IDLE
        lab[stuck] = L_STUCK
        lab[trans] = L_TRANS
        lab[corrupt] = L_CORRUPT

        hours = {LABELS[k]: float(step[lab == k].sum()) / 3600 for k in range(6)}
        h_true = float(step[corrupt_true].sum()) / 3600
        h_excl = float(step[excluded & ~corrupt_true].sum()) / 3600
        tot = sum(hours.values())
        print(f"   时长预算（合计 {tot:.2f} h）")
        for k in ("clean", "corrupt", "transition", "stuck", "dark", "idle"):
            note = f"  (真损坏 {h_true:.2f} + 白模缺陷区 {h_excl:.2f})" if k == "corrupt" else ""
            print(f"     {k:<11} {hours[k]:6.2f} h  {100*hours[k]/tot:5.1f}%{note}")

        # ---- 可用片段 ----
        usable = lab == L_CLEAN
        # 断点：日志空洞 / 瞬移 / leg 变化
        dvt = np.diff(vt, prepend=vt[0])
        jump = np.hypot(np.diff(x, prepend=x[0]), np.diff(z, prepend=z[0]))
        brk = (dvt > GAP_S) | (jump > JUMP_M)
        legs = leg_of(events, vt)
        brk |= np.diff(legs, prepend=legs[0]) != 0
        # 注意：区域变化【不】断段。交付规格里 clip 允许跨场景，只记录每个 cell 的
        # 场景纯度（preview 里的「最低 cell 纯度 0.75」= 该 cell 4 帧里 3 帧同场景）。
        # 在这里断段会把连续素材切碎，clip 数会少一成多。

        n_jump = int((jump > JUMP_M).sum())
        n_gap = int((dvt > GAP_S).sum())

        segs = []
        for i0, i1 in runs_of(usable):
            cut = [i0] + [i for i in range(i0 + 1, i1) if brk[i]] + [i1]
            for a, b in zip(cut[:-1], cut[1:]):
                if b - a < 2:
                    continue
                dur_v = float(vid_t[b - 1] - vid_t[a])
                if dur_v < MIN_SEG_S:
                    continue
                segs.append(dict(
                    i0=int(a), i1=int(b),
                    vt_lo=float(vt[a]), vt_hi=float(vt[b - 1]),
                    video_lo=float(vid_t[a]), video_hi=float(vid_t[b - 1]),
                    dur_s=dur_v, leg=int(legs[a]), region=regions[int(rg[a])],
                    n_clips=max(0, int((dur_v * CLIP_FPS - CLIP_FRAMES) // CLIP_STRIDE) + 1),
                    mean_lum=float(lum_at[a:b].mean()),
                ))
        segs.sort(key=lambda s: s["video_lo"])
        for k, s in enumerate(segs):
            s["seg_id"] = k + 1
        n_clips = sum(s["n_clips"] for s in segs)
        seg_h = sum(s["dur_s"] for s in segs) / 3600
        print(f"   可用片段 {len(segs)} 段 · {seg_h:.2f} h · 可切 {n_clips:,} 个 clip "
              f"(81 帧 @16fps, 步长 84)")
        print(f"   断点来源：日志空洞 {n_gap} · 瞬移>20m {n_jump}")

        d = os.path.join(args.logs, sid)
        np.savez_compressed(os.path.join(d, "labels.npz"), vt=vt, video_t=vid_t,
                            label=lab, lum=lum_at.astype(np.float32),
                            mv_mag=mv_mag.astype(np.float32), disp=disp.astype(np.float32),
                            step=step.astype(np.float32), leg=legs, rg=rg)
        with open(os.path.join(d, "segments.json"), "w", encoding="utf-8") as fh:
            json.dump(segs, fh, ensure_ascii=False)
        with open(os.path.join(d, "budget.json"), "w", encoding="utf-8") as fh:
            json.dump(dict(session=sid, hours=hours, total_h=tot,
                           dark_thresh=args.dark, stuck_min_run=STUCK_MIN_RUN,
                           trans_margin=[TRANS_PRE, TRANS_POST],
                           excluded_regions=sorted(EXCLUDE_REGIONS),
                           video_end_cap=vend,
                           corrupt_true_h=h_true, excluded_region_h=h_excl,
                           n_segments=len(segs), segment_hours=seg_h, n_clips=n_clips,
                           breaks=dict(log_gap=n_gap, jump=n_jump)), fh,
                      ensure_ascii=False, indent=1)
    print("DONE")


if __name__ == "__main__":
    main()