ww_index: window list, captions, lags and scripts to rebuild the WildWorld windows from upstream
a54e6a7 verified Download ww_index/scripts/build_v7.py from yuzhewu207/wizard-precoded: direct link, hf CLI and curl.
- Browser
- Download file 37.9 kB
-
https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/build_v7.py
- Command line
-
hf download hf://datasets/yuzhewu207/wizard-precoded/ww_index/scripts/build_v7.py
-
curl -L -o build_v7.py https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/build_v7.py
37.9 kB
| """10-17 (user: v7 条件,开始编码数据) the v7 condition of every training window -> /data/yuzhewu/datasets/wan_v7/cond7/clip_<key>.pt | |
| cond [48,31,30,52] bf16 VAE latent of the v7 condition video (832x480 crop) | |
| dep [121,60,104] f16 planar depth (m) at the cell centres for the token coordinates (0 = none: sky / characters) | |
| tier [121,60,104] u8 0 sky | 1 unknown | 2 coarse | 3 exact (token tier channel; characters' cells carry nothing via dep = 0) | |
| meta dict source, variant (moge / holes / patch), normals | |
| Encoding (v7enc.py): R height, B depth (v5), skeleton on top with a black outline (+ the player's shield disc), G = tier, exact G modulated by normals. | |
| Sources (tier by where the geometry comes from): | |
| ww exact WildWorld 8-bit depth (sigma 5), characters = silhouette_mask, background behind them from other frames | |
| bk exact Black Knife raw depth_packed (lossless), characters = capsules of shot.npz, other frames | |
| roam exact memroam windows: capture.mkv depth, player capsules (prep_mem), skeleton layer = prep_mem.Skel, R/B built here | |
| synth exact ground plane (analytic) + the v5 props; above the horizon: sky (MoGe-2 by direction) / unknown | |
| er,ue coarse the BOSSV2V proxy geometry of the v5 condition, black = sky (MoGe-2) / unknown | |
| Variants (fixed per window by its key): 30% MoGe-2 first-frame world (coarse; outside it unknown; exact sources: 50% of them get a world-anchored exact patch), | |
| 15% time-spanning holes (unknown), normals off for 20%. | |
| build_v7.py <source> --rank R --world N [--limit K] [--preview]""" | |
| import sys, os, json, gzip, hashlib, argparse, subprocess, time | |
| import numpy as np, cv2, torch | |
| import torch.nn.functional as F | |
| sys.path.insert(0, "/data/yuzhewu/runs/v7demo"); sys.path.insert(0, "/data/yuzhewu/wancond_mem"); sys.path.insert(0, "/data/yuzhewu/wancond") | |
| sys.path.insert(0, "/data/yuzhewu/datasets/wildworld"); sys.path.insert(0, "/data/yuzhewu/runs/proxykit") | |
| import v7enc as E | |
| DS = "/data/yuzhewu/datasets"; OUT = f"{DS}/wan_v7"; CK = "/data/yuzhewu/models/Wan2.2-TI2V-5B"; N = 121; W8, H8, X0 = 853, 480, 10 | |
| GV, GU = np.mgrid[0:60, 0:104]; CV, CU = 8 * GV + 4, 8 * GU + 4 + X0 # cell centres in the 853x480 frame | |
| NB = (-60, -40, -25, -12, 12, 25, 40, 60) # other frames for the background behind the characters | |
| PAR17 = [-1, 0, 1, 2, 3, 2, 5, 6, 2, 8, 9, 0, 11, 12, 0, 14, 15] | |
| key_of = lambda v: hashlib.md5(v.encode()).hexdigest()[:16] | |
| def u100(key, salt): return int(hashlib.md5((key + salt).encode()).hexdigest(), 16) % 100 | |
| def ff(path, start, n, w=None, h=None, fmt="rgb24", scale=None): | |
| """frames [start, start+n) of a video -> uint8/uint16 array""" | |
| vf = f"select='between(n\\,{start}\\,{start + n - 1})'" + (f",scale={scale[0]}:{scale[1]}:flags=area" if scale else "") | |
| if w is None or scale: | |
| if scale: w, h = scale | |
| else: w, h = map(int, subprocess.run(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height", "-of", "csv=p=0", path], capture_output=True, text=True).stdout.strip().split(",")[:2]) | |
| raw = subprocess.run(["ffmpeg", "-v", "error", "-i", path, "-vf", vf, "-vsync", "0", "-f", "rawvideo", "-pix_fmt", fmt, "-"], capture_output=True).stdout | |
| dt = np.uint16 if fmt == "rgb48le" else np.uint8; a = np.frombuffer(raw, dt) | |
| return a.reshape(-1, h, w, 3)[:n] | |
| def r853(x, interp=cv2.INTER_AREA): return cv2.resize(x, (W8, H8), interpolation=interp) | |
| def z853(z, ok): | |
| """planar depth -> 853x480 by AREA in disparity (nearest aliases into a grid in the normals); 0 where mostly invalid""" | |
| d = np.where(ok, 1.0 / np.maximum(z, 1e-3), 0).astype(np.float32); w = ok.astype(np.float32) | |
| d = cv2.resize(d, (W8, H8), interpolation=cv2.INTER_AREA); w = cv2.resize(w, (W8, H8), interpolation=cv2.INTER_AREA); good = w > 0.5 | |
| return np.where(good, 1.0 / np.maximum(d / np.maximum(w, 1e-6), 1e-6), 0.0), good | |
| class Models: | |
| def __init__(self): | |
| from wanvendor.vae2_2 import Wan2_2_VAE | |
| self.vae = Wan2_2_VAE(vae_pth=f"{CK}/Wan2.2_VAE.pth", device="cuda"); self.moge = None | |
| def mg(self, im): | |
| if self.moge is None: | |
| from moge.model.v2 import MoGeModel; self.moge = MoGeModel.from_pretrained("Ruicheng/moge-2-vitl-normal").to("cuda").eval() | |
| with torch.no_grad(): o = self.moge.infer(torch.from_numpy(np.ascontiguousarray(im)).permute(2, 0, 1).float().div(255).cuda()) | |
| return o["points"].cpu().numpy().astype(np.float64), o["mask"].cpu().numpy().astype(bool) | |
| def encode(self, v): # [121,480,832,3] uint8 (numpy or cuda) -> [48,31,30,52] | |
| if isinstance(v, np.ndarray): v = torch.from_numpy(np.ascontiguousarray(v)) | |
| x = v.cuda().permute(3, 0, 1, 2).float().div(127.5).sub(1.0) | |
| with torch.no_grad(): return self.vae.encode([x])[0].to(torch.bfloat16).cpu() | |
| # ------------------------------------------------------------------ geometry helpers (853x480, cam = (pos, Rrows right/up/forward, f, cx, cy), y up, metres) | |
| def world_pts(cam, z): | |
| pos, R, f, cx, cy = cam; v, u = np.mgrid[0:z.shape[0], 0:z.shape[1]] + 0.5 | |
| return pos + ((u - cx) / f * z)[..., None] * R[0] - ((v - cy) / f * z)[..., None] * R[1] + z[..., None] * R[2] | |
| def capsules(cam, J, rad, shape, par=PAR17): | |
| """character mask from joints [n,3] (world): bones as thick lines of radius rad (m) in perspective""" | |
| pos, R, f, cx, cy = cam; rel = J - pos; X, Y, Zc = rel @ R[0], rel @ R[1], rel @ R[2]; m = np.zeros(shape, np.uint8) | |
| for j, p in enumerate(par): | |
| if p is None or not (np.isfinite(J[j]).all() and np.isfinite(J[p]).all()): continue | |
| if p < 0 or Zc[j] < 0.2 or Zc[p] < 0.2: continue | |
| a = (int(cx + f * X[j] / Zc[j]), int(cy - f * Y[j] / Zc[j])); b = (int(cx + f * X[p] / Zc[p]), int(cy - f * Y[p] / Zc[p])) | |
| wpx = max(3, int(round(f * rad / min(Zc[j], Zc[p])))); cv2.line(m, a, b, 1, 2 * wpx); cv2.circle(m, a, wpx, 1, -1) | |
| return m.astype(bool) | |
| def fill_chars(Z, valid, CH, cams): | |
| """depth behind the characters: other frames reprojected (v7enc.temporal_fill), then the smooth fill""" | |
| out = [] | |
| for t in range(len(Z)): | |
| m = CH[t] & valid[t]; z = Z[t] | |
| if m.any(): | |
| srcs = [(cams[t + d], Z[t + d], valid[t + d] & ~CH[t + d]) for d in NB if 0 <= t + d < len(Z)] | |
| z, got = E.temporal_fill(cams[t], np.where(m, 0, z), m, srcs); m = m & ~got | |
| z = E.fill_under(z, m, valid[t] | CH[t]) | |
| out.append(z) | |
| return np.stack(out) | |
| def height_fit(V5, Z, valid, cams): | |
| """the v5 R = a * (world height) + b on the environment of frame 0 (each source has its own range / origin)""" | |
| P = world_pts(cams[0], Z[0]); r = V5[0][..., 0].astype(float) / 255; ok = valid[0] & (r > 0.52) & (r < 0.98) & (V5[0][..., 1] < 20) | |
| if ok.sum() < 500: return 0.5 / 56, 0.5 + 0.5 * 8 / 56 | |
| A = np.stack([P[..., 1][ok], np.ones(ok.sum())], 1); a, b = np.linalg.lstsq(A, r[ok], rcond=None)[0]; return a, b | |
| def rb_from(z, cam, ab): | |
| P = world_pts(cam, z); R_ = np.clip(ab[0] * P[..., 1] + ab[1], 0.5, 1.0); B_ = 1 - np.clip((z - 0.1) / 79.9, 0, 1); return R_, B_ | |
| # ------------------------------------------------------------------ the shared core | |
| def core(key, src, V5, Z, valid, sky, CH, cams, exact_src, sig, rgb0, M, shield=None, ab=None, tier0=None): | |
| """V5 [121,480,853,3] (characters drawn), Z planar depth (0 = none), valid geometry, sky, CH characters (excluded from geometry), | |
| tier0: optional base tier map (synth). GPU (v7gpu.py). Returns v7 frames (cuda uint8 [121,480,832,3]), dep cells, tier cells, meta.""" | |
| import v7gpu as G | |
| dev = "cuda"; moge = u100(key, "moge") < 30; holes = u100(key, "holes") < 15; normals = u100(key, "nrm") >= 20; patch = exact_src and moge and u100(key, "patch") < 50 | |
| pos = torch.tensor(np.stack([c[0] for c in cams]), dtype=torch.float32, device=dev); R = torch.tensor(np.stack([c[1] for c in cams]), dtype=torch.float32, device=dev) | |
| f, cx, cy = float(cams[0][2]), float(cams[0][3]), float(cams[0][4]) | |
| Zt = torch.from_numpy(np.ascontiguousarray(Z)).float().to(dev); vt = torch.from_numpy(valid).to(dev); skt = torch.from_numpy(sky).to(dev); cht = torch.from_numpy(CH).to(dev) | |
| if exact_src: Zf, miss = G.temporal_fill(Zt, vt, cht, pos, R, f, cx, cy); Zf = G.fill_rest(Zf, miss, vt) | |
| else: Zf = Zt | |
| if tier0 is not None: tier = torch.from_numpy(tier0).to(dev) | |
| else: tier = torch.where(vt, torch.full_like(Zt, 3 if exact_src else 2), torch.where(skt, torch.zeros_like(Zt), torch.ones_like(Zt))).to(torch.uint8) | |
| Zc = Zf; RB = None; pm = None | |
| if moge: # the inference world: MoGe-2 of the first frame along the true cameras | |
| Zf0 = Zf[0].cpu().numpy().astype(np.float64) | |
| P, ok = M.mg(rgb0); sel = valid[0] & ok & ~CH[0] | |
| s = float(np.median((Z[0][sel] + 1e-6) / (P[..., 2][sel] + 1e-6))) if sel.sum() > 500 else 1.0 | |
| chm = cv2.dilate(CH[0].astype(np.uint8), np.ones((15, 15), np.uint8)).astype(bool) | |
| near = valid[0] & (s * P[..., 2] < 0.9 * Zf0 - 0.3) # (10-18) nearer than the environment = a character (bodies are wider than skeleton lines) | |
| g0 = V5[0][..., 1].astype(int); hull = np.zeros((H8, W8), np.uint8) # and each character's skeleton hull (a boss against the sky has no environment behind it) | |
| for slot in np.unique(g0[g0 >= 20] // 32): | |
| ys, xs = np.nonzero((g0 >= 20) & (g0 // 32 == slot)) | |
| if len(xs) >= 3: cv2.fillConvexPoly(hull, cv2.convexHull(np.stack([xs, ys], 1).astype(np.int32)), 1) | |
| near |= cv2.dilate(hull, np.ones((61, 61), np.uint8)).astype(bool) | |
| chm |= cv2.dilate(near.astype(np.uint8), np.ones((9, 9), np.uint8)).astype(bool); okm = ok & ~chm & np.isfinite(P).all(-1) | |
| fillm = chm & ~char_fill(~ok, chm) # the characters' pixels whose surroundings are ground / walls (not sky): fill those only | |
| zM = np.where(okm, s * P[..., 2], 0.0); zM = E.fill_under(zM, fillm, okm | fillm); okm = okm | fillm | |
| Pw = world_pts(cams[0], zM); st = 2; Q = Pw[::st, ::st]; mm = okm[::st, ::st]; dd = zM[::st, ::st]; idx = np.arange(mm.size).reshape(mm.shape) | |
| a_, b_, c_, d_ = idx[:-1, :-1], idx[:-1, 1:], idx[1:, :-1], idx[1:, 1:]; D4 = np.stack([dd[:-1, :-1], dd[:-1, 1:], dd[1:, :-1], dd[1:, 1:]]) | |
| g = mm[:-1, :-1] & mm[:-1, 1:] & mm[1:, :-1] & mm[1:, 1:] & (D4.max(0) < 1.12 * D4.min(0)) | |
| F_ = np.concatenate([np.stack([a_[g], b_[g], c_[g]], 1), np.stack([b_[g], d_[g], c_[g]], 1)]); Vm = Q.reshape(-1, 3)[F_].reshape(-1, 3).astype("f4") | |
| zc = G.splat_grid(torch.from_numpy(Pw).float().to(dev), torch.from_numpy(okm).to(dev), pos, R, f, cx, cy, H8, W8) # GPU surface splat (EGL in many processes aborts: exit 134) | |
| if ab is None: ab = height_fit(V5, Zf.cpu().numpy(), valid, cams) | |
| ray = G.rays(N, H8, W8, f, cx, cy, R, dev); Py = (pos[:, None, None] + zc[..., None] * ray)[..., 1] | |
| RB = ((ab[0] * Py + ab[1]).clamp(0.5, 1.0), 1 - ((zc - 0.1) / 79.9).clamp(0, 1)); cov = zc > 0 | |
| skyd = torch.from_numpy(sky_dirs(cams, char_fill(~ok, cv2.dilate(chm.astype(np.uint8), np.ones((15, 15), np.uint8)).astype(bool)))).to(dev) # what inference knows: sky = directions frame 0 saw as sky | |
| skyd &= ~(vt & ~cht) # (10-18) sky only where the truth has no geometry: a big boss's char_fill must not call the ruins behind it sky | |
| tier = torch.where(cov, torch.full_like(tier, 2), torch.where(skyd, torch.zeros_like(tier), torch.ones_like(tier))); Zc = torch.where(cov, zc, Zf) | |
| if patch: # a world-anchored exact block round a ground point of frame 0 (an agent's object) | |
| yy, xx = int(H8 * 0.68), W8 // 2 | |
| if valid[0][yy, xx]: | |
| Pf = pos[:, None, None] + Zf[..., None] * ray; pc = Pf[0, yy, xx]; half = torch.tensor([2.0, 2.5, 2.0], device=dev) | |
| pm = ((Pf - pc).abs() < half).all(-1) & vt; tier[pm] = 3; Zc = torch.where(pm, Zf, Zc) | |
| if holes: # 1-3 ellipses, each over a contiguous span of frames | |
| rng = np.random.default_rng(int(key, 16) % 2 ** 32); hm = np.zeros((N, H8, W8), bool) | |
| for _ in range(int(rng.integers(1, 4))): | |
| t0 = int(rng.integers(0, 80)); t1 = int(rng.integers(t0 + 40, N + 1)); cx_, cy_ = int(rng.integers(100, 750)), int(rng.integers(80, 400)) | |
| ax_ = (int(rng.integers(60, 220)), int(rng.integers(40, 160))); m = np.zeros((H8, W8), np.uint8); cv2.ellipse(m, (cx_, cy_), ax_, float(rng.uniform(0, 180)), 0, 360, 1, -1) | |
| hm[t0:t1] |= m.astype(bool)[None] | |
| hm = torch.from_numpy(hm).to(dev); tier = torch.where(hm & (tier != 0), torch.ones_like(tier), tier) | |
| if os.environ.get("MEMUNK") == "1": # (10-19 user: 必须看记忆的窗口一定比例给未知) the whole environment unknown in the VIDEO; the cells keep their depth -> tokens keep coordinates | |
| tier = torch.where(tier != 0, torch.ones_like(tier), tier); meta_memunk = True | |
| if shield is not None: V5 = np.stack([E.draw_shield_853(V5[t], shield[t]) if np.isfinite(shield[t][0]) else V5[t] for t in range(N)]) | |
| V5t = torch.from_numpy(np.ascontiguousarray(V5)).to(dev) | |
| if RB is not None: # the coarse MoGe world's R / B (the patch and the characters keep theirs) | |
| keep = (V5t[..., 1] >= 20) | (pm if pm is not None else torch.zeros_like(vt)) | |
| V5t[..., 0] = torch.where(keep, V5t[..., 0], torch.round(RB[0] * 255).to(torch.uint8)); V5t[..., 2] = torch.where(keep, V5t[..., 2], torch.round(RB[1] * 255).to(torch.uint8)) | |
| ex = tier == 3 | |
| sh = G.shade(torch.where(ex, Zf, Zc), ex, R, f, cx, cy, sig * W8 / 1280) if normals else torch.full_like(Zt, 0.5) | |
| out = G.compose(V5t, tier, sh)[:, :, X0:X0 + 832] | |
| cvi = torch.from_numpy(CV).to(dev); cui = torch.from_numpy(CU).to(dev) | |
| chc = F.max_pool2d(cht[:, None].float(), 9, 1, 4)[:, 0] > 0 | |
| zc_ = torch.where(chc | (tier == 0), torch.zeros_like(Zc), Zc) | |
| zc_ = torch.where(torch.isfinite(zc_) & (zc_ < 1000), zc_, torch.zeros_like(zc_)) # f16 cells: nothing past 1 km | |
| dep = zc_[:, cvi, cui].half().cpu().numpy(); tc = tier[:, cvi, cui].cpu().numpy() | |
| return out, dep, tc, dict(src=src, moge=moge, holes=holes, patch=bool(patch and pm is not None), normals=normals) | |
| _ctx = {} | |
| class egl_lock: | |
| """one EGL user per card at a time: many processes rendering on one card stall in the driver's lock (os_acquire_rwlock) and abort (exit 134)""" | |
| def __enter__(self): | |
| import fcntl; self.f = open(f"/tmp/v7_egl_{os.environ.get('EGL', '0')}.lock", "w"); fcntl.flock(self.f, fcntl.LOCK_EX); return self | |
| def __exit__(self, *a): | |
| import fcntl; fcntl.flock(self.f, fcntl.LOCK_UN); self.f.close() | |
| def render_mesh(Vm, cams): | |
| with egl_lock(): return _render_mesh(Vm, cams) | |
| def _render_mesh(Vm, cams): | |
| import moderngl | |
| if True: # a fresh context per call: Skel's renderer can invalidate a cached one | |
| ctx = moderngl.create_standalone_context(backend="egl", require=330, device_index=int(os.environ.get("EGL", "0"))); ctx.enable(moderngl.DEPTH_TEST) | |
| prog = ctx.program(vertex_shader="""#version 330 | |
| uniform vec3 cf, cr, cu, cpos; uniform float foc, ox, oy, hw, hh; in vec3 pos; out float fd; | |
| void main(){ vec3 d = pos - cpos; float z = dot(d, cf); fd = z; float n = 0.05, f = 5000.0; | |
| gl_Position = vec4((foc * dot(d, cr) + ox * z) / hw, (foc * dot(d, cu) + oy * z) / hh, z * (f + n) / (f - n) - 2.0 * f * n / (f - n), z); }""", | |
| fragment_shader="#version 330\nin float fd; out float o; void main(){ o = fd; }") | |
| fbo = ctx.framebuffer(color_attachments=[ctx.texture((W8, H8), 1, dtype="f4")], depth_attachment=ctx.depth_renderbuffer((W8, H8))) | |
| _ctx.update(ctx=ctx, prog=prog, fbo=fbo) | |
| ctx, prog, fbo = _ctx["ctx"], _ctx["prog"], _ctx["fbo"]; buf = ctx.buffer(Vm.tobytes()); vao = ctx.vertex_array(prog, [(buf, "3f", "pos")]); out = [] | |
| prog["hw"].value = W8 / 2; prog["hh"].value = H8 / 2 | |
| for pos, R, f, cx, cy in cams: | |
| for k_, v_ in (("cf", R[2]), ("cr", R[0]), ("cu", R[1]), ("cpos", pos)): prog[k_].value = tuple(map(float, v_)) | |
| prog["foc"].value = float(f); prog["ox"].value = float(cx - W8 / 2); prog["oy"].value = float(-(cy - H8 / 2)) | |
| fbo.use(); fbo.clear(0.0, 0.0, 0.0, 0.0, depth=1.0); vao.render(); out.append(np.frombuffer(fbo.read(components=1, dtype="f4"), np.float32).reshape(H8, W8)[::-1].astype(np.float64)) | |
| vao.release(); buf.release(); fbo.release(); prog.release(); ctx.release(); _ctx.clear(); return np.stack(out) | |
| def dir_grid(cam): | |
| pos, R, f, cx, cy = cam; v, u = np.mgrid[0:H8, 0:W8] + 0.5 | |
| d = ((u - cx) / f)[..., None] * R[0] - ((v - cy) / f)[..., None] * R[1] + R[2]; d /= np.linalg.norm(d, axis=-1, keepdims=True) | |
| yaw = ((np.degrees(np.arctan2(d[..., 0], d[..., 2])) + 180) * 2).astype(int) % 720; pit = np.clip(((np.degrees(np.arcsin(np.clip(d[..., 1], -1, 1))) + 90) * 2).astype(int), 0, 359) | |
| return pit, yaw | |
| def char_fill(sky, char): | |
| """(10-18) characters must not decide sky / not sky (a character-shaped unknown hole in the sky = a cut-out trace): inside the character | |
| mask take the label of the nearest pixel outside it""" | |
| if not char.any() or char.all(): return sky | |
| from scipy import ndimage as ndi | |
| _, (iy, ix) = ndi.distance_transform_edt(char, return_indices=True); return np.where(char, sky[iy, ix], sky) | |
| def sky_dirs(cams, sky0): | |
| """sky in every frame = the directions frame 0 saw as sky (0.5 deg grid); directions frame 0 never saw are NOT sky""" | |
| sky0 = cv2.morphologyEx(sky0.astype(np.uint8), cv2.MORPH_OPEN, np.ones((7, 7), np.uint8)).astype(bool) # MoGe's invalid specks on grass / edges are not sky | |
| p0, y0 = dir_grid(cams[0]); sky0 &= p0 >= 178 # and nothing below the horizon is sky | |
| G = np.zeros((360, 720), np.int8); G[p0[sky0], y0[sky0]] = 1 | |
| G = cv2.dilate(G.astype(np.uint8), np.ones((3, 3), np.uint8)).astype(bool) | |
| return np.stack([G[dir_grid(c)] for c in cams]) | |
| def gb_cams(gb): | |
| Kg = gb["K"].numpy().astype(float); f = Kg[0] * 8; cx = Kg[2] * 8 + X0; cy = Kg[3] * 8 | |
| return [(gb["pos"][t].numpy().astype(float), gb["R"][t].numpy().astype(float), f, cx, cy) for t in range(N)] | |
| def sky_mg(M, frames, every=10, CH=None): | |
| """MoGe-2 sky (its invalid mask) every `every` frames, nearest for the rest; characters filled from their surroundings""" | |
| ks = list(range(0, N, every)) + ([N - 1] if (N - 1) % every else []); S = {k: (char_fill(~M.mg(frames[k])[1], CH[k]) if CH is not None else ~M.mg(frames[k])[1]) for k in ks} | |
| return np.stack([S[min(ks, key=lambda k: abs(k - t))] for t in range(N)]) | |
| # ------------------------------------------------------------------ sources | |
| def rows_of(src): | |
| v5 = {json.loads(l)["video"]: json.loads(l) for l in open(f"{OUT}/v5_list.jsonl")} | |
| rows = [json.loads(l) for l in open(f"{OUT}/v6_rows.jsonl")] | |
| if src == "ww": return [r for r in rows if r["group"] == "ww"] | |
| if src == "bk": return [r for r in rows if r["group"] == "bk"] | |
| if src == "er": return [r for r in rows if r["group"] == "er"] | |
| if src == "ue": return [r for r in rows if r["group"] == "ue"] | |
| if src == "synth": return [r for r in rows if r["group"] in ("e1o", "e2o", "e1n", "e2n", "e1x", "turn")] | |
| def cond_of(v): | |
| d = os.path.dirname(v); b = os.path.basename(v) | |
| return f"{d}/" + (b.replace("rgb_", "condition_") if b.startswith("rgb_") else "cond.mp4") | |
| def do_coarse(r, M): | |
| key = r["key"]; gb = torch.load(f"{OUT}/gbuf2/clip_{key}.pt", weights_only=False); cams = gb_cams(gb) | |
| V5 = np.stack([r853(x) for x in ff(cond_of(r["video"]), 0, N)]); rgb = np.stack([r853(x) for x in ff(r["video"], 0, N)]) | |
| env = ((V5[..., 0] > 8) | (V5[..., 2] > 8)) & (V5[..., 1] < 20); Z = np.where(env, 0.1 + (1 - V5[..., 2] / 255.0) * 79.9, 0.0) | |
| CH = np.stack([cv2.dilate((x[..., 1] >= 20).astype(np.uint8), np.ones((15, 15), np.uint8)) > 0 for x in V5]); valid = env | CH | |
| CHw = np.stack([cv2.dilate((x[..., 1] >= 20).astype(np.uint8), np.ones((41, 41), np.uint8)) > 0 for x in V5]) | |
| sky = sky_mg(M, rgb, CH=CHw) & ~valid | |
| return core(key, r["group"], V5, Z, valid, sky, CH, cams, False, 1.0, rgb[0], M, shield=shield_of(key)) | |
| def shield_of(key): | |
| p = f"{OUT}/shield/clip_{key}.npy"; return np.load(p) if os.path.exists(p) else None | |
| def do_ww(r, M, cache): | |
| import ww_to_bossv2v_v2 as WW | |
| from proxykit.geometry import Camera, quat_from_matrix | |
| wd = os.path.dirname(r["video"]); m = json.load(open(f"{wd}/meta.json")); sd = f"{DS}/wildworld/data_part1/{m['sample']}"; t0 = int(m["t0"]); ts = np.arange(t0, t0 + N) | |
| if cache.get("sid") != m["sample"]: | |
| st = WW.load_state(f"{sd}/state.csv"); z = np.load(f"{sd}/skeleton.npz"); keys = {k[0]: k for k in z.files}; ents = {} | |
| edges = json.load(open(f"{DS}/wildworld/skeleton_edges.json")) | |
| for kind, rotcol in (("n", "npc.list.1.rot"), ("m", "monster.list.1.rot")): | |
| k = keys[kind]; tid = k.split("_", 1)[1]; ek = "npc" if kind == "n" else f"em_{tid}" | |
| parts, parent, size, labels, _ = WW.assign_parts(z[k], edges[ek], st[rotcol], kind); ents[kind] = dict(joints=z[k], parts=parts, parent=parent, size_m=size) | |
| cache.clear(); cache.update(sid=m["sample"], st=st, ents=ents) | |
| st, ents = cache["st"], cache["ents"]; K = st["camera.K"][ts]; ground = float(m["ground_y_m"]); to_ue = lambda p: WW.S_SWAP(p - np.array([0, ground, 0])) * 100.0 | |
| dep = WW.decode_gray(f"{sd}/depth.mkv", t0, N); W_, H_ = 1280, 720 | |
| global LUT8 | |
| if "LUT8" not in globals(): LUT8 = WW.depth8_to_m(np.arange(256, dtype=np.uint8)) | |
| e_ = lambda v: np.array([v[0], v[2], -v[1]], float) | |
| V5 = np.stack([r853(x) for x in ff(f"{wd}/cond.mp4", 0, N)]); rgb0 = r853(ff(r["video"], 0, 1)[0]) | |
| Z, valid, sky, CH, cams = [], [], [], [], [] | |
| for i, t in enumerate(ts): | |
| Rgl = WW.q2R(st["camera.rot"][t]); Mx = np.stack([WW.S_SWAP(-Rgl[:, 2]), WW.S_SWAP(Rgl[:, 0]), WW.S_SWAP(Rgl[:, 1])], 1) | |
| cam = Camera(to_ue(st["camera.pos"][t]), quat_from_matrix(Mx), float(np.degrees(2 * np.arctan(W_ / 2 / K[i, 0]))), W_, H_) | |
| zm = LUT8[dep[i]]; sk = dep[i] >= WW.SKY_DEPTH8 | |
| zz, gd = z853(zm, ~sk); Z.append(zz); sky.append(~gd); valid.append(gd) | |
| s = 480 / 720; cams.append((e_(cam.position) / 100.0, np.stack([e_(cam.R[:, 1]), e_(cam.R[:, 2]), e_(cam.R[:, 0])]), cam.focal * s, W8 / 2, H8 / 2)) | |
| m = np.zeros((H8, W8), bool) # characters: capsules round their bones (radius by body size) | |
| for e in ents.values(): | |
| Jw = np.stack([e_(to_ue(q)) / 100.0 if np.isfinite(q).all() else np.full(3, np.nan) for q in e["joints"][t]]) | |
| par = [int(p) if (p is not None and p >= 0 and e["parts"][j] > 0 and e["parts"][int(p)] > 0) else None for j, p in enumerate(e["parent"])] | |
| m |= capsules(cams[-1], Jw, max(0.3, 0.16 * float(e["size_m"])), (H8, W8), par) | |
| CH.append(cv2.dilate(m.astype(np.uint8), np.ones((11, 11), np.uint8)) > 0) | |
| Z = np.stack(Z).astype(np.float64); return core(r["key"], "ww", V5, Z, np.stack(valid), np.stack(sky), np.stack(CH), cams, True, 5.0, rgb0, M) | |
| def do_bk(r, M): | |
| import prep_mem as PM | |
| v = r["video"]; clip = os.path.dirname(v); k = int(os.path.basename(v)[4:7]); b0 = k * 120 | |
| src = clip.replace("/blackknife_121/", "/blackknife_cond/"); meta = json.load(open(f"{src}/meta.json")); raw = meta["attempt"]; sh = np.load(f"{src}/shot.npz") | |
| off = int(round(float(meta.get("window", [0.0])[0]) * 30)) # the cond's frame 0 in the raw capture | |
| gb = torch.load(f"{OUT}/gbuf2/clip_{r['key']}.pt", weights_only=False); cams = gb_cams(gb) | |
| V5 = np.stack([r853(x) for x in ff(cond_of(v), 0, N)]); dp = ff(f"{raw}/depth_packed.mkv", off + b0, N); rgb0 = r853(ff(f"{raw}/rgb.mp4", off + b0, 1)[0]) | |
| e_ = lambda p: np.stack([p[..., 0], p[..., 2], -p[..., 1]], -1) / 100.0 | |
| Z, valid, CH = [], [], [] | |
| for i in range(N): | |
| z, ok = PM.depth_m(dp[i]); ok &= z < 2000; zz, gd = z853(z, ok); Z.append(zz); valid.append(gd) | |
| m = capsules(cams[i], e_(sh["player_poses"][b0 + i]), 0.30, (H8, W8)) | capsules(cams[i], e_(sh["boss_poses"][b0 + i]), 0.35, (H8, W8)) | |
| CH.append(m | (cv2.dilate((V5[i][..., 1] >= 20).astype(np.uint8), np.ones((7, 7), np.uint8)) > 0)) | |
| Z = np.stack(Z).astype(np.float64); valid = np.stack(valid); return core(r["key"], "bk", V5, Z, valid, ~valid, np.stack(CH), cams, True, 1.0, rgb0, M, shield=shield_of(r["key"])) | |
| def do_synth(r, M): | |
| key = r["key"]; gb = torch.load(f"{OUT}/gbuf2/clip_{key}.pt", weights_only=False); cams = gb_cams(gb) | |
| V5 = np.stack([r853(x) for x in ff(cond_of(r["video"]), 0, N)]); rgb = np.stack([r853(x) for x in ff(r["video"], 0, N)]) | |
| Z, geo, CH, dirs = [], [], [], [] | |
| v, u = np.mgrid[0:H8, 0:W8] + 0.5 | |
| for t in range(N): | |
| pos, R, f, cx, cy = cams[t]; d = ((u - cx) / f)[..., None] * R[0] - ((v - cy) / f)[..., None] * R[1] + R[2] | |
| tt = np.where(d[..., 1] < -1e-6, -pos[1] / np.minimum(d[..., 1], -1e-6), 0.0); gnd = (tt > 0) & (tt < 60.0) | |
| c5 = V5[t]; env5 = ((c5[..., 0] > 8) | (c5[..., 2] > 8)) & (c5[..., 1] < 20); z5 = 0.1 + (1 - c5[..., 2] / 255.0) * 79.9 | |
| prop = env5 & ~(gnd & (np.abs(tt - z5) < 0.05 * tt + 0.3)); Z.append(np.where(prop, z5, np.where(gnd, tt, 0))); geo.append(gnd | env5) | |
| CH.append(cv2.dilate((c5[..., 1] >= 20).astype(np.uint8), np.ones((15, 15), np.uint8)) > 0); dirs.append(d / np.linalg.norm(d, axis=-1, keepdims=True)) | |
| # sky by DIRECTION (the HDRI is at infinity): MoGe-2 on frames 0 / 60 / 120 votes into a yaw-pitch grid | |
| G_ = np.zeros((360, 720, 2), np.int32) | |
| for k in (0, 60, 120): | |
| skym = char_fill(~M.mg(rgb[k])[1], cv2.dilate(CH[k].astype(np.uint8), np.ones((29, 29), np.uint8)).astype(bool)) & ~geo[k]; dd = dirs[k]; yaw = ((np.degrees(np.arctan2(dd[..., 0], dd[..., 2])) + 180) * 2).astype(int) % 720; pit = np.clip(((np.degrees(np.arcsin(np.clip(dd[..., 1], -1, 1))) + 90) * 2).astype(int), 0, 359) | |
| np.add.at(G_, (pit.ravel(), yaw.ravel(), skym.ravel().astype(int)), 1) | |
| sky = [] | |
| for t in range(N): | |
| dd = dirs[t]; yaw = ((np.degrees(np.arctan2(dd[..., 0], dd[..., 2])) + 180) * 2).astype(int) % 720; pit = np.clip(((np.degrees(np.arcsin(np.clip(dd[..., 1], -1, 1))) + 90) * 2).astype(int), 0, 359) | |
| c = G_[pit, yaw]; sky.append((c[..., 1] > c[..., 0]) & ~geo[t]) | |
| Z = np.stack(Z).astype(np.float64); geo = np.stack(geo); sky = np.stack(sky) | |
| tier0 = np.where(geo, 3, np.where(sky, 0, 1)).astype(np.uint8) | |
| return core(key, r["group"], V5, Z, geo, sky, np.stack(CH), cams, True, 1.0, rgb[0], M, tier0=tier0) | |
| # ------------------------------------------------------------------ roam (memroam windows; whole segments read once) | |
| def roam_rows(): | |
| """memroam training windows (Leyndell held out); user 10-17: Siofra 1/2, snowfield 1/4, every clip (outfit) keeps >= 1 window""" | |
| idx = json.load(open(f"{DS}/wan_memroam/index.json")); by = {} | |
| ev = set(json.load(open(f"{OUT}/leyndell_eval.json"))["eval_segments"]) # (user 10-17) Leyndell trains too, only the 4 eval windows' segments stay out | |
| for name, v in idx.items(): | |
| if v["test"] and v["seg"] in ev: continue | |
| by.setdefault(v["seg"], []).append((int(v["f0"]), name[5:-3], v["session"])) | |
| out = [] | |
| for seg, ws in by.items(): | |
| ws.sort(); keep = 2 if "siofra" in ws[0][2] else 4 if "snowfield" in ws[0][2] else 1 | |
| out += [dict(seg=seg, f0=f0, key=k, session=s) for i, (f0, k, s) in enumerate(ws) if i % keep == 0] | |
| return out | |
| def skel_layer(key, M): | |
| """memroam stored the skeleton-only layer (prep_mem.Skel, the live engine's actor layer) as a VAE latent: decode it, keep the bone pixels""" | |
| z = torch.load(f"{DS}/wan_memroam/clips/clip_{key}.pt", map_location="cpu", weights_only=False)["skel"].float().cuda() | |
| with torch.no_grad(): x = M.vae.decode([z])[0] | |
| v = ((x.clamp(-1, 1) + 1) * 127.5).round().byte().permute(1, 2, 3, 0).cpu().numpy()[:N] | |
| m = v[..., 1] >= 24; return np.where(m[..., None], v, 0).astype(np.uint8) | |
| def _weapon_track(rows, M, ground): | |
| """(10-18) the roaming player's sword: samples' weapons[0] (start, end), world = local + the row's offset; into the Skel frame (cm, z up, grounded)""" | |
| W_ = [] | |
| for r in rows: | |
| if r["Wp"]: | |
| off = np.asarray(r["J"][0], float) - np.asarray(r["Jl"][0], float) | |
| W_.append(np.stack([(np.asarray(p, float) - off) @ M.T * 100.0 for p in r["Wp"][0]])) | |
| else: W_.append(None) | |
| ok = [i for i, w in enumerate(W_) if w is not None] | |
| out = np.stack([W_[min(ok, key=lambda j: abs(j - i))] for i in range(len(W_))]); out[..., 2] -= ground; return out | |
| _SKW = None | |
| def skel_weapon(rows): | |
| """(10-18) the player's skeleton layer WITH the sword, drawn by prep_mem.Skel.video itself (same renderer, same codes) with tr.weapon set | |
| (memroam's stored layer has tr.weapon = None, so the roaming windows had no sword condition while every boss-fight source draws it)""" | |
| global _SKW | |
| import prep_mem as PM, inspect, textwrap | |
| if _SKW is None: | |
| src = textwrap.dedent(inspect.getsource(PM.Skel.video)); assert src.count("tr.weapon = None") == 1 | |
| ns = dict(PM.__dict__); ns["_weapon_track"] = _weapon_track; exec(src.replace("tr.weapon = None", "tr.weapon = _weapon_track(rows, M, ground)"), ns) | |
| cls = type("SkelW", (PM.Skel,), {"video": ns["video"]}); _SKW = cls(int(os.environ.get("EGL", "0"))) | |
| with egl_lock(): return _SKW.video(rows) | |
| def do_roam_seg(seg, wins, M, sk): | |
| """every window of one recording segment: rgb + packed depth decoded once""" | |
| import prep_mem as PM | |
| rows = PM.load_states(seg); last = max(w["f0"] for w in wins) + N; need = set(f for w in wins for f in range(w["f0"], w["f0"] + N)) | |
| S = [json.loads(l) for l in gzip.open(seg + "/samples.jsonl.gz", "rt")]; FA = [json.loads(l) for l in gzip.open(seg + "/frame_association.jsonl.gz", "rt")] | |
| def equip(f): | |
| r = FA[f]; s = S[r["raw_sample_index"]] if r["raw_sample_index"] < len(S) else None; return (s or {}).get("equipment") or {} | |
| RGB, DP = {}, {} | |
| for f, (fr, fd) in enumerate(zip(PM.frames(seg, 0), PM.frames(seg, 1))): | |
| if f >= last: break | |
| if f in need: RGB[f] = r853(fr); DP[f] = fd.copy() | |
| res = [] | |
| for w in wins: | |
| f0 = w["f0"]; R_ = [rows[f0 + i] for i in range(N)] | |
| if any(r is None for r in R_) or (f0 + N - 1) not in DP: continue | |
| cams, Z, valid, CH = [], [], [], [] | |
| for i, r in enumerate(R_): | |
| fx, fy, cx, cy = r["K"]; s = 480 / 540; cams.append((np.asarray(r["pos"], float), np.asarray(r["R"], float), fx * s, cx * s, cy * s)) | |
| z, ok = PM.depth_m(DP[f0 + i]); ok &= z < 2000; zz, gd = z853(z, ok); Z.append(zz); valid.append(gd) | |
| CH.append(capsules(cams[-1], np.asarray(r["J"], float), 0.35, (H8, W8))) | |
| Z = np.stack(Z); valid = np.stack(valid); CH = np.stack(CH) | |
| feet = float(np.asarray(R_[0]["J"])[:, 1].min()); ab = (1 / 112.0, 0.5 + (8 - feet) / 112.0) # R = 0.5 + 0.5 clamp((h - feet + 8) / 56) | |
| skl = skel_weapon(R_) if os.environ.get("V7_SWORD") and any(r["Wp"] for r in R_) else skel_layer(w["key"], M) # (10-18) sword off: the samples' weapon direction is unreliable (curved / reverse-grip blades point the wrong way) # the player's skeleton layer prep_mem.Skel drew for this window (no EGL here) | |
| V5 = np.zeros((N, H8, W8, 3), np.uint8) | |
| for t in range(N): | |
| Rr, Bb = rb_from(Z[t], cams[t], ab); V5[t][..., 0] = np.where(valid[t], np.round(Rr * 255), 0); V5[t][..., 2] = np.where(valid[t], np.round(Bb * 255), 0) | |
| a = skl[t][..., 1] > 0; V5[t][:, X0:X0 + 832][a] = skl[t][a] | |
| sh = None # the round shield (left_param_id 30000000..33000000): a disc 6 cm past the left hand, r 0.30 m | |
| if 30000000 <= int(equip(f0).get("left_param_id") or 0) < 33000000: | |
| sh = [] | |
| for t, r in enumerate(R_): | |
| J = np.asarray(r["J"], float); pos, Rm, f, cx, cy = cams[t]; p = J[7] + 0.06 * (J[7] - J[6]) / max(np.linalg.norm(J[7] - J[6]), 1e-6) - pos | |
| x, y, z = p @ Rm[0], p @ Rm[1], p @ Rm[2] | |
| sh.append((cx + f * x / z - X0, cy - f * y / z, f * 0.30 / z) if z > 0.2 else (np.nan,) * 3) | |
| sh = np.array(sh) | |
| res.append((w, core(w["key"], "roam", V5, Z, valid, ~valid, CH, cams, True, 1.0, RGB[f0], M, shield=sh, ab=ab))) | |
| return res | |
| MARK = os.environ.get("V7_MARK", "redo_"); C7 = os.environ.get("V7_SUB", "cond7") # (10-19) MEMUNK=1 V7_SUB=cond7_memunk writes the variant beside the normal ones | |
| KEYS = set(json.load(open(os.environ["V7_KEYS"]))) if os.environ.get("V7_KEYS") else None # (10-18) re-render these windows (overwrite); a redo_<key> marker = done | |
| def main(): | |
| ap = argparse.ArgumentParser(); ap.add_argument("src"); ap.add_argument("--rank", type=int, default=0); ap.add_argument("--world", type=int, default=1) | |
| ap.add_argument("--limit", type=int, default=0); ap.add_argument("--preview", action="store_true"); a = ap.parse_args() | |
| os.makedirs(f"{OUT}/cond7", exist_ok=True); os.makedirs(f"{OUT}/{C7}", exist_ok=True); os.makedirs(f"{OUT}/preview", exist_ok=True); torch.set_num_threads(4); cv2.setNumThreads(4) | |
| if a.src == "roam": | |
| import prep_mem as PM | |
| W_ = roam_rows(); segs = {} | |
| if KEYS is not None: W_ = [w for w in W_ if w["key"] in KEYS] | |
| for w in W_: segs.setdefault(w["seg"], []).append(w) | |
| mine = sorted(segs)[a.rank::a.world]; M = Models(); sk = None; n = 0; t_ = time.time() # skeleton layer from memroam's latent | |
| print(f"rank {a.rank} roam: {len(W_)} windows in {len(segs)} segments, mine {len(mine)}", flush=True) | |
| for seg in mine: | |
| todo = [w for w in segs[seg] if KEYS is not None and not os.path.exists(f"{OUT}/{C7}/{MARK}{w['key']}") or not os.path.exists(f"{OUT}/{C7}/clip_{w['key']}.pt")] | |
| if not todo: continue | |
| try: res = do_roam_seg(seg, todo, M, sk) | |
| except Exception as ex: | |
| import traceback; print("FAIL", seg, repr(ex)[:200], traceback.format_exc().splitlines()[-3:], flush=True); continue | |
| for w, (v7, dep, tc, meta) in res: | |
| dst = f"{OUT}/{C7}/clip_{w['key']}.pt"; meta["session"] = w["session"] | |
| torch.save(dict(cond=M.encode(v7), dep=torch.from_numpy(dep), tier=torch.from_numpy(tc), meta=meta), dst + ".tmp"); os.replace(dst + ".tmp", dst); n += 1 | |
| if KEYS is not None: open(f"{OUT}/{C7}/{MARK}{w['key']}", "w").close() | |
| if a.preview and n <= 3: cv2.imwrite(f"{OUT}/preview/roam_{w['key']}.jpg", cv2.cvtColor(np.concatenate([v7[i].cpu().numpy() for i in (0, 60, 120)], 1), cv2.COLOR_RGB2BGR)) | |
| if a.limit and n >= a.limit: break | |
| print(f"rank {a.rank} roam: {n} done, {(time.time() - t_) / max(n, 1):.1f} s/window", flush=True) | |
| if a.limit and n >= a.limit: break | |
| print(f"rank {a.rank} roam BUILD_V7_DONE {n}", flush=True); return | |
| rows = rows_of(a.src) | |
| if KEYS is not None: rows = [r for r in rows if r["key"] in KEYS] | |
| if a.src == "ww": rows = sorted(rows, key=lambda r: r["video"]) # windows of one sample together (state cache) | |
| rows = rows[a.rank::a.world]; M = Models(); cache = {}; n = 0; t_ = time.time() | |
| if os.environ.get("REVERSE"): rows = rows[::-1] # a second host works from the other end | |
| for r in rows: | |
| dst = f"{OUT}/{C7}/clip_{r['key']}.pt" | |
| if os.path.exists(dst) and (KEYS is None or os.path.exists(f"{OUT}/{C7}/{MARK}{r['key']}")): continue | |
| try: | |
| if a.src in ("er", "ue"): v7, dep, tc, meta = do_coarse(r, M) | |
| elif a.src == "ww": v7, dep, tc, meta = do_ww(r, M, cache) | |
| elif a.src == "bk": v7, dep, tc, meta = do_bk(r, M) | |
| elif a.src == "synth": v7, dep, tc, meta = do_synth(r, M) | |
| except Exception as ex: | |
| import traceback; print("FAIL", r["video"], repr(ex)[:200], traceback.format_exc().splitlines()[-3:], flush=True); continue | |
| lat = M.encode(v7); torch.save(dict(cond=lat, dep=torch.from_numpy(dep), tier=torch.from_numpy(tc), meta=meta), dst + ".tmp"); os.replace(dst + ".tmp", dst); n += 1 | |
| if KEYS is not None: open(f"{OUT}/{C7}/{MARK}{r['key']}", "w").close() | |
| if a.preview and n <= 3: | |
| img = np.concatenate([v7[i].cpu().numpy() for i in (0, 60, 120)], 1); cv2.imwrite(f"{OUT}/preview/{a.src}_{r['key']}_{'m' if meta['moge'] else ''}{'h' if meta['holes'] else ''}{'p' if meta['patch'] else ''}.jpg", cv2.cvtColor(img, cv2.COLOR_RGB2BGR)) | |
| if n % 20 == 0: print(f"rank {a.rank} {a.src}: {n} done, {(time.time() - t_) / n:.1f} s/window", flush=True) | |
| if a.limit and n >= a.limit: break | |
| print(f"rank {a.rank} {a.src} BUILD_V7_DONE {n}", flush=True) | |
| if __name__ == "__main__": | |
| main() | |