| |
| """ |
| Lightweight AnchorWorld human-pose and scene-pose visualizer. |
| |
| Dependencies: |
| numpy, torch, smplx, ffmpeg |
| |
| The human is rendered as a 22-joint SMPL-X skeleton. Scene poses are rendered |
| as camera frustums in the same coordinate system. No GVHMR, PyTorch3D, OpenCV, |
| or custom renderer is required. |
| """ |
|
|
| import argparse |
| import math |
| import shutil |
| import subprocess |
| import sys |
| from pathlib import Path |
| from typing import Any, Dict, List, Optional, Sequence, Tuple |
|
|
| import numpy as np |
|
|
|
|
| SMPL22_PARENTS = [ |
| -1, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, |
| 8, 9, 9, 9, 12, 13, 14, 16, 17, 18, 19, |
| ] |
| LEFT_JOINTS = {1, 4, 7, 10, 13, 16, 18, 20} |
| RIGHT_JOINTS = {2, 5, 8, 11, 14, 17, 19, 21} |
| CAMERA_COLORS = [ |
| (245, 90, 85), |
| (80, 200, 120), |
| (90, 150, 245), |
| (235, 180, 70), |
| (190, 105, 235), |
| (70, 205, 215), |
| ] |
|
|
|
|
| def import_torch(): |
| try: |
| import torch |
| except ImportError as exc: |
| raise RuntimeError( |
| "PyTorch is required. Install dependencies with: " |
| "pip install -r requirements-visualization.txt" |
| ) from exc |
| return torch |
|
|
|
|
| def load_file(path: Path) -> Any: |
| if not path.is_file(): |
| raise FileNotFoundError(f"File not found: {path}") |
|
|
| if path.suffix.lower() in {".pt", ".pth"}: |
| torch = import_torch() |
| try: |
| return torch.load(path, map_location="cpu", weights_only=False) |
| except TypeError: |
| return torch.load(path, map_location="cpu") |
|
|
| if path.suffix.lower() == ".npy": |
| return np.load(path, allow_pickle=False) |
|
|
| raise ValueError(f"Unsupported file format: {path.suffix}. Use .pt or .npy.") |
|
|
|
|
| def to_numpy(value: Any) -> np.ndarray: |
| if isinstance(value, np.ndarray): |
| return value |
| if hasattr(value, "detach"): |
| return value.detach().cpu().numpy() |
| return np.asarray(value) |
|
|
|
|
| def expand_frames(tensor, frame_count: int, name: str): |
| if tensor.shape[0] == frame_count: |
| return tensor |
| if tensor.shape[0] == 1: |
| return tensor.expand(frame_count, *tensor.shape[1:]) |
| raise ValueError( |
| f"{name} has {tensor.shape[0]} frames; expected 1 or {frame_count}." |
| ) |
|
|
|
|
| def resolve_smplx_root(model_dir: Path) -> Path: |
| """Accept either the model root or the root/smplx directory.""" |
| direct_model = model_dir / "SMPLX_NEUTRAL.npz" |
| nested_model = model_dir / "smplx" / "SMPLX_NEUTRAL.npz" |
|
|
| if nested_model.is_file(): |
| return model_dir |
| if direct_model.is_file() and model_dir.name.lower() == "smplx": |
| return model_dir.parent |
|
|
| raise FileNotFoundError( |
| "SMPLX_NEUTRAL.npz was not found. Expected either:\n" |
| f" {nested_model}\n" |
| f"or:\n {direct_model}" |
| ) |
|
|
|
|
| def joints_from_smplx(params: Dict[str, Any], model_dir: Path) -> np.ndarray: |
| torch = import_torch() |
| try: |
| import smplx |
| except ImportError as exc: |
| raise RuntimeError("Install SMPL-X with: pip install smplx") from exc |
|
|
| if "global_orient" not in params or "body_pose" not in params: |
| raise KeyError("SMPL-X parameters must contain global_orient and body_pose.") |
|
|
| global_orient = torch.as_tensor(params["global_orient"]).float() |
| body_pose = torch.as_tensor(params["body_pose"]).float() |
|
|
| if global_orient.ndim == 1: |
| global_orient = global_orient.unsqueeze(0) |
| if body_pose.ndim == 1: |
| body_pose = body_pose.unsqueeze(0) |
|
|
| frame_count = max(global_orient.shape[0], body_pose.shape[0]) |
| global_orient = expand_frames(global_orient, frame_count, "global_orient") |
| body_pose = expand_frames(body_pose, frame_count, "body_pose") |
|
|
| matrix_pose = ( |
| global_orient.shape[-2:] == (3, 3) |
| and body_pose.shape[-2:] == (3, 3) |
| ) |
| if matrix_pose: |
| if global_orient.ndim == 3: |
| global_orient = global_orient.unsqueeze(1) |
| if body_pose.ndim != 4: |
| raise ValueError("Matrix body_pose must have shape [F, J, 3, 3].") |
| pose2rot = False |
| else: |
| if global_orient.ndim == 3 and global_orient.shape[1:] == (1, 3): |
| global_orient = global_orient[:, 0] |
| if body_pose.ndim == 3 and body_pose.shape[-1] == 3: |
| body_pose = body_pose.reshape(frame_count, -1) |
| if global_orient.shape[-1] != 3 or body_pose.ndim != 2: |
| raise ValueError("Invalid axis-angle SMPL-X parameter shape.") |
| pose2rot = True |
|
|
| transl = torch.as_tensor( |
| params.get("transl", torch.zeros(frame_count, 3)) |
| ).float() |
| if transl.ndim == 1: |
| transl = transl.unsqueeze(0) |
| transl = expand_frames(transl, frame_count, "transl") |
|
|
| betas = torch.as_tensor( |
| params.get("betas", torch.zeros(frame_count, 10)) |
| ).float() |
| if betas.ndim == 1: |
| betas = betas.unsqueeze(0) |
| if betas.ndim > 2: |
| betas = betas.reshape(betas.shape[0], -1) |
| betas = expand_frames(betas, frame_count, "betas") |
|
|
| model_root = resolve_smplx_root(model_dir) |
| model = smplx.create( |
| str(model_root), |
| model_type="smplx", |
| gender="neutral", |
| ext="npz", |
| use_pca=False, |
| num_betas=betas.shape[-1], |
| batch_size=frame_count, |
| ) |
|
|
| with torch.no_grad(): |
| output = model( |
| global_orient=global_orient, |
| body_pose=body_pose, |
| betas=betas, |
| transl=transl, |
| pose2rot=pose2rot, |
| return_verts=False, |
| ) |
|
|
| return output.joints[:, :22].cpu().numpy().astype(np.float32) |
|
|
|
|
| def load_human_joints(path: Path, model_dir: Optional[Path]) -> np.ndarray: |
| data = load_file(path) |
|
|
| if not isinstance(data, dict): |
| joints = to_numpy(data) |
| else: |
| joints = None |
| for key in ("joints_global", "global_joints", "joints", "pred_joints"): |
| if key in data: |
| joints = to_numpy(data[key]) |
| break |
|
|
| if joints is None: |
| if model_dir is None: |
| raise ValueError( |
| "--smplx-model-dir is required for SMPL-X parameter files." |
| ) |
| params = data.get("smpl_params_global", data) |
| if not isinstance(params, dict): |
| raise ValueError("Could not find smpl_params_global.") |
| joints = joints_from_smplx(params, model_dir) |
|
|
| if joints.ndim != 3 or joints.shape[-1] != 3: |
| raise ValueError("Human joints must have shape [frames, joints, 3].") |
| if joints.shape[1] < 22: |
| raise ValueError("At least 22 SMPL joints are required.") |
| return joints[:, :22].astype(np.float32) |
|
|
|
|
| def extract_scene_array(data: Any) -> np.ndarray: |
| if not isinstance(data, dict): |
| return to_numpy(data) |
|
|
| for key in ( |
| "scene_pose", "scene_poses", "camera_pose", "camera_poses", |
| "extrinsics", "poses", "c2w", "c2ws", |
| ): |
| if key in data: |
| return to_numpy(data[key]) |
|
|
| arrays = [ |
| value for value in data.values() |
| if isinstance(value, np.ndarray) or hasattr(value, "shape") |
| ] |
| if len(arrays) == 1: |
| return to_numpy(arrays[0]) |
| raise ValueError("Could not identify the scene-pose array.") |
|
|
|
|
| def normalize_scene_shape(array: np.ndarray) -> np.ndarray: |
| """ |
| Return camera poses in [views, frames, 3, 4]. |
| |
| Supported inputs: |
| [3,4], [4,4], [12] |
| [F,3,4], [V,3,4], [F,12] |
| [V,F,3,4], [V,F,4,4], [V,F,12] |
| """ |
| poses = np.asarray(array, dtype=np.float32) |
|
|
| if poses.shape[-2:] == (4, 4): |
| poses = poses[..., :3, :4] |
| elif poses.shape[-1:] == (12,): |
| poses = poses.reshape(*poses.shape[:-1], 3, 4) |
|
|
| if poses.shape[-2:] != (3, 4): |
| raise ValueError(f"Unsupported scene-pose shape: {poses.shape}") |
|
|
| if poses.ndim == 2: |
| return poses[None, None] |
|
|
| if poses.ndim == 3: |
| |
| return poses[:, None] if poses.shape[0] <= 16 else poses[None] |
|
|
| if poses.ndim == 4: |
| |
| return poses |
|
|
| raise ValueError(f"Unsupported scene-pose shape: {poses.shape}") |
|
|
|
|
| def w2c_to_c2w(poses: np.ndarray) -> np.ndarray: |
| rotation = poses[..., :3] |
| translation = poses[..., 3] |
| rotation_inv = np.swapaxes(rotation, -1, -2) |
| translation_inv = -np.einsum( |
| "...ij,...j->...i", rotation_inv, translation |
| ) |
| return np.concatenate( |
| [rotation_inv, translation_inv[..., None]], axis=-1 |
| ) |
|
|
|
|
| def load_scene_poses(path: Path, convention: str) -> np.ndarray: |
| poses = normalize_scene_shape(extract_scene_array(load_file(path))) |
| if convention == "w2c": |
| poses = w2c_to_c2w(poses) |
| return poses.astype(np.float32) |
|
|
|
|
| def scale_camera_distance( |
| poses: np.ndarray, |
| human_center: np.ndarray, |
| distance_scale: float, |
| ) -> np.ndarray: |
| """ |
| Move camera centers toward or away from the human without changing rotation. |
| |
| scale=1.0: original camera positions |
| scale=0.5: half the original distance to the human center |
| scale=0.0: camera centers at the human center |
| scale>1.0: cameras move farther away |
| """ |
| scaled = poses.copy() |
| camera_centers = scaled[..., :3, 3] |
| scaled[..., :3, 3] = ( |
| human_center + distance_scale * (camera_centers - human_center) |
| ) |
| return scaled |
|
|
|
|
| def unit(vector: np.ndarray) -> np.ndarray: |
| norm = float(np.linalg.norm(vector)) |
| if norm < 1e-8: |
| raise ValueError("Cannot normalize a zero vector.") |
| return vector / norm |
|
|
|
|
| def view_basis(azimuth_degrees: float, elevation_degrees: float): |
| azimuth = math.radians(azimuth_degrees) |
| elevation = math.radians(elevation_degrees) |
| eye_direction = np.array( |
| [ |
| math.cos(elevation) * math.sin(azimuth), |
| math.sin(elevation), |
| math.cos(elevation) * math.cos(azimuth), |
| ], |
| dtype=np.float32, |
| ) |
| forward = unit(-eye_direction) |
| world_up = np.array([0.0, 1.0, 0.0], dtype=np.float32) |
| right = unit(np.cross(forward, world_up)) |
| up = unit(np.cross(right, forward)) |
| return right, up |
|
|
|
|
| def project( |
| points: np.ndarray, |
| center: np.ndarray, |
| right: np.ndarray, |
| up: np.ndarray, |
| scale: float, |
| width: int, |
| height: int, |
| ) -> np.ndarray: |
| relative = points - center |
| pixels = np.empty((len(points), 2), dtype=np.float32) |
| pixels[:, 0] = width * 0.5 + (relative @ right) * scale |
| pixels[:, 1] = height * 0.52 - (relative @ up) * scale |
| return np.rint(pixels).astype(np.int32) |
|
|
|
|
| def draw_disc( |
| image: np.ndarray, |
| center: Sequence[int], |
| radius: int, |
| color: Tuple[int, int, int], |
| ) -> None: |
| x, y = int(center[0]), int(center[1]) |
| height, width = image.shape[:2] |
| x0, x1 = max(0, x - radius), min(width, x + radius + 1) |
| y0, y1 = max(0, y - radius), min(height, y + radius + 1) |
| if x0 >= x1 or y0 >= y1: |
| return |
| yy, xx = np.ogrid[y0:y1, x0:x1] |
| mask = (xx - x) ** 2 + (yy - y) ** 2 <= radius ** 2 |
| image[y0:y1, x0:x1][mask] = color |
|
|
|
|
| def draw_line( |
| image: np.ndarray, |
| start: Sequence[int], |
| end: Sequence[int], |
| color: Tuple[int, int, int], |
| width: int, |
| ) -> None: |
| x0, y0 = int(start[0]), int(start[1]) |
| x1, y1 = int(end[0]), int(end[1]) |
| steps = max(abs(x1 - x0), abs(y1 - y0), 1) + 1 |
| xs = np.rint(np.linspace(x0, x1, steps)).astype(np.int32) |
| ys = np.rint(np.linspace(y0, y1, steps)).astype(np.int32) |
| for x, y in zip(xs, ys): |
| draw_disc(image, (x, y), max(0, width // 2), color) |
|
|
|
|
| def camera_frustum(depth: float, aspect: float = 16.0 / 9.0) -> np.ndarray: |
| half_height = depth * 0.22 |
| half_width = half_height * aspect |
| return np.array( |
| [ |
| [0.0, 0.0, 0.0], |
| [-half_width, -half_height, depth], |
| [half_width, -half_height, depth], |
| [half_width, half_height, depth], |
| [-half_width, half_height, depth], |
| ], |
| dtype=np.float32, |
| ) |
|
|
|
|
| def transform(points: np.ndarray, c2w: np.ndarray) -> np.ndarray: |
| return points @ c2w[:, :3].T + c2w[:, 3] |
|
|
|
|
| def scene_frame_index(human_index: int, human_frames: int, scene_frames: int) -> int: |
| if human_frames <= 1 or scene_frames <= 1: |
| return 0 |
| return int(round(human_index / (human_frames - 1) * (scene_frames - 1))) |
|
|
|
|
| def ground_grid( |
| center: np.ndarray, |
| ground_y: float, |
| extent: float, |
| ) -> List[Tuple[np.ndarray, np.ndarray]]: |
| lines = [] |
| for offset in np.linspace(-extent, extent, 11): |
| lines.append(( |
| np.array([center[0] - extent, ground_y, center[2] + offset]), |
| np.array([center[0] + extent, ground_y, center[2] + offset]), |
| )) |
| lines.append(( |
| np.array([center[0] + offset, ground_y, center[2] - extent]), |
| np.array([center[0] + offset, ground_y, center[2] + extent]), |
| )) |
| return lines |
|
|
|
|
| def render_frame( |
| joints: np.ndarray, |
| scene_poses: np.ndarray, |
| center: np.ndarray, |
| right: np.ndarray, |
| up: np.ndarray, |
| image_scale: float, |
| width: int, |
| height: int, |
| grid: List[Tuple[np.ndarray, np.ndarray]], |
| frustum: np.ndarray, |
| ) -> np.ndarray: |
| image = np.full((height, width, 3), (18, 20, 26), dtype=np.uint8) |
|
|
| for start, end in grid: |
| pixels = project( |
| np.stack([start, end]), center, right, up, |
| image_scale, width, height, |
| ) |
| draw_line(image, pixels[0], pixels[1], (50, 55, 65), 1) |
|
|
| edges = [ |
| (0, 1), (0, 2), (0, 3), (0, 4), |
| (1, 2), (2, 3), (3, 4), (4, 1), |
| ] |
| for view_index, pose in enumerate(scene_poses): |
| color = CAMERA_COLORS[view_index % len(CAMERA_COLORS)] |
| pixels = project( |
| transform(frustum, pose), center, right, up, |
| image_scale, width, height, |
| ) |
| for start, end in edges: |
| draw_line(image, pixels[start], pixels[end], color, 3) |
| draw_line(image, pixels[3], pixels[4], (80, 245, 110), 4) |
| draw_disc(image, pixels[0], 5, color) |
|
|
| joint_pixels = project( |
| joints, center, right, up, image_scale, width, height |
| ) |
| for joint_index, parent_index in enumerate(SMPL22_PARENTS): |
| if parent_index < 0: |
| continue |
| if joint_index in LEFT_JOINTS: |
| color = (75, 205, 245) |
| elif joint_index in RIGHT_JOINTS: |
| color = (245, 155, 70) |
| else: |
| color = (230, 235, 245) |
| draw_line( |
| image, joint_pixels[parent_index], joint_pixels[joint_index], |
| color, 5, |
| ) |
|
|
| for joint_index, pixel in enumerate(joint_pixels): |
| if joint_index in LEFT_JOINTS: |
| color = (75, 205, 245) |
| elif joint_index in RIGHT_JOINTS: |
| color = (245, 155, 70) |
| else: |
| color = (240, 240, 245) |
| draw_disc(image, pixel, 5, color) |
|
|
| return image |
|
|
|
|
| class VideoWriter: |
| def __init__(self, output: Path, width: int, height: int, fps: float): |
| ffmpeg = shutil.which("ffmpeg") |
| if ffmpeg is None: |
| raise RuntimeError("ffmpeg is required but was not found.") |
|
|
| output.parent.mkdir(parents=True, exist_ok=True) |
| command = [ |
| ffmpeg, "-y", "-loglevel", "error", |
| "-f", "rawvideo", "-pix_fmt", "rgb24", |
| "-s", f"{width}x{height}", "-r", str(fps), "-i", "-", |
| "-an", "-c:v", "libx264", "-pix_fmt", "yuv420p", str(output), |
| ] |
| self.process = subprocess.Popen( |
| command, stdin=subprocess.PIPE, stderr=subprocess.PIPE |
| ) |
|
|
| def write(self, frame: np.ndarray) -> None: |
| if self.process.stdin is None: |
| raise RuntimeError("ffmpeg input pipe is unavailable.") |
| self.process.stdin.write(np.ascontiguousarray(frame).tobytes()) |
|
|
| def close(self) -> None: |
| if self.process.stdin is not None: |
| self.process.stdin.close() |
| stderr = self.process.stderr.read() if self.process.stderr else b"" |
| self.process.wait() |
| if self.process.returncode: |
| raise RuntimeError(stderr.decode("utf-8", errors="replace")) |
|
|
|
|
| def visualize(args: argparse.Namespace) -> None: |
| if args.width % 2 or args.height % 2: |
| raise ValueError("--width and --height must be even.") |
| if args.stride < 1: |
| raise ValueError("--stride must be at least 1.") |
| if args.camera_distance_scale < 0: |
| raise ValueError("--camera-distance-scale cannot be negative.") |
|
|
| human_path = Path(args.human_pose).expanduser().resolve() |
| scene_path = Path(args.scene_pose).expanduser().resolve() |
| output_path = Path(args.output).expanduser().resolve() |
| model_dir = ( |
| Path(args.smplx_model_dir).expanduser().resolve() |
| if args.smplx_model_dir else None |
| ) |
|
|
| print(f"Loading human pose: {human_path}") |
| joints = load_human_joints(human_path, model_dir) |
|
|
| print(f"Loading scene pose: {scene_path}") |
| scene_poses = load_scene_poses(scene_path, args.scene_convention) |
|
|
| frame_indices = list(range(0, len(joints), args.stride)) |
| if args.max_frames is not None: |
| frame_indices = frame_indices[:args.max_frames] |
| if not frame_indices: |
| raise ValueError("No frames selected.") |
|
|
| selected_joints = joints[frame_indices] |
| human_center = ( |
| selected_joints.reshape(-1, 3).min(axis=0) |
| + selected_joints.reshape(-1, 3).max(axis=0) |
| ) * 0.5 |
|
|
| scene_poses = scale_camera_distance( |
| scene_poses, human_center, args.camera_distance_scale |
| ) |
|
|
| camera_centers = scene_poses[..., :3, 3].reshape(-1, 3) |
| bounds = np.concatenate( |
| [selected_joints.reshape(-1, 3), camera_centers], axis=0 |
| ) |
| view_center = (bounds.min(axis=0) + bounds.max(axis=0)) * 0.5 |
| radius = max( |
| float(np.linalg.norm(bounds - view_center, axis=1).max()), |
| 1.0, |
| ) |
| image_scale = 0.43 * min(args.width, args.height) / radius * args.zoom |
|
|
| human_size = float(np.max( |
| selected_joints.reshape(-1, 3).max(axis=0) |
| - selected_joints.reshape(-1, 3).min(axis=0) |
| )) |
| frustum = camera_frustum(max(0.15, human_size * args.frustum_scale)) |
| right, up = view_basis(args.azimuth, args.elevation) |
| grid = ground_grid( |
| view_center, |
| float(selected_joints[..., 1].min()), |
| radius, |
| ) |
|
|
| print( |
| f"Rendering {len(frame_indices)} frames, " |
| f"{scene_poses.shape[0]} scene views, " |
| f"camera distance scale={args.camera_distance_scale}" |
| ) |
|
|
| writer = VideoWriter(output_path, args.width, args.height, args.fps) |
| try: |
| for output_index, human_index in enumerate(frame_indices): |
| current_scene_poses = [] |
| for view_index in range(scene_poses.shape[0]): |
| scene_index = scene_frame_index( |
| human_index, len(joints), scene_poses.shape[1] |
| ) |
| current_scene_poses.append(scene_poses[view_index, scene_index]) |
|
|
| frame = render_frame( |
| joints[human_index], |
| np.stack(current_scene_poses), |
| view_center, |
| right, |
| up, |
| image_scale, |
| args.width, |
| args.height, |
| grid, |
| frustum, |
| ) |
| writer.write(frame) |
|
|
| if output_index == 0 or (output_index + 1) % 10 == 0: |
| print(f" rendered {output_index + 1}/{len(frame_indices)}") |
| finally: |
| writer.close() |
|
|
| print(f"Saved: {output_path}") |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser( |
| description="Visualize AnchorWorld human pose and scene cameras." |
| ) |
| parser.add_argument("--human-pose", required=True) |
| parser.add_argument("--scene-pose", required=True) |
| parser.add_argument("--smplx-model-dir") |
| parser.add_argument("--output", default="pose_scene_preview.mp4") |
| parser.add_argument( |
| "--scene-convention", |
| choices=("c2w", "w2c"), |
| default="c2w", |
| ) |
| parser.add_argument( |
| "--camera-distance-scale", |
| type=float, |
| default=1.0, |
| help=( |
| "Scale camera distance around the human center. " |
| "1.0 keeps original positions; 0.5 halves the distance." |
| ), |
| ) |
| parser.add_argument("--fps", type=float, default=15.0) |
| parser.add_argument("--width", type=int, default=960) |
| parser.add_argument("--height", type=int, default=720) |
| parser.add_argument("--stride", type=int, default=1) |
| parser.add_argument("--max-frames", type=int) |
| parser.add_argument("--azimuth", type=float, default=-55.0) |
| parser.add_argument("--elevation", type=float, default=25.0) |
| parser.add_argument("--zoom", type=float, default=1.0) |
| parser.add_argument("--frustum-scale", type=float, default=0.35) |
| return parser |
|
|
|
|
| def main() -> int: |
| parser = build_parser() |
| try: |
| visualize(parser.parse_args()) |
| except (KeyError, RuntimeError, ValueError, FileNotFoundError) as exc: |
| parser.error(str(exc)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
