#!/usr/bin/env python3 """ Prepare one SMPL-X sequence using the local SMPL-X Blender add-on. This script is intended to run inside Blender: blender -b --python scripts/prepare_sequence_from_blender_addon.py -- ... It uses the add-on's bundled SMPL-X locked-head model to create a skinned mesh, applies one fixed body shape for the sequence, applies the input pose per frame, then exports evaluated vertices plus an approximate COCO-WholeBody 133 skeleton. Face keypoints are intentionally disabled for v1. """ from __future__ import annotations import argparse import importlib import json import math import sys import tempfile from pathlib import Path from typing import Any import bpy import mathutils import numpy as np COCO_WHOLEBODY_FACE_SLICE = slice(23, 91) LEFT_HAND_SLICE = slice(91, 112) RIGHT_HAND_SLICE = slice(112, 133) SMPLX_VERTEX_IDS = { "nose": 9120, "reye": 9929, "leye": 9448, "rear": 616, "lear": 6, "rthumb": 8079, "rindex": 7669, "rmiddle": 7794, "rring": 7905, "rpinky": 8022, "lthumb": 5361, "lindex": 4933, "lmiddle": 5058, "lring": 5169, "lpinky": 5286, "LBigToe": 5770, "LSmallToe": 5780, "LHeel": 8846, "RBigToe": 8463, "RSmallToe": 8474, "RHeel": 8635, } DEFAULT_ADDON_DIR = Path(__file__).resolve().parents[1] / "addons" / "smplx_blender_addon" SMPLX_BONE_ORDER = ( "pelvis", "left_hip", "right_hip", "spine1", "left_knee", "right_knee", "spine2", "left_ankle", "right_ankle", "spine3", "left_foot", "right_foot", "neck", "left_collar", "right_collar", "head", "left_shoulder", "right_shoulder", "left_elbow", "right_elbow", "left_wrist", "right_wrist", "jaw", "left_eye_smplhf", "right_eye_smplhf", "left_index1", "left_index2", "left_index3", "left_middle1", "left_middle2", "left_middle3", "left_pinky1", "left_pinky2", "left_pinky3", "left_ring1", "left_ring2", "left_ring3", "left_thumb1", "left_thumb2", "left_thumb3", "right_index1", "right_index2", "right_index3", "right_middle1", "right_middle2", "right_middle3", "right_pinky1", "right_pinky2", "right_pinky3", "right_ring1", "right_ring2", "right_ring3", "right_thumb1", "right_thumb2", "right_thumb3", ) def parse_blender_args() -> argparse.Namespace: argv = sys.argv if "--" in argv: argv = argv[argv.index("--") + 1 :] else: argv = [] parser = argparse.ArgumentParser() parser.add_argument("--npz", required=True, type=Path) parser.add_argument("--out-dir", required=True, type=Path) parser.add_argument("--addon-dir", default=DEFAULT_ADDON_DIR, type=Path) parser.add_argument("--gender", default="auto", choices=["auto", "neutral", "male", "female"]) parser.add_argument("--model-variant", default="locked_head", choices=["locked_head", "v1.1"]) parser.add_argument("--uv-version", default="UV_2023", choices=["UV_2023", "UV_2021"]) parser.add_argument("--pose-key", default=None) parser.add_argument("--betas-key", default=None) parser.add_argument("--transl-key", default=None) parser.add_argument("--expression-key", default=None) parser.add_argument("--framerate-key", default=None) parser.add_argument("--frames", default=None, help="Source frame spec start:end:stride. Default exports all frames.") parser.add_argument("--motion-slowdown", type=int, default=2, help="Integer temporal upsampling factor. 2 inserts one SLERP midpoint; 1 disables.") parser.add_argument("--max-output-frames", type=int, default=121, help="Maximum frames after interpolation. 0 keeps the full interpolated sequence.") parser.add_argument("--output-fps", type=int, default=16, help="Final renderer/video FPS, recorded in sequence metadata.") parser.add_argument("--random-betas", action="store_true") parser.add_argument("--ignore-input-betas", action="store_true") parser.add_argument("--beta-seed", type=int, default=42) parser.add_argument("--beta-std", type=float, default=1.0) parser.add_argument("--beta-clip", type=float, default=2.0) parser.add_argument("--num-betas", type=int, default=10) parser.add_argument("--disable-face", action="store_true", default=True) parser.add_argument("--enable-face", dest="disable_face", action="store_false") parser.add_argument("--anim-format", default="SMPL-X", choices=["SMPL-X", "AMASS"]) parser.add_argument("--ignore-global-orient", action="store_true") parser.add_argument("--zero-spine1", action="store_true") parser.add_argument("--center-xy", action="store_true", default=True) parser.add_argument("--no-center-xy", dest="center_xy", action="store_false") parser.add_argument("--ground-plane", action="store_true", default=True) parser.add_argument("--no-ground-plane", dest="ground_plane", action="store_false") return parser.parse_args(argv) def load_npz_array(npz: np.lib.npyio.NpzFile, key: str | None, fallback_keys: list[str]) -> np.ndarray | None: if key: if key not in npz: raise KeyError(f"Key '{key}' not found in npz. Available keys: {list(npz.keys())}") return np.asarray(npz[key]) for candidate in fallback_keys: if candidate in npz: return np.asarray(npz[candidate]) return None def normalize_pose_55(pose: np.ndarray) -> np.ndarray: pose = np.asarray(pose, dtype=np.float32) if pose.ndim == 3 and pose.shape[1:] == (55, 3): return pose if pose.ndim == 2 and pose.shape[1] == 165: return pose.reshape(pose.shape[0], 55, 3) if pose.ndim == 1 and pose.shape[0] == 165: return pose.reshape(1, 55, 3) raise ValueError(f"Pose must be [F,55,3], [F,165], or [165]. Got {pose.shape}.") def normalize_transl(transl: np.ndarray | None, num_frames: int) -> np.ndarray: if transl is None: return np.zeros((num_frames, 3), dtype=np.float32) transl = np.asarray(transl, dtype=np.float32) if transl.ndim == 1 and transl.shape[0] == 3: return np.broadcast_to(transl[None, :], (num_frames, 3)).copy() if transl.ndim == 2 and transl.shape == (num_frames, 3): return transl.copy() raise ValueError(f"transl must be [3] or [F,3]. Got {transl.shape}.") def normalize_expression(expression: np.ndarray | None, num_frames: int) -> np.ndarray | None: if expression is None: return None expression = np.asarray(expression, dtype=np.float32) if expression.ndim == 1: return np.broadcast_to(expression[None, :], (num_frames, expression.shape[0])).copy() if expression.ndim == 2 and expression.shape[0] == num_frames: return expression.copy() raise ValueError(f"expression must be [E] or [F,E]. Got {expression.shape}.") def parse_frame_spec(frame_spec: str | None, num_frames: int) -> list[int]: if frame_spec is None: return list(range(num_frames)) parts = frame_spec.split(":") if len(parts) not in (2, 3): raise ValueError("--frames must be start:end or start:end:stride") start = int(parts[0]) end = int(parts[1]) stride = int(parts[2]) if len(parts) == 3 else 1 if stride <= 0 or start < 0 or end > num_frames or start >= end: raise ValueError(f"Invalid frame range {frame_spec} for num_frames={num_frames}.") return list(range(start, end, stride)) def axis_angle_to_quaternion(axis_angle: np.ndarray) -> np.ndarray: """Convert [..., 3] rotation vectors to unit quaternions [w, x, y, z].""" axis_angle = np.asarray(axis_angle, dtype=np.float64) angle = np.linalg.norm(axis_angle, axis=-1, keepdims=True) half = 0.5 * angle scale = np.empty_like(angle) small = angle < 1e-8 scale[small] = 0.5 scale[~small] = np.sin(half[~small]) / angle[~small] quat = np.concatenate((np.cos(half), axis_angle * scale), axis=-1) quat /= np.maximum(np.linalg.norm(quat, axis=-1, keepdims=True), 1e-12) return quat def quaternion_to_axis_angle(quat: np.ndarray) -> np.ndarray: """Convert unit quaternions to the canonical shortest rotation vectors.""" quat = np.asarray(quat, dtype=np.float64) quat /= np.maximum(np.linalg.norm(quat, axis=-1, keepdims=True), 1e-12) # q and -q encode the same rotation. w >= 0 gives an angle in [0, pi]. quat = np.where((quat[..., :1] < 0.0), -quat, quat) xyz = quat[..., 1:] xyz_norm = np.linalg.norm(xyz, axis=-1, keepdims=True) angle = 2.0 * np.arctan2(xyz_norm, np.clip(quat[..., :1], -1.0, 1.0)) scale = np.empty_like(xyz_norm) small = xyz_norm < 1e-8 scale[small] = 2.0 scale[~small] = angle[~small] / xyz_norm[~small] return (xyz * scale).astype(np.float32) def quaternion_slerp(q0: np.ndarray, q1: np.ndarray, alpha: float) -> np.ndarray: """Vectorized shortest-path SLERP for matching arrays of quaternions.""" q0 = np.asarray(q0, dtype=np.float64) q1 = np.asarray(q1, dtype=np.float64) dot = np.sum(q0 * q1, axis=-1, keepdims=True) q1 = np.where(dot < 0.0, -q1, q1) dot = np.clip(np.abs(dot), 0.0, 1.0) near = dot > 0.9995 theta = np.arccos(dot) sin_theta = np.sin(theta) safe_sin = np.where(np.abs(sin_theta) < 1e-8, 1.0, sin_theta) s0 = np.sin((1.0 - alpha) * theta) / safe_sin s1 = np.sin(alpha * theta) / safe_sin spherical = s0 * q0 + s1 * q1 linear = (1.0 - alpha) * q0 + alpha * q1 out = np.where(near, linear, spherical) out /= np.maximum(np.linalg.norm(out, axis=-1, keepdims=True), 1e-12) return out def interpolate_motion( pose_55: np.ndarray, transl: np.ndarray, expression: np.ndarray | None, factor: int, ) -> tuple[np.ndarray, np.ndarray, np.ndarray | None, np.ndarray]: """Upsample selected poses without duplicating shared segment endpoints.""" if factor < 1: raise ValueError("--motion-slowdown must be an integer >= 1") frame_count = pose_55.shape[0] if frame_count == 0: raise ValueError("Cannot interpolate an empty motion sequence") if factor == 1 or frame_count == 1: positions = np.arange(frame_count, dtype=np.float32) return pose_55.copy(), transl.copy(), None if expression is None else expression.copy(), positions pose_quat = axis_angle_to_quaternion(pose_55) out_count = (frame_count - 1) * factor + 1 out_pose = np.empty((out_count, 55, 3), dtype=np.float32) out_transl = np.empty((out_count, 3), dtype=np.float32) out_expression = None if expression is None else np.empty((out_count, expression.shape[1]), dtype=np.float32) positions = np.arange(out_count, dtype=np.float32) / float(factor) out_idx = 0 for source_idx in range(frame_count - 1): for substep in range(factor): alpha = substep / float(factor) if substep == 0: out_pose[out_idx] = pose_55[source_idx] else: out_pose[out_idx] = quaternion_to_axis_angle( quaternion_slerp(pose_quat[source_idx], pose_quat[source_idx + 1], alpha) ) out_transl[out_idx] = (1.0 - alpha) * transl[source_idx] + alpha * transl[source_idx + 1] if out_expression is not None: out_expression[out_idx] = ((1.0 - alpha) * expression[source_idx] + alpha * expression[source_idx + 1]) out_idx += 1 out_pose[-1] = pose_55[-1] out_transl[-1] = transl[-1] if out_expression is not None: out_expression[-1] = expression[-1] return out_pose, out_transl, out_expression, positions def jsonable(value: Any) -> Any: if isinstance(value, np.ndarray): return value.tolist() if isinstance(value, (np.integer, np.floating)): return value.item() if isinstance(value, Path): return str(value) return value def enable_addon(addon_dir: Path) -> None: addon_dir = addon_dir.resolve() if not addon_dir.exists(): raise FileNotFoundError(f"SMPL-X Blender addon not found: {addon_dir}") parent = addon_dir.parent if str(parent) not in sys.path: sys.path.insert(0, str(parent)) module = importlib.import_module(addon_dir.name) # Registering twice is harmless in the common background case after reload, # but Blender may raise if a class is already registered. try: module.register() except ValueError: pass def create_smplx_body(gender: str, model_variant: str, uv_version: str): wm_tool = bpy.context.window_manager.smplx_tool wm_tool.body_model = "smplx" wm_tool.smplx_gender = gender wm_tool.smplx_version = model_variant wm_tool.smplx_uv = uv_version wm_tool.smplx_handpose = "flat" result = bpy.ops.scene.smplx_add_gender() if "FINISHED" not in result: raise RuntimeError(f"bpy.ops.scene.smplx_add_gender failed: {result}") obj = bpy.context.view_layer.objects.active if obj is None or obj.type != "MESH": raise RuntimeError("SMPL-X addon did not leave an active mesh object.") armature = obj.parent if armature is None or armature.type != "ARMATURE": raise RuntimeError(f"SMPL-X mesh '{obj.name}' has no armature parent.") obj.name = "SMPLX_BODY_PREP" armature.name = "SMPLX_ARMATURE_PREP" return obj, armature def resolve_gender(data: np.lib.npyio.NpzFile, requested: str) -> str: if requested != "auto": return requested if "gender" not in data: return "neutral" gender = str(np.asarray(data["gender"]).item()).lower() if gender not in {"neutral", "male", "female"}: return "neutral" return gender def choose_betas( data: np.lib.npyio.NpzFile, betas_key: str | None, num_betas: int, random_betas: bool, ignore_input_betas: bool, beta_seed: int, beta_std: float, beta_clip: float, ) -> np.ndarray: if random_betas or ignore_input_betas: rng = np.random.default_rng(beta_seed) betas = rng.normal(0.0, beta_std, size=(num_betas,)).astype(np.float32) return np.clip(betas, -beta_clip, beta_clip).astype(np.float32) betas_raw = load_npz_array(data, betas_key, ["betas", "beta", "shape", "shapes"]) if betas_raw is None: return np.zeros((num_betas,), dtype=np.float32) betas_raw = np.asarray(betas_raw, dtype=np.float32) if betas_raw.ndim == 2: betas_raw = betas_raw[0] if betas_raw.ndim != 1: raise ValueError(f"betas must be [B] or [F,B]. Got {betas_raw.shape}.") out = np.zeros((num_betas,), dtype=np.float32) out[: min(num_betas, betas_raw.shape[0])] = betas_raw[:num_betas] return out def scalar_string(value: Any, default: str) -> str: if value is None: return default arr = np.asarray(value) try: item = arr.item() except ValueError: item = arr.reshape(-1)[0] if isinstance(item, bytes): return item.decode("utf-8") return str(item) def addon_ready_pose(pose_55: np.ndarray) -> np.ndarray: """SMPL-X add-on animation import expects poses as [F, 165], not [F, 55, 3].""" return np.asarray(pose_55, dtype=np.float32).reshape(pose_55.shape[0], 165) def write_addon_npz( source_data: np.lib.npyio.NpzFile, out_path: Path, pose_55: np.ndarray, transl: np.ndarray, expression: np.ndarray | None, betas: np.ndarray, gender: str, mocap_framerate: int, ) -> None: """Write a normalized SMPL-X npz for bpy.ops.object.smplx_add_animation.""" payload: dict[str, Any] = {} for key in source_data.files: value = source_data[key] if key in {"poses", "pose", "smplx_poses", "smplx_pose", "trans", "transl", "translation", "translations", "betas", "beta", "shape", "shapes", "gender", "expression", "expressions", "expr", "smplx_expr"}: continue payload[key] = value payload["poses"] = addon_ready_pose(pose_55) payload["trans"] = np.asarray(transl, dtype=np.float32) if expression is not None: payload["expression"] = np.asarray(expression, dtype=np.float32) payload["betas"] = np.asarray(betas, dtype=np.float32) payload["gender"] = np.asarray(gender) payload["mocap_framerate"] = np.asarray(int(mocap_framerate), dtype=np.int32) np.savez(out_path, **payload) def import_addon_animation( npz_path: Path, target_framerate: int, model_variant: str, uv_version: str, ) -> tuple[bpy.types.Object, bpy.types.Object]: wm_tool = bpy.context.window_manager.smplx_tool wm_tool.body_model = "smplx" wm_tool.smplx_version = model_variant wm_tool.smplx_uv = uv_version result = bpy.ops.object.smplx_add_animation( filepath=str(npz_path), anim_format="SMPL-X", keyframe_corrective_pose_weights=True, target_framerate=int(target_framerate), hand_reference="FLAT", ) if "FINISHED" not in result: raise RuntimeError(f"bpy.ops.object.smplx_add_animation failed: {result}") obj = bpy.context.view_layer.objects.active if obj is None or obj.type != "MESH": meshes = [candidate for candidate in bpy.context.scene.objects if candidate.type == "MESH" and candidate.get("body_model") == "smplx"] if not meshes: raise RuntimeError("SMPL-X addon animation import did not create an active SMPL-X mesh.") obj = meshes[-1] armature = obj.parent if armature is None or armature.type != "ARMATURE": raise RuntimeError(f"Imported SMPL-X mesh '{obj.name}' has no armature parent.") obj.name = "SMPLX_BODY_PREP" armature.name = "SMPLX_ARMATURE_PREP" return obj, armature def set_sequence_betas(obj: bpy.types.Object, betas: np.ndarray) -> None: key_blocks = obj.data.shape_keys.key_blocks for key_block in key_blocks: if key_block.name.startswith("Shape"): key_block.value = 0.0 for index, beta in enumerate(betas): name = f"Shape{index:03d}" if name not in key_blocks: raise KeyError(f"Missing SMPL-X shape key: {name}") key_block = key_blocks[name] value = float(beta) if value < key_block.slider_min: key_block.slider_min = value if value > key_block.slider_max: key_block.slider_max = value key_block.value = value bpy.context.view_layer.objects.active = obj bpy.ops.object.smplx_update_joint_locations("EXEC_DEFAULT") def set_expression(obj: bpy.types.Object, expr: np.ndarray | None) -> None: key_blocks = obj.data.shape_keys.key_blocks for key_block in key_blocks: if key_block.name.startswith("Exp"): key_block.value = 0.0 if expr is None: return for index, value in enumerate(np.asarray(expr).reshape(-1)): name = f"Exp{index:03d}" if name not in key_blocks: break key_block = key_blocks[name] value = float(value) if value < key_block.slider_min: key_block.slider_min = value if value > key_block.slider_max: key_block.slider_max = value key_block.value = value def set_pose_frame( obj: bpy.types.Object, armature: bpy.types.Object, pose_55: np.ndarray, transl: np.ndarray, expression: np.ndarray | None, set_pose_from_rodrigues, anim_format: str, ) -> None: bpy.context.view_layer.objects.active = obj set_expression(obj, expression) for bone_index, bone_name in enumerate(SMPLX_BONE_ORDER): bone = armature.pose.bones[bone_name] if bone.rotation_mode != "QUATERNION": bone.rotation_mode = "QUATERNION" if bone_name == "pelvis": bone.location = mathutils.Vector((float(transl[0]), float(transl[1]), float(transl[2]))) set_pose_from_rodrigues(armature, bone_name, pose_55[bone_index]) if anim_format == "AMASS": root = armature.pose.bones["root"] if root.rotation_mode != "QUATERNION": root.rotation_mode = "QUATERNION" root.rotation_quaternion = mathutils.Quaternion((1.0, 0.0, 0.0), math.radians(-90.0)) bpy.ops.object.smplx_set_poseshapes("EXEC_DEFAULT") bpy.context.view_layer.update() def evaluated_vertices(obj: bpy.types.Object) -> np.ndarray: depsgraph = bpy.context.evaluated_depsgraph_get() obj_eval = obj.evaluated_get(depsgraph) mesh = obj_eval.to_mesh() try: vertices = np.empty((len(mesh.vertices), 3), dtype=np.float32) mesh.vertices.foreach_get("co", vertices.reshape(-1)) return vertices finally: obj_eval.to_mesh_clear() def mesh_faces(obj: bpy.types.Object) -> np.ndarray: faces: list[list[int]] = [] for poly in obj.data.polygons: if len(poly.vertices) == 3: faces.append([int(v) for v in poly.vertices]) elif len(poly.vertices) == 4: v = [int(x) for x in poly.vertices] faces.append([v[0], v[1], v[2]]) faces.append([v[0], v[2], v[3]]) else: verts = [int(x) for x in poly.vertices] for i in range(1, len(verts) - 1): faces.append([verts[0], verts[i], verts[i + 1]]) return np.asarray(faces, dtype=np.int32) def to_obj_local(obj: bpy.types.Object, armature: bpy.types.Object, point_armature_local: mathutils.Vector) -> np.ndarray: world = armature.matrix_world @ point_armature_local local = obj.matrix_world.inverted() @ world return np.asarray((local.x, local.y, local.z), dtype=np.float32) def bone_head(obj: bpy.types.Object, armature: bpy.types.Object, name: str) -> np.ndarray | None: bone = armature.pose.bones.get(name) if bone is None: return None return to_obj_local(obj, armature, bone.head) def bone_tail(obj: bpy.types.Object, armature: bpy.types.Object, name: str) -> np.ndarray | None: bone = armature.pose.bones.get(name) if bone is None: return None return to_obj_local(obj, armature, bone.tail) def set_point(out: np.ndarray, mask: np.ndarray, idx: int, value: np.ndarray | None) -> None: if value is None: return out[idx] = value mask[idx] = 1 def vertex_point(vertices: np.ndarray, vertex_id: int) -> np.ndarray | None: if vertex_id < 0 or vertex_id >= vertices.shape[0]: return None return np.asarray(vertices[vertex_id], dtype=np.float32) def interp(a: np.ndarray | None, b: np.ndarray | None, t: float) -> np.ndarray | None: if a is None or b is None: return None return (1.0 - t) * a + t * b def add_offset(point: np.ndarray | None, offset: tuple[float, float, float]) -> np.ndarray | None: if point is None: return None return point + np.asarray(offset, dtype=np.float32) def finger_points( obj: bpy.types.Object, armature: bpy.types.Object, vertices: np.ndarray, side: str, finger: str, ) -> list[np.ndarray | None]: b1 = f"{side}_{finger}1" b2 = f"{side}_{finger}2" b3 = f"{side}_{finger}3" prefix = "l" if side == "left" else "r" return [ bone_head(obj, armature, b1), bone_head(obj, armature, b2), bone_head(obj, armature, b3), vertex_point(vertices, SMPLX_VERTEX_IDS[prefix + finger]), ] def fill_hand( out: np.ndarray, mask: np.ndarray, obj: bpy.types.Object, armature: bpy.types.Object, vertices: np.ndarray, side: str, start: int, ) -> None: wrist = bone_head(obj, armature, f"{side}_wrist") set_point(out, mask, start, wrist) offset = 1 # COCO hand order: thumb, index, middle, ring, pinky. for finger in ("thumb", "index", "middle", "ring", "pinky"): for point in finger_points(obj, armature, vertices, side, finger): set_point(out, mask, start + offset, point) offset += 1 def coco133_from_frame( obj: bpy.types.Object, armature: bpy.types.Object, vertices: np.ndarray, disable_face: bool, ) -> tuple[np.ndarray, np.ndarray]: out = np.zeros((133, 3), dtype=np.float32) mask = np.zeros((133,), dtype=np.uint8) pelvis = bone_head(obj, armature, "pelvis") neck = bone_head(obj, armature, "neck") head = bone_head(obj, armature, "head") l_sh = bone_head(obj, armature, "left_shoulder") r_sh = bone_head(obj, armature, "right_shoulder") l_hip = bone_head(obj, armature, "left_hip") r_hip = bone_head(obj, armature, "right_hip") l_ankle = bone_head(obj, armature, "left_ankle") r_ankle = bone_head(obj, armature, "right_ankle") l_foot = bone_head(obj, armature, "left_foot") r_foot = bone_head(obj, armature, "right_foot") eye_dx = 0.035 ear_dx = 0.075 set_point(out, mask, 0, vertex_point(vertices, SMPLX_VERTEX_IDS["nose"])) set_point(out, mask, 1, vertex_point(vertices, SMPLX_VERTEX_IDS["leye"])) set_point(out, mask, 2, vertex_point(vertices, SMPLX_VERTEX_IDS["reye"])) set_point(out, mask, 3, vertex_point(vertices, SMPLX_VERTEX_IDS["lear"])) set_point(out, mask, 4, vertex_point(vertices, SMPLX_VERTEX_IDS["rear"])) set_point(out, mask, 5, l_sh) set_point(out, mask, 6, r_sh) set_point(out, mask, 7, bone_head(obj, armature, "left_elbow")) set_point(out, mask, 8, bone_head(obj, armature, "right_elbow")) set_point(out, mask, 9, bone_head(obj, armature, "left_wrist")) set_point(out, mask, 10, bone_head(obj, armature, "right_wrist")) set_point(out, mask, 11, l_hip) set_point(out, mask, 12, r_hip) set_point(out, mask, 13, bone_head(obj, armature, "left_knee")) set_point(out, mask, 14, bone_head(obj, armature, "right_knee")) set_point(out, mask, 15, l_ankle) set_point(out, mask, 16, r_ankle) set_point(out, mask, 17, vertex_point(vertices, SMPLX_VERTEX_IDS["LBigToe"])) set_point(out, mask, 18, vertex_point(vertices, SMPLX_VERTEX_IDS["LSmallToe"])) set_point(out, mask, 19, vertex_point(vertices, SMPLX_VERTEX_IDS["LHeel"])) set_point(out, mask, 20, vertex_point(vertices, SMPLX_VERTEX_IDS["RBigToe"])) set_point(out, mask, 21, vertex_point(vertices, SMPLX_VERTEX_IDS["RSmallToe"])) set_point(out, mask, 22, vertex_point(vertices, SMPLX_VERTEX_IDS["RHeel"])) fill_hand(out, mask, obj, armature, vertices, "left", LEFT_HAND_SLICE.start) fill_hand(out, mask, obj, armature, vertices, "right", RIGHT_HAND_SLICE.start) if disable_face: out[COCO_WHOLEBODY_FACE_SLICE, :] = 0.0 mask[COCO_WHOLEBODY_FACE_SLICE] = 0 return out, mask def prepare_sequence(args: argparse.Namespace) -> None: args.out_dir.mkdir(parents=True, exist_ok=True) data = np.load(args.npz, allow_pickle=True) pose_raw = load_npz_array(data, args.pose_key, ["poses", "pose", "smplx_poses", "smplx_pose"]) if pose_raw is None: raise KeyError(f"Could not find pose key. Available keys: {list(data.keys())}") pose_55 = normalize_pose_55(pose_raw) if args.ignore_global_orient: pose_55 = pose_55.copy() pose_55[:, 0, :] = 0.0 if args.zero_spine1: pose_55 = pose_55.copy() pose_55[:, 3, :] = 0.0 num_source_frames = pose_55.shape[0] selected_source_indices = parse_frame_spec(args.frames, num_source_frames) transl = normalize_transl(load_npz_array(data, args.transl_key, ["trans", "transl", "translation", "translations"]), num_source_frames) expression = normalize_expression( load_npz_array(data, args.expression_key, ["smplx_expr", "expression", "expressions", "expr"]), num_source_frames, ) pose_55 = pose_55[selected_source_indices] transl = transl[selected_source_indices] if expression is not None: expression = expression[selected_source_indices] num_selected_source_frames = pose_55.shape[0] pose_55, transl, expression, selected_positions = interpolate_motion( pose_55=pose_55, transl=transl, expression=expression, factor=args.motion_slowdown, ) # Convert local selected-frame positions back to coordinates in the original NPZ. source_indices_np = np.asarray(selected_source_indices, dtype=np.float32) lo = np.floor(selected_positions).astype(np.int64) hi = np.minimum(lo + 1, len(selected_source_indices) - 1) alpha = selected_positions - lo.astype(np.float32) original_frame_positions = ((1.0 - alpha) * source_indices_np[lo] + alpha * source_indices_np[hi]) if args.max_output_frames < 0: raise ValueError("--max-output-frames must be >= 0") num_interpolated_frames_before_limit = pose_55.shape[0] if args.max_output_frames: limit = min(args.max_output_frames, pose_55.shape[0]) pose_55 = pose_55[:limit] transl = transl[:limit] original_frame_positions = original_frame_positions[:limit] if expression is not None: expression = expression[:limit] output_frame_indices = list(range(pose_55.shape[0])) gender = resolve_gender(data, args.gender) betas = choose_betas( data=data, betas_key=args.betas_key, num_betas=args.num_betas, random_betas=args.random_betas, ignore_input_betas=args.ignore_input_betas, beta_seed=args.beta_seed, beta_std=args.beta_std, beta_clip=args.beta_clip, ) framerate = load_npz_array(data, args.framerate_key, ["mocap_framerate", "mocap_frame_rate"]) if framerate is None: mocap_framerate = 30 else: mocap_framerate = int(np.asarray(framerate).reshape(-1)[0]) addon_npz_path = args.out_dir / "_addon_import_sequence.npz" write_addon_npz( source_data=data, out_path=addon_npz_path, pose_55=pose_55, transl=transl, expression=expression, betas=betas, gender=gender, mocap_framerate=mocap_framerate, ) obj, armature = import_addon_animation( addon_npz_path, target_framerate=mocap_framerate, model_variant=args.model_variant, uv_version=args.uv_version, ) faces = mesh_faces(obj) vertices_all: list[np.ndarray] = [] coco_all: list[np.ndarray] = [] mask_all: list[np.ndarray] = [] for out_frame_idx in output_frame_indices: print( f"[prepare] frame {out_frame_idx + 1}/{len(output_frame_indices)} " f"source_position={original_frame_positions[out_frame_idx]:.4f}" ) bpy.context.scene.frame_set(out_frame_idx + 1) set_expression(obj, None if expression is None else expression[out_frame_idx]) bpy.context.view_layer.update() frame_vertices = evaluated_vertices(obj) vertices_all.append(frame_vertices) coco, mask = coco133_from_frame(obj, armature, frame_vertices, disable_face=args.disable_face) coco_all.append(coco) mask_all.append(mask) vertices_np = np.stack(vertices_all, axis=0).astype(np.float32) coco_np = np.stack(coco_all, axis=0).astype(np.float32) mask_np = np.stack(mask_all, axis=0).astype(np.uint8) normalization_offset = np.zeros((3,), dtype=np.float32) if args.center_xy: xy_min = vertices_np[:, :, :2].reshape(-1, 2).min(axis=0) xy_max = vertices_np[:, :, :2].reshape(-1, 2).max(axis=0) normalization_offset[:2] = (xy_min + xy_max) * 0.5 if args.ground_plane: normalization_offset[2] = vertices_np[:, :, 2].min() vertices_np = vertices_np - normalization_offset[None, None, :] coco_np = coco_np - normalization_offset[None, None, :] coco_np[:, COCO_WHOLEBODY_FACE_SLICE, :] = 0.0 np.save(args.out_dir / "vertices.npy", vertices_np) np.save(args.out_dir / "faces.npy", faces) np.save(args.out_dir / "coco133_3d.npy", coco_np) np.save(args.out_dir / "coco133_mask.npy", mask_np) meta = { "source_npz": str(args.npz), "num_source_frames": int(num_source_frames), "num_selected_source_frames": int(num_selected_source_frames), "num_interpolated_frames_before_limit": int(num_interpolated_frames_before_limit), "num_frames": int(vertices_np.shape[0]), "source_frame_indices": selected_source_indices, "output_source_frame_positions": original_frame_positions, "motion_slowdown": int(args.motion_slowdown), "max_output_frames": int(args.max_output_frames), "output_fps": int(args.output_fps), "num_vertices": int(vertices_np.shape[1]), "num_faces": int(faces.shape[0]), "keypoint_format": "coco_wholebody_133", "coco_source": "smplx_blender_addon_armature_plus_official_smplx_vertex_ids_v2", "smplx_vertex_ids_source": "vchoutas/smplx vertex_ids.py", "smplx_vertex_ids": SMPLX_VERTEX_IDS, "face_disabled": bool(args.disable_face), "pose_shape": list(pose_55.shape), "transl_shape": list(transl.shape), "expression_shape": list(expression.shape) if expression is not None else None, "gender": gender, "betas": betas, "betas_source": "random" if (args.random_betas or args.ignore_input_betas) else "input_or_zero", "beta_seed": args.beta_seed, "beta_std": args.beta_std, "beta_clip": args.beta_clip, "addon_dir": str(args.addon_dir), "model_variant": args.model_variant, "uv_version": args.uv_version, "anim_format": "SMPL-X", "ignore_global_orient": bool(args.ignore_global_orient), "zero_spine1": bool(args.zero_spine1), "addon_import_npz": str(addon_npz_path), "addon_import_operator": "bpy.ops.object.smplx_add_animation", "keyframe_corrective_pose_weights": True, "normalization": { "center_xy": bool(args.center_xy), "ground_plane": bool(args.ground_plane), "offset_subtracted": normalization_offset, }, "mocap_framerate": mocap_framerate, "notes": "Selected source poses are temporally interpolated before the official SMPL-X Blender addon import; renderer and COCO consume the resulting capped sequence without further interpolation.", } with open(args.out_dir / "meta.json", "w", encoding="utf-8") as f: json.dump(meta, f, indent=2, default=jsonable) print(f"[OK] Saved Blender-addon sequence cache to {args.out_dir}") def main() -> None: args = parse_blender_args() enable_addon(args.addon_dir) prepare_sequence(args) if __name__ == "__main__": main()