#!/usr/bin/env python3 """Shared Blender rendering helpers for the SMPL-X COCO pipeline.""" from __future__ import annotations import json import shutil import subprocess from pathlib import Path import bpy import mathutils import numpy as np def parse_csv_values(value: str | None) -> list[str]: if not value: return [] return [item.strip() for item in value.split(",") if item.strip()] def encode_video_ffmpeg(frame_paths: list[Path], output_mp4: Path, fps: int, crf: int) -> bool: """Encode an ordered list of PNG frames to MP4 without assuming frame numbers are contiguous.""" if not frame_paths: raise ValueError("No frames were provided for video encoding.") ffmpeg = shutil.which("ffmpeg") if ffmpeg is None: print("[WARN] ffmpeg not found; skip MP4 encoding.") return False output_mp4.parent.mkdir(parents=True, exist_ok=True) concat_path = output_mp4.with_suffix(".ffconcat.txt") with open(concat_path, "w", encoding="utf-8") as f: f.write("ffconcat version 1.0\n") for frame_path in frame_paths: safe_path = str(frame_path.resolve()).replace("\\", "/").replace("'", "'\\''") f.write(f"file '{safe_path}'\n") encoders = subprocess.run( [ffmpeg, "-hide_banner", "-encoders"], check=False, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, ).stdout if "libx264" in encoders: codec_args = ["-c:v", "libx264", "-preset", "medium", "-crf", str(crf)] elif "h264_nvenc" in encoders: codec_args = ["-c:v", "h264_nvenc", "-preset", "p4", "-cq", str(crf), "-b:v", "0"] elif "libopenh264" in encoders: codec_args = ["-c:v", "libopenh264", "-b:v", "8M"] else: print(f"[ERROR] {ffmpeg} has no supported H.264 encoder (libx264, h264_nvenc, or libopenh264).") return False cmd = [ ffmpeg, "-y", "-hide_banner", "-loglevel", "error", "-r", str(fps), "-f", "concat", "-safe", "0", "-i", str(concat_path), *codec_args, "-pix_fmt", "yuv420p", str(output_mp4), ] print(f"[INFO] Encoding {output_mp4}") try: subprocess.run(cmd, check=True) return True except subprocess.CalledProcessError as exc: print(f"[ERROR] ffmpeg failed for {output_mp4}: {exc}") return False def material_image_path(obj: bpy.types.Object) -> Path | None: """Return the first image texture path used by the object's first material.""" if not obj.data.materials: return None material = obj.data.materials[0] if not material.use_nodes or material.node_tree is None: return None for node in material.node_tree.nodes: if node.type == "TEX_IMAGE" and node.image is not None and node.image.filepath: return Path(bpy.path.abspath(node.image.filepath)) return None def create_textured_emission_material(texture_path: Path, strength: float) -> bpy.types.Material: """Create a flat texture material that is independent of scene lighting.""" mat = bpy.data.materials.new("HandOnlyFlatTextureMaterial") mat.use_nodes = True nt = mat.node_tree for node in list(nt.nodes): nt.nodes.remove(node) image = bpy.data.images.load(str(texture_path), check_existing=True) tex = nt.nodes.new(type="ShaderNodeTexImage") tex.image = image tex.extension = "EXTEND" emission = nt.nodes.new(type="ShaderNodeEmission") emission.inputs["Strength"].default_value = float(strength) output = nt.nodes.new(type="ShaderNodeOutputMaterial") nt.links.new(tex.outputs["Color"], emission.inputs["Color"]) nt.links.new(emission.outputs["Emission"], output.inputs["Surface"]) return mat def create_white_emission_material() -> bpy.types.Material: mat = bpy.data.materials.new("HandOnlyMaskMaterial") mat.use_nodes = True nt = mat.node_tree for node in list(nt.nodes): nt.nodes.remove(node) emission = nt.nodes.new(type="ShaderNodeEmission") emission.inputs["Color"].default_value = (1.0, 1.0, 1.0, 1.0) emission.inputs["Strength"].default_value = 1.0 output = nt.nodes.new(type="ShaderNodeOutputMaterial") nt.links.new(emission.outputs["Emission"], output.inputs["Surface"]) return mat def create_depth_emission_material(near_depth: float, far_depth: float, invert: bool = False) -> bpy.types.Material: if far_depth <= near_depth: far_depth = near_depth + 1e-4 mat = bpy.data.materials.new("HandOnlyDepthMaterial") mat.use_nodes = True nt = mat.node_tree for node in list(nt.nodes): nt.nodes.remove(node) camera_data = nt.nodes.new(type="ShaderNodeCameraData") map_range = nt.nodes.new(type="ShaderNodeMapRange") map_range.inputs["From Min"].default_value = float(near_depth) map_range.inputs["From Max"].default_value = float(far_depth) map_range.inputs["To Min"].default_value = 0.0 if invert else 1.0 map_range.inputs["To Max"].default_value = 1.0 if invert else 0.0 if "Clamp" in map_range.inputs: map_range.inputs["Clamp"].default_value = True emission = nt.nodes.new(type="ShaderNodeEmission") emission.inputs["Strength"].default_value = 1.0 output = nt.nodes.new(type="ShaderNodeOutputMaterial") nt.links.new(camera_data.outputs["View Z Depth"], map_range.inputs["Value"]) nt.links.new(map_range.outputs["Result"], emission.inputs["Color"]) nt.links.new(emission.outputs["Emission"], output.inputs["Surface"]) return mat def save_black_background(transparent: bool = False) -> dict: """Set world/render background for reference passes and return restorable state.""" scene = bpy.context.scene world = scene.world state = { "film_transparent": scene.render.film_transparent, "world_color": tuple(world.color) if world is not None else None, "world_use_nodes": world.use_nodes if world is not None else None, "world_nodes": [], } scene.render.film_transparent = bool(transparent) if world is not None: world.color = (0.0, 0.0, 0.0) if world.use_nodes and world.node_tree is not None: for node in world.node_tree.nodes: node_state = {"name": node.name, "inputs": []} for socket in node.inputs: if not hasattr(socket, "default_value"): continue try: saved = tuple(socket.default_value) except TypeError: saved = socket.default_value node_state["inputs"].append((socket.name, saved)) if socket.name == "Color": socket.default_value = (0.0, 0.0, 0.0, 1.0) elif socket.name == "Strength": socket.default_value = 0.0 state["world_nodes"].append(node_state) return state def restore_black_background(state: dict) -> None: scene = bpy.context.scene world = scene.world scene.render.film_transparent = state["film_transparent"] if world is None: return if state["world_color"] is not None: world.color = state["world_color"] if state["world_use_nodes"] is not None: world.use_nodes = state["world_use_nodes"] if world.use_nodes and world.node_tree is not None: by_name = {node.name: node for node in world.node_tree.nodes} for node_state in state["world_nodes"]: node = by_name.get(node_state["name"]) if node is None: continue by_input = {socket.name: socket for socket in node.inputs} for input_name, saved in node_state["inputs"]: socket = by_input.get(input_name) if socket is not None and hasattr(socket, "default_value"): socket.default_value = saved def save_depth_color_management() -> dict: scene = bpy.context.scene view = scene.view_settings state = { "view_transform": view.view_transform, "look": view.look, "exposure": view.exposure, "gamma": view.gamma, "dither_intensity": scene.render.dither_intensity, } try: view.view_transform = "Standard" except TypeError: pass try: view.look = "None" except TypeError: pass view.exposure = 0.0 view.gamma = 1.0 scene.render.dither_intensity = 0.0 return state def restore_depth_color_management(state: dict) -> None: scene = bpy.context.scene view = scene.view_settings for name, value in state.items(): if name == "dither_intensity": scene.render.dither_intensity = value else: try: setattr(view, name, value) except TypeError: pass def load_hand_indices_from_json(path: Path, expected_vertex_count: int) -> dict: with open(path, "r", encoding="utf-8") as f: data = json.load(f) vertex_count = int(data.get("vertex_count", expected_vertex_count)) if vertex_count != expected_vertex_count: raise ValueError( f"Hand index vertex_count mismatch: json has {vertex_count}, mesh has {expected_vertex_count}." ) indices = sorted({int(index) for index in data.get("indices", [])}) if not indices: raise ValueError(f"Hand index file has no indices: {path}") return { "source": str(path), "vertex_groups": data.get("vertex_groups", []), "indices": indices, "selected_vertex_count": len(indices), } def load_hand_indices_from_vertex_groups(obj: bpy.types.Object, group_names: list[str]) -> dict: group_indices = {obj.vertex_groups[name].index for name in group_names if name in obj.vertex_groups} missing = [name for name in group_names if name not in obj.vertex_groups] if missing: raise KeyError(f"Missing hand vertex groups on {obj.name}: {', '.join(missing)}") selected: set[int] = set() for vertex in obj.data.vertices: if any(group.group in group_indices and group.weight > 0.0 for group in vertex.groups): selected.add(vertex.index) if not selected: raise ValueError(f"Hand vertex groups are empty on {obj.name}: {', '.join(group_names)}") return { "source": obj.name, "vertex_groups": group_names, "indices": sorted(selected), "selected_vertex_count": len(selected), } def face_matches_hand(face: tuple[int, ...], hand_indices: set[int], rule: str) -> bool: count = sum(1 for index in face if index in hand_indices) if rule == "any": return count >= 1 if rule == "all": return count == len(face) return count >= 2 def build_hand_mesh_from_body( body_obj: bpy.types.Object, hand_info: dict, face_rule: str, material: bpy.types.Material | None, ) -> tuple[bpy.types.Object, dict]: """Create a hand-only mesh with copied vertices, faces, UV loops, and material.""" mesh = body_obj.data hand_indices = set(hand_info["indices"]) kept_faces: list[tuple[int, ...]] = [] source_poly_indices: list[int] = [] used_indices: set[int] = set() for poly_index, poly in enumerate(mesh.polygons): face = tuple(poly.vertices) if face_matches_hand(face, hand_indices, face_rule): kept_faces.append(face) source_poly_indices.append(poly_index) used_indices.update(face) if not kept_faces: raise ValueError(f"No hand faces selected with rule={face_rule}.") ordered_indices = sorted(used_indices) index_map = {old: new for new, old in enumerate(ordered_indices)} vertices = [mesh.vertices[index].co.copy() for index in ordered_indices] faces = [tuple(index_map[index] for index in face) for face in kept_faces] hand_mesh = bpy.data.meshes.new("HandOnlyReferenceMeshData") hand_mesh.from_pydata(vertices, [], faces) hand_mesh.update() hand_obj = bpy.data.objects.new("HandOnlyReferenceMesh", hand_mesh) bpy.context.collection.objects.link(hand_obj) hand_obj.matrix_world = body_obj.matrix_world.copy() source_uv = mesh.uv_layers.active if source_uv is not None: hand_uv = hand_mesh.uv_layers.new(name=source_uv.name) for hand_poly_index, source_poly_index in enumerate(source_poly_indices): source_poly = mesh.polygons[source_poly_index] hand_poly = hand_mesh.polygons[hand_poly_index] for corner_index, hand_loop_index in enumerate(hand_poly.loop_indices): source_loop_index = source_poly.loop_indices[corner_index] hand_uv.data[hand_loop_index].uv = source_uv.data[source_loop_index].uv if material is not None: hand_mesh.materials.append(material) return hand_obj, { "source": hand_info["source"], "vertex_groups": hand_info.get("vertex_groups", []), "selected_vertex_count": hand_info["selected_vertex_count"], "mesh_vertex_count": len(ordered_indices), "mesh_face_count": len(kept_faces), "face_rule": face_rule, "source_vertex_indices": ordered_indices, } def update_hand_mesh_vertices( hand_obj: bpy.types.Object, body_obj: bpy.types.Object, source_vertex_indices: list[int], ) -> None: source_mesh = body_obj.data hand_mesh = hand_obj.data coords = np.empty((len(source_vertex_indices), 3), dtype=np.float32) for new_index, source_index in enumerate(source_vertex_indices): coords[new_index] = source_mesh.vertices[source_index].co[:] hand_mesh.vertices.foreach_set("co", coords.reshape(-1)) hand_mesh.update() def compute_depth_range_for_frames( hand_obj: bpy.types.Object, body_obj: bpy.types.Object, source_vertex_indices: list[int], frame_indices: list[int], vertices: np.ndarray, set_body_vertices, margin_ratio: float, ) -> dict: camera = bpy.context.scene.camera if camera is None: raise RuntimeError("Cannot compute hand depth without an active camera.") depths: list[float] = [] camera_inv = camera.matrix_world.inverted() for frame_idx in frame_indices: set_body_vertices(body_obj, np.asarray(vertices[frame_idx])) update_hand_mesh_vertices(hand_obj, body_obj, source_vertex_indices) bpy.context.view_layer.update() for vertex in hand_obj.data.vertices: world_co = hand_obj.matrix_world @ vertex.co camera_co = camera_inv @ world_co depth = -camera_co.z if depth > 0.0: depths.append(float(depth)) if not depths: raise RuntimeError("Could not compute a positive camera-space hand depth range.") auto_near = min(depths) auto_far = max(depths) span = max(auto_far - auto_near, 1e-4) margin = max(0.0, float(margin_ratio)) * span return { "mode": "auto", "auto_near": auto_near, "auto_far": auto_far, "near": auto_near - margin, "far": auto_far + margin, "margin": margin, } def blender_camera_intrinsics( cam_data: bpy.types.Camera, scene: bpy.types.Scene, ) -> tuple[list[list[float]], dict]: scale = scene.render.resolution_percentage / 100.0 resolution_x = scene.render.resolution_x * scale resolution_y = scene.render.resolution_y * scale pixel_aspect_ratio = scene.render.pixel_aspect_y / scene.render.pixel_aspect_x sensor_fit = cam_data.sensor_fit if sensor_fit == "AUTO": sensor_fit = "HORIZONTAL" if resolution_x >= pixel_aspect_ratio * resolution_y else "VERTICAL" if sensor_fit == "VERTICAL": sensor_size = cam_data.sensor_height view_fac_px = pixel_aspect_ratio * resolution_y else: sensor_size = cam_data.sensor_width view_fac_px = resolution_x pixel_size_mm = sensor_size / cam_data.lens / view_fac_px fx = 1.0 / pixel_size_mm fy = 1.0 / pixel_size_mm / pixel_aspect_ratio cx = resolution_x * 0.5 - cam_data.shift_x * view_fac_px cy = resolution_y * 0.5 + cam_data.shift_y * view_fac_px / pixel_aspect_ratio K = [[float(fx), 0.0, float(cx)], [0.0, float(fy), float(cy)], [0.0, 0.0, 1.0]] meta = { "sensor_fit_resolved": sensor_fit, "sensor_size_mm": float(sensor_size), "view_fac_px": float(view_fac_px), "pixel_aspect_ratio_y_over_x": float(pixel_aspect_ratio), } return K, meta def export_camera_calibration( camera_obj: bpy.types.Object, smplx_obj: bpy.types.Object, out_json_path: Path, image_width: int, image_height: int, ) -> None: """Export OpenCV-style camera intrinsics/extrinsics and SMPL-X world transform.""" scene = bpy.context.scene cam_data = camera_obj.data K, intrinsics_meta = blender_camera_intrinsics(cam_data, scene) r_bcam_to_cv = mathutils.Matrix(((1, 0, 0), (0, -1, 0), (0, 0, -1))) world_to_bcam = camera_obj.matrix_world.inverted() r_world_to_cv = r_bcam_to_cv @ world_to_bcam.to_3x3() t_world_to_cv = r_bcam_to_cv @ world_to_bcam.translation def matrix_to_list(mat): return [[float(v) for v in row] for row in mat] out = { "image_width": int(image_width), "image_height": int(image_height), "K": K, "intrinsics_meta": intrinsics_meta, "R_world_to_cam": matrix_to_list(r_world_to_cv), "t_world_to_cam": [float(v) for v in t_world_to_cv], "camera_matrix_world": matrix_to_list(camera_obj.matrix_world), "smplx_matrix_world": matrix_to_list(smplx_obj.matrix_world), "camera_name": camera_obj.name, "smplx_object_name": smplx_obj.name, "coordinate_note": "OpenCV camera: +Z forward, X right, Y down. SMPL-X vertices are rendered in Blender world directly.", } out_json_path.parent.mkdir(parents=True, exist_ok=True) with open(out_json_path, "w", encoding="utf-8") as f: json.dump(out, f, indent=2)