ww_index: window list, captions, lags and scripts to rebuild the WildWorld windows from upstream
a54e6a7 verified Download ww_index/scripts/proxykit36/proxykit/scene.py from yuzhewu207/wizard-precoded: direct link, hf CLI and curl.
- Browser
- Download file 6.15 kB
-
https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/proxykit36/proxykit/scene.py
- Command line
-
hf download hf://datasets/yuzhewu207/wizard-precoded/ww_index/scripts/proxykit36/proxykit/scene.py
-
curl -L -o scene.py https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/proxykit36/proxykit/scene.py
6.15 kB
| """A shot: camera track, static environment, entities (skeleton + motion track + identity slot). Renders the | |
| condition video exactly in the BOSSV2V encoding, plus a preview grid, a first-frame overlay and a validation report, | |
| and can run the stage-1 video model on it. | |
| scene = Scene(frames=121, fps=30, camera=Camera.look_at(...), env=ground_env()) | |
| boss = scene.add("boss", skeleton, slot=2, root=(x, y, None), yaw=...) | |
| boss.gait(...); boss.throw_weapon(...) | |
| scene.render("out/", first_frame="first.png") | |
| """ | |
| import json, os, subprocess, sys | |
| from pathlib import Path | |
| import numpy as np | |
| from PIL import Image | |
| from .geometry import Camera | |
| from .motion import Track | |
| from .render import Renderer, VideoWriter, ReadableWriter, readable_rgb8 | |
| from . import validate as V | |
| RUNS = "/data/yuzhewu/runs" | |
| def ground_env(radius_cm=6000.0, z_cm=0.0, boxes=()): | |
| """Flat round arena at z with the sea far below (so the horizon stays dark red like the dataset) plus boxes.""" | |
| return {"platform": {"radius_cm": float(radius_cm), "z_cm": float(z_cm)}, "sea_z_cm": -730.0, "boxes": list(boxes)} | |
| def box(center, size, yaw_deg=0.0, label=2): | |
| return {"center_cm": [float(v) for v in center], "size_cm": [float(v) for v in size], "yaw_degrees": float(yaw_deg), "label": int(label)} | |
| class Scene: | |
| def __init__(self, frames=121, fps=30, camera=None, env=None, width=1280, height=720): | |
| assert (frames - 1) % 8 == 0, "frames must be 8k+1 for the video VAE" | |
| self.frames, self.fps, self.w, self.h = frames, fps, width, height | |
| self.env = env or ground_env() | |
| self.cameras = [camera or Camera.look_at([0, -900, 220], [0, 0, 150])] * frames | |
| self.entities = {} | |
| # ---------------------------------------------------------------- building | |
| def add(self, name, skeleton, slot, root=(0, 0, None), yaw=0.0): | |
| assert 1 <= slot <= 7 and all(e["slot"] != slot for e in self.entities.values()), "slots must be unique 1..7" | |
| tr = Track(skeleton, self.frames, root, yaw) | |
| self.entities[name] = {"skeleton": skeleton, "slot": slot, "track": tr} | |
| return tr | |
| def camera_at(self, t): | |
| return self.cameras[t] | |
| def set_camera_track(self, fn): | |
| """fn(t) -> Camera for every frame.""" | |
| self.cameras = [fn(t) for t in range(self.frames)] | |
| # ---------------------------------------------------------------- outputs | |
| def capsules(self, t): | |
| caps = [] | |
| for ent in self.entities.values(): | |
| w = ent["track"].weapon[t] if ent["track"].weapon is not None else None | |
| caps += ent["skeleton"].capsules(ent["track"].poses[t], ent["slot"], w) | |
| return caps | |
| def check(self, **kw): | |
| return V.check(self, floor_z=self.env["platform"]["z_cm"], **kw) | |
| def render(self, out, first_frame=None, device=None, train_scale=(1024, 576), overlay=False): | |
| """Writes readable.mp4 (colour-coded stick figures for people), cond.mp4 (1024x576 model input), shot.npz and | |
| report.json. overlay=True with first_frame also writes overlay_first_frame.png (for the agent's own alignment | |
| check; not a deliverable).""" | |
| out = Path(out); out.mkdir(parents=True, exist_ok=True) | |
| device = device if device is not None else int(os.environ.get("EGL_DEVICE", 4)) | |
| report = self.check() | |
| rnd = Renderer(self.env, self.w, self.h, device) | |
| readable = ReadableWriter(out / "readable.mp4", self.w, self.h, self.fps) | |
| train = VideoWriter(out / "cond.mp4", self.w, self.h, self.fps, scale_to=train_scale) | |
| clipped, frame0 = 0, None | |
| try: | |
| for t in range(self.frames): | |
| rgb, stats = rnd.render(self.camera_at(t), self.capsules(t)) | |
| clipped += stats["actor_depth_clipped"] | |
| readable.write(readable_rgb8(rgb)); train.write(rgb) | |
| if t == 0: | |
| frame0 = rgb | |
| finally: | |
| readable.close(); train.close(); rnd.close() | |
| report["actor_depth_clipped_pixels"] = clipped | |
| if first_frame is not None: | |
| img = Image.open(first_frame).convert("RGB").resize((self.w, self.h)) | |
| img.resize(train_scale).save(out / "first_frame.png") | |
| if overlay: | |
| cond = Image.fromarray(readable_rgb8(frame0)) | |
| mask = Image.fromarray(((frame0[..., 1] > 0) * 255).astype(np.uint8)) # actors only | |
| over = img.copy(); over.paste(cond, (0, 0), mask) | |
| over.save(out / "overlay_first_frame.png") | |
| np.savez_compressed(out / "shot.npz", cameras=np.stack([c.transform() for c in self.cameras]), | |
| **{f"{n}_poses": e["track"].poses for n, e in self.entities.items()}, | |
| **{f"{n}_weapon": e["track"].weapon for n, e in self.entities.items() if e["track"].weapon is not None}) | |
| json.dump(report, open(out / "report.json", "w"), indent=1) | |
| return report | |
| def generate(self, out, prompt, lora=f"{RUNS}/ltx25_bossv2v121/checkpoints/lora_weights_step_06000.safetensors", gpu=4, | |
| first_frame=True): | |
| """Run the stage-1 video model (1024x576@30, 121 frames) on out/cond.mp4. Returns the generated mp4 path.""" | |
| out = Path(out) | |
| cmd = [f"/data/yuzhewu/venv_ltx/bin/python", f"{RUNS}/infer_v2v.py", "--config", f"{RUNS}/ltx25_bossv2v121.yaml", | |
| "--lora", lora, "--whitebox", str(out / "cond.mp4"), "--prompt", prompt, "--width", "1024", "--height", "576", | |
| "--frames", str(self.frames), "--fps", str(self.fps), "--out-dir", str(out / "gen")] | |
| if first_frame and (out / "first_frame.png").exists(): | |
| cmd += ["--first-frame", str(out / "first_frame.png")] | |
| env = dict(os.environ, CUDA_VISIBLE_DEVICES=str(gpu)) | |
| with open(out / "generate.log", "w") as log: | |
| subprocess.run(cmd, cwd="/data/yuzhewu/LTX-2/packages/ltx-trainer", env=env, stdout=log, stderr=subprocess.STDOUT, check=True) | |
| vids = sorted((out / "gen" / "samples").glob("*.mp4")) | |
| assert vids, "generation produced no video" | |
| return vids[-1] | |