#!/usr/bin/env python3 """InstantMesh 渲染器批处理脚本 用于批量渲染标准化后的 OBJ 文件,生成 InstantMesh 所需的多视角拼接图。 支持 Contact/HO3D 和 HOI4D 两种数据集格式,支持单 GPU / 多 GPU。 使用示例: # 批量渲染 Contact 数据集 (默认 mode=contact,单 GPU) python batch_instantmesh_render.py \ --input_root /path/to/contact_processed/normalized \ --output_root /path/to/contact_processed/renders_6view \ --test --frames 3 # 批量渲染 HOI4D 数据集 (mode=hoi4d,单 GPU) python batch_instantmesh_render.py \ --input_root /path/to/hoi4d_right_hand_grasps_v1_processed \ --output_root /path/to/hoi4d_right_hand_grasps_v1_renders \ --mode hoi4d \ --full \ --batch_size 8 \ --workers 8 # 两张 GPU 并行(内部多进程 + 自动分片,一条命令统一调度) CUDA_VISIBLE_DEVICES=0,1 python batch_instantmesh_render.py \ --input_root /path/to/hoi4d_right_hand_grasps_v1_processed \ --output_root /path/to/hoi4d_right_hand_grasps_v1_renders \ --mode hoi4d \ --full \ --batch_size 8 \ --workers 12 \ --num_gpus 2 """ import os import sys import argparse from pathlib import Path from typing import List, Dict, Optional from tqdm import tqdm import torch import torch.multiprocessing as mp from torch.utils.data import Dataset, DataLoader # 为了能从任意工作目录运行脚本,这里把当前脚本目录加入 sys.path, # 确保可以导入同目录下的 instantmesh_renderer_v4.py SCRIPT_DIR = Path(__file__).resolve().parent if str(SCRIPT_DIR) not in sys.path: sys.path.insert(0, str(SCRIPT_DIR)) from instantmesh_renderer_v4 import InstantMeshRendererV4 def find_normalized_objs_contact(input_root: str, sequence_name: Optional[str] = None) -> List[Dict]: """查找 Contact/HO3D 格式的标准化 OBJ 文件 兼容两种常见命名方式: 1) 旧版/clean_combined 管线: input_root/ ├── SiS1/ │ ├── 0000/ │ │ └── normalized_hand_object_combined.obj │ └── ... └── ABF11/ └── ... 2) 新版 normalized_*.obj 管线(当前 /contact_processed/normalized 的结构): input_root/ ├── SiS1/ │ ├── 0000/ │ │ └── normalized_0000.obj │ └── ... └── ABF11/ └── ... 输出结构统一为: output_root/seq/frame.png """ input_root = Path(input_root) obj_files: List[Dict] = [] if sequence_name: sequences = [sequence_name] else: sequences = [d.name for d in input_root.iterdir() if d.is_dir()] for seq in sorted(sequences): seq_dir = input_root / seq if not seq_dir.exists(): print(f"⚠️ 序列目录不存在: {seq_dir}") continue for frame_dir in sorted(seq_dir.iterdir()): if not frame_dir.is_dir(): continue # 优先使用旧版 normalized_hand_object_combined.obj obj_path = frame_dir / "normalized_hand_object_combined.obj" if not obj_path.exists(): # 兼容新版 normalized_*.obj(例如 normalized_0656.obj) candidates = sorted(frame_dir.glob("normalized_*.obj")) if not candidates: continue if len(candidates) > 1: print( f"⚠️ 帧目录中找到多个 normalized_*.obj,只使用第一个: {frame_dir}" ) obj_path = candidates[0] obj_files.append( { "sequence": seq, "frame": frame_dir.name, "obj_path": str(obj_path), # 直接在序列目录下生成 PNG,例如: ABF11/0071.png "output_subpath": f"{seq}/{frame_dir.name}.png", } ) return obj_files def find_normalized_objs_hoi4d(input_root: str, sequence_name: Optional[str] = None) -> List[Dict]: """查找 HOI4D 格式的标准化 OBJ 文件 预期目录结构: input_root/ ├── C12_N11_S154_s03_T1/ │ ├── normalized_frame_00074.obj │ ├── normalized_frame_00075.obj │ └── ... └── C12_N18_S154_s05_T1/ └── ... 输出结构(固定): output_root/seq/normalized_frame_00074.png """ input_root = Path(input_root) obj_files = [] if sequence_name: sequences = [sequence_name] else: sequences = [d.name for d in input_root.iterdir() if d.is_dir()] for seq in sorted(sequences): seq_dir = input_root / seq if not seq_dir.exists(): print(f"⚠️ 序列目录不存在: {seq_dir}") continue # 直接在序列目录下查找 normalized_frame_*.obj for obj_file in sorted(seq_dir.glob("normalized_frame_*.obj")): # 从 normalized_frame_00074.obj 提取帧名 frame_name = obj_file.stem # normalized_frame_00074 obj_files.append({ 'sequence': seq, 'frame': frame_name, 'obj_path': str(obj_file), # 固定输出结构: output_root/seq/normalized_frame_00074.png 'output_subpath': f"{seq}/{frame_name}.png", }) return obj_files def find_normalized_objs(input_root: str, mode: str = "contact", sequence_name: Optional[str] = None) -> List[Dict]: """根据 mode 选择对应的扫描函数""" if mode == "hoi4d": return find_normalized_objs_hoi4d(input_root, sequence_name) else: return find_normalized_objs_contact(input_root, sequence_name) class RenderTaskDataset(Dataset): """用于 DataLoader 的渲染任务数据集""" def __init__(self, tasks: List[Dict], output_root: str): """保存任务列表和输出根目录""" self.tasks = tasks self.output_root = Path(output_root) def __len__(self) -> int: return len(self.tasks) def __getitem__(self, idx: int) -> Dict: """返回单个渲染任务的信息""" task = self.tasks[idx] output_path = str(self.output_root / task['output_subpath']) return { 'idx': idx, 'obj_path': task['obj_path'], 'output_path': output_path, 'sequence': task['sequence'], 'frame': task['frame'], } def collate_fn_identity(batch): """DataLoader 的简单 collate_fn:直接返回 list[dict] 需要是模块级函数,方便在多进程(spawn)模式下被 pickle。 """ return batch def batch_render( input_root: str, output_root: str, mode: str = "contact", sequence: Optional[str] = None, test_mode: bool = False, max_frames: int = 3, device: Optional[str] = None, batch_size: int = 1, num_workers: int = 0, shard_id: int = 0, num_shards: int = 1, skip_existing: bool = True, input_coord: str = "z_up", ): """批量渲染(支持 batch、DataLoader、多卡分片) Args: input_root: 输入根目录 output_root: 输出根目录 mode: "contact" 或 "hoi4d" sequence: 只处理指定序列 test_mode: 测试模式(每序列只处理少量帧) max_frames: 测试模式下每序列最大帧数 device: 渲染设备 batch_size: 批量渲染大小(多个 mesh 同时渲染) num_workers: DataLoader 的 worker 数量(CPU 预加载) shard_id: 当前分片 ID(用于多卡并行) num_shards: 总分片数 skip_existing: 是否跳过已存在的输出文件 """ print("=" * 80) print("🎨 InstantMesh 渲染器批处理 (v2 - Batch + DataLoader)") print("=" * 80) print(f"📁 输入根目录: {input_root}") print(f"📁 输出根目录: {output_root}") print(f"📦 模式: {mode}") print(f"🔢 Batch Size: {batch_size}, Workers: {num_workers}") if num_shards > 1: print(f"🔀 分片: {shard_id + 1}/{num_shards}") if sequence: print(f"🎯 处理序列: {sequence}") if test_mode: print(f"🧪 测试模式: 每序列最多 {max_frames} 帧") print("=" * 80) # 1. 查找所有 OBJ 文件 obj_files = find_normalized_objs(input_root, mode=mode, sequence_name=sequence) if not obj_files: print("❌ 未找到任何标准化的 OBJ 文件") return False print(f"\n📊 找到 {len(obj_files)} 个文件") # 2. 测试模式:限制每序列的帧数 if test_mode: filtered_files = [] seq_counts = {} for obj_info in obj_files: seq = obj_info['sequence'] if seq not in seq_counts: seq_counts[seq] = 0 if seq_counts[seq] < max_frames: filtered_files.append(obj_info) seq_counts[seq] += 1 obj_files = filtered_files print(f"🧪 测试模式:处理 {len(obj_files)} 个文件") # 3. 分片:只处理属于当前 shard 的任务 if num_shards > 1: obj_files = [f for i, f in enumerate(obj_files) if i % num_shards == shard_id] print(f"🔀 分片后:处理 {len(obj_files)} 个文件") # 4. 跳过已存在的文件 if skip_existing: output_root_path = Path(output_root) filtered = [] skipped = 0 for obj_info in obj_files: output_path = output_root_path / obj_info['output_subpath'] if output_path.exists(): skipped += 1 else: filtered.append(obj_info) obj_files = filtered if skipped > 0: print(f"⏭️ 跳过已存在: {skipped} 个") if not obj_files: print("✅ 所有文件已处理完毕") return True print(f"📝 待处理: {len(obj_files)} 个文件") # 5. 创建 Dataset 和 DataLoader dataset = RenderTaskDataset(obj_files, output_root) dataloader = DataLoader( dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers, collate_fn=collate_fn_identity, prefetch_factor=2 if num_workers > 0 else None, persistent_workers=num_workers > 0, ) # 6. 创建渲染器 # input_coord: # - "z_up": 输入 mesh 已经是 Z-up(默认,适用于新的 normalized_*.obj / HOI4D 等) # - "y_up": 输入 mesh 为 Y-up,这里会自动做一次 Y-up → Z-up 旋转 renderer = InstantMeshRendererV4(device=device, image_size=320, input_coord=input_coord) # 7. 批量渲染 success_count = 0 fail_count = 0 total_batches = len(dataloader) pbar = tqdm(dataloader, desc="渲染进度", total=total_batches) for batch_idx, batch in enumerate(pbar): obj_paths = [item['obj_path'] for item in batch] output_paths = [item['output_path'] for item in batch] # 使用 batch 渲染 if batch_size > 1: batch_success, batch_fail = renderer.render_batch_for_instantmesh( obj_paths, output_paths, verbose=False ) success_count += batch_success fail_count += batch_fail else: # 单个渲染(兼容旧逻辑) for item in batch: try: os.makedirs(os.path.dirname(item['output_path']), exist_ok=True) renderer.render_for_instantmesh(item['obj_path'], item['output_path']) success_count += 1 except Exception as e: fail_count += 1 pbar.set_postfix({'成功': success_count, '失败': fail_count}) print("\n" + "=" * 80) print(f"📊 批量渲染完成") print(f" ✅ 成功: {success_count} 个") print(f" ❌ 失败: {fail_count} 个") print("=" * 80) return fail_count == 0 def _mp_worker(rank: int, world_size: int, args: argparse.Namespace) -> None: """多 GPU 模式下的子进程入口 每个 rank 负责一个 shard,设备固定为 cuda:{rank}(若可用),否则回退到 CPU/指定设备。 """ if torch.cuda.is_available(): device = f"cuda:{rank}" else: # 无 GPU 时,仍然可以多进程跑 CPU(一般用不到) device = args.device or "cpu" print(f"\n[Worker {rank}/{world_size}] 使用设备: {device}") ok = batch_render( input_root=args.input_root, output_root=args.output_root, mode=args.mode, sequence=args.sequence, test_mode=args.test_mode, max_frames=args.frames, device=device, batch_size=args.batch_size, num_workers=args.workers, shard_id=rank, num_shards=world_size, skip_existing=not args.no_skip, input_coord=args.input_coord, ) if not ok: # 让 mp.spawn 感知失败,从而中止所有进程 raise RuntimeError(f"Worker {rank} failed") def main(): parser = argparse.ArgumentParser( description="InstantMesh 渲染器批处理脚本 (v2 - Batch + DataLoader + 多 GPU)", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=__doc__, ) # 基础参数 parser.add_argument( "--input_root", type=str, required=True, help="输入根目录(标准化后的 OBJ 文件所在目录)", ) parser.add_argument( "--output_root", type=str, required=True, help="输出根目录(将保存渲染 PNG 的目录)", ) parser.add_argument( "--mode", type=str, default="contact", choices=["contact", "hoi4d"], help="数据集模式: contact (seq/frame/normalized_*.obj) 或 hoi4d (seq/normalized_frame_*.obj)", ) parser.add_argument( "--sequence", type=str, default=None, help="只处理指定序列名称(例如 SiS1 或 C12_N11_S154_s03_T1),默认处理所有序列", ) # 模式控制 parser.add_argument( "--test", action="store_true", help="测试模式:每个序列只处理少量帧(由 --frames 控制)", ) parser.add_argument( "--full", action="store_true", help="完整模式:处理所有帧(与 --test 互斥)", ) parser.add_argument( "--frames", type=int, default=3, help="测试模式下每个序列处理的最大帧数(默认 3)", ) # 性能参数 parser.add_argument( "--device", type=str, default=None, help="渲染设备,例如 cuda:0;留空则自动检测 GPU/CPU(单 GPU 模式有效)", ) parser.add_argument( "--batch_size", type=int, default=1, help="批量渲染大小:多个 mesh 同时在 GPU 渲染(默认 1,建议 4-16)", ) parser.add_argument( "--workers", type=int, default=0, help="DataLoader worker 数量:CPU 预加载线程(默认 0,建议 4-8)", ) parser.add_argument( "--input_coord", type=str, default="z_up", choices=["z_up", "y_up"], help=( "输入 mesh 的坐标系:z_up (默认,新的 normalized_*.obj / HOI4D);" "y_up 表示老数据集仍为 Y-up,会在渲染前自动旋转到 Z-up" ), ) # 多 GPU / 分片 parser.add_argument( "--num_gpus", type=int, default=1, help="使用的 GPU 数量:>1 时自动按 rank 分片并内部多进程调度", ) parser.add_argument( "--shard_id", type=int, default=0, help="手动分片 ID(从 0 开始),仅在 num_gpus=1 时用于高级自定义", ) parser.add_argument( "--num_shards", type=int, default=1, help="手动总分片数,仅在 num_gpus=1 时有效(默认 1 不分片)", ) # 其他 parser.add_argument( "--no_skip", action="store_true", help="不跳过已存在的输出文件(默认会跳过)", ) args = parser.parse_args() # 参数校验 if args.test and args.full: print("❌ 参数错误:--test 和 --full 不能同时使用") return 1 if args.num_gpus < 1: print("❌ 参数错误:--num_gpus 必须 >= 1") return 1 if args.num_gpus == 1 and args.shard_id >= args.num_shards: print(f"❌ 参数错误:shard_id ({args.shard_id}) 必须小于 num_shards ({args.num_shards})") return 1 if args.num_gpus > 1 and (args.shard_id != 0 or args.num_shards != 1): print("⚠️ 检测到手动分片参数,但在多 GPU 模式下会被忽略,改用自动按 rank 分片") # 默认行为:如果既没有 --test 也没有 --full,则按测试模式处理 test_mode = args.test or (not args.test and not args.full) if not args.test and not args.full: print("ℹ️ 未指定 --test/--full,默认使用测试模式 (--test),每序列仅处理少量帧") # 将 test_mode 挂到 args 上,便于子进程读取 args.test_mode = test_mode # 多 GPU 模式:内部多进程 + 自动分片 if args.num_gpus > 1: world_size = args.num_gpus print(f"🚀 多 GPU 模式:world_size={world_size}(需要提前设置 CUDA_VISIBLE_DEVICES)") try: mp.set_start_method("spawn", force=True) except RuntimeError: # 已经设置过 start method,忽略 pass # mp.spawn 的 args 需为 tuple mp.spawn(_mp_worker, args=(world_size, args), nprocs=world_size, join=True) return 0 # 单 GPU / CPU:直接在当前进程中运行,可选手动分片 ok = batch_render( input_root=args.input_root, output_root=args.output_root, mode=args.mode, sequence=args.sequence, test_mode=test_mode, max_frames=args.frames, device=args.device, batch_size=args.batch_size, num_workers=args.workers, shard_id=args.shard_id, num_shards=args.num_shards, skip_existing=not args.no_skip, input_coord=args.input_coord, ) return 0 if ok else 1 if __name__ == "__main__": sys.exit(main())