Download scripts/refine_pose_physics.py from yianW/goal_gen_cases: direct link, hf CLI and curl.
- Browser
- Download file 25.1 kB
-
https://huggingface.co/datasets/yianW/goal_gen_cases/resolve/main/scripts/refine_pose_physics.py
- Command line
-
hf download hf://datasets/yianW/goal_gen_cases/scripts/refine_pose_physics.py
-
curl -L -o refine_pose_physics.py https://huggingface.co/datasets/yianW/goal_gen_cases/resolve/main/scripts/refine_pose_physics.py
25.1 kB
| """ | |
| Stage 6: Physics-based pose refinement. | |
| Given an estimated pose from Stage 5, sample poses around it and validate | |
| using physics simulation. A pose is valid if: | |
| 1. No collision with container at initial placement | |
| 2. Position doesn't change much after physics settling | |
| 3. Rotation doesn't change much after physics settling | |
| """ | |
| import json | |
| import os | |
| from dataclasses import dataclass | |
| from typing import List, Optional, Tuple | |
| import numpy as np | |
| import torch | |
| from scipy.spatial.transform import Rotation as R | |
| import genesis as gs | |
| import genesis.utils.geom as gu | |
| import genesis_patch # call genesis_patch.apply() AFTER gs.init() | |
| class PhysicsRefineArgs: | |
| """Configuration for physics-based pose refinement.""" | |
| output_dir: str | |
| object_mesh_path: str | |
| container_mesh_path: str | |
| table_path: str = "../video_gen_assets/table.glb" | |
| # Scene layout (must match place_scene.py defaults) | |
| table_pos: Tuple[float, float, float] = (0.0, 0.0, 0.485403) | |
| table_euler: Tuple[float, float, float] = (90.0, 0.0, 90.0) | |
| table_height: float = 0.7451 | |
| container_euler: Tuple[float, float, float] = (90.0, 0.0, 0.0) | |
| container_pos: Optional[Tuple[float, float, float]] = None # Override auto-z placement | |
| container_scale: float = 1.0 # Scale factor for container mesh | |
| object_scale: float = 1.0 # Scale factor for target object mesh | |
| # Sampling parameters | |
| num_samples: int = 64 # Number of poses to sample (use power of 2 for parallel sim) | |
| xy_jitter: float = 0.02 # meters | |
| z_jitter: float = 0.01 # meters | |
| xyz_jitter: Tuple[float, float, float] = None # per-axis jitter (overrides xy/z) | |
| rot_jitter_deg: Tuple[float, float, float] = (5.0, 5.0, 15.0) # degrees | |
| # Physics parameters | |
| physics_steps: int = 300 # Number of simulation steps | |
| dt: float = 0.01 # Simulation timestep | |
| # Validation thresholds | |
| max_pos_drift: float = 0.03 # meters - max allowed position change | |
| max_rot_drift_deg: float = 15.0 # degrees - max allowed rotation change | |
| # Use parallel simulation | |
| use_parallel: bool = True | |
| # Wall-mounted scene (e.g., hanger_hooks) | |
| wall_mode: bool = False | |
| wall_x: float = -0.5 | |
| wall_height: float = 1.2 | |
| # CoACD decomposition parameters | |
| coacd_threshold: float = 0.01 | |
| coacd_resolution: int = 80 | |
| max_convex_hull: int = 20 | |
| # Multi-round sampling | |
| num_rounds: int = 1 # Number of rounds (each round = num_samples parallel envs) | |
| # Render initial pose for debugging | |
| render_initial: bool = False | |
| def jitter_pos(pos: np.ndarray, xy_jitter: float = 0.02, z_jitter: float = 0.01, | |
| xyz_jitter: Tuple[float, float, float] = None) -> np.ndarray: | |
| """Add small uniform noise to position. If xyz_jitter is given, use per-axis values.""" | |
| pos = np.array(pos, dtype=np.float32).copy() | |
| if xyz_jitter is not None: | |
| for i in range(3): | |
| pos[i] += np.random.uniform(-xyz_jitter[i], xyz_jitter[i]) | |
| else: | |
| pos[:2] += np.random.uniform(-xy_jitter, xy_jitter, size=2) | |
| pos[2] += np.random.uniform(-z_jitter, z_jitter) | |
| return pos | |
| def jitter_rot(euler_deg: np.ndarray, jitter_deg: Tuple[float, float, float] = (5, 5, 15)) -> np.ndarray: | |
| """Add small uniform noise to each Euler angle (degrees).""" | |
| euler_deg = np.array(euler_deg, dtype=np.float32).copy() | |
| jitter = np.array(jitter_deg) | |
| euler_deg += np.random.uniform(-jitter, jitter) | |
| return euler_deg | |
| def rotvec_to_euler_deg(rotvec: np.ndarray) -> np.ndarray: | |
| """Convert rotation vector to Euler angles in degrees.""" | |
| rot = R.from_rotvec(rotvec) | |
| return rot.as_euler('xyz', degrees=True) | |
| def euler_deg_to_quat_wxyz(euler_deg: np.ndarray) -> np.ndarray: | |
| """Convert Euler angles (degrees) to quaternion (w, x, y, z).""" | |
| rot = R.from_euler('xyz', euler_deg, degrees=True) | |
| quat_xyzw = rot.as_quat() | |
| return np.array([quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]]) | |
| def compute_rotation_diff_deg(quat1_wxyz: np.ndarray, quat2_wxyz: np.ndarray) -> float: | |
| """Compute rotation difference in degrees between two quaternions.""" | |
| # Convert to scipy format (xyzw) | |
| q1_xyzw = np.array([quat1_wxyz[1], quat1_wxyz[2], quat1_wxyz[3], quat1_wxyz[0]]) | |
| q2_xyzw = np.array([quat2_wxyz[1], quat2_wxyz[2], quat2_wxyz[3], quat2_wxyz[0]]) | |
| r1 = R.from_quat(q1_xyzw) | |
| r2 = R.from_quat(q2_xyzw) | |
| # Compute relative rotation | |
| r_diff = r1.inv() * r2 | |
| angle_rad = r_diff.magnitude() | |
| return np.degrees(angle_rad) | |
| def _load_estimated_pose(args: PhysicsRefineArgs): | |
| """Load estimated pose from Stage 5 results.""" | |
| pose_path = os.path.join(args.output_dir, "pose_estimation", "best_pose.json") | |
| with open(pose_path, "r") as f: | |
| pose_data = json.load(f) | |
| if "tvec_w_icp" in pose_data: | |
| tvec_w = np.array(pose_data["tvec_w_icp"]) | |
| rvec_w = np.array(pose_data["rvec_w_icp"]) | |
| print("Using ICP-refined pose as starting point") | |
| else: | |
| tvec_w = np.array(pose_data["tvec_w"]) | |
| rvec_w = np.array(pose_data["rvec_w"]) | |
| print("Using 3D-3D registration pose as starting point") | |
| print(f"Starting position: {tvec_w}") | |
| print(f"Starting rotation (rotvec): {rvec_w}") | |
| euler_deg = rotvec_to_euler_deg(rvec_w) | |
| return tvec_w, rvec_w, euler_deg | |
| def _build_scene(args: PhysicsRefineArgs, tvec_w, euler_deg): | |
| """Build Genesis scene for physics refinement (table or wall mode).""" | |
| import trimesh | |
| from trimesh.transformations import euler_matrix | |
| gs.init(seed=0, precision="32", logging_level="warning") | |
| genesis_patch.apply() # adds RigidEntity.detect_collision_parallel | |
| # Add renderer if rendering is requested (Rasterizer handles collision meshes) | |
| renderer_kwargs = {} | |
| if args.render_initial: | |
| renderer_kwargs["renderer"] = gs.renderers.Rasterizer() | |
| scene = gs.Scene( | |
| sim_options=gs.options.SimOptions(dt=args.dt, substeps=5), | |
| show_viewer=False, | |
| rigid_options=gs.options.RigidOptions( | |
| enable_collision=True, | |
| enable_self_collision=False, | |
| ), | |
| **renderer_kwargs, | |
| ) | |
| mat_convex = gs.materials.Rigid() | |
| mat_target = gs.materials.Rigid(friction=3.0) | |
| wall = None | |
| coacd_opts = gs.options.CoacdOptions( | |
| threshold=args.coacd_threshold, | |
| preprocess_resolution=args.coacd_resolution, | |
| decimate=True, | |
| max_convex_hull=args.max_convex_hull, | |
| ) | |
| if args.wall_mode: | |
| # Wall-mounted scene | |
| from place_scene import add_wall, DEFAULT_WALL_TEXTURE | |
| c_euler = list(args.container_euler) | |
| # Add wall as a collision plane (box) | |
| wall_thickness = 0.05 | |
| wall = scene.add_entity( | |
| material=gs.materials.Rigid(sdf_min_res=16, sdf_max_res=16), | |
| morph=gs.morphs.Box( | |
| pos=[args.wall_x - wall_thickness / 2, 0.0, 1.5], | |
| size=[wall_thickness, 3.0, 3.0], | |
| collision=True, | |
| fixed=True, | |
| ), | |
| ) | |
| # Place container flush against wall | |
| crx, cry, crz = np.deg2rad(c_euler) | |
| cmesh = trimesh.load(args.container_mesh_path, force="mesh") | |
| cmesh.apply_transform(euler_matrix(crx, cry, crz, "sxyz")) | |
| min_x = cmesh.bounds[0][0] | |
| container_x = args.wall_x - min_x | |
| container_pos = [container_x, 0.0, args.wall_height] | |
| print(f"Container placed on wall at pos={container_pos}") | |
| container = scene.add_entity( | |
| material=mat_convex, | |
| morph=gs.morphs.Mesh( | |
| file=args.container_mesh_path, | |
| pos=container_pos, | |
| euler=c_euler, | |
| scale=args.container_scale, | |
| collision=True, | |
| fixed=True, | |
| convexify=True, | |
| merge_submeshes_for_collision=False, | |
| group_by_material=False, | |
| coacd_options=coacd_opts, | |
| ), | |
| vis_mode="collision", | |
| ) | |
| else: | |
| # Table-mounted scene | |
| mat_sdf_lo = gs.materials.Rigid(sdf_min_res=16, sdf_max_res=16) | |
| c_euler = list(args.container_euler) | |
| scene.add_entity( | |
| material=mat_sdf_lo, | |
| morph=gs.morphs.Mesh( | |
| file=args.table_path, | |
| pos=list(args.table_pos), | |
| euler=list(args.table_euler), | |
| collision=True, | |
| fixed=True, | |
| convexify=True, | |
| ), | |
| ) | |
| if args.container_pos is not None: | |
| container_pos = list(args.container_pos) | |
| print(f"Container placed at pos={container_pos} (override)") | |
| else: | |
| crx, cry, crz = np.deg2rad(c_euler) | |
| cmesh = trimesh.load(args.container_mesh_path, force="mesh") | |
| cmesh.apply_transform(euler_matrix(crx, cry, crz, "sxyz")) | |
| container_z = args.table_height - cmesh.bounds[0][2] | |
| container_pos = [0.0, 0.0, container_z] | |
| print(f"Container auto-placed at z={container_z:.4f}") | |
| container = scene.add_entity( | |
| material=mat_convex, | |
| morph=gs.morphs.Mesh( | |
| file=args.container_mesh_path, | |
| pos=container_pos, | |
| euler=c_euler, | |
| scale=args.container_scale, | |
| collision=True, | |
| fixed=True, | |
| convexify=True, | |
| merge_submeshes_for_collision=False, | |
| group_by_material=False, | |
| coacd_options=coacd_opts, | |
| ), | |
| vis_mode="collision", | |
| ) | |
| # Add target object | |
| target_mesh_kwargs = { | |
| "file": args.object_mesh_path, | |
| "pos": list(tvec_w), | |
| "euler": list(euler_deg), | |
| "collision": True, | |
| "fixed": False, | |
| "coacd_options": coacd_opts, | |
| } | |
| if args.object_scale != 1.0: | |
| target_mesh_kwargs["scale"] = args.object_scale | |
| target = scene.add_entity( | |
| material=mat_target, | |
| morph=gs.morphs.Mesh(**target_mesh_kwargs), | |
| vis_mode="collision", | |
| ) | |
| for link in target.links: | |
| link._inertial_mass = 0.05 | |
| # Add camera if rendering is requested (must be before scene.build) | |
| cam = None | |
| if args.render_initial: | |
| cam_pose_path = os.path.join(args.output_dir, "cam_pose.npy") | |
| if os.path.exists(cam_pose_path): | |
| cam_pose_mat = np.load(cam_pose_path) | |
| cam_pos = cam_pose_mat[:3, 3] | |
| forward = cam_pose_mat[:3, 2] | |
| lookat = cam_pos + forward * 1.0 | |
| cam = scene.add_camera( | |
| pos=tuple(cam_pos), | |
| lookat=tuple(lookat), | |
| res=(1200, 896), | |
| fov=50.0, | |
| GUI=False, | |
| ) | |
| else: | |
| print("WARNING: cam_pose.npy not found, skipping render") | |
| return scene, container, target, wall, cam | |
| def _render_initial_pose(args: PhysicsRefineArgs, cam): | |
| """Render the initial pose with collision meshes for debugging.""" | |
| import imageio | |
| if cam is None: | |
| return | |
| img = cam.render()[0] | |
| out_dir = os.path.join(args.output_dir, "physics_refinement") | |
| os.makedirs(out_dir, exist_ok=True) | |
| out_path = os.path.join(out_dir, "initial_pose_collision_mesh.png") | |
| imageio.imwrite(out_path, img) | |
| print(f"Rendered initial pose with collision meshes: {out_path}") | |
| def refine_pose_physics_sequential(args: PhysicsRefineArgs) -> List[dict]: | |
| """ | |
| Refine pose using sequential physics simulation. | |
| Simpler but slower than parallel version. | |
| """ | |
| print("=" * 60) | |
| print("Physics-based Pose Refinement (Sequential)") | |
| print("=" * 60) | |
| tvec_w, rvec_w, euler_deg = _load_estimated_pose(args) | |
| scene, container, target, wall_ent, _ = _build_scene(args, tvec_w, euler_deg) | |
| scene.build() | |
| # Sample and validate poses | |
| valid_poses = [] | |
| print(f"\nSampling {args.num_samples} poses around estimated position...") | |
| for i in range(args.num_samples): | |
| # Jitter pose | |
| sampled_pos = jitter_pos(tvec_w, args.xy_jitter, args.z_jitter, xyz_jitter=args.xyz_jitter) | |
| sampled_euler = jitter_rot(euler_deg, args.rot_jitter_deg) | |
| sampled_quat = euler_deg_to_quat_wxyz(sampled_euler) | |
| # Reset scene and set pose | |
| scene.reset() | |
| target.set_pos(torch.tensor(sampled_pos, dtype=torch.float32)) | |
| target.set_quat(torch.tensor(sampled_quat, dtype=torch.float32)) | |
| # Record initial pose | |
| init_pos = target.get_pos().cpu().numpy() | |
| init_quat = target.get_quat().cpu().numpy() | |
| # Run physics simulation | |
| for _ in range(args.physics_steps): | |
| scene.step() | |
| # Get final pose | |
| final_pos = target.get_pos().cpu().numpy() | |
| final_quat = target.get_quat().cpu().numpy() | |
| # Compute drift | |
| pos_drift = np.linalg.norm(final_pos - init_pos) | |
| rot_drift = compute_rotation_diff_deg(init_quat, final_quat) | |
| # Check validity | |
| is_valid = (pos_drift < args.max_pos_drift) and (rot_drift < args.max_rot_drift_deg) | |
| if is_valid: | |
| valid_poses.append({ | |
| "pos": final_pos.tolist(), | |
| "quat_wxyz": final_quat.tolist(), | |
| "euler_deg": rotvec_to_euler_deg(R.from_quat( | |
| [final_quat[1], final_quat[2], final_quat[3], final_quat[0]] | |
| ).as_rotvec()).tolist(), | |
| "pos_drift": float(pos_drift), | |
| "rot_drift_deg": float(rot_drift), | |
| "sample_idx": i, | |
| }) | |
| print(f" Sample {i}: VALID (pos_drift={pos_drift:.4f}m, rot_drift={rot_drift:.2f}°)") | |
| else: | |
| if i < 10: # Only print first few invalid ones | |
| print(f" Sample {i}: invalid (pos_drift={pos_drift:.4f}m, rot_drift={rot_drift:.2f}°)") | |
| print(f"\nFound {len(valid_poses)} valid poses out of {args.num_samples} samples") | |
| return valid_poses | |
| def refine_pose_physics_parallel(args: PhysicsRefineArgs) -> List[dict]: | |
| """ | |
| Refine pose using parallel physics simulation with batched environments. | |
| Supports multiple rounds of sampling. | |
| """ | |
| print("=" * 60) | |
| print("Physics-based Pose Refinement (Parallel)") | |
| print("=" * 60) | |
| tvec_w, rvec_w, euler_deg = _load_estimated_pose(args) | |
| n_envs = args.num_samples | |
| scene, container, target, wall_ent, cam = _build_scene(args, tvec_w, euler_deg) | |
| # Build with parallel environments | |
| scene.build(n_envs=n_envs) | |
| # Render initial pose if requested (after build, before sim rounds) | |
| if args.render_initial: | |
| _render_initial_pose(args, cam) | |
| all_valid_poses = [] | |
| total_samples = 0 | |
| total_collisions = 0 | |
| for round_idx in range(args.num_rounds): | |
| if args.num_rounds > 1: | |
| print(f"\n--- Round {round_idx + 1}/{args.num_rounds} ---") | |
| # Pre-generate sampled poses for this round | |
| sampled_positions = np.zeros((n_envs, 3), dtype=np.float32) | |
| sampled_quats = np.zeros((n_envs, 4), dtype=np.float32) | |
| for i in range(n_envs): | |
| if round_idx == 0 and i == 0: | |
| # First sample of first round: original pose (no jitter) | |
| sampled_pos = np.array(tvec_w, dtype=np.float32) | |
| sampled_quat = euler_deg_to_quat_wxyz(euler_deg) | |
| else: | |
| sampled_pos = jitter_pos(tvec_w, args.xy_jitter, args.z_jitter, xyz_jitter=args.xyz_jitter) | |
| sampled_euler = jitter_rot(euler_deg, args.rot_jitter_deg) | |
| sampled_quat = euler_deg_to_quat_wxyz(sampled_euler) | |
| sampled_positions[i] = sampled_pos | |
| sampled_quats[i] = sampled_quat | |
| print(f"\nRunning {n_envs} parallel simulations...") | |
| # Reset scene state for new round | |
| scene.reset() | |
| # Set initial poses for all environments | |
| target.set_pos(torch.tensor(sampled_positions, dtype=torch.float32, device="cuda")) | |
| target.set_quat(torch.tensor(sampled_quats, dtype=torch.float32, device="cuda")) | |
| # Check initial collision before stepping (no state change) | |
| collided = target.detect_collision_parallel(with_entity=container) | |
| if wall_ent is not None: | |
| collided_wall = target.detect_collision_parallel(with_entity=wall_ent) | |
| collided = collided | collided_wall | |
| n_colliding = int(collided.sum()) | |
| total_collisions += n_colliding | |
| total_samples += n_envs | |
| print(f" Initial collision: {n_colliding}/{n_envs} envs") | |
| # Record initial poses | |
| init_pos = target.get_pos().cpu().numpy() # (n_envs, 3) | |
| init_quat = target.get_quat().cpu().numpy() # (n_envs, 4) | |
| # Run physics simulation | |
| for step in range(args.physics_steps): | |
| scene.step() | |
| if (step + 1) % 30 == 0: | |
| print(f" Step {step + 1}/{args.physics_steps}") | |
| # Get final poses | |
| final_pos = target.get_pos().cpu().numpy() # (n_envs, 3) | |
| final_quat = target.get_quat().cpu().numpy() # (n_envs, 4) | |
| # Validate all poses | |
| round_valid = 0 | |
| for i in range(n_envs): | |
| if collided[i]: | |
| continue | |
| pos_drift = np.linalg.norm(final_pos[i] - init_pos[i]) | |
| rot_drift = compute_rotation_diff_deg(init_quat[i], final_quat[i]) | |
| is_valid = (pos_drift < args.max_pos_drift) and (rot_drift < args.max_rot_drift_deg) | |
| if is_valid: | |
| quat_xyzw = [final_quat[i][1], final_quat[i][2], final_quat[i][3], final_quat[i][0]] | |
| final_euler = R.from_quat(quat_xyzw).as_euler('xyz', degrees=True) | |
| init_quat_xyzw = [init_quat[i][1], init_quat[i][2], init_quat[i][3], init_quat[i][0]] | |
| init_euler = R.from_quat(init_quat_xyzw).as_euler('xyz', degrees=True) | |
| all_valid_poses.append({ | |
| "pos": final_pos[i].tolist(), | |
| "quat_wxyz": final_quat[i].tolist(), | |
| "euler_deg": final_euler.tolist(), | |
| "init_pos": init_pos[i].tolist(), | |
| "init_quat_wxyz": init_quat[i].tolist(), | |
| "init_euler_deg": init_euler.tolist(), | |
| "pos_drift": float(pos_drift), | |
| "rot_drift_deg": float(rot_drift), | |
| "sample_idx": round_idx * n_envs + i, | |
| "round": round_idx, | |
| }) | |
| round_valid += 1 | |
| print(f" Round {round_idx + 1}: {round_valid} valid poses") | |
| print(f"\nTotal: {len(all_valid_poses)} valid poses out of {total_samples} samples " | |
| f"({total_collisions} initial collisions)") | |
| # Sort by stability (least drift) | |
| all_valid_poses.sort(key=lambda x: x["pos_drift"] + x["rot_drift_deg"] / 100) | |
| return all_valid_poses | |
| def refine_pose_physics(args: PhysicsRefineArgs) -> dict: | |
| """ | |
| Main entry point for physics-based pose refinement. | |
| Returns dict with best refined pose and all valid poses. | |
| """ | |
| if args.use_parallel: | |
| valid_poses = refine_pose_physics_parallel(args) | |
| else: | |
| valid_poses = refine_pose_physics_sequential(args) | |
| # Save results | |
| refine_dir = os.path.join(args.output_dir, "physics_refinement") | |
| os.makedirs(refine_dir, exist_ok=True) | |
| total_samples = args.num_samples * args.num_rounds | |
| results = { | |
| "num_samples": total_samples, | |
| "num_rounds": args.num_rounds, | |
| "num_valid": len(valid_poses), | |
| "valid_poses": valid_poses, | |
| "best_pose": valid_poses[0] if valid_poses else None, | |
| } | |
| results_path = os.path.join(refine_dir, "refined_poses.json") | |
| with open(results_path, "w") as f: | |
| json.dump(results, f, indent=2) | |
| print(f"\nSaved results to: {results_path}") | |
| if valid_poses: | |
| best = valid_poses[0] | |
| print(f"\nBest refined pose:") | |
| print(f" Position: {best['pos']}") | |
| print(f" Rotation (euler): {best['euler_deg']}") | |
| print(f" Stability: pos_drift={best['pos_drift']:.4f}m, rot_drift={best['rot_drift_deg']:.2f}°") | |
| return results | |
| def main(): | |
| import argparse | |
| parser = argparse.ArgumentParser(description="Physics-based pose refinement") | |
| parser.add_argument("--output_dir", type=str, default="./outputs/mug_tree_goal", | |
| help="Output directory with pipeline outputs") | |
| parser.add_argument("--object_mesh_path", type=str, default="./assets/mug_0.glb", | |
| help="Path to target object mesh") | |
| parser.add_argument("--container_mesh_path", type=str, | |
| default="./assets/metal_mug_holder/metal_mug_holder.obj", | |
| help="Path to container mesh") | |
| parser.add_argument("--table_path", type=str, | |
| default="../video_gen_assets/table.glb", | |
| help="Path to table mesh") | |
| parser.add_argument("--num_samples", type=int, default=64, | |
| help="Number of poses to sample") | |
| parser.add_argument("--sequential", action="store_true", | |
| help="Use sequential simulation instead of parallel") | |
| parser.add_argument("--container_euler", type=float, nargs=3, default=[90.0, 0.0, 0.0], | |
| help="Container euler angles in degrees (default: 90 0 0)") | |
| parser.add_argument("--container_pos", type=float, nargs=3, default=None, | |
| help="Override container position [x, y, z] (skip auto-z computation)") | |
| parser.add_argument("--xy_jitter", type=float, default=0.02, | |
| help="XY jitter range in meters (default: 0.02)") | |
| parser.add_argument("--z_jitter", type=float, default=0.01, | |
| help="Z jitter range in meters (default: 0.01)") | |
| parser.add_argument("--xyz_jitter", type=float, nargs=3, default=None, | |
| help="Per-axis jitter [x, y, z] in meters (overrides xy/z_jitter)") | |
| parser.add_argument("--rot_jitter", type=float, nargs=3, default=[5.0, 5.0, 15.0], | |
| help="Rotation jitter in degrees per axis (default: 5 5 15)") | |
| parser.add_argument("--wall", action="store_true", | |
| help="Use wall-mounted scene instead of table") | |
| parser.add_argument("--wall_x", type=float, default=-0.5, | |
| help="X position of wall plane (default: -0.5)") | |
| parser.add_argument("--wall_height", type=float, default=1.2, | |
| help="Z height to mount container on wall (default: 1.2)") | |
| parser.add_argument("--container_scale", type=float, default=1.0, | |
| help="Scale factor for container mesh (default: 1.0)") | |
| parser.add_argument("--object_scale", type=float, default=1.0, | |
| help="Scale factor for target object mesh (default: 1.0)") | |
| parser.add_argument("--coacd_threshold", type=float, default=0.01, | |
| help="CoACD threshold (default: 0.01)") | |
| parser.add_argument("--coacd_resolution", type=int, default=80, | |
| help="CoACD preprocess resolution (default: 80)") | |
| parser.add_argument("--max_convex_hull", type=int, default=20, | |
| help="CoACD max convex hulls (default: 20)") | |
| parser.add_argument("--num_rounds", type=int, default=1, | |
| help="Number of sampling rounds (default: 1)") | |
| parser.add_argument("--max_pos_drift", type=float, default=0.03, | |
| help="Max position drift for valid pose (meters, default: 0.03)") | |
| parser.add_argument("--max_rot_drift", type=float, default=15.0, | |
| help="Max rotation drift for valid pose (degrees, default: 15.0)") | |
| parser.add_argument("--render_initial", action="store_true", | |
| help="Render initial pose with collision meshes for debugging") | |
| cli_args = parser.parse_args() | |
| args = PhysicsRefineArgs( | |
| output_dir=cli_args.output_dir, | |
| object_mesh_path=cli_args.object_mesh_path, | |
| container_mesh_path=cli_args.container_mesh_path, | |
| table_path=cli_args.table_path, | |
| num_samples=cli_args.num_samples, | |
| use_parallel=not cli_args.sequential, | |
| container_euler=tuple(cli_args.container_euler), | |
| container_pos=tuple(cli_args.container_pos) if cli_args.container_pos else None, | |
| xy_jitter=cli_args.xy_jitter, | |
| z_jitter=cli_args.z_jitter, | |
| rot_jitter_deg=tuple(cli_args.rot_jitter), | |
| wall_mode=cli_args.wall, | |
| wall_x=cli_args.wall_x, | |
| wall_height=cli_args.wall_height, | |
| coacd_threshold=cli_args.coacd_threshold, | |
| coacd_resolution=cli_args.coacd_resolution, | |
| max_convex_hull=cli_args.max_convex_hull, | |
| num_rounds=cli_args.num_rounds, | |
| render_initial=cli_args.render_initial, | |
| object_scale=cli_args.object_scale, | |
| max_pos_drift=cli_args.max_pos_drift, | |
| max_rot_drift_deg=cli_args.max_rot_drift, | |
| ) | |
| refine_pose_physics(args) | |
| if __name__ == "__main__": | |
| main() | |