Download scripts/verify_pose.py from yianW/goal_gen_cases: direct link, hf CLI and curl.
- Browser
- Download file 13.1 kB
-
https://huggingface.co/datasets/yianW/goal_gen_cases/resolve/main/scripts/verify_pose.py
- Command line
-
hf download hf://datasets/yianW/goal_gen_cases/scripts/verify_pose.py
-
curl -L -o verify_pose.py https://huggingface.co/datasets/yianW/goal_gen_cases/resolve/main/scripts/verify_pose.py
13.1 kB
| """ | |
| Verify estimated pose by rendering the scene with the target object at the estimated position. | |
| """ | |
| import json | |
| import os | |
| import imageio | |
| import numpy as np | |
| import trimesh | |
| from scipy.spatial.transform import Rotation as R | |
| from trimesh.transformations import euler_matrix | |
| import genesis as gs | |
| def render_with_estimated_pose( | |
| output_dir: str, | |
| object_mesh_path: str, | |
| container_mesh_path: str, | |
| table_path: str = "../video_gen_assets/table.glb", | |
| use_icp_pose: bool = True, | |
| use_physics_pose: bool = False, | |
| use_physics_initial: bool = False, | |
| container_euler: list = None, | |
| pose_idx: int = None, | |
| wall_mode: bool = False, | |
| wall_x: float = -0.5, | |
| wall_height: float = 1.2, | |
| container_pos: list = None, | |
| object_scale: float = 1.0, | |
| ): | |
| """Render scene with target object at estimated pose.""" | |
| pose_label = "estimated" | |
| if use_physics_pose or use_physics_initial: | |
| # Load physics-refined pose | |
| pose_path = os.path.join(output_dir, "physics_refinement", "refined_poses.json") | |
| with open(pose_path, "r") as f: | |
| pose_data = json.load(f) | |
| if pose_idx is not None: | |
| best_pose = pose_data["valid_poses"][pose_idx] | |
| print(f"Using physics pose at index {pose_idx}") | |
| else: | |
| best_pose = pose_data.get("best_pose") | |
| if best_pose is None: | |
| raise ValueError("No valid physics-refined pose found") | |
| if use_physics_initial: | |
| # Use initial pose (before physics settling) | |
| if "init_pos" not in best_pose: | |
| raise ValueError("Initial pose not stored. Re-run physics refinement.") | |
| tvec_w = np.array(best_pose["init_pos"]) | |
| quat_wxyz = best_pose["init_quat_wxyz"] | |
| pose_label = "physics_initial" | |
| print("Using physics INITIAL pose (before settling)") | |
| else: | |
| # Use final pose (after physics settling) | |
| tvec_w = np.array(best_pose["pos"]) | |
| quat_wxyz = best_pose["quat_wxyz"] | |
| pose_label = "physics_final" | |
| print("Using physics FINAL pose (after settling)") | |
| # Convert quaternion to rotation vector | |
| quat_xyzw = [quat_wxyz[1], quat_wxyz[2], quat_wxyz[3], quat_wxyz[0]] | |
| rvec_w = R.from_quat(quat_xyzw).as_rotvec() | |
| print(f"Stability: pos_drift={best_pose['pos_drift']:.4f}m, rot_drift={best_pose['rot_drift_deg']:.2f}°") | |
| else: | |
| # Load estimated pose | |
| pose_path = os.path.join(output_dir, "pose_estimation", "best_pose.json") | |
| with open(pose_path, "r") as f: | |
| pose_data = json.load(f) | |
| if use_icp_pose and "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") | |
| else: | |
| tvec_w = np.array(pose_data["tvec_w"]) | |
| rvec_w = np.array(pose_data["rvec_w"]) | |
| print("Using 3D-3D registration pose") | |
| print(f"Position: {tvec_w}") | |
| print(f"Rotation (rotvec): {rvec_w}") | |
| # Convert rotation vector to quaternion (scalar-first for Genesis) | |
| rot = R.from_rotvec(rvec_w) | |
| quat_xyzw = rot.as_quat() # [x, y, z, w] | |
| quat_wxyz = np.array([quat_xyzw[3], quat_xyzw[0], quat_xyzw[1], quat_xyzw[2]]) # [w, x, y, z] | |
| # Load camera parameters | |
| cam_pose = np.load(os.path.join(output_dir, "cam_pose.npy")) | |
| intrinsic_K = np.load(os.path.join(output_dir, "intrinsic_K.npy")) | |
| # Extract camera position from pose matrix | |
| # cam_pose is camera-to-world transform (OpenCV convention: Z points into scene) | |
| cam_pos = cam_pose[:3, 3] | |
| # Camera Z axis in world frame (third column of rotation) points into the scene | |
| forward = cam_pose[:3, 2] | |
| # Lookat point is camera position + forward direction | |
| lookat = cam_pos + forward * 1.0 # Look 1 meter ahead | |
| print(f"Camera position: {cam_pos}") | |
| print(f"Camera forward: {forward}") | |
| print(f"Camera lookat: {lookat}") | |
| # Initialize Genesis | |
| gs.init(seed=0, precision="32", logging_level="warning") | |
| # Use same HDR environment + lighting as place_scene.py | |
| DEFAULT_HDR_PATH = os.environ.get( | |
| "DEMO_HDR_PATH", | |
| os.path.join( | |
| os.path.dirname(os.path.abspath(__file__)), | |
| "..", "video_gen_assets", | |
| "9286496a-b761-4bdf-9f08-7966281b9c69.hdr", | |
| ), | |
| ) | |
| renderer_kwargs = { | |
| "env_radius": 200.0, | |
| "lights": [ | |
| {"pos": (0, -70, 40), "color": (255.0, 255.0, 255.0), | |
| "radius": 7, "intensity": 0.42}, | |
| ], | |
| } | |
| if os.path.exists(DEFAULT_HDR_PATH): | |
| renderer_kwargs["env_surface"] = gs.surfaces.Emission( | |
| emissive_texture=gs.textures.ImageTexture( | |
| image_path=DEFAULT_HDR_PATH, | |
| image_color=(0.5, 0.5, 0.5), | |
| ) | |
| ) | |
| scene = gs.Scene( | |
| sim_options=gs.options.SimOptions(dt=0.01, substeps=5, gravity=(0, 0, -9.8)), | |
| show_viewer=False, | |
| rigid_options=gs.options.RigidOptions(enable_collision=False), | |
| renderer=gs.renderers.RayTracer(**renderer_kwargs), | |
| ) | |
| # Add camera with same parameters as original render | |
| cam = scene.add_camera( | |
| pos=tuple(cam_pos), | |
| lookat=tuple(lookat), | |
| res=(1200, 896), | |
| fov=50.0, | |
| GUI=False, | |
| spp=1024, | |
| ) | |
| mat_rigid = gs.materials.Rigid() | |
| if wall_mode: | |
| # Wall-mounted scene (e.g., hanger_hooks) | |
| from place_scene import add_wall, DEFAULT_WALL_TEXTURE | |
| c_euler = container_euler if container_euler is not None else [-180, 0, 90] | |
| # Add wall | |
| if os.path.exists(DEFAULT_WALL_TEXTURE): | |
| add_wall(scene, wall_x, wall_x, -3, 3, height=3.0, | |
| texture=DEFAULT_WALL_TEXTURE, wall_id=0) | |
| # Place container flush against wall at wall_height | |
| crx, cry, crz = np.deg2rad(c_euler) | |
| cmesh = trimesh.load(container_mesh_path, force="mesh") | |
| cmesh.apply_transform(euler_matrix(crx, cry, crz, "sxyz")) | |
| min_x = cmesh.bounds[0][0] | |
| container_x = wall_x - min_x | |
| container_entity = scene.add_entity( | |
| material=mat_rigid, | |
| morph=gs.morphs.Mesh( | |
| file=container_mesh_path, | |
| pos=[container_x, 0.0, wall_height], | |
| euler=c_euler, | |
| collision=False, | |
| ), | |
| surface=gs.surfaces.Plastic(), | |
| ) | |
| else: | |
| # Table-mounted scene (default) | |
| scene.add_entity( | |
| material=mat_rigid, | |
| morph=gs.morphs.Mesh( | |
| file=table_path, | |
| pos=[0.0, 0.0, 0.485403], | |
| euler=[90, 0, 90], | |
| collision=False, | |
| ), | |
| ) | |
| # Background wall (same as place_scene.py) | |
| DEFAULT_WALL_TEXTURE = os.environ.get( | |
| "DEMO_WALL_TEXTURE", | |
| os.path.join( | |
| os.path.dirname(os.path.abspath(__file__)), | |
| "..", "video_gen_assets", "wall-basecolor.jpg", | |
| ), | |
| ) | |
| if os.path.exists(DEFAULT_WALL_TEXTURE): | |
| from place_scene import add_wall | |
| add_wall(scene, -0.345, -0.345, -3, 3, | |
| texture=DEFAULT_WALL_TEXTURE, wall_id=0) | |
| c_euler = container_euler if container_euler is not None else [90, 0, 0] | |
| table_height = 0.7451 | |
| if container_pos is not None: | |
| c_pos = list(container_pos) | |
| print(f"Container placed at pos={c_pos} (override)") | |
| else: | |
| crx, cry, crz = np.deg2rad(c_euler) | |
| cmesh = trimesh.load(container_mesh_path, force="mesh") | |
| cmesh.apply_transform(euler_matrix(crx, cry, crz, "sxyz")) | |
| container_z = table_height - cmesh.bounds[0][2] | |
| c_pos = [0.0, 0.0, container_z] | |
| print(f"Container auto-placed at z={container_z:.4f}") | |
| container_entity_kwargs = { | |
| "material": mat_rigid, | |
| "morph": gs.morphs.Mesh( | |
| file=container_mesh_path, | |
| pos=c_pos, | |
| euler=c_euler, | |
| collision=False, | |
| ), | |
| } | |
| # Match place_scene.py: only apply Metal surface to .obj files | |
| if container_mesh_path.endswith(".obj"): | |
| container_entity_kwargs["surface"] = gs.surfaces.Metal() | |
| container_entity = scene.add_entity(**container_entity_kwargs) | |
| # Add target object (mug) at estimated pose | |
| # Convert euler to degrees for Genesis | |
| euler_deg = rot.as_euler('xyz', degrees=True) | |
| target_mesh_kwargs = { | |
| "file": object_mesh_path, | |
| "pos": list(tvec_w), | |
| "quat": list(quat_wxyz), | |
| "collision": False, | |
| } | |
| if object_scale != 1.0: | |
| target_mesh_kwargs["scale"] = object_scale | |
| target_entity = scene.add_entity( | |
| material=mat_rigid, | |
| morph=gs.morphs.Mesh(**target_mesh_kwargs), | |
| ) | |
| scene.build() | |
| # Render | |
| img, depth, seg, _ = cam.render(depth=True, segmentation=True) | |
| # Save outputs | |
| verify_dir = os.path.join(output_dir, "pose_verification") | |
| os.makedirs(verify_dir, exist_ok=True) | |
| output_path = os.path.join(verify_dir, f"rendered_at_{pose_label}_pose.png") | |
| imageio.imwrite(output_path, img) | |
| print(f"\nSaved verification render: {output_path}") | |
| # Also save a comparison side-by-side | |
| goal_image_path = os.path.join(output_dir, "image_goal.png") | |
| if os.path.exists(goal_image_path): | |
| goal_img = imageio.imread(goal_image_path) | |
| # Resize if needed | |
| if goal_img.shape[:2] != img.shape[:2]: | |
| from PIL import Image | |
| goal_pil = Image.fromarray(goal_img) | |
| goal_pil = goal_pil.resize((img.shape[1], img.shape[0]), Image.BILINEAR) | |
| goal_img = np.array(goal_pil) | |
| # Create side-by-side comparison | |
| comparison = np.concatenate([goal_img[:, :, :3], img], axis=1) | |
| comparison_path = os.path.join(verify_dir, "comparison_goal_vs_estimated.png") | |
| imageio.imwrite(comparison_path, comparison) | |
| print(f"Saved comparison: {comparison_path}") | |
| return img | |
| def main(): | |
| import argparse | |
| parser = argparse.ArgumentParser(description="Verify estimated pose by rendering") | |
| 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("--no_icp", action="store_true", | |
| help="Use pose before ICP refinement") | |
| parser.add_argument("--physics", action="store_true", | |
| help="Use physics-refined final pose (after settling)") | |
| parser.add_argument("--physics_initial", action="store_true", | |
| help="Use physics initial pose (before settling)") | |
| parser.add_argument("--container_euler", type=float, nargs=3, default=None, | |
| help="Container euler angles (default: [90, 0, 0])") | |
| parser.add_argument("--pose_idx", type=int, default=None, | |
| help="Index into valid_poses (default: use best_pose)") | |
| parser.add_argument("--container_pos", type=float, nargs=3, default=None, | |
| help="Override container position [x y z] (default: auto-compute from mesh bounds)") | |
| 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("--object_scale", type=float, default=1.0, | |
| help="Scale factor for target object mesh (default: 1.0)") | |
| args = parser.parse_args() | |
| render_with_estimated_pose( | |
| output_dir=args.output_dir, | |
| object_mesh_path=args.object_mesh_path, | |
| container_mesh_path=args.container_mesh_path, | |
| table_path=args.table_path, | |
| use_icp_pose=not args.no_icp, | |
| use_physics_pose=args.physics, | |
| use_physics_initial=args.physics_initial, | |
| container_euler=args.container_euler, | |
| pose_idx=args.pose_idx, | |
| wall_mode=args.wall, | |
| wall_x=args.wall_x, | |
| wall_height=args.wall_height, | |
| container_pos=args.container_pos, | |
| object_scale=args.object_scale, | |
| ) | |
| if __name__ == "__main__": | |
| main() | |