| |
| """Render one overlay video: tracked 3D object + HaWoR hands on the RGB clip. |
| |
| Uses the optimized camera-frame layout when present (hand-anchored scale), |
| otherwise the combined layout from Fast-SAM3D. |
| |
| python viz_object_motion.py --video-dir /path/to/runs/<seq> |
| |
| Writes: <video-dir>/obj_tracking_out/<object>/object_motion.mp4 |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import sys |
|
|
| import cv2 |
| import numpy as np |
| import torch |
| from scipy.spatial.transform import Rotation as R |
| from pytorch3d.io import load_objs_as_meshes |
| from pytorch3d.structures import Meshes |
| from pytorch3d.renderer import TexturesVertex |
|
|
| from run_project_mesh_combined import ( |
| DirectoryVideoReader, |
| _parse_rgb, |
| make_renderer, |
| read_video_frame, |
| render_combined, |
| render_mesh, |
| transform_to_camera_frame, |
| ) |
|
|
|
|
| def parse_args(): |
| p = argparse.ArgumentParser( |
| description="One MP4 of 3D object + hand motion overlaid on the demo video.", |
| formatter_class=argparse.ArgumentDefaultsHelpFormatter, |
| ) |
| p.add_argument("--video-dir", required=True, help="Pipeline run directory") |
| p.add_argument("--object", default=None, help="Object id (default: config.json)") |
| p.add_argument("--video", default=None, help="RGB source (mp4 or all_frames/). Default: clip.mp4") |
| p.add_argument("--mesh", default=None, help="Object .obj (default: SAM-3D mesh on ref frame)") |
| p.add_argument("--json", default=None, help="Layout JSON (prefers optimized camera-frame)") |
| p.add_argument("--hand-meshes", default=None, help="HaWoR all_hand_meshes.npz") |
| p.add_argument( |
| "--hands", |
| default="auto", |
| choices=["auto", "left", "right", "both", "none"], |
| help="Hands to overlay. auto = config.json anchor_hand (one side). " |
| "both also drops near-camera ghost meshes (unused HaWoR side).", |
| ) |
| p.add_argument("--output", default=None, help="Output mp4 path") |
| p.add_argument("--fps", type=float, default=30.0) |
| p.add_argument( |
| "--object-color", |
| default="0.15,0.85,0.45", |
| help="Solid overlay RGB in 0-1 as r,g,b", |
| ) |
| p.add_argument("--left-hand-color", default="0.95,0.35,0.35") |
| p.add_argument("--right-hand-color", default="0.35,0.45,0.95") |
| p.add_argument( |
| "--alpha", |
| type=float, |
| default=0.72, |
| help="Mesh overlay opacity on the video", |
| ) |
| p.add_argument("--device", default="auto", choices=["auto", "cpu", "cuda"]) |
| return p.parse_args() |
|
|
|
|
| def _object_id(video_dir, explicit): |
| if explicit: |
| return explicit.replace(" ", "_") |
| cfg = os.path.join(video_dir, "config.json") |
| if os.path.isfile(cfg): |
| with open(cfg) as f: |
| names = json.load(f).get("object_names") or [] |
| if names: |
| return str(names[0]).replace(" ", "_") |
| print("[error] pass --object or put object_names in config.json") |
| sys.exit(1) |
|
|
|
|
| def _ref_frame(video_dir): |
| cfg = os.path.join(video_dir, "config.json") |
| if os.path.isfile(cfg): |
| with open(cfg) as f: |
| return int(json.load(f).get("frame_number", 0)) |
| return 0 |
|
|
|
|
| def _anchor_hand(video_dir): |
| cfg = os.path.join(video_dir, "config.json") |
| if os.path.isfile(cfg): |
| with open(cfg) as f: |
| h = json.load(f).get("anchor_hand") |
| if h in ("left", "right"): |
| return h |
| return "right" |
|
|
|
|
| def _layout_json(video_dir, obj_id, explicit): |
| if explicit: |
| return explicit |
| root = os.path.join(video_dir, "obj_tracking_out", obj_id, "combined_visualization") |
| for name in ( |
| "layout_camera_frame_optimized.json", |
| "layout_camera_frame.json", |
| "layout.json", |
| ): |
| path = os.path.join(root, name) |
| if os.path.isfile(path): |
| return path |
| print(f"[error] no layout JSON under {root}") |
| sys.exit(1) |
|
|
|
|
| def _mesh_path(video_dir, obj_id, explicit): |
| if explicit: |
| return explicit |
| n = _ref_frame(video_dir) |
| path = os.path.join( |
| video_dir, |
| "video_segmentation", |
| "masks", |
| f"frame_{n:06d}_masks", |
| obj_id, |
| f"{obj_id}.obj", |
| ) |
| return path |
|
|
|
|
| def _rgb_source(video_dir, explicit): |
| if explicit: |
| return explicit |
| clip = os.path.join(video_dir, "clip.mp4") |
| frames = os.path.join(video_dir, "all_frames") |
| if os.path.isfile(clip): |
| return clip |
| if os.path.isdir(frames): |
| return frames |
| print("[error] need clip.mp4 or all_frames/ (or pass --video)") |
| sys.exit(1) |
|
|
|
|
| def _hand_meshes_npz(video_dir, explicit): |
| if explicit: |
| return explicit |
| clip = os.path.join(video_dir, "clip", "all_hand_meshes.npz") |
| if os.path.isfile(clip): |
| return clip |
| try: |
| for name in os.listdir(video_dir): |
| path = os.path.join(video_dir, name, "all_hand_meshes.npz") |
| if os.path.isfile(path): |
| return path |
| except FileNotFoundError: |
| pass |
| return None |
|
|
|
|
| def _hand_valid(hand_data, hand, frame_idx): |
| key = f"{hand}_valid" |
| if key not in hand_data.files: |
| return True |
| v = np.asarray(hand_data[key]) |
| if frame_idx >= v.shape[0]: |
| return False |
| val = np.asarray(v[frame_idx]).reshape(-1) |
| if val.size == 0: |
| return True |
| return bool(val.flat[0]) |
|
|
|
|
| def _hand_depth_ok(verts, min_median_z=0.15): |
| """Skip unused HaWoR side: infiller parks that mesh at the camera (z~0).""" |
| z = np.asarray(verts)[:, 2] |
| if not np.isfinite(z).all(): |
| return False |
| return float(np.median(z)) >= min_median_z |
|
|
|
|
| def main(): |
| args = parse_args() |
| video_dir = os.path.abspath(args.video_dir) |
| obj_id = _object_id(video_dir, args.object) |
| layout_path = _layout_json(video_dir, obj_id, args.json) |
| mesh_path = _mesh_path(video_dir, obj_id, args.mesh) |
| video_path = _rgb_source(video_dir, args.video) |
| out_path = args.output or os.path.join( |
| video_dir, "obj_tracking_out", obj_id, "object_motion.mp4" |
| ) |
|
|
| if args.device == "auto": |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") |
| else: |
| device = torch.device(args.device) |
|
|
| print(f"device: {device}", flush=True) |
| print(f"layout: {layout_path}", flush=True) |
| print(f"mesh: {mesh_path}", flush=True) |
| print(f"video: {video_path}", flush=True) |
| print(f"output: {out_path}", flush=True) |
|
|
| hand_npz = None if args.hands == "none" else _hand_meshes_npz(video_dir, args.hand_meshes) |
| hand_data = None |
| hands_to_render = [] |
| if args.hands != "none": |
| if not hand_npz or not os.path.isfile(hand_npz): |
| print("[error] HaWoR all_hand_meshes.npz not found (pass --hand-meshes or --hands none)") |
| sys.exit(1) |
| hand_data = np.load(hand_npz) |
| if args.hands == "auto": |
| hands_to_render = [_anchor_hand(video_dir)] |
| elif args.hands == "both": |
| hands_to_render = ["left", "right"] |
| else: |
| hands_to_render = [args.hands] |
| print(f"hands: {hand_npz} ({', '.join(hands_to_render)})", flush=True) |
| hand_colors = { |
| "left": _parse_rgb(args.left_hand_color), |
| "right": _parse_rgb(args.right_hand_color), |
| } |
|
|
| with open(layout_path) as f: |
| data = json.load(f) |
| objects = [o for o in data.get("objects", []) if "frame_idx" in o] |
| objects.sort(key=lambda o: o["frame_idx"]) |
| if not objects: |
| print("[error] layout has no frame_idx objects") |
| sys.exit(1) |
|
|
| fallback_intr = None |
| for obj in objects: |
| if "intrinsics_normalized" in obj: |
| fallback_intr = obj["intrinsics_normalized"] |
| break |
| if fallback_intr is None: |
| print("[error] layout has no intrinsics_normalized") |
| sys.exit(1) |
|
|
| is_camera_frame = data.get("frame") == "camera_frame" |
| override_scale = None |
| tso = data.get("translation_scale_optimization") or {} |
| if is_camera_frame and "mesh_scale" in tso: |
| override_scale = float(tso["mesh_scale"]) |
| print(f"using optimized mesh_scale={override_scale:.6f}") |
|
|
| if not os.path.isfile(mesh_path): |
| print(f"[error] mesh not found: {mesh_path}") |
| sys.exit(1) |
| mesh = load_objs_as_meshes([mesh_path], device=device) |
| rgb = _parse_rgb(args.object_color) |
| verts_list = mesh.verts_list() |
| faces_list = mesh.faces_list() |
| n_verts = verts_list[0].shape[0] |
| color_t = torch.tensor(rgb, dtype=torch.float32, device=device) |
| mesh = Meshes( |
| verts=verts_list, |
| faces=faces_list, |
| textures=TexturesVertex(verts_features=color_t.expand(n_verts, 3).unsqueeze(0)), |
| ) |
|
|
| if os.path.isdir(video_path): |
| frame_source = DirectoryVideoReader(video_path) |
| width, height = frame_source.width, frame_source.height |
| cap = None |
| else: |
| cap = cv2.VideoCapture(video_path) |
| width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) |
| height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) |
| frame_source = None |
|
|
| renderer_cache = {} |
|
|
| def get_renderer(intr, W, H): |
| fx = intr["fx_norm"] * W |
| fy = intr["fy_norm"] * H |
| cx = intr.get("cx_norm", 0.5) * W |
| cy = intr.get("cy_norm", 0.5) * H |
| key = (round(fx, 4), round(fy, 4), round(cx, 4), round(cy, 4), W, H) |
| if key not in renderer_cache: |
| renderer_cache[key] = make_renderer(fx, fy, cx, cy, W, H, device) |
| return renderer_cache[key] |
|
|
| os.makedirs(os.path.dirname(os.path.abspath(out_path)), exist_ok=True) |
| fourcc = cv2.VideoWriter_fourcc(*"mp4v") |
| tmp_avi = out_path + ".tmp.avi" |
| writer = cv2.VideoWriter(tmp_avi, fourcc, args.fps, (width, height)) |
| if not writer.isOpened(): |
| print("[error] could not open video writer") |
| sys.exit(1) |
|
|
| last_read_idx = -1 |
| n_ok = 0 |
| blend = float(np.clip(args.alpha, 0.0, 1.0)) |
| for i, obj in enumerate(objects): |
| frame_idx = obj["frame_idx"] |
| lts = obj["local_to_scene"] |
| scale = override_scale if override_scale is not None else lts["scale"][0] |
| if is_camera_frame: |
| quat = lts["quat_wxyz_camera_frame"] |
| translation = list(lts["translation_camera_frame"]) |
| else: |
| quat = lts["new_quat"] |
| tx, ty, tz = lts["translation"] |
| translation = [tz, tx, ty] |
|
|
| if frame_source is not None: |
| frame_rgb = frame_source.read_frame(frame_idx) |
| else: |
| frame_rgb, last_read_idx = read_video_frame(cap, frame_idx, last_read_idx) |
| if frame_rgb is None: |
| print(f" skip frame {frame_idx} (no RGB)") |
| continue |
|
|
| renderer = get_renderer(obj.get("intrinsics_normalized", fallback_intr), width, height) |
| quat_xyzw = np.array([quat[1], quat[2], quat[3], quat[0]]) |
| rot_matrix = R.from_quat(quat_xyzw).as_matrix() |
|
|
| obj_verts_cam = transform_to_camera_frame( |
| mesh.verts_packed(), rot_matrix, translation, scale, device, |
| camera_frame=is_camera_frame, |
| ) |
| meshes_data = [(obj_verts_cam, mesh.faces_packed(), rgb)] |
| n_hand_frames = None |
| if hand_data is not None: |
| n_hand_frames = int(hand_data["right_vertices"].shape[0]) |
| if frame_idx < n_hand_frames: |
| for hand in hands_to_render: |
| verts_np = np.asarray(hand_data[f"{hand}_vertices"][frame_idx]) |
| if not _hand_valid(hand_data, hand, frame_idx): |
| continue |
| if not _hand_depth_ok(verts_np): |
| continue |
| verts = torch.tensor(verts_np, dtype=torch.float32, device=device) |
| faces = torch.tensor( |
| hand_data[f"{hand}_faces"], dtype=torch.int64, device=device, |
| ) |
| meshes_data.append((verts, faces, hand_colors[hand])) |
|
|
| if len(meshes_data) > 1: |
| render_rgb, render_alpha = render_combined(meshes_data, renderer, device) |
| else: |
| render_rgb, render_alpha = render_mesh( |
| mesh, rot_matrix, translation, scale, renderer, device, |
| camera_frame=is_camera_frame, |
| ) |
| render_u8 = (render_rgb * 255).clip(0, 255).astype(np.uint8) |
| mask = render_alpha > 0.5 |
| result = frame_rgb.copy() |
| result[mask] = ( |
| (1.0 - blend) * result[mask].astype(np.float32) |
| + blend * render_u8[mask].astype(np.float32) |
| ).clip(0, 255).astype(np.uint8) |
| cv2.putText( |
| result, |
| f"frame {frame_idx}", |
| (12, 28), |
| cv2.FONT_HERSHEY_SIMPLEX, |
| 0.7, |
| (255, 255, 255), |
| 2, |
| cv2.LINE_AA, |
| ) |
| writer.write(cv2.cvtColor(result, cv2.COLOR_RGB2BGR)) |
| n_ok += 1 |
| if (i + 1) % 10 == 0 or i == 0: |
| print(f" [{i+1}/{len(objects)}] frame {frame_idx}", flush=True) |
|
|
| writer.release() |
| if cap is not None: |
| cap.release() |
|
|
| |
| import subprocess |
| cmd = [ |
| "ffmpeg", "-y", "-i", tmp_avi, |
| "-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", "18", |
| out_path, |
| ] |
| subprocess.run(cmd, check=True) |
| os.remove(tmp_avi) |
| print(f"Wrote {n_ok} frames -> {out_path}", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
