""" Fast-SAM3D **batched** variant: - Batched sampling: all K pose samples processed in parallel (chunked) - Taylor expansion cache (ShortCut_faster): ~2.7x per-sample speedup - Optional torch.compile on DiT backbone - All Fast-SAM3D acceleration flags (SS cache, SLaT carving, mesh aggregation) Usage: python track_object.py \ --config checkpoints/hf/pipeline.yaml \ --vid_dir /path/to/video_dir \ --masks_root /path/to/video_dir/video_segmentation/masks \ --object_name cup \ --init_frame 0 \ --output_dir /path/to/video_dir/obj_tracking_out \ --guidance_strength 1 \ --save_layout \ --fix_scale_to_init_frame \ --pose_guidance_strength 0.5 \ --num_pose_samples 25 \ --scoring_metric render_iou \ --pose_selection cluster \ --cluster_dist_thresh 0.3 \ --cluster_min_size 3 \ --cluster_w_rot 1.5 \ --chain_poses \ --post_optimize \ --no-enable_shape_icp \ --chain_on_diffusion \ --enable_ss_cache \ --torch_compile \ --euler_steps 25 optionally: --rotvel_json /path/to/video_dir/426_motion_stats.json With pose_log_likelihood selection (selects pose with highest log p(pose | shape, image)): python track_object.py \ --config checkpoints/hf/pipeline.yaml \ --vid_dir /path/to/video_dir \ --object_name pourer \ --init_frame 37 \ --frames 37:41 \ --guidance_strength 1 \ --save_layout \ --fix_scale_to_init_frame \ --scoring_metric render_iou \ --pose_selection pose_log_likelihood \ --ll_steps 25 \ --chain_poses \ --post_optimize \ --no-enable_shape_icp \ --chain_on_diffusion \ --num_pose_samples_per_pgs 3 \ --euler_steps 25 \ --batch_chunk_size 5 \ --output_dir /path/to/video_dir/pose_ll_test """ import sys import os if "CUDA_HOME" not in os.environ: if "CONDA_PREFIX" in os.environ: os.environ["CUDA_HOME"] = os.environ["CONDA_PREFIX"] os.environ["LIDRA_SKIP_INIT"] = "true" project_root = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, project_root) sys.path.insert(0, os.path.join(project_root, "notebook")) import argparse import glob import json import time from copy import deepcopy import numpy as np import open3d as o3d import torch import torch.nn.functional as F import trimesh from PIL import Image from loguru import logger from omegaconf import OmegaConf import h5py import shutil from scipy.spatial.transform import Rotation as ScipyRotation from pytorch3d.transforms import quaternion_to_matrix from sam3d_objects.data.dataset.tdfy.transforms_3d import compose_transform from pytorch3d.structures import Meshes from pytorch3d.renderer import ( PerspectiveCameras, RasterizationSettings, MeshRenderer, MeshRasterizer, SoftPhongShader, PointLights, TexturesVertex, ) from notebook.inference import Inference, load_image, load_mask from sam3d_objects.pipeline.inference_utils import ( voxelize_mesh, prune_sparse_structure, ROTATION_6D_MEAN, ROTATION_6D_STD, ) from sam3d_objects.pipeline.inference_utils import layout_post_optimization from sam3d_objects.data.dataset.tdfy.pose_target import PoseTargetConverter from fft.fft2d import calculate_hfer_robust from pose_log_likelihood import compute_pose_only_log_likelihoods # ------------------------------------------------------------------ # Mesh voxelization helpers (inlined from mesh_to_shape.py) # ------------------------------------------------------------------ def load_mesh_as_open3d(mesh_path: str) -> o3d.geometry.TriangleMesh: tm = trimesh.load(mesh_path, force="mesh") logger.info(f"Loaded mesh: {mesh_path} vertices={len(tm.vertices)} faces={len(tm.faces)}") o3d_mesh = o3d.geometry.TriangleMesh() o3d_mesh.vertices = o3d.utility.Vector3dVector(np.array(tm.vertices)) o3d_mesh.triangles = o3d.utility.Vector3iVector(np.array(tm.faces)) o3d_mesh.compute_vertex_normals() return o3d_mesh def voxelize(mesh_path: str): o3d_mesh = load_mesh_as_open3d(mesh_path) mesh_ss, scale, center = voxelize_mesh(o3d_mesh, resolution=64) mesh_coords = torch.argwhere(mesh_ss > 0) logger.info(f"Voxelized mesh: {mesh_coords.shape[0]} occupied voxels") return mesh_ss, mesh_coords.int(), scale, center def compute_iou(a: torch.Tensor, b: torch.Tensor) -> float: a_bool = a.bool() b_bool = b.bool() intersection = (a_bool & b_bool).sum().item() union = (a_bool | b_bool).sum().item() return intersection / max(union, 1) def downsample_sparse_structure(coord_batch, max_coords=42000, downsample_factor=2): if coord_batch.shape[0] <= max_coords: return coord_batch, 1 coords = coord_batch[:, 1:].float() batch_indices = coord_batch[:, 0:1] coords_min = coords.min(dim=0)[0] coords_max = coords.max(dim=0)[0] original_size = coords_max - coords_min + 1 target_size = original_size / downsample_factor offset = (original_size - target_size) / 2 target_min = coords_min + offset target_max = coords_min + offset + target_size - 1 coords_normalized = (coords - coords_min) / (coords_max - coords_min) coords_rescaled = coords_normalized * (target_size - 1) + target_min coords_rescaled = torch.round(coords_rescaled).int() coords_rescaled = torch.clamp(coords_rescaled, target_min.int(), target_max.int()) combined = torch.cat([batch_indices, coords_rescaled], dim=1) unique_combined = torch.unique(combined, dim=0) if unique_combined.shape[0] > max_coords: indices = torch.randperm(unique_combined.shape[0], device=coord_batch.device)[:max_coords] unique_combined = unique_combined[indices] return unique_combined.int(), downsample_factor # ------------------------------------------------------------------ # Rendering IoU helpers # ------------------------------------------------------------------ _R_YUP_TO_ZUP_RENDER = np.array([[1, 0, 0], [0, 0, -1], [0, 1, 0]], dtype=np.float32).T # ------------------------------------------------------------------ # Camera extrinsics helpers # ------------------------------------------------------------------ _F_ARKIT_P3D = np.diag([-1.0, 1.0, -1.0, 1.0]) def load_extrinsics_from_hdf5(hdf5_path, frame_indices): with h5py.File(hdf5_path, 'r') as f: camera_transforms = f['transforms/camera'][:] extrinsics = {} for idx in frame_indices: T_c2w_arkit = camera_transforms[idx].astype(np.float64) T_c2w_p3d = T_c2w_arkit @ _F_ARKIT_P3D extrinsics[idx] = T_c2w_p3d return extrinsics def _make_T(translation, rotation_matrix): T = np.eye(4) T[:3, :3] = rotation_matrix T[:3, 3] = translation return T def _T_to_pos_quat_wxyz(T): pos = T[:3, 3].copy() quat_wxyz = ScipyRotation.from_matrix(T[:3, :3]).as_quat(scalar_first=True) return pos, quat_wxyz def _quat_to_matrix_np(quat_wxyz): return ScipyRotation.from_quat(quat_wxyz, scalar_first=True).as_matrix() def transform_pose_between_cameras(pose_dict, T_c2w_src, T_c2w_dst): quat_np = pose_dict["rotation"].detach().cpu().squeeze().numpy().astype(np.float64) trans_np = pose_dict["translation"].detach().cpu().squeeze().numpy().astype(np.float64) T_obj_in_src = _make_T(trans_np, _quat_to_matrix_np(quat_np)) T_obj_in_dst = np.linalg.inv(T_c2w_dst) @ T_c2w_src @ T_obj_in_src new_trans, new_quat = _T_to_pos_quat_wxyz(T_obj_in_dst) return { "rotation": torch.tensor(new_quat, dtype=torch.float32).unsqueeze(0), "translation": torch.tensor(new_trans, dtype=torch.float32).unsqueeze(0), "scale": pose_dict["scale"].clone(), } def _maybe_transform_pose(pose_dict, prev_frame_idx, curr_frame_idx, extrinsics): if extrinsics is None or pose_dict is None or prev_frame_idx == curr_frame_idx: return pose_dict return transform_pose_between_cameras( pose_dict, extrinsics[prev_frame_idx], extrinsics[curr_frame_idx], ) def _build_renderable_mesh(init_trimesh_obj, device): verts = np.array(init_trimesh_obj.vertices, dtype=np.float32) @ _R_YUP_TO_ZUP_RENDER verts_t = torch.from_numpy(verts).to(device) faces_t = torch.from_numpy(np.array(init_trimesh_obj.faces, dtype=np.int64)).to(device) textures = TexturesVertex(verts_features=torch.ones_like(verts_t)[None]) return Meshes(verts=[verts_t], faces=[faces_t], textures=textures) def _build_silhouette_renderer(intrinsics_3x3, width, height, device): K = intrinsics_3x3.detach().float().to(device) fx = (K[0, 0] * width).item() fy = (K[1, 1] * height).item() cx = (K[0, 2] * width).item() cy = (K[1, 2] * height).item() cameras = PerspectiveCameras( focal_length=torch.tensor([[fx, fy]], dtype=torch.float32, device=device), principal_point=torch.tensor([[cx, cy]], dtype=torch.float32, device=device), image_size=((height, width),), in_ndc=False, device=device, ) raster_settings = RasterizationSettings( image_size=(height, width), blur_radius=0.0, faces_per_pixel=1, max_faces_per_bin=50000, bin_size=0, ) lights = PointLights(device=device, location=[[0.0, 0.0, -3.0]]) return MeshRenderer( rasterizer=MeshRasterizer(cameras=cameras, raster_settings=raster_settings), shader=SoftPhongShader(device=device, cameras=cameras, lights=lights), ) def _render_silhouette(mesh, pose_dict, intrinsics_3x3, width, height, device, renderer=None): quat = pose_dict["rotation"].detach().float().squeeze().to(device) if quat.dim() == 1: quat = quat.unsqueeze(0) trans = pose_dict["translation"].detach().float().squeeze().to(device) if trans.dim() == 1: trans = trans.unsqueeze(0) sc = pose_dict["scale"].detach().float().squeeze().to(device) if sc.dim() == 1: sc = sc.unsqueeze(0) R_mat = quaternion_to_matrix(quat) tfm = compose_transform(scale=sc, rotation=R_mat, translation=trans) verts = mesh.verts_packed() verts_cam = tfm.transform_points(verts.unsqueeze(0)).squeeze(0) mesh_transformed = mesh.clone() mesh_transformed = mesh_transformed.update_padded(verts_cam.unsqueeze(0)) if renderer is None: renderer = _build_silhouette_renderer(intrinsics_3x3, width, height, device) with torch.no_grad(): images = renderer(mesh_transformed) alpha = images[0, ..., 3].cpu().numpy() return alpha def compute_render_iou(mesh, pose_dict, intrinsics_3x3, gt_mask, width, height, device, renderer=None): alpha = _render_silhouette(mesh, pose_dict, intrinsics_3x3, width, height, device, renderer=renderer) render_binary = alpha > 0.5 gt_binary = gt_mask > 0 intersection = (render_binary & gt_binary).sum() union = (render_binary | gt_binary).sum() if union == 0: return 0.0 return float(intersection) / float(union) # ------------------------------------------------------------------ # Clustering-based pose selection # ------------------------------------------------------------------ def _pose_distance(pose_a, pose_b, w_trans=1.0, w_rot=1.0): t_a = pose_a["translation"].detach().cpu().squeeze().numpy().astype(np.float64) t_b = pose_b["translation"].detach().cpu().squeeze().numpy().astype(np.float64) trans_dist = np.linalg.norm(t_b - t_a) q_a = pose_a["rotation"].detach().cpu().squeeze().numpy().astype(np.float64) q_b = pose_b["rotation"].detach().cpu().squeeze().numpy().astype(np.float64) r_a = ScipyRotation.from_quat([q_a[1], q_a[2], q_a[3], q_a[0]]) r_b = ScipyRotation.from_quat([q_b[1], q_b[2], q_b[3], q_b[0]]) rot_dist = (r_a.inv() * r_b).magnitude() return w_trans * trans_dist + w_rot * rot_dist def _compute_pose_distance_matrix(candidates, w_trans=1.0, w_rot=1.0): K = len(candidates) full_matrix = np.zeros((K, K), dtype=np.float64) for i in range(K): for j in range(i + 1, K): d = _pose_distance(candidates[i], candidates[j], w_trans, w_rot) full_matrix[i, j] = d full_matrix[j, i] = d from scipy.spatial.distance import squareform condensed = squareform(full_matrix) return condensed, full_matrix def cluster_pose_candidates( candidates, scoring_metric="shape_iou", dist_thresh=0.5, min_cluster_size=1, w_trans=1.0, w_rot=1.0, ): from scipy.cluster.hierarchy import linkage, fcluster K = len(candidates) if K <= 1: return 0, {"num_clusters": 1, "cluster_sizes": [K], "selected_cluster": 0} if K == 2: scores = [] for c in candidates: if scoring_metric in c: scores.append(c[scoring_metric]) elif "shape_iou" in c: scores.append(c["shape_iou"]) else: scores.append(0.0) best = int(np.argmax(scores)) return best, {"num_clusters": 1, "cluster_sizes": [2], "selected_cluster": 0} condensed, full_matrix = _compute_pose_distance_matrix(candidates, w_trans, w_rot) Z = linkage(condensed, method='average') labels = fcluster(Z, t=dist_thresh, criterion='distance') unique_labels = np.unique(labels) num_clusters = len(unique_labels) cluster_members = {} for idx, lab in enumerate(labels): cluster_members.setdefault(lab, []).append(idx) scores = [] for c in candidates: if scoring_metric in c: scores.append(c[scoring_metric]) elif "shape_iou" in c: scores.append(c["shape_iou"]) else: scores.append(0.0) scores = np.array(scores) cluster_ranking = [] for lab, members in cluster_members.items(): size = len(members) avg_score = scores[members].mean() cluster_ranking.append((lab, size, avg_score, members)) cluster_ranking.sort(key=lambda x: (x[1], x[2]), reverse=True) valid_clusters = [c for c in cluster_ranking if c[1] >= min_cluster_size] if not valid_clusters: valid_clusters = cluster_ranking selected_lab, selected_size, selected_avg_score, selected_members = valid_clusters[0] member_scores = [(m, scores[m]) for m in selected_members] member_scores.sort(key=lambda x: x[1], reverse=True) best_idx = member_scores[0][0] cluster_sizes = sorted([len(m) for m in cluster_members.values()], reverse=True) cluster_info = { "num_clusters": num_clusters, "cluster_sizes": cluster_sizes, "selected_cluster": int(selected_lab), "selected_cluster_size": selected_size, "selected_cluster_avg_score": float(selected_avg_score), "best_candidate_idx": best_idx, "best_candidate_score": float(scores[best_idx]), "dist_thresh": dist_thresh, "labels": labels.tolist(), } return best_idx, cluster_info # ------------------------------------------------------------------ # Path helpers # ------------------------------------------------------------------ def get_frame_mask_dir(masks_root, frame_idx): return os.path.join(masks_root, f"frame_{frame_idx:06d}_masks") def discover_frames(vid_dir, object_name, frame_range=None, masks_root=None, frames_dir=None): if frames_dir is None: frames_dir = os.path.join(vid_dir, "all_frames") if masks_root is None: masks_root = os.path.join(vid_dir, "video_segmentation", "masks") frame_files = sorted(glob.glob(os.path.join(frames_dir, "*.png"))) results = [] for fpath in frame_files: fname = os.path.basename(fpath) frame_idx = int(os.path.splitext(fname)[0]) if frame_range is not None: start, end = frame_range if frame_idx < start or frame_idx >= end: continue mask_dir = get_frame_mask_dir(masks_root, frame_idx) mask_path = os.path.join(mask_dir, f"{object_name}.png") if os.path.isfile(mask_path): results.append((frame_idx, fpath, mask_path)) return results def load_frame_result_from_layout(masks_root, object_name, frame_idx=0): frame_dir = get_frame_mask_dir(masks_root, frame_idx) layout_path = os.path.join(frame_dir, "layout.json") if not os.path.isfile(layout_path): logger.warning(f"Frame {frame_idx} layout.json not found at {layout_path}") return None with open(layout_path) as f: layout = json.load(f) target_mesh = f"{object_name}.obj" obj_entry = None for obj in layout.get("objects", []): if obj.get("mesh_obj") == target_mesh: obj_entry = obj break if obj_entry is None: logger.warning(f"Object '{object_name}' not found in frame {frame_idx} layout.json") return None l2s = obj_entry["local_to_scene"] result = { "translation": torch.tensor(l2s["translation"], dtype=torch.float32).unsqueeze(0), "rotation": torch.tensor(l2s["quat_wxyz"], dtype=torch.float32).unsqueeze(0), "scale": torch.tensor(l2s["scale"], dtype=torch.float32).unsqueeze(0), "shape_iou": 1.0, } intr = layout.get("intrinsics_normalized") if intr: K = torch.zeros(3, 3) K[0, 0] = intr["fx_norm"] K[1, 1] = intr["fy_norm"] K[0, 2] = intr["cx_norm"] K[1, 2] = intr["cy_norm"] K[2, 2] = 1.0 result["intrinsics"] = K.unsqueeze(0) return result # ------------------------------------------------------------------ # Decoder inversion # ------------------------------------------------------------------ @torch.no_grad() def check_encoder_available(pipeline): enc = pipeline.models["ss_encoder"] if "ss_encoder" in pipeline.models else None if enc is None: return False try: for p in enc.parameters(): if p.numel() > 0 and p.abs().sum() > 0: return True return False except Exception: return False def encode_target_occupancy(pipeline, target_occ, device, opt_steps=1000, lr=0.05, verbose=True): ss_decoder = pipeline.models["ss_decoder"] target = target_occ.float().unsqueeze(1).to(device) if check_encoder_available(pipeline): ss_encoder = pipeline.models["ss_encoder"] with torch.no_grad(): result = ss_encoder(target) z_target = result["mean"] if isinstance(result, dict) else result logger.info(f"[Encoder] z_target shape: {z_target.shape}") return z_target.detach(), "encoder" logger.info(f"SS encoder not available -- optimizing z_target through decoder ({opt_steps} steps)") z_target = torch.randn(1, 8, 16, 16, 16, device=device, requires_grad=True) optimizer = torch.optim.Adam([z_target], lr=lr) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=opt_steps) best_loss = float("inf") best_z = None for step in range(opt_steps): optimizer.zero_grad() decoded = ss_decoder(z_target) loss = F.binary_cross_entropy_with_logits(decoded, target) reg_loss = 0.001 * (z_target ** 2).mean() total_loss = loss + reg_loss total_loss.backward() optimizer.step() scheduler.step() if total_loss.item() < best_loss: best_loss = total_loss.item() best_z = z_target.detach().clone() if verbose and (step % 100 == 0 or step == opt_steps - 1): with torch.no_grad(): recon_occ = (ss_decoder(z_target) > 0).squeeze() target_bool = target.squeeze().bool() intersection = (recon_occ & target_bool).sum().item() union = (recon_occ | target_bool).sum().item() iou = intersection / max(union, 1) logger.info( f" Step {step:4d}: loss={total_loss.item():.4f}, " f"recon_IoU={iou:.4f}, lr={scheduler.get_last_lr()[0]:.6f}" ) logger.info(f"[Decoder Inversion] best_loss={best_loss:.4f}, z_target shape={best_z.shape}") return best_z, "decoder_inversion" # ------------------------------------------------------------------ # Pose encoding (decoded pose -> latent dict) # ------------------------------------------------------------------ _POSE_LATENT_KEYS = frozenset({ "6drotation_normalized", "translation", "scale", "translation_scale", }) def encode_pose_to_latent( rotation, translation, scale, scene_scale, scene_shift, device=None, ): rotation = torch.as_tensor(rotation, dtype=torch.float32) translation = torch.as_tensor(translation, dtype=torch.float32) scale = torch.as_tensor(scale, dtype=torch.float32) if device is not None: rotation = rotation.to(device) translation = translation.to(device) scale = scale.to(device) dev = rotation.device scene_scale_t = torch.as_tensor(scene_scale, dtype=torch.float32, device=dev) scene_shift_t = torch.as_tensor(scene_shift, dtype=torch.float32, device=dev) if rotation.ndim == 1: rotation = rotation.unsqueeze(0) if translation.ndim == 1: translation = translation.unsqueeze(0) if scale.ndim == 1: scale = scale.unsqueeze(0) if scale.shape[-1] == 1: scale = scale.expand(-1, 3) if rotation.ndim == 2: rotation = rotation.unsqueeze(1) if translation.ndim == 2: translation = translation.unsqueeze(1) if scale.ndim == 2: scale = scale.unsqueeze(1) pose_target_dict = PoseTargetConverter.dicts_instance_pose_to_pose_target( pose_target_convention="ScaleShiftInvariant", instance_scale_l2c=scale, instance_position_l2c=translation, instance_quaternion_l2c=rotation, scene_scale=scene_scale_t, scene_shift=scene_shift_t, ) quat = pose_target_dict["x_instance_rotation"] R = quaternion_to_matrix(quat) rot_6d = torch.cat([R[..., :, 0], R[..., :, 1]], dim=-1) rot_6d_norm = (rot_6d - ROTATION_6D_MEAN.to(dev)) / ROTATION_6D_STD.to(dev) ssi_scale = pose_target_dict["x_instance_scale"] scale_latent = torch.log(ssi_scale.clamp(min=1e-8)) trans_latent = pose_target_dict["x_instance_translation"] trans_scale = pose_target_dict["x_translation_scale"] trans_scale_latent = torch.log(trans_scale.clamp(min=1e-8)) return { "6drotation_normalized": rot_6d_norm, "translation": trans_latent, "scale": scale_latent, "translation_scale": trans_scale_latent, } def _prepare_pose_target_latent(pose_target, ss_input_dict, device): if pose_target is None: return None if _POSE_LATENT_KEYS.issubset(pose_target.keys()): return {k: torch.as_tensor(v, dtype=torch.float32, device=device) for k, v in pose_target.items() if k in _POSE_LATENT_KEYS} assert "rotation" in pose_target and "translation" in pose_target and "scale" in pose_target, ( f"Decoded pose_target must have 'rotation', 'translation', 'scale'. Got: {list(pose_target.keys())}" ) scene_scale = pose_target.get("scene_scale", ss_input_dict.get("pointmap_scale")) scene_shift = pose_target.get("scene_shift", ss_input_dict.get("pointmap_shift")) return encode_pose_to_latent( rotation=pose_target["rotation"], translation=pose_target["translation"], scale=pose_target["scale"], scene_scale=scene_scale, scene_shift=scene_shift, device=device, ) # ------------------------------------------------------------------ # Batched guided sampling (with Taylor cache support) # ------------------------------------------------------------------ def batched_guided_sample_sparse_structure( pipeline, ss_input_dict, z_target_flat, mesh_ss, num_samples=1, guidance_strength=0.7, pose_guidance_strength=0.0, pose_target=None, base_seed=42, inference_steps=None, verbose=True, pose_sde_strength=0.0, chunk_size=None, ): """Batched guided sampling with Taylor cache support. Runs K=num_samples in parallel (or chunked) forward passes. When the generator is ShortCut_faster, the Taylor expansion cache is re-initialized per chunk before the Euler loop. Returns list of K tuples (return_dict, shape_iou), one per sample. """ ss_generator = pipeline.models["ss_generator"] ss_decoder = pipeline.models["ss_decoder"] ss_generator.no_shortcut = True ss_generator.reverse_fn.strength = pipeline.ss_cfg_strength ss_generator.reverse_fn.strength_pm = pipeline.ss_cfg_strength_pm prev_steps = ss_generator.inference_steps if inference_steps: ss_generator.inference_steps = inference_steps device = ss_input_dict["image"].device alpha = guidance_strength alpha_pose = pose_guidance_strength K = num_samples if chunk_size is None: chunk_size = K # Resolve pose target to latent dict (shared across all samples) pose_target_latent = None if alpha_pose > 0 and pose_target is not None: pose_target_latent = _prepare_pose_target_latent( pose_target, ss_input_dict, device, ) # Embed conditions ONCE at batch=1, then expand per chunk with torch.no_grad(): with torch.autocast(device_type="cuda", dtype=pipeline.shape_model_dtype): condition_args_1, condition_kwargs = pipeline.get_condition_input( pipeline.condition_embedders["ss_condition_embedder"], ss_input_dict, pipeline.ss_condition_input_mapping, ) # Time schedule (shared) t_seq, d = ss_generator._prepare_t_and_d() # Detect ShortCut_faster (has cache_dic attribute) _is_faster_gen = hasattr(ss_generator, 'cache_dic') # Generate per-seed noise (exact reproducibility with sequential version) assert pipeline.is_mm_dit(), "Expected multi-modal DiT" latent_shape_1 = { k: (1,) + (v.pos_emb.shape[0], v.input_layer.in_features) for k, v in ss_generator.reverse_fn.backbone.latent_mapping.items() } all_noise = {} for ki in range(K): torch.manual_seed(base_seed + ki) noise_ki = ss_generator._generate_noise(latent_shape_1, device) for k in noise_ki: all_noise.setdefault(k, []).append(noise_ki[k]) all_noise = {k: torch.cat(v, dim=0) for k, v in all_noise.items()} if verbose: parts = [f"K={K}", f"{len(t_seq)-1} steps", f"chunk_size={chunk_size}", f"alpha_shape={alpha:.2f}"] if alpha_pose > 0: parts.append(f"alpha_pose={alpha_pose:.2f}") if pose_sde_strength > 0: parts.append(f"pose_sde={pose_sde_strength:.3f}") if _is_faster_gen: parts.append("taylor_cache=ON") logger.info(f"Batched guided sampling: {', '.join(parts)}") # Process in chunks all_x_t_chunks = [] for chunk_start in range(0, K, chunk_size): chunk_end = min(chunk_start + chunk_size, K) chunk_K = chunk_end - chunk_start with torch.no_grad(): with torch.autocast(device_type="cuda", dtype=pipeline.shape_model_dtype): x_t = {k: v[chunk_start:chunk_end].clone() for k, v in all_noise.items()} z_noise = x_t["shape"].clone() z_target = z_target_flat.expand(chunk_K, -1, -1).to(device, dtype=z_noise.dtype) pose_noise = {} if pose_target_latent is not None: for k in _POSE_LATENT_KEYS: pose_noise[k] = x_t[k].clone() condition_args = tuple( a.expand(chunk_K, *a.shape[1:]) if isinstance(a, torch.Tensor) else a for a in condition_args_1 ) # Initialize Taylor cache for this chunk (ShortCut_faster) if _is_faster_gen: from cache_utils_ss import cache_init as _ss_cache_init num_euler_steps = len(t_seq) - 1 if ss_generator.ss_params is None: ss_generator.ss_params = { 'ss_cache_stride': 3, 'ss_warmup': 2, 'ss_order': 1, 'ss_momentum_beta': 0.5, } ss_generator.cache_dic, ss_generator.current = _ss_cache_init( num_euler_steps, cache_interval=ss_generator.ss_params['ss_cache_stride'], max_order=ss_generator.ss_params['ss_order'], first_enhance=ss_generator.ss_params['ss_warmup'], end_enhance=num_euler_steps, ) ss_generator.prev_v = None for t0, t1 in zip(t_seq[:-1], t_seq[1:]): dt = t1 - t0 velocity = ss_generator._generate_dynamics( x_t, t0, d, *condition_args, **condition_kwargs ) x_next = {} for k in x_t: x_next[k] = x_t[k] + velocity[k] * dt t_next = t1 # Shape guidance if alpha > 0: z_ref = (1.0 - t_next) * z_noise + t_next * z_target x_next["shape"] = (1.0 - alpha) * x_next["shape"] + alpha * z_ref # Pose guidance if alpha_pose > 0 and pose_target_latent is not None: for k in _POSE_LATENT_KEYS: pt = pose_target_latent[k].expand(chunk_K, -1, -1).to(x_next[k].dtype) z_ref_pose = (1.0 - t_next) * pose_noise[k] + t_next * pt x_next[k] = (1.0 - alpha_pose) * x_next[k] + alpha_pose * z_ref_pose # SDE noise injection on pose channels only if pose_sde_strength > 0: sigma = 1.0 - t_next if sigma > 1e-3: var_t = sigma / max(1.0 - sigma, dt) std_dev_t = (var_t ** 0.5) * pose_sde_strength noise_scale = std_dev_t * (dt ** 0.5) for k in _POSE_LATENT_KEYS: x_next[k] = x_next[k] + noise_scale * torch.randn_like(x_next[k]) x_t = x_next all_x_t_chunks.append(x_t) # Concatenate all chunks x_t_all = {k: torch.cat([c[k] for c in all_x_t_chunks], dim=0) for k in all_x_t_chunks[0]} # Batched shape decode with torch.no_grad(): with torch.autocast(device_type="cuda", dtype=pipeline.shape_model_dtype): shape_latent = x_t_all["shape"] shape_cube = shape_latent.permute(0, 2, 1).contiguous().view(K, 8, 16, 16, 16) ss = ss_decoder(shape_cube) # Per-sample coord extraction + shape IoU results = [] for b in range(K): ret_b = {k: v[b:b+1] for k, v in x_t_all.items()} coords_b = torch.argwhere(ss[b] > 0)[:, [1, 2, 3]] batch_col = torch.full((coords_b.shape[0], 1), 0, dtype=torch.int32, device=device) coords_b = torch.cat([batch_col, coords_b], dim=1).int() ret_b["coords_original"] = coords_b if pipeline.downsample_ss_dist > 0: coords_b = prune_sparse_structure( coords_b, max_neighbor_axes_dist=pipeline.downsample_ss_dist, ) coords_b, downsample_factor = downsample_sparse_structure(coords_b) ret_b["coords"] = coords_b ret_b["downsample_factor"] = downsample_factor # Shape IoU g_coords = ret_b["coords_original"] guided_ss = torch.zeros(1, 64, 64, 64, dtype=torch.long, device=device) if g_coords.shape[0] > 0: guided_ss[0, g_coords[:, 1].long(), g_coords[:, 2].long(), g_coords[:, 3].long()] = 1 shape_iou = compute_iou(mesh_ss.to(device), guided_ss) results.append((ret_b, shape_iou)) ss_generator.inference_steps = prev_steps if verbose: logger.info(f"Batched sampling complete: {K} samples") return results # ------------------------------------------------------------------ # Sequential guided sampling (reference / fallback) # ------------------------------------------------------------------ def guided_sample_sparse_structure( pipeline, ss_input_dict, z_target_flat, mesh_ss, guidance_strength=0.7, pose_guidance_strength=0.0, pose_target=None, seed=42, inference_steps=None, verbose=True, pose_sde_strength=0.0, condition_args=None, condition_kwargs=None, ): """Single-sample sequential guided sampling with Taylor cache support.""" ss_generator = pipeline.models["ss_generator"] ss_decoder = pipeline.models["ss_decoder"] ss_generator.no_shortcut = True ss_generator.reverse_fn.strength = pipeline.ss_cfg_strength ss_generator.reverse_fn.strength_pm = pipeline.ss_cfg_strength_pm prev_steps = ss_generator.inference_steps if inference_steps: ss_generator.inference_steps = inference_steps img = ss_input_dict["image"] bs = img.shape[0] device = img.device alpha = guidance_strength alpha_pose = pose_guidance_strength pose_target_latent = None if alpha_pose > 0 and pose_target is not None: pose_target_latent = _prepare_pose_target_latent( pose_target, ss_input_dict, device, ) with torch.no_grad(): with torch.autocast(device_type="cuda", dtype=pipeline.shape_model_dtype): assert pipeline.is_mm_dit(), "Expected multi-modal DiT" latent_shape_dict = { k: (bs,) + (v.pos_emb.shape[0], v.input_layer.in_features) for k, v in ss_generator.reverse_fn.backbone.latent_mapping.items() } if condition_args is None or condition_kwargs is None: condition_args, condition_kwargs = pipeline.get_condition_input( pipeline.condition_embedders["ss_condition_embedder"], ss_input_dict, pipeline.ss_condition_input_mapping, ) torch.manual_seed(seed) x_t = ss_generator._generate_noise(latent_shape_dict, device) z_noise = x_t["shape"].clone() z_target = z_target_flat.to(device, dtype=z_noise.dtype) pose_noise = {} if pose_target_latent is not None: for k in _POSE_LATENT_KEYS: pose_noise[k] = x_t[k].clone() t_seq, d = ss_generator._prepare_t_and_d() # Initialize Taylor expansion cache for ShortCut_faster _is_faster_gen = hasattr(ss_generator, 'cache_dic') if _is_faster_gen: from cache_utils_ss import cache_init as _ss_cache_init num_euler_steps = len(t_seq) - 1 if ss_generator.ss_params is None: ss_generator.ss_params = { 'ss_cache_stride': 3, 'ss_warmup': 2, 'ss_order': 1, 'ss_momentum_beta': 0.5, } ss_generator.cache_dic, ss_generator.current = _ss_cache_init( num_euler_steps, cache_interval=ss_generator.ss_params['ss_cache_stride'], max_order=ss_generator.ss_params['ss_order'], first_enhance=ss_generator.ss_params['ss_warmup'], end_enhance=num_euler_steps, ) ss_generator.prev_v = None if verbose: parts = [f"{len(t_seq)-1} steps", f"alpha_shape={alpha:.2f}"] if alpha_pose > 0: parts.append(f"alpha_pose={alpha_pose:.2f}") if pose_sde_strength > 0: parts.append(f"pose_sde={pose_sde_strength:.3f}") logger.info(f"Guided sampling: {', '.join(parts)}") for t0, t1 in zip(t_seq[:-1], t_seq[1:]): dt = t1 - t0 velocity = ss_generator._generate_dynamics( x_t, t0, d, *condition_args, **condition_kwargs ) x_next = {} for k in x_t: x_next[k] = x_t[k] + velocity[k] * dt t_next = t1 if alpha > 0: z_ref = (1.0 - t_next) * z_noise + t_next * z_target x_next["shape"] = (1.0 - alpha) * x_next["shape"] + alpha * z_ref if alpha_pose > 0 and pose_target_latent is not None: for k in _POSE_LATENT_KEYS: z_ref_pose = (1.0 - t_next) * pose_noise[k] + t_next * pose_target_latent[k].to(x_next[k].dtype) x_next[k] = (1.0 - alpha_pose) * x_next[k] + alpha_pose * z_ref_pose if pose_sde_strength > 0: sigma = 1.0 - t_next if sigma > 1e-3: var_t = sigma / max(1.0 - sigma, dt) std_dev_t = (var_t ** 0.5) * pose_sde_strength noise_scale = std_dev_t * (dt ** 0.5) for k in _POSE_LATENT_KEYS: x_next[k] = x_next[k] + noise_scale * torch.randn_like(x_next[k]) x_t = x_next # Decode shape to coords return_dict = x_t shape_latent = return_dict["shape"] ss = ss_decoder( shape_latent.permute(0, 2, 1) .contiguous() .view(shape_latent.shape[0], 8, 16, 16, 16) ) coords = torch.argwhere(ss > 0)[:, [0, 2, 3, 4]].int() return_dict["coords_original"] = coords original_count = coords.shape[0] if pipeline.downsample_ss_dist > 0: coords = prune_sparse_structure( coords, max_neighbor_axes_dist=pipeline.downsample_ss_dist, ) coords, downsample_factor = downsample_sparse_structure(coords) return_dict["coords"] = coords return_dict["downsample_factor"] = downsample_factor ss_generator.inference_steps = prev_steps # Compute shape IoU g_coords = return_dict["coords_original"] guided_ss = torch.zeros(1, 64, 64, 64, dtype=torch.long, device=device) guided_ss[0, g_coords[:, 1].long(), g_coords[:, 2].long(), g_coords[:, 3].long()] = 1 shape_iou = compute_iou(mesh_ss.to(device), guided_ss) if verbose: logger.info( f" Final: {coords.shape[0]} coords " f"(from {original_count}, factor={downsample_factor}), " f"shape_IoU={shape_iou:.4f}" ) return return_dict, shape_iou # ------------------------------------------------------------------ # Single-frame guided pose (batched) # ------------------------------------------------------------------ def guided_predict_pose( pipeline, mesh_ss, rgba, z_target_flat, device, guidance_strength=0.7, pose_guidance_strength=0.0, pose_target=None, seed=42, post_optimize=False, init_trimesh=None, fixed_scale=None, pose_sde_strength=0.0, num_pose_samples=1, scoring_metric="shape_iou", render_mesh=None, gt_mask=None, image_hw=None, enable_shape_icp=True, pose_selection="greedy", cluster_dist_thresh=0.5, cluster_min_size=1, cluster_w_trans=1.0, cluster_w_rot=1.0, batch_chunk_size=8, ss_inference_steps=None, ll_steps=25, num_pose_samples_per_pgs=None, ): # Preprocess (once -- independent of seed) pointmap_dict = pipeline.compute_pointmap(rgba) pointmap = pointmap_dict["pointmap"] ss_input_dict = pipeline.preprocess_image( rgba, pipeline.ss_preprocessor, pointmap=pointmap, ) pointmap_scale = ss_input_dict.get("pointmap_scale", None) pointmap_shift = ss_input_dict.get("pointmap_shift", None) # Intrinsics if "intrinsics" in pointmap_dict: intrinsics = pointmap_dict["intrinsics"].detach().cpu() else: loaded_img = pipeline.image_to_float(rgba) loaded_img_t = torch.from_numpy(loaded_img).permute(2, 0, 1).contiguous()[:3] with torch.no_grad(): with torch.autocast(device_type="cuda", dtype=pipeline.dtype): dm_output = pipeline.depth_model(loaded_img_t) intrinsics = dm_output["intrinsics"].detach().cpu() # Build renderer once for render_iou scoring frame_renderer = None if scoring_metric == "render_iou" and render_mesh is not None and gt_mask is not None: H, W = image_hw frame_renderer = _build_silhouette_renderer(intrinsics.squeeze(), W, H, device) # Batched sampling: all K seeds in one (or chunked) forward pass if num_pose_samples_per_pgs is not None: # PGS sweep: sample num_pose_samples_per_pgs candidates at each pgs level pgs_levels = [i * 0.1 for i in range(10)] batched_results = [] seed_offset = 0 for pgs_val in pgs_levels: chunk_results = batched_guided_sample_sparse_structure( pipeline, ss_input_dict, z_target_flat, mesh_ss, num_samples=num_pose_samples_per_pgs, guidance_strength=guidance_strength, pose_guidance_strength=pgs_val, pose_target=pose_target, base_seed=seed + seed_offset, inference_steps=ss_inference_steps, verbose=False, pose_sde_strength=pose_sde_strength, chunk_size=batch_chunk_size, ) batched_results.extend(chunk_results) seed_offset += num_pose_samples_per_pgs num_pose_samples = len(batched_results) logger.info(f" PGS sweep: {num_pose_samples} samples across {len(pgs_levels)} levels {pgs_levels}") else: batched_results = batched_guided_sample_sparse_structure( pipeline, ss_input_dict, z_target_flat, mesh_ss, num_samples=num_pose_samples, guidance_strength=guidance_strength, pose_guidance_strength=pose_guidance_strength, pose_target=pose_target, base_seed=seed, inference_steps=ss_inference_steps, verbose=False, pose_sde_strength=pose_sde_strength, chunk_size=batch_chunk_size, ) best_result = None best_score = -float("inf") all_samples = [] for k, (guided_return_dict, shape_iou) in enumerate(batched_results): sample_seed = seed + k # Snapshot x1 latent BEFORE pose_decoder overwrites translation/scale x1_latent = { k_: guided_return_dict[k_].detach().clone().cpu() for k_ in guided_return_dict if k_ not in ("coords_original", "coords", "downsample_factor") } # Decode pose with torch.autocast(device_type="cuda", dtype=pipeline.shape_model_dtype): guided_return_dict.update(pipeline.pose_decoder( guided_return_dict, scene_scale=pointmap_scale, scene_shift=pointmap_shift, )) if "scale" in guided_return_dict and "downsample_factor" in guided_return_dict: guided_return_dict["scale"] = guided_return_dict["scale"] * guided_return_dict["downsample_factor"] # Override scale before post-optimization if fixed_scale is not None: guided_return_dict["scale"] = fixed_scale.to(guided_return_dict["scale"].device) pose = { k_: guided_return_dict[k_].detach().cpu() for k_ in ("translation", "rotation", "scale") if k_ in guided_return_dict } result = { **pose, "shape_iou": shape_iou, "intrinsics": intrinsics, "sample_seed": sample_seed, "x1_latent": x1_latent, } # Compute render IoU if requested if scoring_metric == "render_iou" and render_mesh is not None and gt_mask is not None: H, W = image_hw if "post_opt_rotation" in result: pose_for_render = { "rotation": result["post_opt_rotation"], "translation": result["post_opt_translation"], "scale": result["post_opt_scale"], } else: pose_for_render = { "rotation": result["rotation"], "translation": result["translation"], "scale": result["scale"], } riou = compute_render_iou( render_mesh, pose_for_render, intrinsics.squeeze(), gt_mask, W, H, device, renderer=frame_renderer, ) result["render_iou"] = riou # Score selection if scoring_metric == "render_iou" and "render_iou" in result: score = result["render_iou"] else: score = result["shape_iou"] all_samples.append(result) if num_pose_samples > 1: logger.info(f" sample {k+1}/{num_pose_samples} (seed={sample_seed}): score={score:.4f}") if score > best_score: best_score = score best_result = result # Candidate selection if num_pose_samples > 1: if pose_selection == "pose_log_likelihood": logger.info(f" Computing pose-only log-likelihoods for {len(all_samples)} candidates (steps={ll_steps})...") log_liks = compute_pose_only_log_likelihoods( pipeline, ss_input_dict, all_samples, steps=ll_steps, ) for sample, ll in zip(all_samples, log_liks): sample["pose_log_likelihood"] = ll best_idx = int(np.argmax(log_liks)) best_result = all_samples[best_idx] best_score = log_liks[best_idx] logger.info( f" Pose log-likelihood selection: best sample {best_idx} " f"(seed={best_result['sample_seed']}, " f"pose_log_p={best_score:.4f})" ) elif pose_selection == "cluster": best_idx, cluster_info = cluster_pose_candidates( all_samples, scoring_metric=scoring_metric, dist_thresh=cluster_dist_thresh, min_cluster_size=cluster_min_size, w_trans=cluster_w_trans, w_rot=cluster_w_rot, ) best_result = all_samples[best_idx] best_result["cluster_info"] = cluster_info logger.info( f" Cluster selection: {cluster_info['num_clusters']} clusters, " f"sizes={cluster_info['cluster_sizes']}, " f"selected cluster size={cluster_info['selected_cluster_size']}, " f"best candidate idx={best_idx} " f"(seed={best_result['sample_seed']}, " f"score={cluster_info['best_candidate_score']:.4f})" ) else: logger.info( f" Greedy best of {num_pose_samples}: " f"score={best_score:.4f} (seed={best_result['sample_seed']})" ) best_result["all_samples"] = all_samples # Run post-optimization on the best sample only if post_optimize and init_trimesh is not None: try: mesh_copy = deepcopy(init_trimesh) postopt_pose = { k_: best_result[k_].to(device) for k_ in ("translation", "rotation", "scale") if k_ in best_result } postopt = pipeline.run_post_optimization( mesh_copy, intrinsics.to(device), deepcopy(postopt_pose), ss_input_dict, force_alignment=True, fixed_scale=fixed_scale, Enable_visible_ICP=False, Enable_shape_ICP=enable_shape_icp, ) for k_ in ("translation", "rotation", "scale"): if k_ in postopt: v = postopt[k_] best_result[f"post_opt_{k_}"] = v.detach().cpu() if hasattr(v, "cpu") else v if "iou" in postopt: best_result["post_opt_iou"] = postopt["iou"] except Exception as e: logger.warning(f"Post-optimization failed: {e}") # Hard override: ensure fixed_scale is the final scale if fixed_scale is not None: fixed_cpu = fixed_scale.detach().cpu() if "post_opt_scale" in best_result: best_result["post_opt_scale"] = fixed_cpu.clone() return best_result # ------------------------------------------------------------------ # Layout / combined visualization helpers # ------------------------------------------------------------------ P3D_TO_ISAAC = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]], dtype=np.float32) _R_YUP_TO_ZUP = np.array([[1, 0, 0], [0, 0, -1], [0, 1, 0]], dtype=np.float32).T def _to_tensor(v): if isinstance(v, torch.Tensor): return v.float() return torch.tensor(v, dtype=torch.float32) def _get_best_pose(result): if "post_opt_rotation" in result: rot = result["post_opt_rotation"] trans = result["post_opt_translation"] has_nan = (torch.isnan(rot).any() if hasattr(rot, 'isnan') else False) or \ (torch.isnan(trans).any() if hasattr(trans, 'isnan') else False) if not has_nan: return { "rotation": result["post_opt_rotation"], "translation": result["post_opt_translation"], "scale": result["post_opt_scale"], } logger.warning("Post-opt pose contains NaN, falling back to diffusion pose") return { "rotation": result["rotation"], "translation": result["translation"], "scale": result["scale"], "_copied_from_diffusion": True, } return { "rotation": result["rotation"], "translation": result["translation"], "scale": result["scale"], } def _get_diffusion_pose(result): return { "rotation": result["rotation"], "translation": result["translation"], "scale": result["scale"], } def compute_new_quat(mesh_vertices_yup, rotation, translation, scale): rot = _to_tensor(rotation) if rot.dim() == 1: rot = rot.unsqueeze(0) trans = _to_tensor(translation) if trans.dim() == 1: trans = trans.unsqueeze(0) sc = _to_tensor(scale) if sc.dim() == 1: sc = sc.unsqueeze(0) old_verts = mesh_vertices_yup.copy() verts_zup = mesh_vertices_yup.astype(np.float32) @ _R_YUP_TO_ZUP verts_t = torch.from_numpy(verts_zup).float() R_l2c = quaternion_to_matrix(rot) l2c = compose_transform(scale=sc, rotation=R_l2c, translation=trans) new_verts = ( l2c.transform_points(verts_t.unsqueeze(0)).squeeze(0).numpy() @ P3D_TO_ISAAC ) matrix_proc, _, _ = trimesh.registration.procrustes( old_verts, new_verts, reflection=False, return_cost=True, ) return ScipyRotation.from_matrix(matrix_proc[:3, :3]).as_quat(scalar_first=True) def _build_intrinsics_dict(intrinsics): if intrinsics is None: return None K = intrinsics.detach().cpu().numpy() if hasattr(intrinsics, "cpu") else np.array(intrinsics) return { "fx_norm": float(K[0, 0]), "fy_norm": float(K[1, 1]), "cx_norm": float(K[0, 2]), "cy_norm": float(K[1, 2]), } def _build_pose_dict(pose, init_trimesh, include_matrix=False): rot = _to_tensor(pose["rotation"]) if rot.dim() == 1: rot = rot.unsqueeze(0) trans = _to_tensor(pose["translation"]) if trans.dim() == 1: trans = trans.unsqueeze(0) sc = _to_tensor(pose["scale"]) if sc.dim() == 1: sc = sc.unsqueeze(0) new_quat = compute_new_quat(init_trimesh.vertices.copy(), rot, trans, sc) q_wxyz = rot.detach().cpu().flatten().tolist() q_xyzw = [q_wxyz[1], q_wxyz[2], q_wxyz[3], q_wxyz[0]] d = { "translation": trans.detach().cpu().flatten().tolist(), "scale": sc.detach().cpu().flatten().tolist(), "quat_wxyz": q_wxyz, "new_quat": new_quat.tolist(), "quat_xyzw": q_xyzw, } if include_matrix: R_mat = quaternion_to_matrix(rot.detach()) tfm = compose_transform(scale=sc.detach(), rotation=R_mat, translation=trans.detach()) M = tfm.get_matrix().detach().cpu().squeeze(0) d["matrix_4x4_row_major"] = [float(v) for v in M.reshape(-1).tolist()] return d def save_combined_visualization( output_dir, mesh_path, object_name, all_results, frame_indices, init_trimesh, plane_dir=None, plane_pose=None, ): combined_dir = os.path.join(output_dir, "combined_visualization") os.makedirs(combined_dir, exist_ok=True) objects_list = [] for idx, frame_idx in enumerate(sorted(frame_indices)): result = all_results.get(frame_idx) if result is None: continue obj_name = f"{object_name}_frame{frame_idx}" best_dict = _build_pose_dict(_get_best_pose(result), init_trimesh) diff_dict = _build_pose_dict(_get_diffusion_pose(result), init_trimesh) entry = { "index": idx, "frame_idx": frame_idx, "camera_frame": f"cam{frame_idx}", "mesh_obj": f"{obj_name}.obj", "local_to_scene": best_dict, "diffusion_pose": diff_dict, } intrinsics_dict = _build_intrinsics_dict(result.get("intrinsics")) if intrinsics_dict is not None: entry["intrinsics_normalized"] = intrinsics_dict objects_list.append(entry) logger.info(f" Frame {frame_idx}: added to combined layout") if plane_dir and os.path.isdir(plane_dir): plane_src = os.path.join(plane_dir, "plane.obj") if os.path.isfile(plane_src): plane_dst = os.path.join(combined_dir, "plane") os.makedirs(plane_dst, exist_ok=True) shutil.copy(plane_src, os.path.join(plane_dst, "plane.obj")) plane_entry = { "index": len(objects_list), "mesh_obj": "plane.obj", "local_to_scene": plane_pose or { "translation": [0, 0, 0], "scale": [1, 1, 1], "new_quat": [1, 0, 0, 0], }, } objects_list.append(plane_entry) layout = { "frame": "per_camera", "note": ( f"Guided pose tracking visualization. " f"Frames: {sorted(frame_indices)}. " f"Each object's pose is in its own camera frame." ), "objects": objects_list, } layout_path = os.path.join(combined_dir, "layout.json") with open(layout_path, "w", encoding="utf-8") as f: json.dump(layout, f, indent=2) logger.info(f"Saved combined layout ({len(objects_list)} objects) to: {layout_path}") return layout_path # ------------------------------------------------------------------ # Video processing (bidirectional from init_frame) # ------------------------------------------------------------------ def process_video(args): # If num_pose_samples_per_pgs is set, compute effective num_pose_samples if args.num_pose_samples_per_pgs is not None: args.num_pose_samples = args.num_pose_samples_per_pgs * 10 logger.info(f"PGS sweep mode: {args.num_pose_samples_per_pgs} samples/level × 10 levels = {args.num_pose_samples} total") device = torch.device(args.device) init_frame = args.init_frame masks_root = args.masks_root if args.masks_root else os.path.join(args.vid_dir, "video_segmentation", "masks") if args.mesh: mesh_path = args.mesh else: init_frame_dir = get_frame_mask_dir(masks_root, init_frame) mesh_path = os.path.join( init_frame_dir, args.object_name, f"{args.object_name}.obj" ) logger.info(f"Init mesh: {mesh_path}") frame_range = None if args.frames: parts = args.frames.split(":") frame_range = (int(parts[0]), int(parts[1])) logger.info(f"Frame range: {frame_range[0]} to {frame_range[1]}") frames = discover_frames(args.vid_dir, args.object_name, frame_range, masks_root=masks_root) logger.info(f"Found {len(frames)} frames with masks for '{args.object_name}'") if not frames: logger.error("No frames found. Check vid_dir and object_name.") return frame_lookup = {fidx: (fidx, img, msk) for fidx, img, msk in frames} all_frame_indices = sorted(frame_lookup.keys()) extrinsics = None if args.hdf5_path is not None: extrinsics = load_extrinsics_from_hdf5(args.hdf5_path, all_frame_indices) logger.info(f"Loaded camera extrinsics for {len(extrinsics)} frames from {args.hdf5_path}") elif args.chain_poses: logger.info("No --hdf5_path provided; pose chaining will not account for camera motion.") if init_frame not in frame_lookup: logger.error(f"Init frame {init_frame} not found among discovered frames: " f"{all_frame_indices[:5]}...{all_frame_indices[-5:]}") return # ---- Load pipeline (Fast-SAM3D style) ---- logger.info("Loading pipeline...") config_path = os.path.join(project_root, args.config) config = OmegaConf.load(config_path) config.workspace_dir = os.path.dirname(config_path) # Fast-SAM3D acceleration config if args.enable_acceleration: args.enable_ss_cache = True args.enable_slat_carving = True args.enable_mesh_aggregation = True if args.enable_ss_cache: config['ss_generator_config_path'] = "ss_generator_faster.yaml" if args.enable_slat_carving: config['slat_generator_config_path'] = "slat_generator_faster.yaml" logger.info(f"[Fast-SAM3D] SS:{args.enable_ss_cache}, " f"SLaT:{args.enable_slat_carving}, " f"Mesh:{args.enable_mesh_aggregation}") inference = Inference(config, compile=False, args=args) pipeline = inference._pipeline # Wire up post-optimization method if pipeline.layout_post_optimization_method is None: pipeline.layout_post_optimization_method = layout_post_optimization logger.info("Wired layout_post_optimization_method onto pipeline") # Set Euler steps override ss_gen = pipeline.models["ss_generator"] if args.euler_steps is not None: ss_gen.inference_steps = args.euler_steps logger.info(f"Set euler steps to {args.euler_steps}") else: logger.info(f"Using default euler steps: {ss_gen.inference_steps}") # Set ss_params on the generator for ShortCut_faster cache if hasattr(ss_gen, 'ss_params') and ss_gen.ss_params is None: ss_gen.ss_params = { 'ss_cache_stride': args.ss_cache_stride, 'ss_warmup': args.ss_warmup, 'ss_order': args.ss_order, 'ss_momentum_beta': args.ss_momentum_beta, } logger.info(f"Set ss_params on generator: {ss_gen.ss_params}") logger.info("Pipeline loaded.") # ---- torch.compile backbone (one-time) ---- if args.torch_compile: import time as _time logger.info("Compiling DiT backbone with torch.compile(mode='default')...") _t0 = _time.perf_counter() ss_gen.reverse_fn.backbone = torch.compile( ss_gen.reverse_fn.backbone, mode="default" ) logger.info(f"torch.compile call took {_time.perf_counter() - _t0:.1f}s") # Trigger compilation with a dummy forward pass at batch=num_pose_samples logger.info("Running compile warmup (first forward triggers Triton codegen)...") _t0 = _time.perf_counter() _warmup_K = min(args.num_pose_samples, args.batch_chunk_size) _backbone = ss_gen.reverse_fn.backbone _lat_shape = { k: (1,) + (v.pos_emb.shape[0], v.input_layer.in_features) for k, v in _backbone.latent_mapping.items() } with torch.no_grad(): with torch.autocast(device_type="cuda", dtype=pipeline.shape_model_dtype): _warmup_noise = [ss_gen._generate_noise(_lat_shape, device) for _ in range(_warmup_K)] _warmup_x = {k: torch.cat([n[k] for n in _warmup_noise], dim=0) for k in _warmup_noise[0]} _dummy_rgba = np.zeros((480, 640, 4), dtype=np.uint8) _dummy_rgba[:, :, 3] = 255 _pm = pipeline.compute_pointmap(_dummy_rgba) _ss_inp = pipeline.preprocess_image(_dummy_rgba, pipeline.ss_preprocessor, pointmap=_pm["pointmap"]) _cond_args, _cond_kw = pipeline.get_condition_input( pipeline.condition_embedders["ss_condition_embedder"], _ss_inp, pipeline.ss_condition_input_mapping, ) _cond_args_K = tuple( a.expand(_warmup_K, *a.shape[1:]) if isinstance(a, torch.Tensor) else a for a in _cond_args ) ss_gen.reverse_fn.strength = pipeline.ss_cfg_strength ss_gen.reverse_fn.strength_pm = pipeline.ss_cfg_strength_pm _t_seq, _d = ss_gen._prepare_t_and_d() # For ShortCut_faster, initialize cache for warmup step if hasattr(ss_gen, 'cache_dic'): from cache_utils_ss import cache_init as _ss_cache_init ss_gen.cache_dic, ss_gen.current = _ss_cache_init( len(_t_seq) - 1, cache_interval=ss_gen.ss_params['ss_cache_stride'], max_order=ss_gen.ss_params['ss_order'], first_enhance=ss_gen.ss_params['ss_warmup'], end_enhance=len(_t_seq) - 1, ) ss_gen.prev_v = None _ = ss_gen._generate_dynamics(_warmup_x, _t_seq[0], _d, *_cond_args_K, **_cond_kw) del _warmup_noise, _warmup_x, _cond_args, _cond_kw, _cond_args_K, _ss_inp, _pm, _dummy_rgba torch.cuda.empty_cache() logger.info(f"Compile warmup done in {_time.perf_counter() - _t0:.1f}s") # ---- Voxelize mesh ---- mesh_ss, mesh_coords, scale, center = voxelize(mesh_path) logger.info(f"Voxelized: {mesh_ss.sum().item()} occupied voxels") # ---- Decoder inversion ---- z_target_5d, encode_method = encode_target_occupancy( pipeline, mesh_ss, device, opt_steps=args.latent_opt_steps, lr=args.latent_opt_lr, ) z_target_flat = z_target_5d.view(1, 8, -1).permute(0, 2, 1).contiguous() logger.info(f"z_target ready ({encode_method}), shape: {z_target_flat.shape}") init_trimesh = ( trimesh.load(mesh_path, force="mesh") if (args.post_optimize or args.save_layout or args.scoring_metric == "render_iou") else None ) init_frame_result = load_frame_result_from_layout(masks_root, args.object_name, frame_idx=init_frame) if init_frame_result is None: logger.error(f"Could not load frame {init_frame} pose from layout.json. " f"Run single-frame prediction for frame {init_frame} first.") return init_frame_scale = init_frame_result["scale"] logger.info(f"Loaded frame {init_frame} pose from layout.json " f"(scale={init_frame_scale.squeeze().tolist()})") if init_frame != 0 and not args.chain_poses: logger.warning(f"--init_frame {init_frame} without --chain_poses: " f"pose guidance will use the same init frame pose for every frame. " f"Consider adding --chain_poses for sequential propagation.") plane_pose = None if args.save_layout and args.plane_dir: init_frame_dir = get_frame_mask_dir(masks_root, init_frame) init_frame_layout_path = os.path.join(init_frame_dir, "layout.json") if os.path.isfile(init_frame_layout_path): with open(init_frame_layout_path) as f: init_frame_layout = json.load(f) for obj in init_frame_layout.get("objects", []): if obj.get("mesh_obj") == "plane.obj": plane_pose = obj["local_to_scene"] break # Load rotation velocity for adaptive pose guidance rotvel_dict = None if args.rotvel_json is not None: with open(args.rotvel_json) as f: raw = json.load(f) rotvel_dict = {int(entry["frame"]): abs(entry["rotation_deg"]) for entry in raw if "rotation_deg" in entry} logger.info(f"Loaded rotation velocity for {len(rotvel_dict)} frames from {args.rotvel_json}") # adaptive strength: --pg_ceil at 0 deg/frame, linear with --pg_slope, floor at --pg_floor. # Defaults reproduce the original formula: max(0.1, 0.7 - 0.09 * v). adaptive_pose_strength = lambda v: max(args.pg_floor, args.pg_ceil - args.pg_slope * v) logger.info(f"adaptive_pose_strength formula: max({args.pg_floor}, {args.pg_ceil} - {args.pg_slope} * v)") pose_target_from_file = None if args.pose_guidance_strength > 0 and args.pose_target_file: pose_target_data = torch.load(args.pose_target_file, map_location="cpu") pose_target_from_file = { k: v for k, v in pose_target_data.items() if k in _POSE_LATENT_KEYS or k in ("rotation", "translation", "scale", "scene_scale", "scene_shift") } logger.info(f"Loaded pose target from {args.pose_target_file} (keys: {list(pose_target_from_file.keys())})") if args.chain_poses: if args.pose_guidance_strength <= 0: logger.warning("--chain_poses requires --pose_guidance_strength > 0, " "setting pose_guidance_strength to 0.5") args.pose_guidance_strength = 0.5 render_mesh = None image_hw = None if args.scoring_metric == "render_iou": render_mesh = _build_renderable_mesh(init_trimesh, device) first_image = load_image(frames[0][1]) image_hw = (first_image.shape[0], first_image.shape[1]) logger.info(f"Render IoU scoring: mesh built, image size={image_hw}") # Split frames into backward and forward passes backward_indices = sorted( [fidx for fidx in all_frame_indices if fidx < init_frame], reverse=True, ) forward_indices = sorted( [fidx for fidx in all_frame_indices if fidx > init_frame], ) total_to_process = len(backward_indices) + len(forward_indices) logger.info(f"Init frame: {init_frame} | " f"Backward: {len(backward_indices)} frames ({backward_indices[:3]}{'...' if len(backward_indices) > 3 else ''}) | " f"Forward: {len(forward_indices)} frames ({forward_indices[:3]}{'...' if len(forward_indices) > 3 else ''})") os.makedirs(args.output_dir, exist_ok=True) all_results = {} processed_count = [0] def _process_single_frame(frame_idx, pose_target, pass_name): processed_count[0] += 1 fidx, image_path, mask_path = frame_lookup[frame_idx] logger.info( f"[{processed_count[0]}/{total_to_process}] ({pass_name}) Frame {frame_idx}: " f"{os.path.basename(image_path)} + {os.path.basename(mask_path)}" ) image = load_image(image_path) mask = load_mask(mask_path) if mask.sum() == 0: logger.warning(f" Frame {frame_idx}: empty mask -- skipping, reusing previous pose target") return None rgba = np.concatenate( [image[..., :3], (mask.astype(np.uint8) * 255)[..., None]], axis=-1 ) # Inject HFER and acceleration params hfer = calculate_hfer_robust(mask_path) if hasattr(inference, 'get_hfer'): inference.get_hfer(hfer) if hasattr(inference, 'get_params'): inference.get_params(args) # Run guided prediction (batched) torch.cuda.synchronize() _t0 = time.perf_counter() # Compute per-frame pose guidance strength # rotvel_dict[n] = rotation from frame n to n+1 # Forward (finding n+1): use rotvel[n] = rotvel[frame_idx - 1] # Backward (finding n-1): use rotvel[n-1] = rotvel[frame_idx] rotvel_key = (frame_idx - 1) if pass_name == "forward" else frame_idx if rotvel_dict is not None and rotvel_key in rotvel_dict: frame_pose_strength = adaptive_pose_strength(rotvel_dict[rotvel_key]) logger.info(f" rotvel[{rotvel_key}]={rotvel_dict[rotvel_key]:.2f} deg/frame → pose_guidance_strength={frame_pose_strength:.3f}") else: frame_pose_strength = args.pose_guidance_strength result = guided_predict_pose( pipeline, mesh_ss, rgba, z_target_flat, device, guidance_strength=args.guidance_strength, pose_guidance_strength=frame_pose_strength, pose_target=pose_target, seed=args.seed, post_optimize=args.post_optimize, init_trimesh=init_trimesh, fixed_scale=init_frame_scale if args.fix_scale_to_init_frame else None, pose_sde_strength=args.pose_sde_strength, num_pose_samples=args.num_pose_samples, scoring_metric=args.scoring_metric, render_mesh=render_mesh, gt_mask=mask, image_hw=image_hw, enable_shape_icp=args.enable_shape_icp, pose_selection=args.pose_selection, cluster_dist_thresh=args.cluster_dist_thresh, cluster_min_size=args.cluster_min_size, cluster_w_trans=args.cluster_w_trans, cluster_w_rot=args.cluster_w_rot, batch_chunk_size=args.batch_chunk_size, ss_inference_steps=args.ss_inference_steps, ll_steps=args.ll_steps, num_pose_samples_per_pgs=args.num_pose_samples_per_pgs, ) torch.cuda.synchronize() result["frame_time_s"] = time.perf_counter() - _t0 result.pop("x1_latent", None) # strip large latent before saving # Save all K samples to a separate file if args.num_pose_samples > 1 and "all_samples" in result: all_samples_data = result.pop("all_samples") # Strip large latent tensors to keep saved files lean for s in all_samples_data: s.pop("x1_latent", None) samples_save = { "frame_idx": frame_idx, "num_samples": len(all_samples_data), "scoring_metric": args.scoring_metric, "pose_selection": args.pose_selection, "best_seed": result["sample_seed"], "samples": all_samples_data, } if "cluster_info" in result: samples_save["cluster_info"] = result.pop("cluster_info") samples_path = os.path.join(args.output_dir, f"frame_{frame_idx:06d}_samples.pt") torch.save(samples_save, samples_path) # Log pose t = result["translation"].squeeze().numpy() s = result["scale"].squeeze().numpy() iou = result["shape_iou"] msg = f" pose: t=[{t[0]:.4f}, {t[1]:.4f}, {t[2]:.4f}], s={s[0]:.4f}, IoU={iou:.4f}" if "post_opt_iou" in result: msg += f", post_opt_IoU={result['post_opt_iou']:.4f}" if "render_iou" in result: msg += f", render_IoU={result['render_iou']:.4f}" logger.info(msg) all_results[frame_idx] = result return result # ---- Backward pass: K-1 -> 0 ---- if backward_indices: logger.info(f"\n{'='*60}") logger.info(f"BACKWARD PASS: frame {init_frame} -> frame {backward_indices[-1]}") logger.info(f"{'='*60}") bwd_pose_target = _get_best_pose(init_frame_result) if args.chain_poses else pose_target_from_file bwd_pose_frame = init_frame for frame_idx in backward_indices: if args.chain_poses: bwd_pose_target_in_curr = _maybe_transform_pose( bwd_pose_target, bwd_pose_frame, frame_idx, extrinsics, ) elif extrinsics is not None and pose_target_from_file is not None: bwd_pose_target_in_curr = _maybe_transform_pose( pose_target_from_file, init_frame, frame_idx, extrinsics, ) else: bwd_pose_target_in_curr = bwd_pose_target result = _process_single_frame(frame_idx, bwd_pose_target_in_curr, "backward") if result is None: continue if args.chain_poses: if args.chain_on_diffusion: bwd_pose_target = _get_diffusion_pose(result) else: bwd_pose_target = _get_best_pose(result) bwd_pose_frame = frame_idx # ---- Forward pass: K+1 -> N ---- if forward_indices: logger.info(f"\n{'='*60}") logger.info(f"FORWARD PASS: frame {init_frame} -> frame {forward_indices[-1]}") logger.info(f"{'='*60}") fwd_pose_target = _get_best_pose(init_frame_result) if args.chain_poses else pose_target_from_file fwd_pose_frame = init_frame for frame_idx in forward_indices: if args.chain_poses: fwd_pose_target_in_curr = _maybe_transform_pose( fwd_pose_target, fwd_pose_frame, frame_idx, extrinsics, ) elif extrinsics is not None and pose_target_from_file is not None: fwd_pose_target_in_curr = _maybe_transform_pose( pose_target_from_file, init_frame, frame_idx, extrinsics, ) else: fwd_pose_target_in_curr = fwd_pose_target result = _process_single_frame(frame_idx, fwd_pose_target_in_curr, "forward") if result is None: continue if args.chain_poses: if args.chain_on_diffusion: fwd_pose_target = _get_diffusion_pose(result) else: fwd_pose_target = _get_best_pose(result) fwd_pose_frame = frame_idx # Always include init frame result all_results[init_frame] = init_frame_result # Save output = { "mesh_path": mesh_path, "object_name": args.object_name, "init_frame": init_frame, "euler_steps": args.euler_steps if args.euler_steps is not None else ss_gen.inference_steps, "guidance_strength": args.guidance_strength, "pose_guidance_strength": args.pose_guidance_strength, "pose_sde_strength": args.pose_sde_strength, "num_pose_samples": args.num_pose_samples, "scoring_metric": args.scoring_metric, "pose_selection": args.pose_selection, "cluster_dist_thresh": args.cluster_dist_thresh if args.pose_selection == "cluster" else None, "cluster_min_size": args.cluster_min_size if args.pose_selection == "cluster" else None, "latent_opt_steps": args.latent_opt_steps, "encode_method": encode_method, "hdf5_path": args.hdf5_path, "enable_ss_cache": args.enable_ss_cache, "torch_compile": args.torch_compile, "batch_chunk_size": args.batch_chunk_size, "frames": all_results, } save_path = os.path.join(args.output_dir, "guided_poses.pt") torch.save(output, save_path) logger.info(f"Saved {len(all_results)} frame results to {save_path}") if args.save_layout and init_trimesh is not None: frame_indices = sorted(all_results.keys()) save_combined_visualization( args.output_dir, mesh_path, args.object_name, all_results, frame_indices, init_trimesh, plane_dir=args.plane_dir, plane_pose=plane_pose, ) # ------------------------------------------------------------------ # Main # ------------------------------------------------------------------ def main(): parser = argparse.ArgumentParser( description="Guided pose prediction for video (Fast-SAM3D batched, bidirectional from arbitrary init frame)." ) parser.add_argument("--config", default="checkpoints/hf/pipeline.yaml", help="Path to pipeline config YAML (relative to project root)") parser.add_argument("--vid_dir", required=True, help="Path to video directory") parser.add_argument("--object_name", required=True, help="Object name (e.g. bottle_0)") parser.add_argument("--masks_root", default=None, help="Override masks root directory. Default: /video_segmentation/masks") parser.add_argument("--mesh", default=None, help="Override init mesh path") parser.add_argument("--output_dir", default="guided_pose_output", help="Output directory") parser.add_argument("--device", default="cuda", help="Device") parser.add_argument("--seed", type=int, default=42, help="Random seed") parser.add_argument("--init_frame", type=int, default=0, help="Anchor frame index (default 0)") parser.add_argument("--guidance_strength", type=float, default=0.7, help="Shape guidance alpha") parser.add_argument("--pose_guidance_strength", type=float, default=0.0, help="Pose guidance alpha") parser.add_argument("--pose_target_file", default=None, help="Path to .pt file with target pose") parser.add_argument("--latent_opt_steps", type=int, default=1000, help="Decoder inversion steps") parser.add_argument("--latent_opt_lr", type=float, default=0.05, help="Decoder inversion LR") parser.add_argument("--post_optimize", action="store_true", help="Run post-optimization") parser.add_argument("--frames", default=None, help="Frame range as 'start:end'") parser.add_argument("--save_layout", action="store_true", help="Save per-frame layout.json and combined visualization") parser.add_argument("--plane_dir", default=None, help="Path to plane mesh directory") parser.add_argument("--fix_scale_to_init_frame", action="store_true", help="Fix scale to init frame's scale") parser.add_argument("--fix_scale_to_frame0", action="store_true", dest="fix_scale_to_init_frame", help=argparse.SUPPRESS) parser.add_argument("--chain_poses", action="store_true", help="Chain previous frame's pose as target for next frame") parser.add_argument("--chain_on_diffusion", action="store_true", default=False, help="When chaining, use raw diffusion pose instead of post-optimized") parser.add_argument("--pose_sde_strength", type=float, default=0.0, help="SDE noise strength for pose channels") parser.add_argument("--num_pose_samples", type=int, default=1, help="Number of pose samples (K) per frame") parser.add_argument("--num_pose_samples_per_pgs", type=int, default=None, help="Samples per PGS level (0.0, 0.1, ..., 0.9). " "Overrides --num_pose_samples. Total = this * 10.") parser.add_argument("--scoring_metric", default="shape_iou", choices=["render_iou", "shape_iou"], help="Metric for selecting best of K samples") parser.add_argument("--pose_selection", default="greedy", choices=["greedy", "cluster", "pose_log_likelihood"], help="How to select best of K pose samples") parser.add_argument("--ll_steps", type=int, default=25, help="Number of ODE integration steps for pose log-likelihood scoring") parser.add_argument("--cluster_dist_thresh", type=float, default=0.5, help="Distance threshold for clustering") parser.add_argument("--cluster_min_size", type=int, default=1, help="Minimum cluster size") parser.add_argument("--cluster_w_trans", type=float, default=1.0, help="Translation distance weight in clustering") parser.add_argument("--cluster_w_rot", type=float, default=0.5, help="Rotation distance weight in clustering") parser.add_argument("--enable_shape_icp", action=argparse.BooleanOptionalAction, default=True, help="Enable ICP in post-optimization") parser.add_argument("--hdf5_path", default=None, help="Path to HDF5 file with camera extrinsics") parser.add_argument("--rotvel_json", default=None, help="Path to rotation velocity JSON (frame_idx → degrees/frame). " "When provided, pose_guidance_strength is set per-frame via " "max(--pg_floor, --pg_ceil - --pg_slope * v).") parser.add_argument("--pg_floor", type=float, default=0.1, help="Floor for adaptive pose_guidance_strength formula (used with --rotvel_json).") parser.add_argument("--pg_ceil", type=float, default=0.7, help="Ceiling (intercept) for adaptive pose_guidance_strength formula.") parser.add_argument("--pg_slope", type=float, default=0.09, help="Slope (per deg/frame) for adaptive pose_guidance_strength formula.") parser.add_argument("--ss_inference_steps", type=int, default=None, help="Override SS generator inference steps for guided sampling") # --- Batching --- parser.add_argument("--batch_chunk_size", type=int, default=8, help="Batch chunk size for batched sampling (adjust based on GPU VRAM)") parser.add_argument("--euler_steps", type=int, default=None, help="Number of Euler steps (default: pipeline default)") # --- torch.compile --- parser.add_argument("--torch_compile", action="store_true", default=False, help="Apply torch.compile(mode='default') to DiT backbone. " "One-time ~60s compile warmup at startup.") # --- Fast-SAM3D acceleration: SS cache --- parser.add_argument("--ss_cache_stride", type=int, default=3) parser.add_argument("--ss_warmup", type=int, default=2) parser.add_argument("--ss_order", type=int, default=1) parser.add_argument("--ss_momentum_beta", type=float, default=0.5) # --- Fast-SAM3D acceleration: SLaT --- parser.add_argument("--slat_thresh", type=float, default=0.5) parser.add_argument("--slat_warmup", type=int, default=2) parser.add_argument("--slat_carving_ratio", type=float, default=0.15) # --- Fast-SAM3D acceleration: Mesh --- parser.add_argument("--mesh_spectral_threshold_low", type=float, default=0.5) parser.add_argument("--mesh_spectral_threshold_high", type=float, default=0.7) # --- Acceleration toggles --- parser.add_argument("--enable_ss_cache", action="store_true") parser.add_argument("--enable_slat_carving", action="store_true") parser.add_argument("--enable_mesh_aggregation", action="store_true") parser.add_argument("--enable_acceleration", action="store_true", help="Enable all acceleration stages (SS + SLaT + Mesh)") args = parser.parse_args() process_video(args) if __name__ == "__main__": main()