#!/usr/bin/env python3 """Build and run a RoboCasa -> VACE object-insertion batch. The target mesh is the object to insert. The source video is sampled from a same-category target-object episode across the PickPlace target datasets. """ from __future__ import annotations import argparse import gzip import json import os import re import shutil import subprocess import sys import time import xml.etree.ElementTree as ET from concurrent.futures import ProcessPoolExecutor, as_completed from collections import Counter, defaultdict from pathlib import Path os.environ.setdefault("MUJOCO_GL", "egl") os.environ.setdefault("PYOPENGL_PLATFORM", "egl") import cv2 import mujoco import numpy as np import robocasa import robosuite from robosuite.utils.binding_utils import MjSim from robosuite.utils.mjcf_utils import array_to_string, find_elements TARGET_MESHES = [ "onion/onion_8", "fish/fish_7", "ladle/ladle_4", "eggplant/eggplant_3", "carrot/carrot_7", "tomato/tomato_7", "eggplant/eggplant_4", "pear/pear_18", "lemon/lemon_3", "pear/pear_8", "orange/orange_3", "orange/orange_5", "tangerine/tangerine_4", "steak/steak_6", "steak/steak_8", "egg/egg_6", "measuring_cup/MeasuringCup009", "orange/orange_8", "wooden_spoon/WoodenSpoon012", ] CAMS = [ "robot0_agentview_left", "robot0_agentview_right", "robot0_eye_in_hand", ] _HERE = Path(__file__).resolve().parent # The mesh reference-view renderer needs trimesh + pyrender, which the driver's own # interpreter already has -- so by default reuse it and the vendored copy of the script, # and this tree needs nothing from outside it. RENDER_PYTHON = Path(os.environ.get("VACE_RENDER_PYTHON", sys.executable)) RENDER_SCRIPT_DIR = Path(os.environ.get( "VACE_RENDER_SCRIPT_DIR", _HERE / "aug32" / "vendor")) ROBOCASA_ROOT = Path(os.environ.get( "VACE_ROBOCASA_ROOT", "/home/nvidia/jonghoon/robocasa_full/pickplace_target_human")) # env override so a regenerated / relocated mask tree can be used without editing this file AUG_MATERIALS_ROOT = Path(os.environ.get( "VACE_AUG_MATERIALS", "/home/nvidia/jonghoon/robocasa_full/aug_materials/robocasa")) # where the target meshes live; ":"-separated override, e.g. # VACE_ASSET_ROOTS=$PWD/data/lightwheel:$PWD/data/objaverse _DEFAULT_ASSET_ROOTS = ( "/lp-dev/jonghoon/robocasa_calib/repos/robocasa/robocasa/models/assets/objects/lightwheel:" "/lp-dev/jonghoon/robocasa_calib/repos/robocasa/robocasa/models/assets/objects/objaverse" ) ASSET_ROOTS = [Path(p) for p in os.environ.get("VACE_ASSET_ROOTS", _DEFAULT_ASSET_ROOTS).split(":") if p] def sanitize(value: str) -> str: value = value.strip().replace("/", "_") value = re.sub(r"[^A-Za-z0-9_.-]+", "_", value) value = re.sub(r"_+", "_", value) return value.strip("_") or "x" def read_json(path: Path) -> dict: return json.loads(path.read_text()) def target_obj_info(ep_dir: Path) -> dict | None: meta = ep_dir / "ep_meta.json" if not meta.exists(): return None data = read_json(meta) obj = next((cfg for cfg in data.get("object_cfgs", []) if cfg.get("name") == "obj"), None) if obj is None: return None info = obj.get("info") or {} mjcf = info.get("mjcf_path") or "" return { "category": info.get("cat"), "model": Path(mjcf).parent.name if mjcf else None, "mjcf_path": mjcf, "lang": data.get("lang"), } def scan_sources(dataset_root: Path, categories: set[str]) -> dict[str, list[dict]]: sources: dict[str, list[dict]] = defaultdict(list) for task_dir in sorted(p for p in dataset_root.iterdir() if p.is_dir()): extras = task_dir / "extras" if not extras.exists(): continue for ep_dir in sorted(extras.glob("episode_*")): try: episode = int(ep_dir.name.split("_")[-1]) except ValueError: continue info = target_obj_info(ep_dir) if not info or info["category"] not in categories: continue videos = { cam: task_dir / "videos/chunk-000" / f"observation.images.{cam}" / f"episode_{episode:06d}.mp4" for cam in CAMS } if not all(path.exists() for path in videos.values()): continue sources[info["category"]].append({ "task": task_dir.name, "episode": episode, "source_mesh": f"{info['category']}/{info['model']}", "source_model": info["model"], "source_category": info["category"], "lang": info["lang"], "extras_dir": str(ep_dir), "videos": {cam: str(path) for cam, path in videos.items()}, }) return sources def visibility_check_source(job: tuple[str, dict, str, int]) -> tuple[dict, dict | None]: category, row, out_root_text, min_mask_area = job out_root = Path(out_root_text) ep_dir = Path(row["extras_dir"]) cam_stats = {} ok = True for cam in CAMS: seed_dir = ( out_root / "visibility_seed_masks" / sanitize(row["task"]) / f"episode_{row['episode']:06d}" ) try: stats = render_target_mask( ep_dir, cam, seed_dir / f"{cam}.png", seed_dir / f"{cam}.json", ) cam_stats[cam] = stats if stats["area"] <= min_mask_area: ok = False except Exception as exc: ok = False cam_stats[cam] = {"error": repr(exc), "area": 0, "bbox_xyxy": None} vis_row = { "task": row["task"], "episode": row["episode"], "source_mesh": row["source_mesh"], "category": category, "visible_all_cams": ok, "camera_stats": cam_stats, } return vis_row, row if ok else None def round_robin_sources(candidates: list[dict], n: int) -> list[dict]: by_task: dict[str, list[dict]] = defaultdict(list) for row in candidates: by_task[row["task"]].append(row) task_names = sorted(by_task) cursors = {task: 0 for task in task_names} out: list[dict] = [] while len(out) < n: progressed = False for task in task_names: rows = by_task[task] if not rows: continue out.append(rows[cursors[task] % len(rows)]) cursors[task] += 1 progressed = True if len(out) >= n: break if not progressed: break return out def build_assignments(args: argparse.Namespace) -> None: targets = [line.strip() for line in (args.targets or TARGET_MESHES) if line.strip()] cats = {t.split("/", 1)[0] for t in targets} sources = scan_sources(args.dataset_root, cats) args.out_root.mkdir(parents=True, exist_ok=True) visibility_rows: list[dict] = [] if args.require_visible_all_cams: filtered: dict[str, list[dict]] = defaultdict(list) jobs = [ (category, row, str(args.out_root), args.min_mask_area) for category, rows in sorted(sources.items()) for row in rows ] print(json.dumps({ "visibility_prefilter_jobs": len(jobs), "visibility_workers": args.visibility_workers, }), flush=True) sources = filtered with (args.out_root / "visibility_filter.jsonl").open("w", encoding="utf-8") as f: if args.visibility_workers <= 1: iterator = map(visibility_check_source, jobs) for idx, (vis_row, kept_row) in enumerate(iterator, start=1): visibility_rows.append(vis_row) if kept_row is not None: filtered[vis_row["category"]].append(kept_row) f.write(json.dumps(vis_row, ensure_ascii=False) + "\n") f.flush() if idx % 25 == 0: print(json.dumps({"visibility_done": idx, "total": len(jobs)}), flush=True) else: done = 0 with ProcessPoolExecutor(max_workers=args.visibility_workers) as ex: future_map = {ex.submit(visibility_check_source, job): job for job in jobs} for fut in as_completed(future_map): vis_row, kept_row = fut.result() visibility_rows.append(vis_row) if kept_row is not None: filtered[vis_row["category"]].append(kept_row) f.write(json.dumps(vis_row, ensure_ascii=False) + "\n") f.flush() done += 1 if done % 25 == 0 or done == len(jobs): print(json.dumps({"visibility_done": done, "total": len(jobs)}), flush=True) sources = filtered assignments: list[dict] = [] summary: dict[str, object] = { "created_at": time.strftime("%Y-%m-%d %H:%M:%S %Z"), "dataset_root": str(args.dataset_root), "out_root": str(args.out_root), "per_mesh": args.per_mesh, "require_visible_all_cams": bool(args.require_visible_all_cams), "min_mask_area": args.min_mask_area, "targets": targets, "source_counts": {}, "target_counts": {}, } assignment_idx = 0 for target_mesh in targets: category, target_model = target_mesh.split("/", 1) candidates = [ row for row in sources.get(category, []) if row.get("source_model") != target_model ] selected = round_robin_sources(candidates, args.per_mesh) if len(selected) < args.per_mesh: raise SystemExit( f"Only {len(selected)} usable same-category sources for {target_mesh}; " f"requested {args.per_mesh}" ) task_counts = Counter(row["task"] for row in selected) mesh_counts = Counter(row["source_mesh"] for row in selected) summary["target_counts"][target_mesh] = { "candidate_count_excluding_same_mesh": len(candidates), "selected_count": len(selected), "selected_by_task": dict(sorted(task_counts.items())), "selected_by_source_mesh": dict(sorted(mesh_counts.items())), } for sample_idx, src in enumerate(selected): run_name = ( f"assignment_{assignment_idx:06d}_" f"{sanitize(src['task'])}_ep{src['episode']:06d}_" f"{sanitize(target_model)}_from_{sanitize(src['source_model'])}" ) case_dir = args.out_root / run_name assignments.append({ "assignment_idx": assignment_idx, "sample_idx_for_target": sample_idx, "target_mesh": target_mesh, "target_category": category, "target_model": target_model, "source": src, "case_dir": str(case_dir), "run_name": run_name, }) assignment_idx += 1 for cat, rows in sorted(sources.items()): summary["source_counts"][cat] = { "total": len(rows), "by_task": dict(sorted(Counter(row["task"] for row in rows).items())), "by_source_mesh": dict(sorted(Counter(row["source_mesh"] for row in rows).items())), } with (args.out_root / "assignments.jsonl").open("w", encoding="utf-8") as f: for row in assignments: f.write(json.dumps(row, ensure_ascii=False) + "\n") (args.out_root / "source_summary.json").write_text(json.dumps(summary, indent=2, ensure_ascii=False)) print(json.dumps({ "assignments": len(assignments), "view_jobs": len(assignments) * len(CAMS), "out_root": str(args.out_root), "assignment_file": str(args.out_root / "assignments.jsonl"), }, indent=2)) def patch_xml_for_local_assets(xml: str) -> str: local_rs = os.path.dirname(robosuite.__file__) local_rc = os.path.dirname(robocasa.__file__) xml = re.sub(r'/[^"\'\s]*?/robosuite(?=/models/)', local_rs, xml) xml = re.sub(r'/[^"\'\s]*?/robocasa(?=/models/)', local_rc, xml) return xml def sim_from_episode(ep_dir: Path) -> tuple[MjSim, np.ndarray]: xml = patch_xml_for_local_assets(gzip.open(ep_dir / "model.xml.gz", "rt").read()) root = ET.fromstring(xml) wb = root.find("worldbody") existing_cam_names = {c.get("name") for c in root.iter("camera") if c.get("name")} ep_meta = read_json(ep_dir / "ep_meta.json") for cn, cfg in ep_meta.get("cam_configs", {}).items(): if cn in existing_cam_names: continue parent = find_elements(root=wb, tags="body", attribs={"name": cfg["parent_body"]}) if parent is None: continue cam = ET.SubElement(parent, "camera") cam.set("mode", "fixed") cam.set("name", cn) cam.set("pos", array_to_string(cfg["pos"])) cam.set("quat", array_to_string(cfg["quat"])) for key, value in (cfg.get("camera_attribs") or {}).items(): cam.set(key, str(value)) sim = MjSim.from_xml_string(ET.tostring(root, encoding="unicode")) states = np.load(ep_dir / "states.npz")["states"] return sim, states def render_target_mask(ep_dir: Path, cam: str, out_path: Path, stats_path: Path) -> dict: if out_path.exists() and stats_path.exists(): return read_json(stats_path) sim, states = sim_from_episode(ep_dir) sim.set_state_from_flattened(states[0]) sim.forward() model = sim.model._model data = sim.data._data target_geom_ids = { gid for gid in range(model.ngeom) if (mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_GEOM, gid) or "").startswith("obj_") } if not target_geom_ids: raise RuntimeError(f"No target geoms with obj_ prefix in {ep_dir}") cam_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_CAMERA, cam) if cam_id < 0: raise RuntimeError(f"Camera not found: {cam} in {ep_dir}") renderer = mujoco.Renderer(model, height=256, width=256) renderer.enable_segmentation_rendering() scene_option = mujoco.MjvOption() scene_option.sitegroup[:] = 0 try: renderer.update_scene(data, camera=cam_id, scene_option=scene_option) seg = render_segmentation_safe(renderer) finally: renderer.close() mask = np.isin(seg[..., 0], list(target_geom_ids)).astype(np.uint8) * 255 ys, xs = np.where(mask > 127) stats = { "episode_dir": str(ep_dir), "camera": cam, "area": int(len(xs)), "bbox_xyxy": [int(xs.min()), int(ys.min()), int(xs.max()), int(ys.max())] if len(xs) else None, } out_path.parent.mkdir(parents=True, exist_ok=True) cv2.imwrite(str(out_path), mask) stats_path.write_text(json.dumps(stats, indent=2)) return stats def render_segmentation_safe(renderer: mujoco.Renderer) -> np.ndarray: """Render segmentation without MuJoCo's small segid remap allocation bug.""" original_flags = renderer._scene.flags.copy() renderer._scene.flags[mujoco.mjtRndFlag.mjRND_SEGMENT] = True renderer._scene.flags[mujoco.mjtRndFlag.mjRND_IDCOLOR] = True if renderer._gl_context: renderer._gl_context.make_current() rgb = np.empty((renderer.height, renderer.width, 3), dtype=np.uint8) mujoco.mjr_render(renderer._rect, renderer._scene, renderer._mjr_context) mujoco.mjr_readPixels(rgb, None, renderer._rect, renderer._mjr_context) image3 = rgb.astype(np.uint32) segimage = image3[:, :, 0] + image3[:, :, 1] * (2**8) + image3[:, :, 2] * (2**16) max_segid = int(segimage.max(initial=0)) ngeoms = int(renderer._scene.ngeom) segid2output = np.full((max(max_segid, ngeoms) + 1, 2), fill_value=-1, dtype=np.int32) for geom in renderer._scene.geoms[:ngeoms]: if geom.segid == -1: continue segid = int(geom.segid) + 1 if segid < segid2output.shape[0]: segid2output[segid, 0] = int(geom.objid) segid2output[segid, 1] = int(geom.objtype) seg = segid2output[segimage] np.copyto(renderer._scene.flags, original_flags) return np.flipud(seg) def load_assignments(path: Path) -> list[dict]: return [json.loads(line) for line in path.read_text().splitlines() if line.strip()] def is_archived_path(path: Path) -> bool: return any(part.startswith("_archive_") for part in path.parts) def run_cmd(cmd: list[str], log_path: Path) -> int: log_path.parent.mkdir(parents=True, exist_ok=True) with log_path.open("a", encoding="utf-8") as log: log.write("$ " + " ".join(map(str, cmd)) + "\n") log.flush() proc = subprocess.run(cmd, stdout=log, stderr=subprocess.STDOUT, text=True) log.write(f"[exit_code] {proc.returncode}\n") return proc.returncode def ffprobe_video(video: Path) -> dict: proc = subprocess.run( [ "ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height,r_frame_rate,avg_frame_rate,nb_frames,duration", "-of", "json", str(video), ], check=True, capture_output=True, text=True, ) streams = json.loads(proc.stdout).get("streams") or [] if not streams: raise RuntimeError(f"No video stream found in {video}") return streams[0] def parse_rate(rate: str | None) -> float: if not rate: return 20.0 if "/" in rate: num, den = rate.split("/", 1) den_f = float(den) return float(num) / den_f if den_f else 20.0 return float(rate) def video_frame_count(video: Path) -> int: info = ffprobe_video(video) nb_frames = info.get("nb_frames") if str(nb_frames).isdigit(): return int(nb_frames) cap = cv2.VideoCapture(str(video)) try: count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) finally: cap.release() if count <= 0: raise RuntimeError(f"Could not determine frame count for {video}") return count def video_fps(video: Path) -> float: info = ffprobe_video(video) return parse_rate(info.get("avg_frame_rate") or info.get("r_frame_rate")) def video_max_mask_area(video: Path, *, threshold: int = 16) -> int: cap = cv2.VideoCapture(str(video)) if not cap.isOpened(): raise RuntimeError(f"Could not open mask video: {video}") max_area = 0 try: while True: ok, frame = cap.read() if not ok: break gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) if frame.ndim == 3 else frame max_area = max(max_area, int((gray > threshold).sum())) finally: cap.release() return max_area def segment_starts(total_frames: int, frame_num: int) -> list[int]: if total_frames <= 0: raise ValueError(f"total_frames must be positive, got {total_frames}") if frame_num <= 1: return [0] stride = frame_num - 1 starts = [0] while starts[-1] + frame_num < total_frames: starts.append(starts[-1] + stride) return starts def vace_segment_frame_num(remaining_frames: int, max_frame_num: int) -> int: """Use a dynamic tail segment, keeping VACE's preferred 4n+1 length.""" if remaining_frames >= max_frame_num: return max_frame_num if remaining_frames <= 1: return min(max_frame_num, 9) remainder = remaining_frames % 4 adjusted = remaining_frames if remainder == 1 else remaining_frames + ((1 - remainder) % 4) return min(max_frame_num, max(9, adjusted)) def write_video_segment(src: Path, dst: Path, start: int, frame_num: int, fps: float) -> dict: if dst.exists(): try: existing_count = video_frame_count(dst) if existing_count == frame_num: return { "path": str(dst), "start": start, "frame_num": frame_num, "reused": True, } except Exception: pass cap = cv2.VideoCapture(str(src)) if not cap.isOpened(): raise RuntimeError(f"Could not open video: {src}") cap.set(cv2.CAP_PROP_POS_FRAMES, start) frames = [] try: for _ in range(frame_num): ok, frame = cap.read() if not ok: break frames.append(frame) finally: cap.release() if not frames: raise RuntimeError(f"No frames read from {src} at start={start}") real_frames = len(frames) while len(frames) < frame_num: frames.append(frames[-1].copy()) dst.parent.mkdir(parents=True, exist_ok=True) h, w = frames[0].shape[:2] writer = cv2.VideoWriter(str(dst), cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h)) if not writer.isOpened(): raise RuntimeError(f"Could not open writer for {dst}") try: for frame in frames: writer.write(frame) finally: writer.release() return { "path": str(dst), "start": start, "frame_num": frame_num, "real_frames": real_frames, "padded_frames": frame_num - real_frames, "reused": False, } def write_copy_through_manifest(row: dict, cam: str, work_dir: Path, stats: dict) -> Path: """Make a complete view output for cameras where the source object is not visible.""" work_dir.mkdir(parents=True, exist_ok=True) target_tag = sanitize(row["target_model"]).replace("_", "") inference_dir = work_dir / f"inference_copythrough_{target_tag}" inference_dir.mkdir(parents=True, exist_ok=True) src_video = Path(row["source"]["videos"][cam]) out_video = inference_dir / "out_video.mp4" if out_video.exists() or out_video.is_symlink(): out_video.unlink() try: out_video.symlink_to(src_video) except OSError: shutil.copy2(src_video, out_video) manifest = { "copy_through": True, "copy_through_reason": stats.get( "copy_through_reason", "target-object GT mask is empty or too small for this camera", ), "video": str(src_video), "video_info": ffprobe_video(src_video), "target": row["target_mesh"], "target_meaning": "new object reference to insert", "target_model": row["target_model"], "out_dir": str(work_dir), "seed_mask_stats": stats, "mask_source": stats.get("mask_source"), "preprocess": None, "inference_save_dir": str(inference_dir), "out_video": str(out_video), } manifest_path = work_dir / "manifest.json" manifest_path.write_text(json.dumps(manifest, indent=2, ensure_ascii=False)) return manifest_path def gt_mask_video_path(task: str, episode: int, cam: str, granularity: str = "target_object") -> Path: ep_dir = AUG_MATERIALS_ROOT / task / f"ep{episode:06d}" direct = ep_dir / f"mask_gt_{granularity}_{cam}.mp4" if direct.exists(): return direct encoded = ep_dir / "encoded_videos" / f"mask_gt_{granularity}_{cam}.mp4" if encoded.exists(): return encoded return direct def mask_video_stats(mask_video: Path, *, threshold: int = 16) -> dict: cap = cv2.VideoCapture(str(mask_video)) if not cap.isOpened(): raise RuntimeError(f"Could not open GT mask video: {mask_video}") frame_idx = 0 first_nonzero = None last_nonzero = None max_area = 0 nonzero_frames = 0 frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or None try: while True: ok, frame = cap.read() if not ok: break gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) if frame.ndim == 3 else frame area = int((gray > threshold).sum()) if area > 0: nonzero_frames += 1 if first_nonzero is None: first_nonzero = frame_idx last_nonzero = frame_idx max_area = max(max_area, area) frame_idx += 1 finally: cap.release() return { "mask_video": str(mask_video), "frame_count": frame_count or frame_idx, "decoded_frames": frame_idx, "nonzero_frames": nonzero_frames, "first_nonzero_frame": first_nonzero, "last_nonzero_frame": last_nonzero, "max_area": max_area, "threshold": threshold, } def write_gtmask_manifest(row: dict, cam: str, work_dir: Path, stats: dict, ref_images: list[Path]) -> Path: work_dir.mkdir(parents=True, exist_ok=True) target_tag = sanitize(row["target_model"]).replace("_", "") inference_dir = work_dir / f"inference_gtmask_{target_tag}" inference_dir.mkdir(parents=True, exist_ok=True) src_video = Path(row["source"]["videos"][cam]) src_mask = Path(stats["mask_video"]) ref_csv = ",".join(str(path) for path in ref_images) manifest = { "copy_through": False, "video": str(src_video), "video_info": ffprobe_video(src_video), "target": row["target_mesh"], "target_meaning": "new object reference to insert", "target_model": row["target_model"], "out_dir": str(work_dir), "mask_source": "gt_mujoco_aug_materials", "gt_mask_stats": stats, "reference_images": [str(path) for path in ref_images], "reference_views": row.get("reference_views"), "reference_view_variant": row.get("reference_view_variant"), "preprocess": { "src_video": str(src_video), "src_mask": str(src_mask), "src_ref_images": ref_csv, }, "inference_save_dir": str(inference_dir), } manifest_path = work_dir / "manifest.json" manifest_path.write_text(json.dumps(manifest, indent=2, ensure_ascii=False)) return manifest_path def find_asset_dir(target_mesh: str) -> Path: category, model = target_mesh.split("/", 1) checked: list[Path] = [] for root in ASSET_ROOTS: checked.extend([root / category / model, root / model]) for path in checked: if (path / "visual").is_dir() and any((path / "visual").glob("*.obj")): return path raise FileNotFoundError(f"Could not find visual asset for {target_mesh}; checked {checked}") def ensure_reference_images(target_mesh: str, out_root: Path, gpu: int, views: list[str] | None = None) -> list[Path]: category, model = target_mesh.split("/", 1) ref_dir = out_root / "reference_images" / f"{sanitize(category)}__{sanitize(model)}" requested_views = tuple(views or ("front", "left", "right")) refs = [ref_dir / f"{view}.png" for view in requested_views] if all(path.exists() for path in refs): return refs lock_root = out_root / "reference_images" / ".locks" lock_root.mkdir(parents=True, exist_ok=True) lock_dir = lock_root / f"{sanitize(category)}__{sanitize(model)}.lock" while True: try: lock_dir.mkdir() break except FileExistsError: if all(path.exists() for path in refs): return refs time.sleep(2.0) try: if all(path.exists() for path in refs): return refs asset_dir = find_asset_dir(target_mesh) ref_dir.mkdir(parents=True, exist_ok=True) code = f""" import os, sys os.environ.setdefault("PYOPENGL_PLATFORM", "egl") sys.path.insert(0, {str(RENDER_SCRIPT_DIR)!r}) from render_mesh_views_side import render_views ok = render_views({str(asset_dir)!r}, {str(ref_dir)!r}, resolution=512, min_distance=0.0) if not ok: raise SystemExit("render_views failed") """ env = os.environ.copy() env["CUDA_VISIBLE_DEVICES"] = str(gpu) env.setdefault("PYOPENGL_PLATFORM", "egl") log_path = out_root / "logs" / "reference_render" / f"{sanitize(category)}__{sanitize(model)}.log" log_path.parent.mkdir(parents=True, exist_ok=True) with log_path.open("a", encoding="utf-8") as log: log.write(f"$ render target={target_mesh} asset={asset_dir} out={ref_dir}\n") proc = subprocess.run( [str(RENDER_PYTHON), "-c", code], stdout=log, stderr=subprocess.STDOUT, text=True, env=env, ) log.write(f"[exit_code] {proc.returncode}\n") if proc.returncode != 0: raise RuntimeError(f"reference render failed for {target_mesh}; see {log_path}") missing = [path for path in refs if not path.exists()] if missing: raise FileNotFoundError(f"reference render missing outputs for {target_mesh}: {missing}") return refs finally: try: lock_dir.rmdir() except OSError: pass def prep_worker(args: argparse.Namespace) -> None: rows = load_assignments(args.assignments) todo = rows[args.worker_id :: args.num_workers] status_path = args.out_root / "logs" / f"prep_worker_{args.worker_id:02d}_gpu{args.gpu}.jsonl" status_path.parent.mkdir(parents=True, exist_ok=True) for row in todo: ep_dir = Path(row["source"]["extras_dir"]) for cam in CAMS: case_dir = Path(row["case_dir"]) work_dir = case_dir / f"work_{cam}" manifest_path = work_dir / "manifest.json" if manifest_path.exists() and not args.force: status = {"status": "skipped_existing", "assignment_idx": row["assignment_idx"], "camera": cam} with status_path.open("a", encoding="utf-8") as f: f.write(json.dumps(status) + "\n") continue try: mask_video = gt_mask_video_path(row["source"]["task"], int(row["source"]["episode"]), cam, "target_object") if not mask_video.exists(): raise FileNotFoundError( f"Missing GT target-object mask video for " f"{row['source']['task']} ep{int(row['source']['episode']):06d} {cam}: {mask_video}" ) stats = mask_video_stats(mask_video) stats["mask_source"] = "gt_mujoco_aug_materials" if int(stats["max_area"]) <= args.min_mask_area: stats["copy_through_reason"] = "GT target-object mask is empty or too small across the whole video" manifest_path = write_copy_through_manifest(row, cam, work_dir, stats) status = { "status": "copy_through_invisible", "assignment_idx": row["assignment_idx"], "camera": cam, "target_mesh": row["target_mesh"], "source_mesh": row["source"]["source_mesh"], "source_task": row["source"]["task"], "source_episode": row["source"]["episode"], "mask_stats": stats, "manifest": str(manifest_path), } with status_path.open("a", encoding="utf-8") as f: f.write(json.dumps(status, ensure_ascii=False) + "\n") print(json.dumps(status), flush=True) continue ref_images = ensure_reference_images( row["target_mesh"], args.out_root, args.gpu, row.get("reference_views"), ) manifest_path = write_gtmask_manifest(row, cam, work_dir, stats, ref_images) status = { "status": "ok", "returncode": 0, "assignment_idx": row["assignment_idx"], "camera": cam, "target_mesh": row["target_mesh"], "source_mesh": row["source"]["source_mesh"], "source_task": row["source"]["task"], "source_episode": row["source"]["episode"], "mask_stats": stats, "manifest": str(manifest_path), "prep_mode": "gt_mask_no_sam2", } except Exception as exc: status = { "status": "failed", "assignment_idx": row["assignment_idx"], "camera": cam, "target_mesh": row["target_mesh"], "source_mesh": row["source"]["source_mesh"], "source_task": row["source"]["task"], "source_episode": row["source"]["episode"], "error": repr(exc), } with status_path.open("a", encoding="utf-8") as f: f.write(json.dumps(status, ensure_ascii=False) + "\n") print(json.dumps(status), flush=True) def split_batch_manifests(args: argparse.Namespace) -> None: if args.assignments is not None: assignment_rows = load_assignments(args.assignments) manifests = [] for row in assignment_rows: case_dir = Path(row["case_dir"]) for cam in CAMS: manifest = case_dir / f"work_{cam}" / "manifest.json" if manifest.exists(): manifests.append(manifest) else: manifests = sorted( path for path in args.out_root.rglob("assignment_*/work_*/manifest.json") if not is_archived_path(path.relative_to(args.out_root)) ) jobs: list[dict] = [] for manifest in manifests: data = read_json(manifest) if data.get("copy_through"): continue preprocess = data["preprocess"] match = re.search(r"assignment_(\d+)_", str(manifest)) assignment_idx = int(match.group(1)) if match else 0 src_video = Path(preprocess["src_video"]) src_mask = Path(preprocess["src_mask"]) total_frames = min(video_frame_count(src_video), video_frame_count(src_mask)) fps = video_fps(src_video) starts = segment_starts(total_frames, args.frame_num) segment_rows = [] segment_root = Path(data["inference_save_dir"]) / "segments" for segment_idx, start in enumerate(starts): remaining_frames = max(1, total_frames - start) segment_frame_num = vace_segment_frame_num(remaining_frames, args.frame_num) segment_dir = segment_root / f"seg_{segment_idx:03d}_f{start:06d}" seg_src_video = segment_dir / "src_video_segment.mp4" seg_src_mask = segment_dir / "src_mask_segment.mp4" video_info = write_video_segment(src_video, seg_src_video, start, segment_frame_num, fps) mask_info = write_video_segment(src_mask, seg_src_mask, start, segment_frame_num, fps) real_frames = max(0, min(segment_frame_num, total_frames - start)) segment_max_mask_area = video_max_mask_area(seg_src_mask) segment_out_video = segment_dir / "out_video.mp4" segment_copy_through = segment_max_mask_area <= args.min_mask_area if segment_copy_through: if segment_out_video.exists() or segment_out_video.is_symlink(): segment_out_video.unlink() try: segment_out_video.symlink_to(seg_src_video) except OSError: shutil.copy2(seg_src_video, segment_out_video) segment_rows.append({ "segment_idx": segment_idx, "start_frame": start, "frame_num": segment_frame_num, "real_frames": real_frames, "padded_frames": segment_frame_num - real_frames, "copy_through_zero_mask": segment_copy_through, "segment_max_mask_area": segment_max_mask_area, "src_video_segment": str(seg_src_video), "src_mask_segment": str(seg_src_mask), "save_dir": str(segment_dir), "video_segment_info": video_info, "mask_segment_info": mask_info, }) if not segment_copy_through: jobs.append({ "name": f"{manifest.parent.relative_to(args.out_root)}/seg_{segment_idx:03d}_f{start:06d}", "src_video": str(seg_src_video), "src_mask": str(seg_src_mask), "src_ref_images": preprocess["src_ref_images"], "save_dir": str(segment_dir), "prompt": "", "base_seed": args.base_seed + assignment_idx * 1000 + segment_idx, "frame_num": segment_frame_num, }) segment_manifest = { "manifest": str(manifest), "inference_save_dir": data["inference_save_dir"], "total_frames": total_frames, "fps": fps, "max_frame_num": args.frame_num, "stride": args.frame_num - 1, "segments": segment_rows, "final_out_video": str(Path(data["inference_save_dir"]) / "out_video.mp4"), } (Path(data["inference_save_dir"]) / "segments_manifest.json").write_text( json.dumps(segment_manifest, indent=2, ensure_ascii=False) ) split_dir = args.split_dir or (args.out_root / "batch_manifests") split_dir.mkdir(parents=True, exist_ok=True) for worker_id in range(args.num_workers): out = split_dir / f"wan_worker_{worker_id:02d}.jsonl" with out.open("w", encoding="utf-8") as f: for job in jobs[worker_id :: args.num_workers]: f.write(json.dumps(job, ensure_ascii=False) + "\n") print(json.dumps({ "prepared_view_manifests": len(manifests), "wan_jobs": len(jobs), "num_workers": args.num_workers, "split_dir": str(split_dir), }, indent=2)) def stitch_one_segments_manifest(path: Path, force: bool = False) -> dict: data = read_json(path) out_video = Path(data["final_out_video"]) if out_video.exists() and not force: return {"status": "skipped_existing", "segments_manifest": str(path), "out_video": str(out_video)} total_frames = int(data["total_frames"]) fps = float(data.get("fps") or 20.0) frames_written = 0 writer = None out_video.parent.mkdir(parents=True, exist_ok=True) try: for segment in data["segments"]: seg_video = Path(segment["save_dir"]) / "out_video.mp4" if not seg_video.exists(): return { "status": "missing_segment", "segments_manifest": str(path), "missing": str(seg_video), } cap = cv2.VideoCapture(str(seg_video)) if not cap.isOpened(): return { "status": "bad_segment", "segments_manifest": str(path), "bad": str(seg_video), } frame_idx = 0 try: while frames_written < total_frames: ok, frame = cap.read() if not ok: break if int(segment["segment_idx"]) > 0 and frame_idx == 0: frame_idx += 1 continue if writer is None: h, w = frame.shape[:2] writer = cv2.VideoWriter( str(out_video), cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h), ) if not writer.isOpened(): raise RuntimeError(f"Could not open writer for {out_video}") writer.write(frame) frames_written += 1 frame_idx += 1 if frames_written >= total_frames: break finally: cap.release() finally: if writer is not None: writer.release() if frames_written != total_frames: return { "status": "incomplete", "segments_manifest": str(path), "out_video": str(out_video), "frames_written": frames_written, "expected_frames": total_frames, } return { "status": "ok", "segments_manifest": str(path), "out_video": str(out_video), "frames_written": frames_written, } def stitch_segments(args: argparse.Namespace) -> None: if args.assignments is not None: assignment_rows = load_assignments(args.assignments) paths = [] for row in assignment_rows: case_dir = Path(row["case_dir"]) for cam in CAMS: manifest = case_dir / f"work_{cam}" / "manifest.json" if not manifest.exists(): continue data = read_json(manifest) seg_manifest = Path(data["inference_save_dir"]) / "segments_manifest.json" if seg_manifest.exists(): paths.append(seg_manifest) paths = sorted(paths) else: paths = sorted( path for path in args.out_root.rglob("segments_manifest.json") if not is_archived_path(path.relative_to(args.out_root)) ) rows = [stitch_one_segments_manifest(path, force=args.force) for path in paths] out_path = args.out_root / "stitch_segments_summary.jsonl" with out_path.open("w", encoding="utf-8") as f: for row in rows: f.write(json.dumps(row, ensure_ascii=False) + "\n") counts = Counter(row["status"] for row in rows) print(json.dumps({ "segments_manifests": len(paths), "status_counts": dict(sorted(counts.items())), "summary": str(out_path), }, indent=2)) bad = {k: v for k, v in counts.items() if k not in {"ok", "skipped_existing"}} if bad: raise SystemExit(2) def make_parser() -> argparse.ArgumentParser: p = argparse.ArgumentParser() sub = p.add_subparsers(dest="cmd", required=True) b = sub.add_parser("build") b.add_argument("--dataset-root", type=Path, default=ROBOCASA_ROOT) b.add_argument("--out-root", type=Path, required=True) b.add_argument("--per-mesh", type=int, default=40) b.add_argument("--targets", nargs="*") b.add_argument("--require-visible-all-cams", action="store_true") b.add_argument("--min-mask-area", type=int, default=8) b.add_argument("--visibility-workers", type=int, default=24) w = sub.add_parser("prep-worker") w.add_argument("--assignments", type=Path, required=True) w.add_argument("--out-root", type=Path, required=True) w.add_argument("--worker-id", type=int, required=True) w.add_argument("--num-workers", type=int, required=True) w.add_argument("--gpu", type=int, required=True) w.add_argument("--base-seed", type=int, default=2025) w.add_argument("--min-mask-area", type=int, default=8) w.add_argument("--force", action="store_true") s = sub.add_parser("split-wan") s.add_argument("--out-root", type=Path, required=True) s.add_argument("--assignments", type=Path) s.add_argument("--split-dir", type=Path) s.add_argument("--num-workers", type=int, required=True) s.add_argument("--base-seed", type=int, default=2025) s.add_argument("--frame-num", type=int, default=81) s.add_argument("--min-mask-area", type=int, default=8) st = sub.add_parser("stitch-segments") st.add_argument("--out-root", type=Path, required=True) st.add_argument("--assignments", type=Path) st.add_argument("--force", action="store_true") return p def main() -> int: args = make_parser().parse_args() if args.cmd == "build": build_assignments(args) elif args.cmd == "prep-worker": prep_worker(args) elif args.cmd == "split-wan": split_batch_manifests(args) elif args.cmd == "stitch-segments": stitch_segments(args) return 0 if __name__ == "__main__": raise SystemExit(main())