update

app.py

@@ -57,13 +57,13 @@ with gr.Blocks(delete_cache=(43200, 43200), theme=custom_theme) as demo:
             <a href="https://horizonrobotics.github.io/EmbodiedGen">
                 <img alt="📖 Documentation" src="https://img.shields.io/badge/📖-Documentation-blue">
             </a>
-            <a href="https://arxiv.org/abs/2506.10600">
+            <a href="https://arxiv.org/abs/2607.07459">
                 <img alt="📄 arXiv" src="https://img.shields.io/badge/📄-arXiv-b31b1b">
             </a>
             <a href="https://github.com/HorizonRobotics/EmbodiedGen">
                 <img alt="💻 GitHub" src="https://img.shields.io/badge/GitHub-000000?logo=github">
             </a>
-            <a href="https://www.youtube.com/watch?v=rG4odybuJRk">
+            <a href="https://youtu.be/MIkJJSVM8L4">
                 <img alt="🎥 Video" src="https://img.shields.io/badge/🎥-Video-red">
             </a>
         </p>

app_style.py

@@ -15,7 +15,7 @@
 # permissions and limitations under the License.
 
 from gradio.themes import Soft
-from gradio.themes.utils.colors import gray, neutral, slate, stone, teal, zinc
+from gradio.themes.utils.colors import gray, stone
 
 lighting_css = """
 <style>

common.py

@@ -16,15 +16,15 @@
 
 import spaces  # noqa: E402
 from embodied_gen.utils.monkey_patch.gradio import (
-    _disable_xformers_flash3,
     _neutralize_warp_in_parent,
     _patch_open3d_cuda_device_count_bug,
 )
 from embodied_gen.utils.monkey_patch.trellis import monkey_path_trellis
+from embodied_gen.utils.monkey_patch.xformers import disable_xformers_flash3
 
 _neutralize_warp_in_parent()
 _patch_open3d_cuda_device_count_bug()
-_disable_xformers_flash3()
+disable_xformers_flash3()
 monkey_path_trellis()
 
 
@@ -93,12 +93,6 @@ os.environ.setdefault("OPENAI_API_KEY", "sk-placeholder")
 MAX_SEED = 100000
 
 
-def _move_pipeline(pipeline: object, device: str) -> None:
-    pipeline.to(device)
-    image_encoder = getattr(pipeline, "image_encoder", None)
-    if image_encoder is not None:
-        image_encoder.to(device)
-
 # Global variables for lazy initialization
 _RBG_REMOVER = None
 _RBG14_REMOVER = None
@@ -136,6 +130,7 @@ elif os.getenv("GRADIO_APP").startswith("textto3d"):
         text_model_dir,
         device="cpu",
         download_ip_adapter=True,
+        enable_cpu_offload=True,
     )
     _PIPELINE_IMG_IP = None
     SEG_CHECKER = ImageSegChecker(GPT_CLIENT)
@@ -624,12 +619,12 @@ def text2image_fn(
                     "weights/Kolors",
                     ref_scale=ip_adapt_scale,
                     device="cpu",
+                    enable_cpu_offload=True,
                 )
             pipeline = _PIPELINE_IMG_IP
             pipeline.set_ip_adapter_scale([ip_adapt_scale])
 
         try:
-            _move_pipeline(pipeline, "cuda")
             images = text2img_gen(
                 prompt=prompt,
                 n_sample=n_sample,
@@ -641,10 +636,8 @@ def text2image_fn(
                 seed=seed,
             )
         finally:
-            try:
-                _move_pipeline(pipeline, "cpu")
-            except Exception:
-                logger.exception("Failed to move text-to-image pipeline to CPU")
+            if hasattr(pipeline, "maybe_free_model_hooks"):
+                pipeline.maybe_free_model_hooks()
             gc.collect()
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()

embodied_gen/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("embodied_gen")
+except PackageNotFoundError:
+    __version__ = "0+unknown"
+
+__all__ = ["__version__"]

embodied_gen/data/__init__.py

@@ -0,0 +1 @@
+"""Data processing utilities for EmbodiedGen."""

embodied_gen/data/asset_converter.py

@@ -24,6 +24,7 @@ from abc import ABC, abstractmethod
 from glob import glob
 from shutil import copy, copytree, rmtree
 
+import numpy as np
 import trimesh
 from scipy.spatial.transform import Rotation
 from embodied_gen.utils.enum import AssetType
@@ -204,6 +205,123 @@ class MeshtoMJCFConverter(AssetConverterBase):
         os.makedirs(os.path.dirname(dst), exist_ok=True)
         copy(src, dst)
 
+    @staticmethod
+    def _ensure_collision_volume(
+        mesh: trimesh.Trimesh,
+        min_thickness: float = 1e-3,
+    ) -> trimesh.Trimesh:
+        """Replace degenerate collision surfaces with thin boxes."""
+        extents = mesh.extents
+        if min(extents) >= min_thickness:
+            return mesh
+
+        box_extents = [max(float(extent), min_thickness) for extent in extents]
+        transform = trimesh.transformations.translation_matrix(
+            mesh.bounds.mean(axis=0)
+        )
+        return trimesh.creation.box(extents=box_extents, transform=transform)
+
+    @staticmethod
+    def _origin_to_matrix(origin: ET.Element | None) -> np.ndarray:
+        """Convert a URDF ``<origin>`` element to a 4x4 homogeneous matrix.
+
+        A missing element is treated as the identity transform. The rotation
+        follows the URDF convention (intrinsic XYZ Euler angles in radians),
+        matching ``transform_mesh`` which applies ``v' = R @ v + t``.
+        """
+        matrix = np.eye(4)
+        if origin is None:
+            return matrix
+        xyz = list(map(float, origin.get("xyz", "0 0 0").split()))
+        rpy = list(map(float, origin.get("rpy", "0 0 0").split()))
+        matrix[:3, :3] = Rotation.from_euler(
+            "xyz", rpy, degrees=False
+        ).as_matrix()
+        matrix[:3, 3] = xyz
+        return matrix
+
+    @staticmethod
+    def _bake_obj_vertices(
+        input_obj: str, output_obj: str, matrix: np.ndarray
+    ) -> None:
+        """Bake a rigid transform into an OBJ's vertex/normal lines only.
+
+        Unlike a full mesh re-export, this rewrites just the ``v`` (rotated and
+        translated) and ``vn`` (rotated) lines, leaving ``vt`` UVs, faces,
+        ``usemtl``/``mtllib`` and the referenced texture atlas byte-identical.
+        That keeps MuJoCo/Isaac Gym texturing identical to the source asset
+        while the geometry is placed in world space.
+
+        Args:
+            input_obj (str): Source OBJ path.
+            output_obj (str): Destination OBJ path.
+            matrix (np.ndarray): 4x4 homogeneous transform (rotation only,
+                no scale).
+        """
+        rotation = matrix[:3, :3]
+        translation = matrix[:3, 3]
+
+        lines: list[str] = []
+        with open(input_obj, "r", encoding="utf-8", errors="ignore") as handle:
+            for line in handle:
+                if line.startswith("v "):
+                    parts = line.split()
+                    point = (
+                        rotation @ np.array(parts[1:4], dtype=float)
+                        + translation
+                    )
+                    extra = " " + " ".join(parts[4:]) if len(parts) > 4 else ""
+                    lines.append(
+                        f"v {point[0]:.6f} {point[1]:.6f} {point[2]:.6f}{extra}\n"
+                    )
+                elif line.startswith("vn "):
+                    parts = line.split()
+                    normal = rotation @ np.array(parts[1:4], dtype=float)
+                    lines.append(
+                        f"vn {normal[0]:.6f} {normal[1]:.6f} {normal[2]:.6f}\n"
+                    )
+                else:
+                    lines.append(line)
+
+        os.makedirs(os.path.dirname(output_obj), exist_ok=True)
+        with open(output_obj, "w", encoding="utf-8") as handle:
+            handle.writelines(lines)
+
+    @classmethod
+    def _compose_origin(
+        cls,
+        outer: ET.Element | None,
+        inner: ET.Element | None,
+    ) -> ET.Element | None:
+        """Compose two URDF origins into a single ``<origin>`` element.
+
+        The returned transform applies ``inner`` first and then ``outer``
+        (``M = M_outer @ M_inner``), so baking a link's world frame onto its
+        local visual/collision origin yields world-space mesh vertices. The
+        result always carries both ``xyz`` and ``rpy`` so it can be consumed by
+        ``transform_mesh``. Returns ``None`` when both inputs are absent.
+
+        Args:
+            outer (ET.Element | None): Outer (parent/world) origin.
+            inner (ET.Element | None): Inner (local) origin.
+
+        Returns:
+            ET.Element | None: Composed origin, or ``None`` if both are ``None``.
+        """
+        if outer is None and inner is None:
+            return None
+
+        matrix = cls._origin_to_matrix(outer) @ cls._origin_to_matrix(inner)
+        xyz = matrix[:3, 3]
+        rpy = Rotation.from_matrix(matrix[:3, :3]).as_euler(
+            "xyz", degrees=False
+        )
+
+        origin = ET.Element("origin")
+        origin.set("xyz", " ".join(f"{value:.8g}" for value in xyz))
+        origin.set("rpy", " ".join(f"{value:.8g}" for value in rpy))
+        return origin
+
     def add_geometry(
         self,
         mujoco_element: ET.Element,
@@ -215,6 +333,7 @@ class MeshtoMJCFConverter(AssetConverterBase):
         mesh_name: str,
         material: ET.Element | None = None,
         is_collision: bool = False,
+        body_origin: ET.Element | None = None,
     ) -> None:
         """Adds geometry to MJCF body from URDF link.
 
@@ -228,6 +347,8 @@ class MeshtoMJCFConverter(AssetConverterBase):
             mesh_name (str): Mesh name.
             material (ET.Element, optional): Material element.
             is_collision (bool, optional): If True, treat as collision geometry.
+            body_origin (ET.Element, optional): Link world origin to bake into
+                the mesh vertices; when None only the local origin is applied.
         """
         element = link.find(tag)
         geometry = element.find("geometry")
@@ -238,9 +359,18 @@ class MeshtoMJCFConverter(AssetConverterBase):
         output_mesh = f"{output_dir}/{filename}"
         self._copy_asset_file(input_mesh, output_mesh)
 
-        mesh_origin = element.find("origin")
+        mesh_origin = self._compose_origin(body_origin, element.find("origin"))
         if mesh_origin is not None:
-            self.transform_mesh(input_mesh, output_mesh, mesh_origin)
+            if not is_collision and input_mesh.lower().endswith(".obj"):
+                # Preserve UVs/material atlas for textured visuals; a trimesh
+                # re-export would rewrite mtllib and drop the diffuse atlas.
+                self._bake_obj_vertices(
+                    input_mesh,
+                    output_mesh,
+                    self._origin_to_matrix(mesh_origin),
+                )
+            else:
+                self.transform_mesh(input_mesh, output_mesh, mesh_origin)
 
         if is_collision:
             mesh_parts = trimesh.load(
@@ -251,11 +381,13 @@ class MeshtoMJCFConverter(AssetConverterBase):
             mesh_parts = [trimesh.load(output_mesh, force="mesh")]
         for idx, mesh_part in enumerate(mesh_parts):
             if is_collision:
+                mesh_part = self._ensure_collision_volume(mesh_part)
                 idx_mesh_name = f"{mesh_name}_{idx}"
                 base, ext = os.path.splitext(filename)
                 idx_filename = f"{base}_{idx}{ext}"
-                base_outdir = os.path.dirname(output_mesh)
-                mesh_part.export(os.path.join(base_outdir, '..', idx_filename))
+                idx_output_mesh = os.path.join(output_dir, idx_filename)
+                os.makedirs(os.path.dirname(idx_output_mesh), exist_ok=True)
+                mesh_part.export(idx_output_mesh)
                 geom_attrs = {
                     "contype": "1",
                     "conaffinity": "1",
@@ -263,7 +395,11 @@ class MeshtoMJCFConverter(AssetConverterBase):
                 }
             else:
                 idx_mesh_name, idx_filename = mesh_name, filename
-                geom_attrs = {"contype": "0", "conaffinity": "0"}
+                geom_attrs = {
+                    "contype": "0",
+                    "conaffinity": "0",
+                    "density": "0",
+                }
 
             ET.SubElement(
                 mujoco_element,
@@ -271,6 +407,7 @@ class MeshtoMJCFConverter(AssetConverterBase):
                 name=idx_mesh_name,
                 file=idx_filename,
                 scale=scale,
+                inertia="shell",
             )
             geom = ET.SubElement(body, "geom", type="mesh", mesh=idx_mesh_name)
             geom.attrib.update(geom_attrs)
@@ -286,7 +423,7 @@ class MeshtoMJCFConverter(AssetConverterBase):
         output_dir: str,
         name: str,
         reflectance: float = 0.2,
-    ) -> ET.Element:
+    ) -> ET.Element | None:
         """Adds materials to MJCF asset from URDF link.
 
         Args:
@@ -306,37 +443,51 @@ class MeshtoMJCFConverter(AssetConverterBase):
         mesh = geometry.find("mesh")
         filename = mesh.get("filename")
         dirname = os.path.dirname(filename)
-        material = None
-        for path in glob(f"{input_dir}/{dirname}/*.png"):
-            file_name = os.path.basename(path)
-            if "keep_materials" in self.kwargs:
-                find_flag = False
-                for keep_key in self.kwargs["keep_materials"]:
-                    if keep_key in file_name.lower():
-                        find_flag = True
-                if find_flag is False:
-                    continue
-
-            self._copy_asset_file(
-                path,
-                f"{output_dir}/{dirname}/{file_name}",
-            )
-            texture_name = f"texture_{name}_{os.path.splitext(file_name)[0]}"
-            material = ET.SubElement(
-                mujoco_element,
-                "material",
-                name=f"material_{name}",
-                texture=texture_name,
-                reflectance=str(reflectance),
-            )
-            ET.SubElement(
-                mujoco_element,
-                "texture",
-                name=texture_name,
-                type="2d",
-                file=f"{dirname}/{file_name}",
-            )
-
+        texture_paths = sorted(glob(f"{input_dir}/{dirname}/*.png"))
+        keep_materials = self.kwargs.get("keep_materials")
+        if keep_materials:
+            texture_paths = [
+                path
+                for path in texture_paths
+                if any(
+                    key.lower() in os.path.basename(path).lower()
+                    for key in keep_materials
+                )
+            ]
+        if not texture_paths:
+            return None
+
+        texture_path = next(
+            (
+                path
+                for path in texture_paths
+                if "diffuse" in os.path.basename(path).lower()
+            ),
+            texture_paths[0],
+        )
+        file_name = os.path.basename(texture_path)
+        texture_file = (
+            os.path.join(dirname, file_name) if dirname else file_name
+        )
+        self._copy_asset_file(
+            texture_path,
+            os.path.join(output_dir, texture_file),
+        )
+        texture_name = f"texture_{name}_{os.path.splitext(file_name)[0]}"
+        material = ET.SubElement(
+            mujoco_element,
+            "material",
+            name=f"material_{name}",
+            texture=texture_name,
+            reflectance=str(reflectance),
+        )
+        ET.SubElement(
+            mujoco_element,
+            "texture",
+            name=texture_name,
+            type="2d",
+            file=texture_file,
+        )
         return material
 
     def convert(self, urdf_path: str, mjcf_path: str):
@@ -369,7 +520,7 @@ class MeshtoMJCFConverter(AssetConverterBase):
                 output_dir,
                 name=str(idx),
             )
-            joint = ET.SubElement(body, "joint", attrib={"type": "free"})
+            ET.SubElement(body, "joint", attrib={"type": "free"})
             self.add_geometry(
                 mujoco_asset,
                 link,
@@ -427,6 +578,37 @@ class URDFtoMJCFConverter(MeshtoMJCFConverter):
         output_dir = os.path.dirname(mjcf_path)
         os.makedirs(output_dir, exist_ok=True)
 
+        parent_by_child = {}
+        origin_by_child = {}
+        for joint in root.findall("joint"):
+            joint_type = joint.get("type")
+            if joint_type != "fixed":
+                raise NotImplementedError(
+                    f"URDFtoMJCFConverter only supports fixed joints, got "
+                    f"{joint_type!r} for joint {joint.get('name')!r}."
+                )
+            parent_by_child[joint.find("child").get("link")] = joint.find(
+                "parent"
+            ).get("link")
+            origin_by_child[joint.find("child").get("link")] = joint.find(
+                "origin"
+            )
+
+        link_world_origins = {}
+
+        def get_link_world_origin(link_name: str) -> ET.Element | None:
+            if link_name in link_world_origins:
+                return link_world_origins[link_name]
+            parent_link = parent_by_child.get(link_name)
+            if parent_link is None:
+                link_world_origins[link_name] = None
+            else:
+                link_world_origins[link_name] = self._compose_origin(
+                    get_link_world_origin(parent_link),
+                    origin_by_child.get(link_name),
+                )
+            return link_world_origins[link_name]
+
         body_dict = {}
         for idx, link in enumerate(root.findall("link")):
             link_name = link.get("name", f"unnamed_link_{idx}")
@@ -450,6 +632,7 @@ class URDFtoMJCFConverter(MeshtoMJCFConverter):
                     output_dir,
                     f"visual_mesh_{idx}",
                     material,
+                    body_origin=get_link_world_origin(link_name),
                 )
             if link.find("collision") is not None:
                 self.add_geometry(
@@ -461,18 +644,15 @@ class URDFtoMJCFConverter(MeshtoMJCFConverter):
                     output_dir,
                     f"collision_mesh_{idx}",
                     is_collision=True,
+                    body_origin=get_link_world_origin(link_name),
                 )
 
-        # Process joints to set transformations and hierarchy
+        # Fixed-joint world transforms are baked into the mesh vertices above,
+        # so here we only rebuild the body hierarchy (all bodies stay at the
+        # identity frame), keeping the output identical across MuJoCo/Isaac Gym.
         for joint in root.findall("joint"):
-            joint_type = joint.get("type")
-            if joint_type != "fixed":
-                logger.warning("Only support fixed joints in conversion now.")
-                continue
-
             parent_link = joint.find("parent").get("link")
             child_link = joint.find("child").get("link")
-            origin = joint.find("origin")
             if parent_link not in body_dict or child_link not in body_dict:
                 logger.warning(
                     f"Parent or child link not found for joint: {joint.get('name')}"
@@ -483,11 +663,6 @@ class URDFtoMJCFConverter(MeshtoMJCFConverter):
             mujoco_worldbody.remove(child_body)
             parent_body = body_dict[parent_link]
             parent_body.append(child_body)
-            if origin is not None:
-                xyz = origin.get("xyz", "0 0 0")
-                rpy = origin.get("rpy", "0 0 0")
-                child_body.set("pos", xyz)
-                child_body.set("euler", rpy)
 
         tree = ET.ElementTree(mujoco_struct)
         ET.indent(tree, space="  ", level=0)
@@ -916,13 +1091,6 @@ if __name__ == "__main__":
 
     urdf_paths = [
         'outputs/EmbodiedGenData/demo_assets/banana/result/banana.urdf',
-        'outputs/EmbodiedGenData/demo_assets/book/result/book.urdf',
-        'outputs/EmbodiedGenData/demo_assets/lamp/result/lamp.urdf',
-        'outputs/EmbodiedGenData/demo_assets/mug/result/mug.urdf',
-        'outputs/EmbodiedGenData/demo_assets/remote_control/result/remote_control.urdf',
-        "outputs/EmbodiedGenData/demo_assets/rubik's_cube/result/rubik's_cube.urdf",
-        'outputs/EmbodiedGenData/demo_assets/table/result/table.urdf',
-        'outputs/EmbodiedGenData/demo_assets/vase/result/vase.urdf',
     ]
 
     if target_asset_type == AssetType.MJCF:
@@ -937,13 +1105,6 @@ if __name__ == "__main__":
     elif target_asset_type == AssetType.USD:
         output_files = [
             'outputs/EmbodiedGenData/demo_assets/banana/usd/banana.usd',
-            'outputs/EmbodiedGenData/demo_assets/book/usd/book.usd',
-            'outputs/EmbodiedGenData/demo_assets/lamp/usd/lamp.usd',
-            'outputs/EmbodiedGenData/demo_assets/mug/usd/mug.usd',
-            'outputs/EmbodiedGenData/demo_assets/remote_control/usd/remote_control.usd',
-            "outputs/EmbodiedGenData/demo_assets/rubik's_cube/usd/rubik's_cube.usd",
-            'outputs/EmbodiedGenData/demo_assets/table/usd/table.usd',
-            'outputs/EmbodiedGenData/demo_assets/vase/usd/vase.usd',
         ]
         asset_converter = AssetConverterFactory.create(
             target_type=AssetType.USD,
@@ -979,8 +1140,21 @@ if __name__ == "__main__":
 
     # # Convert infinigen usdc to physics usdc
     # converter = PhysicsUSDAdder()
+    # usd_paths = [
+    #     "outputs/gen_rooms_v2/simple/House_seed0/usd/export_scene/export_scene.usdc",
+    # ]
     # with converter:
-    #     converter.convert(
-    #         usd_path="/home/users/xinjie.wang/xinjie/infinigen/outputs/usdc/export_scene/export_scene.usdc",
-    #         output_file="/home/users/xinjie.wang/xinjie/infinigen/outputs/usdc_p3/export_scene/export_scene.usdc",
-    #     )
+    #     for usd_path in usd_paths:
+    #         output_path = usd_path.replace("/export_scene/", "/export_scene_physics/")
+    #         converter.convert(usd_path=usd_path, output_file=output_path)
+
+    # converter = URDFtoMJCFConverter()
+    # urdf_paths = [
+    #     "outputs/gen_rooms_v2/simple/House_seed0/urdf/export_scene/scene.urdf",
+
+    #     # "outputs/gen_rooms_v2/detail/House_seed0/urdf/export_scene/scene.urdf",
+    # ]
+    # for urdf_path in urdf_paths:
+    #     output_path = urdf_path.replace("/urdf/export_scene/", "/mjcf/export_scene/").replace(".urdf", ".xml")
+    #     os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    #     converter.convert(urdf_path=urdf_path, mjcf_path=output_path)

embodied_gen/data/backproject_v3.py

@@ -419,7 +419,7 @@ def parse_args():
     parser.add_argument(
         "--save_glb_path", type=str, default=None, help="Save glb path."
     )
-    parser.add_argument("--n_max_faces", type=int, default=30000)
+    parser.add_argument("--n_max_faces", type=int, default=50000)
     args, unknown = parser.parse_known_args()
 
     return args

embodied_gen/data/differentiable_render.py

@@ -80,7 +80,11 @@ def create_mp4_from_images(
     color = (255, 255, 255)
     position = (20, 25)
 
-    with imageio.get_writer(output_path, fps=fps) as writer:
+    with imageio.get_writer(
+        output_path,
+        fps=fps,
+        macro_block_size=1,
+    ) as writer:
         for image in images:
             image = image.clip(min=0, max=1)
             image = (255.0 * image).astype(np.uint8)
@@ -147,6 +151,7 @@ class ImageRender(object):
         gen_viewnormal_mp4 (bool, optional): Generate MP4 of view-space normals. Defaults to False.
         gen_glonormal_mp4 (bool, optional): Generate MP4 of global-space normals. Defaults to False.
         no_index_file (bool, optional): Skip saving index file. Defaults to False.
+        video_fps (int, optional): FPS for generated videos. Defaults to 15.
         light_factor (float, optional): PBR light intensity multiplier. Defaults to 1.0.
 
     Example:
@@ -185,7 +190,9 @@ class ImageRender(object):
         gen_viewnormal_mp4: bool = False,
         gen_glonormal_mp4: bool = False,
         no_index_file: bool = False,
+        video_fps: int = 15,
         light_factor: float = 1.0,
+        metallic: bool = False,
     ) -> None:
         camera = init_kal_camera(camera_params)
         self.camera = camera
@@ -218,7 +225,9 @@ class ImageRender(object):
         self.gen_color_mp4 = gen_color_mp4
         self.gen_viewnormal_mp4 = gen_viewnormal_mp4
         self.gen_glonormal_mp4 = gen_glonormal_mp4
+        self.video_fps = video_fps
         self.light_factor = light_factor
+        self.metallic = metallic
         self.no_index_file = no_index_file
 
     def render_mesh(
@@ -313,7 +322,7 @@ class ImageRender(object):
                 create_mp4_from_images(
                     rendered_normals,
                     output_path=f"{output_dir}/normal.mp4",
-                    fps=15,
+                    fps=self.video_fps,
                     prompt=prompt,
                 )
             else:
@@ -325,9 +334,9 @@ class ImageRender(object):
                 data_dict[RenderItems.GLOBAL_NORMAL.value] = render_paths
 
             if RenderItems.VIEW_NORMAL.value in self.render_items:
-                assert (
-                    RenderItems.GLOBAL_NORMAL in self.render_items
-                ), f"Must render global normal firstly, got render_items: {self.render_items}."  # noqa
+                assert RenderItems.GLOBAL_NORMAL in self.render_items, (
+                    f"Must render global normal firstly, got render_items: {self.render_items}."
+                )  # noqa
                 rendered_view_normals = self.renderer.transform_normal(
                     rendered_normals, self.mv, masks, to_view=True
                 )
@@ -336,7 +345,7 @@ class ImageRender(object):
                     create_mp4_from_images(
                         rendered_view_normals,
                         output_path=f"{output_dir}/view_normal.mp4",
-                        fps=15,
+                        fps=self.video_fps,
                         prompt=prompt,
                     )
                 else:
@@ -388,7 +397,10 @@ class ImageRender(object):
             try:
                 for idx, cam in enumerate(self.camera):
                     image, albedo, diffuse, _ = render_pbr(
-                        mesh, cam, light_factor=self.light_factor
+                        mesh,
+                        cam,
+                        light_factor=self.light_factor,
+                        metallic=self.metallic,
                     )
                     image = torch.cat([image[0], masks[idx]], axis=-1)
                     images.append(image.detach().cpu().numpy())
@@ -409,14 +421,14 @@ class ImageRender(object):
                 create_gif_from_images(
                     images,
                     output_path=f"{output_dir}/color.gif",
-                    fps=15,
+                    fps=self.video_fps,
                 )
 
             if self.gen_color_mp4:
                 create_mp4_from_images(
                     images,
                     output_path=f"{output_dir}/color.mp4",
-                    fps=15,
+                    fps=self.video_fps,
                     prompt=prompt,
                 )
 
@@ -507,6 +519,12 @@ def parse_args():
         default=1.0,
         help="Light factor for mesh PBR rendering (default: 1.)",
     )
+    parser.add_argument(
+        "--pbr_metallic",
+        action=argparse.BooleanOptionalAction,
+        default=False,
+        help="Whether to keep metallic material properties for mesh PBR rendering (default: True).",
+    )
     parser.add_argument(
         "--with_mtl",
         action="store_true",
@@ -544,6 +562,12 @@ def parse_args():
         default=None,
         help="Text prompts for the rendering.",
     )
+    parser.add_argument(
+        "--video_fps",
+        type=int,
+        default=15,
+        help="FPS for generated video outputs.",
+    )
 
     args, unknown = parser.parse_known_args()
 
@@ -607,7 +631,9 @@ def entrypoint(**kwargs) -> None:
         gen_color_mp4=args.gen_color_mp4,
         gen_viewnormal_mp4=args.gen_viewnormal_mp4,
         gen_glonormal_mp4=args.gen_glonormal_mp4,
+        video_fps=args.video_fps,
         light_factor=args.pbr_light_factor,
+        metallic=args.pbr_metallic,
         no_index_file=gen_video or args.no_index_file,
     )
     image_render.render_mesh(

embodied_gen/data/mesh_operator.py

@@ -159,9 +159,10 @@ class MeshFixer(object):
             yaws.append(y)
             pitchs.append(p)
 
-        yaws, pitchs = torch.tensor(yaws).to(vertices), torch.tensor(
-            pitchs
-        ).to(vertices)
+        yaws, pitchs = (
+            torch.tensor(yaws).to(vertices),
+            torch.tensor(pitchs).to(vertices),
+        )
         radius, fov = 2.0, torch.deg2rad(torch.tensor(40)).to(vertices)
         projection = utils3d.torch.perspective_from_fov_xy(fov, fov, 1, 3)
 
@@ -361,7 +362,7 @@ class MeshFixer(object):
 
             tqdm.write(f"Removed {(~mask).sum()} faces by mincut")
         else:
-            tqdm.write(f"Removed 0 faces by mincut")
+            tqdm.write("Removed 0 faces by mincut")
 
         # Fill small boundaries (holes)
         mesh = _meshfix.PyTMesh()

embodied_gen/data/utils.py

@@ -21,6 +21,7 @@ import os
 import time
 import zipfile
 from contextlib import contextmanager
+from copy import deepcopy
 from dataclasses import dataclass, field
 from shutil import rmtree
 from typing import List, Tuple, Union
@@ -441,6 +442,37 @@ def save_images(
     return save_paths
 
 
+def _disable_metallic_for_render(materials):
+    if materials is None:
+        return
+
+    for material in materials:
+        if hasattr(material, "metallic_texture"):
+            material.metallic_texture = None
+        if (
+            hasattr(material, "metallic_value")
+            and material.metallic_value is not None
+        ):
+            if torch.is_tensor(material.metallic_value):
+                material.metallic_value = torch.zeros_like(
+                    material.metallic_value
+                )
+            else:
+                material.metallic_value = 0.0
+
+
+def _build_render_materials(mesh, metallic: bool = False):
+    if metallic:
+        return None
+
+    if mesh.materials is None:
+        return None
+
+    render_materials = deepcopy(mesh.materials)
+    _disable_metallic_for_render(render_materials)
+    return render_materials
+
+
 def _current_lighting(
     azimuths: List[float],
     elevations: List[float],
@@ -471,29 +503,59 @@ def _current_lighting(
     return light_condition
 
 
+def _uniform_lighting(
+    light_factor: float = 1.0,
+    device: str = "cuda",
+    sharpness: float = 0.5,
+    num_lights: int = 1024,
+):
+    indices = torch.arange(num_lights, dtype=torch.float32, device=device)
+    golden_angle = math.pi * (3.0 - math.sqrt(5.0))
+    z = 1.0 - 2.0 * (indices + 0.5) / num_lights
+    radius = torch.sqrt(torch.clamp(1.0 - z * z, min=0.0))
+    theta = golden_angle * indices
+    directions = torch.stack(
+        [
+            radius * torch.cos(theta),
+            radius * torch.sin(theta),
+            z,
+        ],
+        dim=1,
+    )
+    directions = F.normalize(directions, dim=1)
+
+    amplitude = torch.ones_like(directions) * (light_factor / len(directions))
+    light_condition = kal.render.lighting.SgLightingParameters(
+        amplitude=amplitude,
+        direction=directions,
+        sharpness=sharpness,
+    ).to(device)
+
+    return light_condition
+
+
 def render_pbr(
     mesh,
     camera,
     device="cuda",
     cxt=None,
-    custom_materials=None,
     light_factor=1.0,
+    metallic: bool = False,
 ):
     if cxt is None:
         cxt = dr.RasterizeCudaContext()
 
-    light_condition = _current_lighting(
-        azimuths=[0, 90, 180, 270],
-        elevations=[90, 60, 30, 20],
+    light_condition = _uniform_lighting(
         light_factor=light_factor,
         device=device,
     )
+    render_materials = _build_render_materials(mesh, metallic)
     render_res = kal.render.easy_render.render_mesh(
         camera,
         mesh,
         lighting=light_condition,
         nvdiffrast_context=cxt,
-        custom_materials=custom_materials,
+        custom_materials=render_materials,
     )
 
     image = render_res[kal.render.easy_render.RenderPass.render]
@@ -676,9 +738,9 @@ def import_kaolin_mesh(mesh_path: str, with_mtl: bool = False):
         mesh = kal.io.obj.import_mesh(mesh_path, with_materials=with_material)
         if with_mtl and mesh.materials and len(mesh.materials) > 0:
             material = kal.render.materials.PBRMaterial()
-            assert (
-                "map_Kd" in mesh.materials[0]
-            ), "'map_Kd' not found in materials."
+            assert "map_Kd" in mesh.materials[0], (
+                "'map_Kd' not found in materials."
+            )
             material.diffuse_texture = mesh.materials[0]["map_Kd"] / 255.0
             mesh.materials = [material]
     elif mesh_path.endswith(".ply"):
@@ -727,6 +789,7 @@ def save_mesh_with_mtl(
     output_path: str,
     material_base=(250, 250, 250, 255),
     mesh_process: bool = True,
+    glossiness: float = 250.0,
 ) -> trimesh.Trimesh:
     if isinstance(texture, np.ndarray):
         texture = Image.fromarray(texture)
@@ -742,6 +805,8 @@ def save_mesh_with_mtl(
         diffuse=material_base,
         ambient=material_base,
         specular=material_base,
+        # 250 gives a tight visible highlight similar to glossy plastic.
+        glossiness=glossiness,
     )
 
     dir_name = os.path.dirname(output_path)

embodied_gen/envs/__init__.py

@@ -0,0 +1 @@
+"""Simulation environments for EmbodiedGen."""

embodied_gen/envs/pick_embodiedgen.py

@@ -289,7 +289,7 @@ class PickEmbodiedGen(BaseEnv):
             options: A dictionary of options for loading the scene.
         """
         all_objects = []
-        logger.info(f"Loading EmbodiedGen assets...")
+        logger.info("Loading EmbodiedGen assets...")
         for env_idx in range(self.num_envs):
             env_actors = load_assets_from_layout_file(
                 self.scene,

embodied_gen/models/__init__.py

@@ -0,0 +1 @@
+"""Model implementations for EmbodiedGen."""

embodied_gen/models/gs_model.py

@@ -488,7 +488,7 @@ class GaussianOperator(GaussianBase):
         renders = renders[0]
         alphas = alphas[0].squeeze(-1)
 
-        assert renders.shape[-1] == 4, f"Must render rgb, depth and alpha"
+        assert renders.shape[-1] == 4, "Must render rgb, depth and alpha"
         rendered_rgb, rendered_depth = torch.split(renders, [3, 1], dim=-1)
 
         return RenderResult(

embodied_gen/models/hunyuan3d.py

@@ -0,0 +1,957 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+import re
+import socket
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from glob import glob
+from http.client import HTTPSConnection
+from shutil import copy, copytree, rmtree
+from typing import Optional, Tuple
+
+import numpy as np
+import trimesh
+from PIL import Image
+from embodied_gen.data.differentiable_render import (
+    entrypoint as render_pbr_video,
+)
+from embodied_gen.data.utils import delete_dir
+from embodied_gen.utils.gpt_clients import GPT_CLIENT
+from embodied_gen.utils.log import logger
+from embodied_gen.utils.process_media import combine_images_to_grid
+from embodied_gen.utils.tags import VERSION
+from embodied_gen.validators.quality_checkers import (
+    BaseChecker,
+    ImageSegChecker,
+)
+from embodied_gen.validators.urdf_convertor import URDFGenerator
+
+
+@dataclass(frozen=True)
+class HunyuanConfig:
+    """Tencent Hunyuan3D Pro endpoint + timing.
+
+    Defaults match the validated probe in ``outputs/hunyuan3d_api_expert/``.
+    Only the Pro action set is supported.
+    """
+
+    host: str = "ai3d.tencentcloudapi.com"
+    service: str = "ai3d"
+    region: str = "ap-guangzhou"
+    version: str = "2025-05-13"
+    image_action: str = "SubmitHunyuanTo3DProJob"
+    query_action: str = "QueryHunyuanTo3DProJob"
+    result_format: str = "GLB"
+    texture_size: int = 2048
+    connect_timeout: float = 10.0
+    read_timeout: float = 60.0
+    poll_interval: float = 10.0
+    max_wait_seconds: float = 900.0
+    max_download_bytes: int = 512 * 1024 * 1024
+
+
+def load_credentials() -> Tuple[str, str]:
+    """Read Tencent Cloud SecretId/SecretKey from environment.
+
+    Prefers ``TENCENT_SECRET_ID/KEY``; falls back to ``TENCENTCLOUD_*``.
+    Raises ``RuntimeError`` (credential-free message) when missing.
+    """
+    sid = os.environ.get("TENCENT_SECRET_ID") or os.environ.get(
+        "TENCENTCLOUD_SECRET_ID"
+    )
+    skey = os.environ.get("TENCENT_SECRET_KEY") or os.environ.get(
+        "TENCENTCLOUD_SECRET_KEY"
+    )
+    if not sid or not skey:
+        raise RuntimeError(
+            "HUNYUAN3D backend requires Tencent Cloud credentials. Set "
+            "TENCENT_SECRET_ID and TENCENT_SECRET_KEY (or TENCENTCLOUD_*) "
+            "in the environment, e.g. `source .secrets/hunyuan3d.env`."
+        )
+    return sid, skey
+
+
+def _signed_headers(
+    payload: str,
+    action: str,
+    credentials: Tuple[str, str],
+    cfg: HunyuanConfig,
+) -> dict:
+    """Build fresh TC3-HMAC-SHA256 auth headers (re-built every request)."""
+    sid, skey = credentials
+    ts = int(time.time())
+    date = datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d")
+    canon_headers = (
+        "content-type:application/json; charset=utf-8\n"
+        f"host:{cfg.host}\n"
+        f"x-tc-action:{action.lower()}\n"
+    )
+    signed = "content-type;host;x-tc-action"
+    canon_req = (
+        f"POST\n/\n\n{canon_headers}\n{signed}\n"
+        f"{hashlib.sha256(payload.encode()).hexdigest()}"
+    )
+    scope = f"{date}/{cfg.service}/tc3_request"
+    string_to_sign = (
+        f"TC3-HMAC-SHA256\n{ts}\n{scope}\n"
+        f"{hashlib.sha256(canon_req.encode()).hexdigest()}"
+    )
+
+    def _sign(key, msg):
+        return hmac.new(key, msg.encode(), hashlib.sha256).digest()
+
+    sd = _sign(("TC3" + skey).encode(), date)
+    ss = _sign(sd, cfg.service)
+    signing = _sign(ss, "tc3_request")
+    sig = hmac.new(
+        signing, string_to_sign.encode(), hashlib.sha256
+    ).hexdigest()
+    return {
+        "Authorization": (
+            f"TC3-HMAC-SHA256 Credential={sid}/{scope}, "
+            f"SignedHeaders={signed}, Signature={sig}"
+        ),
+        "Content-Type": "application/json; charset=utf-8",
+        "Host": cfg.host,
+        "X-TC-Action": action,
+        "X-TC-Timestamp": str(ts),
+        "X-TC-Version": cfg.version,
+        "X-TC-Region": cfg.region,
+    }
+
+
+def _post_signed(
+    payload_obj: dict,
+    action: str,
+    credentials: Tuple[str, str],
+    cfg: HunyuanConfig,
+) -> dict:
+    """POST a Tencent Cloud TC3-signed JSON request and return ``Response``.
+
+    Routes through ``HTTPS_PROXY`` via CONNECT (``HTTPSConnection`` does not
+    honor the env var on its own). Never logs credentials, signed headers,
+    or the request payload (which carries base64 image data).
+    """
+    payload = json.dumps(
+        payload_obj, separators=(",", ":"), ensure_ascii=False
+    )
+    headers = _signed_headers(payload, action, credentials, cfg)
+    # ``http.client.HTTPSConnection`` does NOT auto-honor ``HTTPS_PROXY``
+    # (unlike ``urllib.request.urlopen``); read it explicitly and tunnel
+    # via CONNECT, otherwise direct connections to Tencent Cloud will be
+    # blocked by the corporate egress firewall.
+    proxy = os.environ.get("HTTPS_PROXY") or os.environ.get("HTTP_PROXY")
+    timeout = cfg.connect_timeout + cfg.read_timeout
+    if proxy:
+        from urllib.parse import urlparse
+
+        p = urlparse(proxy)
+        conn = HTTPSConnection(p.hostname, p.port or 80, timeout=timeout)
+        conn.set_tunnel(cfg.host, 443)
+    else:
+        conn = HTTPSConnection(cfg.host, timeout=timeout)
+    try:
+        conn.request("POST", "/", body=payload.encode(), headers=headers)
+        resp = conn.getresponse()
+        status, body = resp.status, resp.read().decode(errors="replace")
+    finally:
+        conn.close()
+
+    if not 200 <= status < 300:
+        raise RuntimeError(
+            f"Hunyuan3D {action} HTTP {status}; len={len(body)}."
+        )
+    try:
+        data = json.loads(body).get("Response", {})
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(
+            f"Hunyuan3D {action} non-JSON (HTTP {status}): {exc}"
+        )
+    err = data.get("Error")
+    if err:
+        raise RuntimeError(
+            f"Hunyuan3D {action} Tencent error: "
+            f"Code={err.get('Code')} Message={err.get('Message')} "
+            f"RequestId={data.get('RequestId')}"
+        )
+    return data
+
+
+def submit_pro_job(
+    image_path: Optional[str] = None,
+    credentials: Tuple[str, str] = None,
+    cfg: HunyuanConfig = None,
+    prompt: Optional[str] = None,
+) -> str:
+    """Submit a Hunyuan3D Pro job, return its ``JobId``.
+
+    Provide exactly one of ``image_path`` (image-to-3D, body field
+    ``ImageBase64``) or ``prompt`` (text-to-3D, body field ``Prompt``).
+    Tencent's ``SubmitHunyuanTo3DProJob`` action is shared between both
+    modes; only the body discriminator differs.
+    """
+    if (image_path is None) == (prompt is None):
+        raise ValueError(
+            "submit_pro_job requires exactly one of image_path or prompt."
+        )
+    if credentials is None or cfg is None:
+        raise ValueError("credentials and cfg are required.")
+
+    payload = {"ResultFormat": cfg.result_format, "EnablePBR": True}
+    if image_path is not None:
+        if not os.path.isfile(image_path):
+            raise FileNotFoundError(
+                f"Hunyuan3D input image missing: {image_path}"
+            )
+        with open(image_path, "rb") as fh:
+            payload["ImageBase64"] = base64.b64encode(fh.read()).decode()
+        mode = "image"
+    else:
+        payload["Prompt"] = prompt
+        mode = "text"
+
+    resp = _post_signed(payload, cfg.image_action, credentials, cfg)
+    job_id = resp.get("JobId")
+    if not job_id:
+        raise RuntimeError(
+            f"Hunyuan3D submit returned no JobId; "
+            f"RequestId={resp.get('RequestId')}."
+        )
+    logger.info(
+        "HUNYUAN3D submit OK (%s): JobId=%s RequestId=%s",
+        mode,
+        job_id,
+        resp.get("RequestId"),
+    )
+    return job_id
+
+
+def wait_for_pro_job(
+    job_id: str,
+    credentials: Tuple[str, str],
+    cfg: HunyuanConfig,
+) -> dict:
+    """Poll the job until DONE; raise on FAIL/unknown/timeout."""
+    deadline = time.time() + cfg.max_wait_seconds
+    last_status = None
+    while True:
+        resp = _post_signed(
+            {"JobId": job_id}, cfg.query_action, credentials, cfg
+        )
+        status = resp.get("Status")
+        if status != last_status:
+            logger.info(
+                "HUNYUAN3D job %s status=%s RequestId=%s",
+                job_id,
+                status,
+                resp.get("RequestId"),
+            )
+            if last_status is None and status in ("WAIT", "RUN"):
+                logger.info(
+                    "HUNYUAN3D Pro inference typically takes ~3 minutes; "
+                    "polling every %ss.",
+                    int(cfg.poll_interval),
+                )
+            last_status = status
+        if status == "DONE":
+            return resp
+        if status == "FAIL":
+            raise RuntimeError(
+                f"Hunyuan3D job {job_id} FAIL: "
+                f"code={resp.get('ErrorCode')} "
+                f"message={resp.get('ErrorMessage')} "
+                f"RequestId={resp.get('RequestId')}."
+            )
+        if status not in ("WAIT", "RUN"):
+            raise RuntimeError(
+                f"Hunyuan3D job {job_id} unknown status={status!r}; "
+                f"RequestId={resp.get('RequestId')}."
+            )
+        if time.time() >= deadline:
+            raise TimeoutError(
+                f"Hunyuan3D job {job_id} did not finish within "
+                f"{cfg.max_wait_seconds}s (last status={status})."
+            )
+        time.sleep(cfg.poll_interval)
+
+
+def _download_url_to_path(url: str, dst: str, cfg: HunyuanConfig) -> int:
+    """Stream ``url`` to ``dst`` with size/timeout caps. Returns bytes written.
+
+    Logs only the host (signed URL paths carry short-lived auth tokens).
+    """
+    from urllib.parse import urlparse
+
+    os.makedirs(os.path.dirname(os.path.abspath(dst)), exist_ok=True)
+    logger.info(
+        "HUNYUAN3D downloading %s from host=%s",
+        os.path.basename(dst),
+        urlparse(url).hostname or "?",
+    )
+    total = 0
+    timeout = cfg.connect_timeout + cfg.read_timeout
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as resp:
+            if not 200 <= resp.status < 300:
+                raise RuntimeError(
+                    f"Hunyuan3D download HTTP {resp.status} for "
+                    f"{os.path.basename(dst)}."
+                )
+            with open(dst, "wb") as out:
+                while True:
+                    chunk = resp.read(1024 * 1024)
+                    if not chunk:
+                        break
+                    total += len(chunk)
+                    if total > cfg.max_download_bytes:
+                        raise RuntimeError(
+                            f"Hunyuan3D download exceeded "
+                            f"{cfg.max_download_bytes} bytes for "
+                            f"{os.path.basename(dst)}."
+                        )
+                    out.write(chunk)
+    except (urllib.error.URLError, socket.timeout) as exc:
+        raise RuntimeError(
+            f"Hunyuan3D download failed for {os.path.basename(dst)}: {exc}"
+        )
+    return total
+
+
+def acquire_pro_glb(
+    image_path: Optional[str] = None,
+    output_dir: str = None,
+    asset_name: str = None,
+    credentials: Tuple[str, str] = None,
+    cfg: HunyuanConfig = None,
+    prompt: Optional[str] = None,
+) -> str:
+    """End-to-end: submit + poll + download GLB into the output dir.
+
+    Provide exactly one of ``image_path`` or ``prompt`` (see
+    :func:`submit_pro_job` for the body-field difference).
+    """
+    if (
+        output_dir is None
+        or asset_name is None
+        or credentials is None
+        or cfg is None
+    ):
+        raise ValueError(
+            "output_dir, asset_name, credentials and cfg are required."
+        )
+    os.makedirs(output_dir, exist_ok=True)
+    glb_path = os.path.join(output_dir, f"{asset_name}.glb")
+
+    job_id = submit_pro_job(
+        image_path=image_path,
+        prompt=prompt,
+        credentials=credentials,
+        cfg=cfg,
+    )
+    resp = wait_for_pro_job(job_id, credentials, cfg)
+
+    files = resp.get("ResultFile3Ds") or []
+    glb_url = next(
+        (
+            f.get("Url")
+            for f in files
+            if (f.get("Type") or "").upper() == "GLB" and f.get("Url")
+        ),
+        None,
+    )
+    if not glb_url:
+        raise RuntimeError(
+            f"Hunyuan3D job {job_id} returned no GLB; "
+            f"RequestId={resp.get('RequestId')}."
+        )
+    _download_url_to_path(glb_url, glb_path, cfg)
+    return glb_path
+
+
+def _texture_array(tex) -> Optional[np.ndarray]:
+    """Return RGB ndarray for a glTF texture, or None if absent/invalid."""
+    if tex is None or not hasattr(tex, "convert"):
+        return None
+    return np.asarray(tex.convert("RGB"))
+
+
+def _save_rgb(arr: Optional[np.ndarray], dst: str, max_edge: int) -> bool:
+    """Save an RGB texture as PNG, capping the longest edge at ``max_edge``."""
+    if arr is None:
+        return False
+    img = Image.fromarray(arr)
+    longest = max(img.size)
+    if longest > max_edge:
+        scale = max_edge / float(longest)
+        img = img.resize(
+            (
+                max(1, int(img.size[0] * scale)),
+                max(1, int(img.size[1] * scale)),
+            ),
+            Image.LANCZOS,
+        )
+    img.save(dst)
+    return True
+
+
+def _bake_scene_transform(
+    scene: trimesh.Scene,
+) -> Tuple[trimesh.Trimesh, np.ndarray, str]:
+    """Apply scene-graph transforms to mesh vertices; return one Trimesh."""
+    if len(scene.graph.nodes_geometry) != 1:
+        parts = []
+        for n in scene.graph.nodes_geometry:
+            xform, gname = scene.graph[n]
+            m = scene.geometry[gname].copy()
+            m.apply_transform(xform)
+            parts.append(m)
+        return trimesh.util.concatenate(parts), np.eye(4), "concatenated"
+    n = next(iter(scene.graph.nodes_geometry))
+    xform, gname = scene.graph[n]
+    mesh = scene.geometry[gname].copy()
+    mesh.apply_transform(xform)
+    return mesh, xform, gname
+
+
+def export_glb_to_obj(
+    glb_path: str,
+    output_dir: str,
+    asset_name: str,
+    texture_size: int = 2048,
+    pre_align_rotation: Optional[np.ndarray] = None,
+) -> str:
+    """Convert a Hunyuan3D Pro GLB into the full-PBR OBJ + MTL + PBR PNGs.
+
+    Bakes the GLB scene transform, optionally applies ``pre_align_rotation``
+    to the vertex array (used by the text-to-3D path, whose endpoint emits
+    a frame rotated 90° around the up axis relative to the image-to-3D
+    endpoint), recenters to the bbox origin (matching SAM3D's convention
+    of putting the model origin at the geometric center), and writes a
+    Blender-compatible OBJ/MTL referencing 4 PBR PNGs (baseColor /
+    metallic / roughness / normal) plus a ``_pbr_material.json`` metadata
+    sidecar. The source GLB at ``glb_path`` is overwritten with the
+    aligned mesh so downstream steps can reuse it. Returns the OBJ path.
+    """
+    from trimesh.exchange.obj import export_obj
+
+    os.makedirs(output_dir, exist_ok=True)
+    obj_path = os.path.join(output_dir, f"{asset_name}.obj")
+    mtl_path = os.path.join(output_dir, f"{asset_name}.mtl")
+    json_path = os.path.join(output_dir, f"{asset_name}_pbr_material.json")
+
+    scene = trimesh.load(glb_path, force="scene", process=False)
+    mesh, baked_xform, geom_name = _bake_scene_transform(scene)
+    material = getattr(getattr(mesh, "visual", None), "material", None)
+
+    # Align to SAM3D convention: optional pre-rotation (text-to-3D needs a
+    # -90° around the up axis to share the image-to-3D frame) + recenter to
+    # the bbox origin. Overwrite the source GLB so downstream steps can
+    # reuse the aligned full-PBR mesh without an extra load/export pass.
+    V = np.asarray(mesh.vertices, dtype=np.float32)
+    if pre_align_rotation is not None:
+        V = V @ np.asarray(pre_align_rotation, dtype=np.float32)
+    bbox_center = (V.min(axis=0) + V.max(axis=0)) * 0.5
+    mesh.vertices = V - bbox_center
+    mesh.export(glb_path)
+
+    raw_name = getattr(material, "name", None) or f"{asset_name}_material"
+    material_name = re.sub(r"[^A-Za-z0-9_.-]+", "_", raw_name).strip("._")
+    if not material_name:
+        material_name = f"{asset_name}_material"
+
+    # Write OBJ (rewrite usemtl so it points at our material, after mtllib).
+    obj_text = export_obj(
+        mesh,
+        include_normals=True,
+        include_color=True,
+        include_texture=True,
+        return_texture=False,
+        write_texture=False,
+        mtl_name=os.path.basename(mtl_path),
+        header=(
+            "Exported from Hunyuan3D Pro GLB; "
+            "scene transform baked, recentered to bbox origin"
+        ),
+    )
+    obj_text = re.sub(
+        r"^usemtl\s+.+$",
+        f"usemtl {material_name}",
+        obj_text,
+        flags=re.MULTILINE,
+    )
+    mtllib_line = f"mtllib {os.path.basename(mtl_path)}\n"
+    if f"usemtl {material_name}" not in obj_text:
+        obj_text = obj_text.replace(
+            mtllib_line, f"{mtllib_line}usemtl {material_name}\n", 1
+        )
+    with open(obj_path, "w", encoding="utf-8") as fh:
+        fh.write(obj_text)
+
+    # PBR textures. metallicRoughnessTexture: G=roughness, B=metallic.
+    base_arr = _texture_array(getattr(material, "baseColorTexture", None))
+    mr_arr = _texture_array(
+        getattr(material, "metallicRoughnessTexture", None)
+    )
+    normal_arr = _texture_array(getattr(material, "normalTexture", None))
+    files = {
+        "baseColor": f"{asset_name}_baseColor.png",
+        "metallic": f"{asset_name}_metallic.png",
+        "roughness": f"{asset_name}_roughness.png",
+        "normal": f"{asset_name}_normal.png",
+    }
+    metallic_arr = (
+        np.stack([mr_arr[:, :, 2]] * 3, axis=-1)
+        if mr_arr is not None
+        else None
+    )
+    roughness_arr = (
+        np.stack([mr_arr[:, :, 1]] * 3, axis=-1)
+        if mr_arr is not None
+        else None
+    )
+    saved = {
+        "baseColor": _save_rgb(
+            base_arr,
+            os.path.join(output_dir, files["baseColor"]),
+            texture_size,
+        ),
+        "metallic": _save_rgb(
+            metallic_arr,
+            os.path.join(output_dir, files["metallic"]),
+            texture_size,
+        ),
+        "roughness": _save_rgb(
+            roughness_arr,
+            os.path.join(output_dir, files["roughness"]),
+            texture_size,
+        ),
+        "normal": _save_rgb(
+            normal_arr,
+            os.path.join(output_dir, files["normal"]),
+            texture_size,
+        ),
+    }
+
+    def _factor(attr: str, default: float = 1.0) -> float:
+        v = getattr(material, attr, default)
+        return default if v is None else float(v)
+
+    bc = getattr(material, "baseColorFactor", None)
+    if bc is None:
+        base_factor = [1.0, 1.0, 1.0, 1.0]
+    else:
+        arr = np.asarray(bc, dtype=float).reshape(-1)
+        if arr.max(initial=1.0) > 1.0:
+            arr = arr / 255.0
+        base_factor = [float(arr[0]), float(arr[1]), float(arr[2])]
+        base_factor.append(float(arr[3]) if len(arr) >= 4 else 1.0)
+    metallic_factor = _factor("metallicFactor", 1.0)
+    roughness_factor = _factor("roughnessFactor", 1.0)
+
+    ns = max(1.0, min(1000.0, (1.0 - roughness_factor) * 1000.0))
+    lines = [
+        "# Exported from Hunyuan3D Pro GLB",
+        "# PBR note: glTF metallicRoughnessTexture stores roughness in G "
+        "and metallic in B.",
+        f"newmtl {material_name}",
+        f"Ka {base_factor[0]:.8g} {base_factor[1]:.8g} {base_factor[2]:.8g}",
+        f"Kd {base_factor[0]:.8g} {base_factor[1]:.8g} {base_factor[2]:.8g}",
+        "Ks 0 0 0",
+        f"Ns {ns:.8g}",
+        f"d {base_factor[3]:.8g}",
+        "illum 2",
+        f"Pm {metallic_factor:.8g}",
+        f"Pr {roughness_factor:.8g}",
+    ]
+    if saved["baseColor"]:
+        lines.append(f"map_Kd {files['baseColor']}")
+    if saved["normal"]:
+        lines.append(f"norm {files['normal']}")
+        lines.append(f"bump {files['normal']}")
+    if saved["metallic"]:
+        lines.append(f"map_Pm {files['metallic']}")
+    if saved["roughness"]:
+        lines.append(f"map_Pr {files['roughness']}")
+    with open(mtl_path, "w", encoding="utf-8") as fh:
+        fh.write("\n".join(lines) + "\n")
+
+    metadata = {
+        "source": glb_path,
+        "obj": os.path.basename(obj_path),
+        "mtl": os.path.basename(mtl_path),
+        "material": material_name,
+        "geometry": geom_name,
+        "alignment": "recenter_to_bbox_origin",
+        "bakedTransform": np.asarray(baked_xform).tolist(),
+        "sourceSceneBounds": np.asarray(scene.bounds).tolist(),
+        "exportedObjBounds": np.asarray(mesh.bounds).tolist(),
+        "baseColorFactor": base_factor,
+        "metallicFactor": metallic_factor,
+        "roughnessFactor": roughness_factor,
+        "textureMaxEdge": texture_size,
+        "textures": {k: (files[k] if saved[k] else None) for k in files},
+    }
+    with open(json_path, "w", encoding="utf-8") as fh:
+        fh.write(json.dumps(metadata, indent=2) + "\n")
+
+    return obj_path
+
+
+def _ship_scaled_pbr_artefacts(
+    aligned_glb: str,
+    urdf_path: str,
+    output_root: str,
+    final_mesh_dir: str,
+    asset_name: str,
+) -> None:
+    """Write scaled OBJ companions + GLB with full PBR into ``final_mesh_dir``.
+
+    URDFGen's trimesh roundtrip drops Hunyuan's metallic/roughness/normal
+    maps; we restore PBR fidelity by:
+
+      1. Inferring the scale factor URDFGen applied by comparing the
+         scaled OBJ's extent with the aligned source GLB's extent (the
+         URDF ``<scale>`` element stores ``real_height`` instead, which is
+         a different quantity).
+      2. Loading the aligned full-PBR source GLB, scaling it, and writing
+         it next to URDFGen's OBJ so both share the same scale.
+      3. Copying the 4 PBR PNGs from ``output_root`` into the mesh dir.
+      4. Patching URDFGen's ``material.mtl`` so Phong rendering has a
+         visible specular highlight and PBR-aware OBJ importers pick up
+         ``map_Pm`` / ``map_Pr`` / ``norm`` / ``bump`` references.
+    """
+    # Derive the actual scale factor from URDFGen's scaled OBJ rather than
+    # the URDF ``<scale>`` element (which stores real_height — a midpoint
+    # value distinct from the geometric scaling factor URDFGen applied).
+    urdfgen_obj = trimesh.load(
+        os.path.join(final_mesh_dir, f"{asset_name}.obj"),
+        force="mesh",
+        process=False,
+    )
+    target_max = float(urdfgen_obj.extents.max())
+
+    scene = trimesh.load(aligned_glb, force="scene", process=False)
+    mesh, _, _ = _bake_scene_transform(scene)
+    V = np.asarray(mesh.vertices, dtype=np.float32)
+    src_max = float((V.max(axis=0) - V.min(axis=0)).max())
+    scale = target_max / src_max if src_max > 1e-9 else 1.0
+    mesh.vertices = V * scale
+    mesh.export(os.path.join(final_mesh_dir, f"{asset_name}.glb"))
+
+    pbr_pngs = {
+        "metallic": f"{asset_name}_metallic.png",
+        "roughness": f"{asset_name}_roughness.png",
+        "normal": f"{asset_name}_normal.png",
+    }
+    base_color_png = f"{asset_name}_baseColor.png"
+    pbr_json = f"{asset_name}_pbr_material.json"
+    for fname in (
+        base_color_png,
+        pbr_pngs["metallic"],
+        pbr_pngs["roughness"],
+        pbr_pngs["normal"],
+        pbr_json,
+    ):
+        src = os.path.join(output_root, fname)
+        if os.path.exists(src):
+            copy(src, os.path.join(final_mesh_dir, fname))
+
+    mtl_path = os.path.join(final_mesh_dir, "material.mtl")
+    if os.path.exists(mtl_path):
+        with open(mtl_path) as fh:
+            mtl_text = fh.read()
+        # trimesh's OBJ exporter writes ``Ks 0 0 0`` + ``Ns 1`` which makes
+        # Blender's OBJ Phong path render the surface as flat matte. Bump
+        # specular and shininess so the OBJ has visible highlights matching
+        # the PBR GLB, then append the PBR texture map references that
+        # PBR-aware OBJ importers (Blender 3.6+, others) will pick up.
+        mtl_text = re.sub(
+            r"^Ks\s.+$", "Ks 0.5 0.5 0.5", mtl_text, flags=re.MULTILINE
+        )
+        mtl_text = re.sub(r"^Ns\s.+$", "Ns 250", mtl_text, flags=re.MULTILINE)
+        if not re.search(r"^illum\s", mtl_text, re.MULTILINE):
+            mtl_text = mtl_text.rstrip() + "\nillum 2\n"
+        extras = []
+        if os.path.exists(os.path.join(final_mesh_dir, pbr_pngs["metallic"])):
+            extras.append(f"map_Pm {pbr_pngs['metallic']}")
+        if os.path.exists(os.path.join(final_mesh_dir, pbr_pngs["roughness"])):
+            extras.append(f"map_Pr {pbr_pngs['roughness']}")
+        if os.path.exists(os.path.join(final_mesh_dir, pbr_pngs["normal"])):
+            extras.append(f"norm {pbr_pngs['normal']}")
+            extras.append(f"bump {pbr_pngs['normal']}")
+        if extras and not any(
+            line in mtl_text for line in ("map_Pm", "map_Pr", "norm ")
+        ):
+            mtl_text = mtl_text.rstrip() + "\n" + "\n".join(extras) + "\n"
+        with open(mtl_path, "w") as fh:
+            fh.write(mtl_text)
+
+
+def _build_asset_attrs(args, idx: int) -> dict:
+    """Build the URDF asset_attrs dict from CLI args."""
+    attrs = {"version": args.version or VERSION}
+    if args.height_range:
+        lo, hi = map(float, args.height_range.split("-"))
+        attrs["min_height"], attrs["max_height"] = lo, hi
+    if args.mass_range:
+        lo, hi = map(float, args.mass_range.split("-"))
+        attrs["min_mass"], attrs["max_mass"] = lo, hi
+    if isinstance(args.asset_type, list) and args.asset_type[idx]:
+        attrs["category"] = args.asset_type[idx]
+    return attrs
+
+
+def _render_color_video(
+    obj_path: str, work_dir: str, filename: str
+) -> Optional[str]:
+    """Render a turntable color mp4 via the shared kaolin renderer.
+
+    Returns the produced mp4 path, or ``None`` on failure (caller logs).
+    """
+    try:
+        # differentiable_render hardcodes mp4 fps=15; 90 frames -> 6s,
+        # matching SAM3D/TRELLIS gs_mesh.mp4 duration.
+        render_pbr_video(
+            mesh_path=obj_path,
+            output_root=work_dir,
+            uuid=[filename],
+            num_images=90,
+            elevation=[20.0],
+            distance=5.0,
+            fov=30.0,
+            with_mtl=True,
+            gen_color_mp4=True,
+            no_index_file=True,
+        )
+        mp4 = os.path.join(work_dir, filename, "color.mp4")
+        return mp4 if os.path.exists(mp4) else None
+    except Exception as exc:  # pragma: no cover - rendering is optional
+        logger.warning(f"HUNYUAN3D video render failed: {exc}")
+        return None
+
+
+def _process_glb(
+    args,
+    idx: int,
+    output_root: str,
+    filename: str,
+    cfg: HunyuanConfig,
+    checkers: list,
+    log_label: str,
+    seg_input_pair: Optional[Tuple[str, str]] = None,
+    pre_align_rotation: Optional[np.ndarray] = None,
+) -> str:
+    """GLB-to-result post-processing shared by image and text paths.
+
+    Expects an aligned full-PBR GLB at ``{output_root}/{filename}.glb``.
+    Runs ``export_glb_to_obj`` → video render → URDFGen → PBR fidelity
+    fixup → single-arg quality checks (skipped when ``checkers`` is empty)
+    → ``result/`` organization. ``seg_input_pair`` lets the image path
+    feed raw/cond images to ``ImageSegChecker``; text path passes ``None``.
+    ``pre_align_rotation`` (3x3) is folded into the single mesh transform
+    inside ``export_glb_to_obj``, avoiding a separate load/export pass.
+    Returns the result dir path.
+    """
+    export_glb_to_obj(
+        glb_path=os.path.join(output_root, f"{filename}.glb"),
+        output_dir=output_root,
+        asset_name=filename,
+        texture_size=cfg.texture_size,
+        pre_align_rotation=pre_align_rotation,
+    )
+    mesh_obj_path = os.path.join(output_root, f"{filename}.obj")
+
+    video_path = _render_color_video(
+        mesh_obj_path, os.path.join(output_root, "_video"), filename
+    )
+
+    urdf_convertor = URDFGenerator(
+        GPT_CLIENT,
+        render_view_num=4,
+        decompose_convex=not args.disable_decompose_convex,
+    )
+    urdf_root = f"{output_root}/URDF_{filename}"
+    urdf_path = urdf_convertor(
+        mesh_path=mesh_obj_path,
+        output_root=urdf_root,
+        **_build_asset_attrs(args, idx),
+    )
+
+    # Final mesh dir: keep URDFGen's scaled OBJ + collision, restore full
+    # PBR fidelity that URDFGen's simple trimesh roundtrip strips (rescaled
+    # source GLB + PBR map refs appended to material.mtl).
+    final_mesh_dir = f"{urdf_root}/{urdf_convertor.output_mesh_dir}"
+    _ship_scaled_pbr_artefacts(
+        aligned_glb=os.path.join(output_root, f"{filename}.glb"),
+        urdf_path=urdf_path,
+        output_root=output_root,
+        final_mesh_dir=final_mesh_dir,
+        asset_name=filename,
+    )
+
+    # Quality checks: only the single-arg (BaseChecker.validate) ones go
+    # here. Two-arg checkers like TextGenAlignChecker run in the caller.
+    if checkers:
+        render_image_paths = glob(
+            f"{urdf_root}/{urdf_convertor.output_render_dir}/image_color/*.png"
+        )
+        images_list = []
+        for ch in checkers:
+            if isinstance(ch, ImageSegChecker) and seg_input_pair is not None:
+                images_list.append(list(seg_input_pair))
+            else:
+                images_list.append(combine_images_to_grid(render_image_paths))
+        qa_results = BaseChecker.validate(checkers, images_list)
+        urdf_convertor.add_quality_tag(urdf_path, qa_results)
+
+    # Organize result/ (no gs.ply; video.mp4 included when render OK).
+    result_dir = f"{output_root}/result"
+    if os.path.exists(result_dir):
+        rmtree(result_dir, ignore_errors=True)
+    os.makedirs(result_dir, exist_ok=True)
+    copy(urdf_path, f"{result_dir}/{os.path.basename(urdf_path)}")
+    copytree(
+        f"{urdf_root}/{urdf_convertor.output_mesh_dir}",
+        f"{result_dir}/{urdf_convertor.output_mesh_dir}",
+    )
+    if video_path and os.path.exists(video_path):
+        copy(video_path, f"{result_dir}/video.mp4")
+
+    if not args.keep_intermediate:
+        delete_dir(output_root, keep_subs=["result"])
+
+    logger.info(f"Saved results for {log_label} in {result_dir}")
+    return result_dir
+
+
+# Rotation that aligns a Hunyuan3D **text**-to-3D GLB with the **image**-to-3D
+# frame. -90° around the file-coord up axis (Y), i.e. x' = z, z' = -x.
+# Applied as a single multiplication inside ``export_glb_to_obj`` so the
+# text path does not need a separate GLB load/save pass.
+TEXT_TO_IMAGE_FRAME_ROTATION = np.array(
+    [[0.0, 0.0, -1.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0]],
+    dtype=np.float32,
+)
+
+
+def _acquire_or_reuse_glb(
+    output_root: str,
+    filename: str,
+    cfg: HunyuanConfig,
+    hunyuan_credentials: Optional[Tuple[str, str]],
+    *,
+    image_path: Optional[str] = None,
+    prompt: Optional[str] = None,
+) -> None:
+    """Ensure ``{output_root}/{filename}.glb`` exists.
+
+    Reuses an existing GLB at that path (dev fixture short-circuit) or
+    calls :func:`acquire_pro_glb` with ``image_path`` or ``prompt``.
+    """
+    glb_path = os.path.join(output_root, f"{filename}.glb")
+    if os.path.exists(glb_path):
+        logger.info(
+            "HUNYUAN3D reusing existing GLB at %s; skipping Tencent API call.",
+            glb_path,
+        )
+        return
+    creds = hunyuan_credentials or load_credentials()
+    acquire_pro_glb(
+        image_path=image_path,
+        prompt=prompt,
+        output_dir=output_root,
+        asset_name=filename,
+        credentials=creds,
+        cfg=cfg,
+    )
+
+
+def process_image(
+    args,
+    idx: int,
+    image_path: str,
+    output_root: str,
+    filename: str,
+    hunyuan_config: Optional[HunyuanConfig],
+    hunyuan_credentials: Optional[Tuple[str, str]],
+    checkers: list,
+) -> None:
+    """HUNYUAN3D image-to-3D entry: image → GLB → export → URDF → result/."""
+    cfg = hunyuan_config or HunyuanConfig()
+    _acquire_or_reuse_glb(
+        output_root, filename, cfg, hunyuan_credentials, image_path=image_path
+    )
+    _process_glb(
+        args=args,
+        idx=idx,
+        output_root=output_root,
+        filename=filename,
+        cfg=cfg,
+        checkers=checkers,
+        log_label=image_path,
+        seg_input_pair=(
+            f"{output_root}/{filename}_raw.png",
+            f"{output_root}/{filename}_cond.png",
+        ),
+    )
+
+
+def process_prompt(
+    args,
+    idx: int,
+    prompt: str,
+    output_root: str,
+    filename: str,
+    hunyuan_config: Optional[HunyuanConfig],
+    hunyuan_credentials: Optional[Tuple[str, str]],
+    checkers: list,
+) -> None:
+    """HUNYUAN3D text-to-3D entry: prompt → GLB → export → URDF → result/.
+
+    Text path skips ``text-to-image`` entirely; ``checkers`` should only
+    contain single-arg (``BaseChecker.validate``-compatible) checkers.
+    Two-arg checkers like ``TextGenAlignChecker`` should be invoked by
+    the caller after this returns.
+    """
+    cfg = hunyuan_config or HunyuanConfig()
+    _acquire_or_reuse_glb(
+        output_root, filename, cfg, hunyuan_credentials, prompt=prompt
+    )
+    # Text endpoint sits 90° offset around the up axis vs the image
+    # endpoint; fold the alignment rotation into export_glb_to_obj's
+    # single mesh-transform pass to avoid a separate GLB roundtrip.
+    _process_glb(
+        args=args,
+        idx=idx,
+        output_root=output_root,
+        filename=filename,
+        cfg=cfg,
+        checkers=checkers,
+        log_label=f"prompt={prompt!r}",
+        seg_input_pair=None,
+        pre_align_rotation=TEXT_TO_IMAGE_FRAME_ROTATION,
+    )

embodied_gen/models/image_comm_model.py

@@ -31,6 +31,9 @@ from diffusers.quantizers import PipelineQuantizationConfig
 from huggingface_hub import snapshot_download
 from PIL import Image
 from transformers import AutoModelForCausalLM, SiglipProcessor
+from embodied_gen.utils.monkey_patch.xformers import (
+    disable_xformers_flash3_on_blackwell,
+)
 
 __all__ = [
     "build_hf_image_pipeline",
@@ -99,6 +102,7 @@ class SD35Loader(BasePipelineLoader):
         )
         pipe = pipe.to(self.device)
         pipe.enable_model_cpu_offload()
+        disable_xformers_flash3_on_blackwell()
         pipe.enable_xformers_memory_efficient_attention()
         pipe.enable_attention_slicing()
         return pipe
@@ -230,6 +234,7 @@ class KolorsLoader(BasePipelineLoader):
             variant="fp16",
         ).to(self.device)
         pipe.enable_model_cpu_offload()
+        disable_xformers_flash3_on_blackwell()
         pipe.enable_xformers_memory_efficient_attention()
         pipe.scheduler = DPMSolverMultistepScheduler.from_config(
             pipe.scheduler.config, use_karras_sigmas=True
@@ -268,6 +273,7 @@ class FluxLoader(BasePipelineLoader):
             "black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16
         )
         pipe.enable_model_cpu_offload()
+        disable_xformers_flash3_on_blackwell()
         pipe.enable_xformers_memory_efficient_attention()
         pipe.enable_attention_slicing()
         return pipe.to(self.device)

embodied_gen/models/sam3d.py

@@ -53,13 +53,6 @@ class Sam3dInference:
         compile (bool): Whether to compile the model for faster inference.
         device (str): Device to run the model on (e.g., "cuda" or "cpu").
 
-    Methods:
-        merge_mask_to_rgba(image, mask):
-            Merges a binary mask into the alpha channel of an RGB image.
-
-        run(image, mask=None, seed=None, pointmap=None, use_stage1_distillation=False,
-            use_stage2_distillation=False, stage1_inference_steps=25, stage2_inference_steps=25):
-            Runs the inference pipeline and returns the output dictionary.
     """
 
     def __init__(
@@ -145,7 +138,7 @@ if __name__ == "__main__":
 
     start = time()
     output = pipeline.run(clean_image, seed=42)
-    print(f"Running cost: {round(time()-start, 1)}")
+    print(f"Running cost: {round(time() - start, 1)}")
 
     if torch.cuda.is_available():
         max_memory = torch.cuda.max_memory_allocated() / (1024**3)

embodied_gen/models/segment_model.py

@@ -236,7 +236,7 @@ class SAMPredictor(object):
         )
 
         labels = (
-            torch.Tensor([int(l) for _, l in selected_points])
+            torch.Tensor([int(label) for _, label in selected_points])
             .to(self.predictor.device)
             .unsqueeze(1)
         )
@@ -469,13 +469,11 @@ def get_segmented_image_by_agent(
     elif _is_valid_seg(image, seg_image_inv):
         final_image = seg_image_inv
     elif _is_valid_seg(image, seg_image_rbg):
-        logger.warning(f"Failed to segment by `SAM`, retry with `rembg`.")
+        logger.warning("Failed to segment by `SAM`, retry with `rembg`.")
         final_image = seg_image_rbg
     else:
         if mode == "strict":
-            raise RuntimeError(
-                f"Failed to segment by `SAM` or `rembg`, abort."
-            )
+            raise RuntimeError("Failed to segment by `SAM` or `rembg`, abort.")
         logger.warning("Failed to segment by SAM or rembg, use raw image.")
         final_image = image.convert("RGBA")
 

embodied_gen/models/text_model.py

@@ -40,6 +40,9 @@ from kolors.pipelines.pipeline_stable_diffusion_xl_chatglm_256_ipadapter import
 )
 from PIL import Image
 from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection
+from embodied_gen.utils.monkey_patch.xformers import (
+    disable_xformers_flash3_on_blackwell,
+)
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -110,6 +113,7 @@ def build_text2img_ip_pipeline(
     ckpt_dir: str,
     ref_scale: float,
     device: str = "cuda",
+    enable_cpu_offload: bool = True,
 ) -> StableDiffusionXLPipelineIP:
     """Builds a Stable Diffusion XL pipeline with IP-Adapter for text-to-image generation.
 
@@ -117,6 +121,7 @@ def build_text2img_ip_pipeline(
         ckpt_dir (str): Directory containing model checkpoints.
         ref_scale (float): Reference scale for IP-Adapter.
         device (str, optional): Device for inference.
+        enable_cpu_offload: Whether to offload inactive modules to CPU.
 
     Returns:
         StableDiffusionXLPipelineIP: Configured pipeline.
@@ -173,11 +178,12 @@ def build_text2img_ip_pipeline(
     )
     pipe.set_ip_adapter_scale([ref_scale])
 
-    pipe = pipe.to(device)
-    pipe.image_encoder = pipe.image_encoder.to(device)
-    # pipe.enable_model_cpu_offload()
-    # # pipe.enable_xformers_memory_efficient_attention()
-    # pipe.enable_vae_slicing()
+    if enable_cpu_offload:
+        # pipe.enable_model_cpu_offload()
+    else:
+        pipe = pipe.to(device)
+        pipe.image_encoder = pipe.image_encoder.to(device)
+    pipe.enable_vae_slicing()
 
     return pipe
 
@@ -186,6 +192,7 @@ def build_text2img_pipeline(
     ckpt_dir: str,
     device: str = "cuda",
     download_ip_adapter: bool = False,
+    enable_cpu_offload: bool = True,
 ) -> StableDiffusionXLPipeline:
     """Builds a Stable Diffusion XL pipeline for text-to-image generation.
 
@@ -193,6 +200,7 @@ def build_text2img_pipeline(
         ckpt_dir (str): Directory containing model checkpoints.
         device (str, optional): Device for inference.
         download_ip_adapter: Whether to predownload IP-Adapter weights.
+        enable_cpu_offload: Whether to offload inactive modules to CPU.
 
     Returns:
         StableDiffusionXLPipeline: Configured pipeline.
@@ -233,9 +241,13 @@ def build_text2img_pipeline(
         scheduler=scheduler,
         force_zeros_for_empty_prompt=False,
     )
-    pipe = pipe.to(device)
-    # pipe.enable_model_cpu_offload()
+    if enable_cpu_offload:
+        # pipe.enable_model_cpu_offload()
+    else:
+        pipe = pipe.to(device)
+    disable_xformers_flash3_on_blackwell()
     # pipe.enable_xformers_memory_efficient_attention()
+    pipe.enable_vae_slicing()
 
     return pipe
 

embodied_gen/models/texture_model.py

@@ -93,7 +93,7 @@ def build_texture_gen_pipe(
     """
 
     download_kolors_weights(f"{base_ckpt_dir}/Kolors")
-    logger.info(f"Load Kolors weights...")
+    logger.info("Load Kolors weights...")
     tokenizer = ChatGLMTokenizer.from_pretrained(
         f"{base_ckpt_dir}/Kolors/text_encoder"
     )
@@ -101,11 +101,17 @@ def build_texture_gen_pipe(
         f"{base_ckpt_dir}/Kolors/text_encoder", torch_dtype=torch.float16
     ).half()
     vae = AutoencoderKL.from_pretrained(
-        f"{base_ckpt_dir}/Kolors/vae", revision=None
-    ).half()
+        f"{base_ckpt_dir}/Kolors/vae",
+        torch_dtype=torch.float16,
+        variant="fp16",
+        use_safetensors=True,
+    )
     unet = UNet2DConditionModel.from_pretrained(
-        f"{base_ckpt_dir}/Kolors/unet", revision=None
-    ).half()
+        f"{base_ckpt_dir}/Kolors/unet",
+        torch_dtype=torch.float16,
+        variant="fp16",
+        use_safetensors=True,
+    )
     scheduler = EulerDiscreteScheduler.from_pretrained(
         f"{base_ckpt_dir}/Kolors/scheduler"
     )

embodied_gen/scripts/__init__.py

@@ -0,0 +1 @@
+"""Command-line workflows for EmbodiedGen."""

embodied_gen/scripts/affordance_annot/affordance_annot.py

@@ -0,0 +1,313 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+import dataclasses
+import os
+import sys
+import time
+from dataclasses import dataclass, field
+
+import tyro
+
+if __package__ is None or __package__ == "":
+    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../../..")))
+
+from embodied_gen.utils.general import filter_warnings
+
+filter_warnings()
+
+from embodied_gen.scripts.affordance_annot.eval_grasps import (
+    EvalGraspsConfig,
+    run_eval,
+)
+from embodied_gen.scripts.affordance_annot.gen_grasp import (
+    GraspGenerator,
+    GraspPoseConfig,
+)
+from embodied_gen.scripts.affordance_annot.part_seg import (
+    PartSegConfig,
+    PartSegmenter,
+)
+from embodied_gen.scripts.affordance_annot.partsemantics_annot import (
+    PartSemanticsAnnotator,
+    PartSemanticsAnnotConfig,
+)
+from embodied_gen.utils.log import logger
+
+__all__ = [
+    "AffordanceAnnotConfig",
+    "AffordanceAnnotator",
+    "run_affordance_annot",
+    "entrypoint",
+]
+
+
+@dataclass
+class AffordanceAnnotConfig:
+    urdf_paths: list[str] = field(default_factory=list)
+    output_dirs: list[str] = field(default_factory=list)
+    run_part_seg: bool = True
+    run_partsemantics_annot: bool = True
+    run_grasp: bool = True
+    run_grasp_eval: bool = True
+    part_seg: PartSegConfig = field(default_factory=PartSegConfig)
+    partsemantics: PartSemanticsAnnotConfig = field(
+        default_factory=PartSemanticsAnnotConfig
+    )
+    grasp: GraspPoseConfig = field(default_factory=GraspPoseConfig)
+    grasp_eval: EvalGraspsConfig = field(default_factory=EvalGraspsConfig)
+
+
+class AffordanceAnnotator:
+    def __init__(self, cfg: AffordanceAnnotConfig):
+        self.validate_config(cfg)
+        self.cfg = cfg
+        self.part_segmenter: PartSegmenter | None = None
+        self.partsemantics_annotator: PartSemanticsAnnotator | None = None
+        self.grasp_generator: GraspGenerator | None = None
+        self.asset_timings: list[dict[str, float | str]] = []
+
+    def validate_config(self, cfg: AffordanceAnnotConfig) -> None:
+        if not cfg.urdf_paths:
+            raise ValueError("urdf_paths must be provided.")
+
+        if len(cfg.output_dirs) == 0:
+            cfg.output_dirs = [
+                os.path.join(os.path.dirname(path), "affordance")
+                for path in cfg.urdf_paths
+            ]
+
+        if len(cfg.urdf_paths) != len(cfg.output_dirs):
+            raise ValueError(
+                "urdf_paths and output_dirs must have the same length, "
+                f"got {len(cfg.urdf_paths)} and {len(cfg.output_dirs)}."
+            )
+
+    def sync_batch_stage_config(self, cfg):
+        updates = {"urdf_paths": list(self.cfg.urdf_paths)}
+        if "output_dirs" in {field.name for field in dataclasses.fields(cfg)}:
+            updates["output_dirs"] = list(self.cfg.output_dirs)
+        return dataclasses.replace(cfg, **updates)
+
+    def sync_single_stage_config(self, cfg, urdf_path: str, output_dir: str):
+        updates = {"urdf_paths": [urdf_path]}
+        if "output_dirs" in {field.name for field in dataclasses.fields(cfg)}:
+            updates["output_dirs"] = [output_dir]
+        return dataclasses.replace(cfg, **updates)
+
+    def process_part_seg(self, urdf_path: str, output_dir: str) -> bool:
+        if not self.cfg.run_part_seg:
+            logger.info("Skipping part segmentation stage.")
+            return True
+
+        return bool(self.get_part_segmenter().process(urdf_path, output_dir))
+
+    def process_partsemantics_annot(
+        self, urdf_path: str, output_dir: str
+    ) -> bool:
+        if not self.cfg.run_partsemantics_annot:
+            logger.info("Skipping part semantics annotation stage.")
+            return True
+
+        return bool(
+            self.get_partsemantics_annotator().process(urdf_path, output_dir)
+        )
+
+    def process_grasp(self, urdf_path: str, output_dir: str) -> bool:
+        if not self.cfg.run_grasp:
+            logger.info("Skipping grasp generation stage.")
+            return True
+
+        return bool(self.get_grasp_generator().process(urdf_path))
+
+    def process_grasp_eval(self, urdf_path: str, output_dir: str) -> bool:
+        if not self.cfg.run_grasp_eval:
+            logger.info("Skipping grasp evaluation stage.")
+            return True
+
+        cfg = self.sync_single_stage_config(
+            self.cfg.grasp_eval,
+            urdf_path,
+            output_dir,
+        )
+        run_eval(cfg)
+        return True
+
+    def get_part_segmenter(self) -> PartSegmenter:
+        if self.part_segmenter is None:
+            cfg = self.sync_batch_stage_config(self.cfg.part_seg)
+            self.part_segmenter = PartSegmenter(cfg)
+        return self.part_segmenter
+
+    def get_partsemantics_annotator(self) -> PartSemanticsAnnotator:
+        if self.partsemantics_annotator is None:
+            cfg = self.sync_batch_stage_config(self.cfg.partsemantics)
+            self.partsemantics_annotator = PartSemanticsAnnotator(cfg)
+        return self.partsemantics_annotator
+
+    def get_grasp_generator(self) -> GraspGenerator:
+        if self.grasp_generator is None:
+            cfg = self.sync_batch_stage_config(self.cfg.grasp)
+            self.grasp_generator = GraspGenerator(cfg)
+        return self.grasp_generator
+
+    def run_stage(
+        self,
+        stage_name: str,
+        stage_fn,
+        urdf_path: str,
+    ) -> bool:
+        try:
+            success = bool(stage_fn())
+        except Exception as exc:
+            logger.warning(
+                "{} failed for URDF {}: {}".format(
+                    stage_name,
+                    urdf_path,
+                    exc,
+                )
+            )
+            return False
+
+        if not success:
+            logger.warning(
+                "{} returned failure for URDF {}".format(
+                    stage_name,
+                    urdf_path,
+                )
+            )
+        return success
+
+    def process_one_urdf(
+        self,
+        urdf_path: str,
+        output_dir: str,
+        index: int,
+    ) -> dict[str, bool]:
+        start_time = time.perf_counter()
+        logger.info(
+            "Starting affordance pipeline for URDF {}/{}: {}".format(
+                index,
+                len(self.cfg.urdf_paths),
+                urdf_path,
+            )
+        )
+        stages = [
+            (
+                "part segmentation",
+                lambda: self.process_part_seg(urdf_path, output_dir),
+            ),
+            (
+                "part semantics annotation",
+                lambda: self.process_partsemantics_annot(urdf_path, output_dir),
+            ),
+            (
+                "grasp generation",
+                lambda: self.process_grasp(urdf_path, output_dir),
+            ),
+            (
+                "grasp evaluation",
+                lambda: self.process_grasp_eval(urdf_path, output_dir),
+            ),
+        ]
+
+        results = {}
+        for stage_name, stage_fn in stages:
+            logger.info(f"Starting affordance stage: {stage_name}")
+            results[stage_name] = self.run_stage(
+                stage_name,
+                stage_fn,
+                urdf_path,
+            )
+            logger.info(
+                "Finished affordance stage: {} ({})".format(
+                    stage_name,
+                    "success" if results[stage_name] else "failed",
+                )
+            )
+
+        failed_stages = [
+            stage_name for stage_name, success in results.items() if not success
+        ]
+        if failed_stages:
+            logger.warning(
+                "Affordance pipeline finished with failed stages for {}: {}".format(
+                    urdf_path,
+                    ", ".join(failed_stages),
+                )
+            )
+        else:
+            logger.info(f"Affordance pipeline finished successfully: {urdf_path}")
+
+        elapsed_seconds = time.perf_counter() - start_time
+        self.asset_timings.append(
+            {
+                "urdf_path": urdf_path,
+                "output_dir": output_dir,
+                "elapsed_seconds": elapsed_seconds,
+            }
+        )
+        logger.info(
+            "Affordance pipeline time for {}: {:.2f}s".format(
+                urdf_path,
+                elapsed_seconds,
+            )
+        )
+        return results
+
+    def log_timing_summary(self) -> None:
+        if not self.asset_timings:
+            return
+
+        total_seconds = sum(
+            float(item["elapsed_seconds"]) for item in self.asset_timings
+        )
+        asset_count = len(self.asset_timings)
+        logger.info(
+            "Affordance pipeline total time: {:.2f}s for {} asset(s).".format(
+                total_seconds,
+                asset_count,
+            )
+        )
+        logger.info(
+            "Affordance pipeline average time per asset: {:.2f}s".format(
+                total_seconds / asset_count,
+            )
+        )
+
+    def process(self) -> list[dict[str, bool]]:
+        results = []
+        for idx, (urdf_path, output_dir) in enumerate(
+            zip(self.cfg.urdf_paths, self.cfg.output_dirs),
+            start=1,
+        ):
+            results.append(self.process_one_urdf(urdf_path, output_dir, idx))
+        self.log_timing_summary()
+        return results
+
+
+def run_affordance_annot(cfg: AffordanceAnnotConfig) -> None:
+    annotator = AffordanceAnnotator(cfg)
+    annotator.process()
+
+
+def entrypoint(*args, **kwargs) -> None:
+    cfg = tyro.cli(AffordanceAnnotConfig)
+    run_affordance_annot(cfg)
+
+
+if __name__ == "__main__":
+    entrypoint()

embodied_gen/scripts/affordance_annot/eval_grasps.py

@@ -0,0 +1,1303 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+import concurrent.futures
+import dataclasses
+import os
+import threading
+import time
+import warnings
+from collections import defaultdict
+from dataclasses import dataclass, field
+
+warnings.filterwarnings("ignore", category=UserWarning)
+
+from typing import Literal
+
+import imageio
+import numpy as np
+import sapien.core as sapien
+import sapien.physx as physx
+import torch
+import tyro
+from PIL import Image, ImageColor
+from scipy.spatial.transform import Rotation as R
+from tqdm import tqdm
+from embodied_gen.data.utils import DiffrastRender
+from embodied_gen.utils.geometry import MeshInfo
+from embodied_gen.utils.io_utils import (
+    URDFFile,
+    load_json,
+    load_mesh_info,
+    write_json,
+)
+from embodied_gen.utils.log import logger
+
+COLORMAP = list(set(ImageColor.colormap.values()))
+COLOR_PALETTE = np.array(
+    [ImageColor.getrgb(c) for c in COLORMAP], dtype=np.uint8
+)
+MAX_NUM_WORKERS = 10
+MAX_GRASPS_PER_WORKER_PROCESS = 8
+SAPIEN_DEFAULT_STATIC_FRICTION = 0.3
+SAPIEN_DEFAULT_DYNAMIC_FRICTION = 0.3
+SAPIEN_DEFAULT_RESTITUTION = 0.1
+
+_EVALUATOR_KEEPALIVE: list["EvalGrasps"] = []
+_EVALUATOR_KEEPALIVE_LOCK = threading.Lock()
+
+__all__ = [
+    "EvalGraspsConfig",
+    "GripperControlInfo",
+    "SapienSceneManager",
+    "EvalGrasps",
+    "run_eval",
+    "entrypoint",
+]
+
+
+@dataclass
+class EvalGraspsConfig:
+    urdf_paths: list[str] = field(default_factory=list)
+    gripper_name: str = "franka_panda"
+    gripper_urdf_path: str = (
+        f"embodied_gen/scripts/affordance_annot/{gripper_name}/gripper.urdf"
+    )
+    output_dirs: list[str] = field(default_factory=list)
+    sim_freq: int = 240
+    video_fps: int = 30
+    render_interval: int = 24
+    image_hw: tuple[int, int] = (512, 512)
+    num_cameras: int = 1
+    fovy_deg: float = 45.0
+    sim_backend: str = "cpu"
+    ray_tracing: bool = False
+    gripper_move_speed: float = 0.1
+    gripper_close_speed: float = 0.01
+    action_wait_seconds: float = 0.5
+    lift_height: float = 0.5
+    sweep_distance: float = 0.5
+    num_workers: int | None = None
+    max_grasps_per_worker_process: int = MAX_GRASPS_PER_WORKER_PROCESS
+    gripper_drive_stiffness: float = 2500.0
+    gripper_static_friction: float = SAPIEN_DEFAULT_STATIC_FRICTION
+    gripper_dynamic_friction: float = SAPIEN_DEFAULT_DYNAMIC_FRICTION
+    gripper_restitution: float = SAPIEN_DEFAULT_RESTITUTION
+    root_drive_stiffness: float = 1e6
+    root_drive_damping: float = 1e4
+    object_bottom_clearance: float = 0.1
+    hold_object_during_close: bool = True
+    slip_translation_threshold: float = 0.05
+    slip_rotation_threshold_deg: float = 30.0
+    check_close_slip: bool = True
+    debug_mode: bool = False
+    save_failed_grasps: bool = False
+
+
+@dataclass
+class GripperControlInfo:
+    open_qpos: float
+    close_qpos: float
+    drive_damping: float
+    force_limit: float
+
+
+class GripperActionAgent:
+    def __init__(
+        self,
+        scene_manager: "SapienSceneManager",
+        gripper: physx.PhysxArticulation,
+        root_target: sapien.Entity,
+        root_drive: physx.PhysxDriveComponent,
+    ) -> None:
+        self.scene_manager = scene_manager
+        self.gripper = gripper
+        self.root_target = root_target
+        self.root_drive = root_drive
+
+    def set_action(self, action: np.ndarray | torch.Tensor) -> None:
+        if isinstance(action, torch.Tensor):
+            values = action.detach().cpu().numpy().reshape(-1)
+        else:
+            values = np.asarray(action).reshape(-1)
+        if values.size != 8:
+            raise ValueError(
+                f"Gripper action must have 8 values, got {values.size}."
+            )
+        self.root_target.set_pose(
+            sapien.Pose(
+                p=values[:3].astype(np.float64),
+                q=values[3:7].astype(np.float64),
+            )
+        )
+        self.scene_manager.set_gripper_target(
+            self.gripper,
+            float(values[7]),
+        )
+
+
+class SapienSceneManager:
+    def __init__(
+        self, sim_freq: int, ray_tracing: bool, device: str = "cpu"
+    ) -> None:
+        self.sim_freq = sim_freq
+        self.ray_tracing = ray_tracing
+        self.device = device
+        self.renderer = sapien.SapienRenderer()
+        self.scene = self.setup_scene()
+        self.cameras: list[sapien.render.RenderCameraComponent] = []
+        self.actors: dict[str, sapien.pysapien.Entity] = {}
+
+    def setup_scene(self) -> sapien.Scene:
+        # Ray tracing settings
+        if self.ray_tracing:
+            sapien.render.set_camera_shader_dir("rt")
+            sapien.render.set_ray_tracing_samples_per_pixel(64)
+            sapien.render.set_ray_tracing_path_depth(10)
+            sapien.render.set_ray_tracing_denoiser("oidn")
+
+        scene = sapien.Scene()
+        scene.set_timestep(1 / self.sim_freq)
+
+        # Add lighting
+        scene.set_ambient_light([0.2, 0.2, 0.2])
+        scene.add_directional_light(
+            direction=[0, 1, -1],
+            color=[1.5, 1.45, 1.4],
+            shadow=True,
+            shadow_map_size=2048,
+        )
+        scene.add_directional_light(
+            direction=[0, -0.5, 1], color=[0.8, 0.8, 0.85], shadow=False
+        )
+        scene.add_directional_light(
+            direction=[0, -1, 1], color=[1.0, 1.0, 1.0], shadow=False
+        )
+
+        ground_material = self.renderer.create_material()
+        ground_material.base_color = [0.5, 0.5, 0.5, 1]  # rgba, gray
+        ground_material.roughness = 0.7
+        ground_material.metallic = 0.0
+        scene.add_ground(0, render_material=ground_material)
+        return scene
+
+    def set_ground_color(self, rgba: list[float]) -> None:
+        """Update the default ground plane material color for this scene."""
+        for actor in self.scene.get_all_actors():
+            if actor.name != "ground":
+                continue
+            for component in actor.components:
+                render_shapes = getattr(component, "render_shapes", None)
+                if render_shapes is None:
+                    continue
+                for render_shape in render_shapes:
+                    render_shape.material.set_base_color(rgba)
+            return
+        raise ValueError("Ground actor not found in the scene.")
+
+    def create_camera(
+        self,
+        cam_name: str,
+        pose: sapien.Pose,
+        image_hw: tuple[int, int],
+        fovy_deg: float,
+    ) -> sapien.render.RenderCameraComponent:
+        cam_actor = self.scene.create_actor_builder().build_kinematic()
+        cam_actor.set_pose(pose)
+        camera = self.scene.add_mounted_camera(
+            name=cam_name,
+            mount=cam_actor,
+            pose=sapien.Pose(p=[0, 0, 0], q=[1, 0, 0, 0]),
+            width=image_hw[1],
+            height=image_hw[0],
+            fovy=np.deg2rad(fovy_deg),
+            near=0.01,
+            far=100,
+        )
+        self.cameras.append(camera)
+        return camera
+
+    def add_ring_cameras(
+        self,
+        num_cameras: int,
+        radius: float,
+        height: float,
+        target_pt: list[float],
+        image_hw: tuple[int, int],
+        fovy_deg: float,
+    ) -> list[sapien.render.RenderCameraComponent]:
+        angle_step = 2 * np.pi / num_cameras
+        world_up_vec = np.array([0.0, 0.0, 1.0])
+        target_pt = np.array(target_pt)
+
+        for i in range(num_cameras):
+            angle = i * angle_step
+            cam_x = target_pt[0] + radius * np.cos(angle)
+            cam_y = target_pt[1] + radius * np.sin(angle)
+            cam_z = height
+            eye_pos = [cam_x, cam_y, cam_z]
+
+            forward_vec = target_pt - eye_pos
+            forward_vec = forward_vec / np.linalg.norm(forward_vec)
+            temp_right_vec = np.cross(forward_vec, world_up_vec)
+
+            if np.linalg.norm(temp_right_vec) < 1e-6:
+                temp_right_vec = np.array([1.0, 0.0, 0.0])
+                if np.abs(np.dot(temp_right_vec, forward_vec)) > 0.99:
+                    temp_right_vec = np.array([0.0, 1.0, 0.0])
+
+            right_vec = temp_right_vec / np.linalg.norm(temp_right_vec)
+            up_vec = np.cross(right_vec, forward_vec)
+            rotation_matrix = np.array([forward_vec, -right_vec, up_vec]).T
+
+            rot = R.from_matrix(rotation_matrix)
+            scipy_quat = rot.as_quat()  # (x, y, z, w)
+            quat = [
+                scipy_quat[3],
+                scipy_quat[0],
+                scipy_quat[1],
+                scipy_quat[2],
+            ]  # (w, x, y, z)
+
+            self.create_camera(
+                f"camera_{i}",
+                sapien.Pose(p=eye_pos, q=quat),
+                image_hw,
+                fovy_deg,
+            )
+
+        return self.cameras
+
+    def add_actor(
+        self,
+        mesh_info: MeshInfo,
+        position: list[float],
+    ) -> sapien.Entity:
+        builder = self.scene.create_actor_builder()
+        material = physx.PhysxMaterial(
+            static_friction=float(
+                np.clip(mesh_info.static_friction, 0.1, 0.7)
+            ),
+            dynamic_friction=float(
+                np.clip(mesh_info.dynamic_friction, 0.1, 0.6)
+            ),
+            restitution=0.05,
+        )
+        builder.set_physx_body_type("dynamic")
+        builder.add_multiple_convex_collisions_from_file(
+            mesh_info.collision_mesh_path,
+            scale=mesh_info.collision_mesh_scale,
+            pose=mesh_info.collision_local_pose,
+            material=material,
+        )
+        builder.add_visual_from_file(
+            mesh_info.visual_mesh_path,
+            scale=mesh_info.visual_mesh_scale,
+            pose=mesh_info.visual_local_pose,
+        )
+
+        builder.set_initial_pose(sapien.Pose(p=position))
+        actor = builder.build(name=mesh_info.actor_name)
+        if mesh_info.mass is not None and hasattr(
+            actor.components[1], "set_mass"
+        ):
+            actor.components[1].set_mass(mesh_info.mass)
+        return actor
+
+    def add_gripper(
+        self,
+        gripper_urdf_path: str,
+        root_pose: sapien.Pose,
+        open_qpos: float,
+        drive_stiffness: float,
+        drive_damping: float,
+        force_limit: float,
+        static_friction: float,
+        dynamic_friction: float,
+        restitution: float,
+        root_drive_stiffness: float,
+        root_drive_damping: float,
+    ) -> tuple[
+        physx.PhysxArticulation,
+        sapien.Entity,
+        physx.PhysxDriveComponent,
+    ]:
+        loader = self.scene.create_urdf_loader()
+        loader.fix_root_link = False
+        gripper = loader.load(gripper_urdf_path)
+        gripper.set_root_pose(root_pose)
+        self.set_articulation_contact_material(
+            gripper,
+            physx.PhysxMaterial(
+                static_friction,
+                dynamic_friction,
+                restitution,
+            ),
+        )
+        for link in gripper.get_links():
+            link.set_disable_gravity(True)
+
+        root_target = self.scene.create_actor_builder().build_kinematic(
+            name="gripper_root_target"
+        )
+        root_target.set_pose(root_pose)
+        root_drive = self.scene.create_drive(
+            root_target,
+            sapien.Pose(),
+            gripper.get_root(),
+            sapien.Pose(),
+        )
+        root_drive.set_limit_x(
+            0.0, 0.0, root_drive_stiffness, root_drive_damping
+        )
+        root_drive.set_limit_y(
+            0.0, 0.0, root_drive_stiffness, root_drive_damping
+        )
+        root_drive.set_limit_z(
+            0.0, 0.0, root_drive_stiffness, root_drive_damping
+        )
+        root_drive.set_limit_twist(
+            0.0, 0.0, root_drive_stiffness, root_drive_damping
+        )
+        root_drive.set_limit_cone(
+            0.0, 0.0, root_drive_stiffness, root_drive_damping
+        )
+        root_drive.set_drive_property_x(
+            root_drive_stiffness, root_drive_damping
+        )
+        root_drive.set_drive_property_y(
+            root_drive_stiffness, root_drive_damping
+        )
+        root_drive.set_drive_property_z(
+            root_drive_stiffness, root_drive_damping
+        )
+        root_drive.set_drive_property_slerp(
+            root_drive_stiffness,
+            root_drive_damping,
+        )
+        root_drive.set_inv_mass_scales(0.0, 1.0)
+
+        qpos = []
+        for joint in gripper.get_active_joints():
+            joint.set_drive_properties(
+                drive_stiffness,
+                drive_damping,
+                force_limit,
+            )
+            joint.set_friction(0.1)
+            limit = np.asarray(joint.get_limits()).reshape(-1, 2)[0]
+            target = float(np.clip(open_qpos, limit[0], limit[1]))
+            joint.set_drive_target(target)
+            qpos.append(target)
+        if qpos:
+            gripper.set_qpos(qpos)
+            gripper.set_qvel(np.zeros(len(qpos), dtype=np.float32))
+        return gripper, root_target, root_drive
+
+    @staticmethod
+    def set_articulation_contact_material(
+        articulation: physx.PhysxArticulation,
+        material: physx.PhysxMaterial,
+    ) -> None:
+        for link in articulation.get_links():
+            for shape in link.get_collision_shapes():
+                shape.set_physical_material(material)
+
+    def set_gripper_target(
+        self,
+        gripper: physx.PhysxArticulation,
+        finger_qpos: float,
+    ) -> None:
+        for joint in gripper.get_active_joints():
+            limit = np.asarray(joint.get_limits()).reshape(-1, 2)[0]
+            target = float(np.clip(finger_qpos, limit[0], limit[1]))
+            joint.set_drive_target(target)
+
+    def render_images(
+        self,
+        camera,
+        render_keys: list[
+            Literal[
+                "Color",
+                "Segmentation",
+                "Normal",
+                "Mask",
+                "Depth",
+                "Foreground",
+            ]
+        ] = None,
+    ) -> dict[str, Image.Image]:
+        if render_keys is None:
+            render_keys = [
+                "Color",
+                "Segmentation",
+                "Normal",
+                "Mask",
+                "Depth",
+                "Foreground",
+            ]
+
+        results: dict[str, Image.Image] = {}
+        if "Color" in render_keys:
+            color = camera.get_picture("Color")
+            color_rgb = (np.clip(color[..., :3], 0, 1) * 255).astype(np.uint8)
+            results["Color"] = Image.fromarray(color_rgb)
+
+        if "Mask" in render_keys:
+            alpha = (np.clip(color[..., 3], 0, 1) * 255).astype(np.uint8)
+            results["Mask"] = Image.fromarray(alpha)
+
+        if "Segmentation" in render_keys:
+            seg_labels = camera.get_picture("Segmentation")
+            label0 = seg_labels[..., 0].astype(np.uint8)
+            seg_color = COLOR_PALETTE[label0]
+            results["Segmentation"] = Image.fromarray(seg_color)
+
+        if "Foreground" in render_keys:
+            seg_labels = camera.get_picture("Segmentation")
+            label0 = seg_labels[..., 0]
+            mask = np.where((label0 > 1), 255, 0).astype(np.uint8)
+            color = camera.get_picture("Color")
+            color_rgb = (np.clip(color[..., :3], 0, 1) * 255).astype(np.uint8)
+            foreground = np.concatenate([color_rgb, mask[..., None]], axis=-1)
+            results["Foreground"] = Image.fromarray(foreground)
+
+        if "Normal" in render_keys:
+            normal = camera.get_picture("Normal")[..., :3]
+            normal_img = (((normal + 1) / 2) * 255).astype(np.uint8)
+            results["Normal"] = Image.fromarray(normal_img)
+
+        if "Depth" in render_keys:
+            position_map = camera.get_picture("Position")
+            depth = -position_map[..., 2]
+            alpha = torch.tensor(color[..., 3], dtype=torch.float32)
+            norm_depth = DiffrastRender.normalize_map_by_mask(
+                torch.tensor(depth), alpha
+            )
+            depth_img = (norm_depth * 255).to(torch.uint8).numpy()
+            results["Depth"] = Image.fromarray(depth_img)
+
+        return results
+
+    def step_action(
+        self,
+        agent: GripperActionAgent | None,
+        action: np.ndarray | torch.Tensor | None,
+        render_keys: list[str],
+        sim_steps_per_control: int = 1,
+        render: bool = True,
+    ) -> dict:
+        if action is not None:
+            agent.set_action(action)
+        frames = defaultdict(defaultdict)
+        for _ in range(sim_steps_per_control):
+            self.scene.step()
+        if not render:
+            return frames
+        self.scene.update_render()
+        for camera in self.cameras:
+            camera.take_picture()
+            images = self.render_images(camera, render_keys=render_keys)
+            frames[camera.name].update(images)
+        return frames
+
+
+class EvalGrasps:
+    def __init__(
+        self,
+        cfg: EvalGraspsConfig,
+        mesh_info: MeshInfo,
+        gripper_control: GripperControlInfo,
+        grasp: dict,
+    ) -> None:
+        self.cfg = cfg
+        self.mesh_info = mesh_info
+        self.gripper_control = gripper_control
+        self.grasp = grasp
+        self.init_scene()
+        if self.cfg.debug_mode:
+            self.setup_cameras(mesh_info)
+        self.object_actor = self.add_object(mesh_info)
+
+        self.frames = {}
+        self.step_index = 0
+        self.world_x_offset = np.array(
+            [self.cfg.sweep_distance, 0.0, 0.0],
+            dtype=np.float64,
+        )
+        self.world_y_offset = np.array(
+            [0.0, self.cfg.sweep_distance, 0.0],
+            dtype=np.float64,
+        )
+
+    def should_render(self) -> bool:
+        return (
+            self.cfg.debug_mode
+            and self.step_index % max(1, self.cfg.render_interval) == 0
+        )
+
+    def init_scene(self) -> None:
+        self.scene_manager = SapienSceneManager(
+            sim_freq=self.cfg.sim_freq,
+            ray_tracing=self.cfg.ray_tracing,
+            device=self.cfg.sim_backend,
+        )
+        if self.cfg.debug_mode:
+            self.scene_manager.set_ground_color([0.78, 0.90, 0.72, 1.0])
+
+    def setup_cameras(self, mesh_info: MeshInfo) -> None:
+        bounds = mesh_info.transformed_mesh.bounds.copy()
+
+        mesh_size = bounds[1] - bounds[0]
+        mesh_height = max(float(mesh_size[2]), 0.5)
+        target_pt = [
+            float((bounds[0, 0] + bounds[1, 0]) * 0.5),
+            float((bounds[0, 1] + bounds[1, 1]) * 0.5),
+            float(bounds[1, 2]),
+        ]
+
+        aspect = self.cfg.image_hw[1] / self.cfg.image_hw[0]
+        half_vfov = np.deg2rad(self.cfg.fovy_deg) * 0.5
+        half_hfov = np.arctan(np.tan(half_vfov) * aspect)
+        half_min_fov = min(half_vfov, half_hfov)
+        framing_half_extents = np.array(
+            [
+                max(float(mesh_size[0]) * 0.5, 1e-6),
+                max(float(mesh_size[1]) * 0.5, 1e-6),
+                mesh_height,
+            ],
+            dtype=np.float64,
+        )
+        camera_radius = max(
+            float(
+                np.linalg.norm(framing_half_extents)
+                / np.sin(half_min_fov)
+                * 1.5
+            ),
+            2.5,
+        )
+        camera_height = target_pt[2]
+
+        self.scene_manager.add_ring_cameras(
+            num_cameras=self.cfg.num_cameras,
+            radius=camera_radius,
+            height=camera_height,
+            target_pt=target_pt,
+            image_hw=self.cfg.image_hw,
+            fovy_deg=self.cfg.fovy_deg,
+        )
+
+    def add_object(
+        self,
+        mesh_info: MeshInfo,
+    ) -> sapien.Entity:
+        spawn_z = self.cfg.object_bottom_clearance - float(
+            mesh_info.transformed_mesh.bounds[0, 2]
+        )
+        actor = self.scene_manager.add_actor(mesh_info, [0.0, 0.0, spawn_z])
+        self.set_object_gravity(not self.cfg.hold_object_during_close, actor)
+        return actor
+
+    def set_object_gravity(
+        self,
+        enabled: bool,
+        actor: sapien.Entity | None = None,
+    ) -> None:
+        actor = self.object_actor if actor is None else actor
+        for component in actor.components:
+            set_disable_gravity = getattr(
+                component,
+                "set_disable_gravity",
+                None,
+            )
+            if set_disable_gravity is not None:
+                set_disable_gravity(not enabled)
+            if enabled:
+                wake_up = getattr(component, "wake_up", None)
+                if wake_up is not None:
+                    wake_up()
+
+    def run_actions(
+        self,
+        agent: GripperActionAgent,
+        actions: np.ndarray,
+    ) -> None:
+        for action in actions:
+            this_frames = self.scene_manager.step_action(
+                agent=agent,
+                action=action,
+                render_keys=["Color"],
+                sim_steps_per_control=1,
+                render=self.should_render(),
+            )
+            self.update_frames(this_frames)
+            self.step_index += 1
+
+    @staticmethod
+    def make_pose(
+        position: np.ndarray,
+        quat_wxyz: np.ndarray,
+    ) -> sapien.Pose:
+        return sapien.Pose(
+            p=[float(v) for v in position],
+            q=[float(v) for v in quat_wxyz],
+        )
+
+    @staticmethod
+    def pose_matrix(pose: sapien.Pose) -> np.ndarray:
+        quat_wxyz = np.asarray(pose.q, dtype=np.float64)
+        quat_norm = np.linalg.norm(quat_wxyz)
+        if quat_norm <= 0.0:
+            raise ValueError("Pose quaternion has zero norm.")
+        quat_wxyz = quat_wxyz / quat_norm
+
+        matrix = np.eye(4, dtype=np.float64)
+        matrix[:3, :3] = R.from_quat(
+            [
+                quat_wxyz[1],
+                quat_wxyz[2],
+                quat_wxyz[3],
+                quat_wxyz[0],
+            ]
+        ).as_matrix()
+        matrix[:3, 3] = np.asarray(pose.p, dtype=np.float64)
+        return matrix
+
+    @staticmethod
+    def pose_delta(
+        reference_relative_pose: np.ndarray,
+        current_relative_pose: np.ndarray,
+    ) -> dict[str, float]:
+        delta_pose = (
+            np.linalg.inv(reference_relative_pose) @ current_relative_pose
+        )
+        translation_m = float(np.linalg.norm(delta_pose[:3, 3]))
+        rotation_rad = float(R.from_matrix(delta_pose[:3, :3]).magnitude())
+        return {
+            "translation_m": translation_m,
+            "rotation_rad": rotation_rad,
+            "rotation_deg": float(np.rad2deg(rotation_rad)),
+        }
+
+    def object_rel_pose(
+        self,
+        agent: GripperActionAgent,
+    ) -> np.ndarray:
+        gripper_pose = self.pose_matrix(agent.gripper.get_root_pose())
+        object_pose = self.pose_matrix(self.object_actor.get_pose())
+        return np.linalg.inv(gripper_pose) @ object_pose
+
+    def object_bottom_z(self) -> float:
+        object_pose = self.pose_matrix(self.object_actor.get_pose())
+        vertices = np.asarray(self.mesh_info.transformed_mesh.vertices)
+        world_vertices = (object_pose[:3, :3] @ vertices.T).T + object_pose[
+            :3, 3
+        ]
+        return float(np.min(world_vertices[:, 2]))
+
+    def check_slip(
+        self,
+        agent: GripperActionAgent,
+        reference_relative_pose: np.ndarray,
+    ) -> dict[str, float | bool]:
+        delta = self.pose_delta(
+            reference_relative_pose,
+            self.object_rel_pose(agent),
+        )
+        slipped = (
+            delta["translation_m"] > self.cfg.slip_translation_threshold
+            or delta["rotation_deg"] > self.cfg.slip_rotation_threshold_deg
+        )
+        return {
+            **delta,
+            "slipped": slipped,
+        }
+
+    def checked_action(
+        self,
+        step_name: str,
+        agent: GripperActionAgent,
+        action_fn,
+        *,
+        check_slip: bool = True,
+    ) -> dict:
+        reference_relative_pose = self.object_rel_pose(agent)
+        action_fn()
+        self.wait_scene(self.cfg.action_wait_seconds)
+        delta = self.check_slip(
+            agent,
+            reference_relative_pose,
+        )
+        slipped = bool(delta["slipped"])
+        success = not slipped if check_slip else True
+        return {
+            "step": step_name,
+            "success": success,
+            "checked": check_slip,
+            "slipped": slipped,
+            "reason": None if success else "relative_pose_slip",
+            "relative_pose_delta": {
+                "translation_m": delta["translation_m"],
+                "rotation_rad": delta["rotation_rad"],
+                "rotation_deg": delta["rotation_deg"],
+            },
+        }
+
+    def get_steps(
+        self,
+        distance: float,
+        speed: float,
+    ) -> int:
+        if distance <= 0.0:
+            return 2
+        duration = distance / speed
+        return max(2, int(np.ceil(duration * self.cfg.sim_freq)))
+
+    def move_to_pose(
+        self,
+        agent: GripperActionAgent,
+        start_pose: sapien.Pose,
+        end_pose: sapien.Pose,
+        finger_qpos: float | None = None,
+    ) -> None:
+        if finger_qpos is None:
+            finger_qpos = self.gripper_control.close_qpos
+
+        start_pos = np.asarray(start_pose.p, dtype=np.float64)
+        end_pos = np.asarray(end_pose.p, dtype=np.float64)
+        travel_distance = float(np.linalg.norm(end_pos - start_pos))
+        num_steps = self.get_steps(
+            travel_distance,
+            self.cfg.gripper_move_speed,
+        )
+        alphas = np.linspace(0.0, 1.0, num_steps)
+        quat = np.asarray(start_pose.q, dtype=np.float64)
+
+        actions = []
+        for alpha in alphas:
+            pose = self.make_pose(
+                (1.0 - alpha) * start_pos + alpha * end_pos,
+                quat,
+            )
+            actions.append(self.make_action(pose, finger_qpos))
+        self.run_actions(agent, np.stack(actions, axis=0))
+
+    def move_gripper(
+        self,
+        agent: GripperActionAgent,
+        offset: np.ndarray,
+    ) -> None:
+        start_pose = agent.gripper.get_root_pose()
+        end_pose = self.make_pose(
+            np.asarray(start_pose.p, dtype=np.float64)
+            + np.asarray(offset, dtype=np.float64),
+            np.asarray(start_pose.q, dtype=np.float64),
+        )
+        self.move_to_pose(agent, start_pose, end_pose)
+
+    def init_grasp_pose(self) -> sapien.Pose:
+        orientation = self.grasp["orientation"]
+        self.grasp = sapien.Pose(
+            p=[float(v) for v in self.grasp["position"]],
+            q=[
+                float(orientation["w"]),
+                float(orientation["xyz"][0]),
+                float(orientation["xyz"][1]),
+                float(orientation["xyz"][2]),
+            ],
+        )
+        gripper_pose = self.object_actor.get_pose() * self.grasp
+        return gripper_pose
+
+    def make_action(
+        self,
+        pose: sapien.Pose,
+        finger_qpos: float,
+    ) -> np.ndarray:
+        return np.array(
+            [
+                float(pose.p[0]),
+                float(pose.p[1]),
+                float(pose.p[2]),
+                float(pose.q[0]),
+                float(pose.q[1]),
+                float(pose.q[2]),
+                float(pose.q[3]),
+                float(finger_qpos),
+            ],
+            dtype=np.float32,
+        )
+
+    def add_gripper_agent(self) -> GripperActionAgent:
+        gripper_pose = self.init_grasp_pose()
+        gripper, root_target, root_drive = self.scene_manager.add_gripper(
+            self.cfg.gripper_urdf_path,
+            gripper_pose,
+            self.gripper_control.open_qpos,
+            self.cfg.gripper_drive_stiffness,
+            self.gripper_control.drive_damping,
+            self.gripper_control.force_limit,
+            self.cfg.gripper_static_friction,
+            self.cfg.gripper_dynamic_friction,
+            self.cfg.gripper_restitution,
+            self.cfg.root_drive_stiffness,
+            self.cfg.root_drive_damping,
+        )
+        return GripperActionAgent(
+            self.scene_manager,
+            gripper,
+            root_target,
+            root_drive,
+        )
+
+    def update_frames(self, this_frames: dict) -> None:
+        for cam_name, images_list in this_frames.items():
+            if cam_name not in self.frames:
+                self.frames[cam_name] = []
+            self.frames[cam_name].append(np.array(images_list["Color"]))
+
+    def wait_scene(self, seconds: float) -> None:
+        num_steps = int(self.cfg.sim_freq * seconds)
+        for _ in range(num_steps):
+            this_frames = self.scene_manager.step_action(
+                agent=None,
+                action=None,
+                render_keys=["Color"],
+                sim_steps_per_control=1,
+                render=self.should_render(),
+            )
+            self.update_frames(this_frames)
+            self.step_index += 1
+
+    def close_gripper(self, agent: GripperActionAgent) -> None:
+        num_close_steps = self.get_steps(
+            abs(
+                self.gripper_control.open_qpos
+                - self.gripper_control.close_qpos
+            ),
+            self.cfg.gripper_close_speed,
+        )
+        root_pose = agent.gripper.get_root_pose()
+        actions = [
+            self.make_action(
+                root_pose,
+                (1.0 - alpha) * self.gripper_control.open_qpos
+                + alpha * self.gripper_control.close_qpos,
+            )
+            for alpha in np.linspace(0.0, 1.0, max(1, num_close_steps))
+        ]
+        self.run_actions(agent, np.stack(actions, axis=0))
+
+    @staticmethod
+    def summarize_steps(step_results: list[dict]) -> dict:
+        failure = next(
+            (
+                step_result
+                for step_result in step_results
+                if not step_result["success"]
+            ),
+            None,
+        )
+        result = {
+            "success": failure is None,
+            "relative_pose_deltas": {
+                step_result["step"]: step_result["relative_pose_delta"]
+                for step_result in step_results
+            },
+        }
+        if failure is not None:
+            result.update(
+                {
+                    "failure_step": failure["step"],
+                    "reason": failure["reason"],
+                }
+            )
+        return result
+
+    def run(self) -> dict:
+        step_results = []
+        self.wait_scene(2.0)
+
+        this_agent = self.add_gripper_agent()
+        self.wait_scene(self.cfg.action_wait_seconds)
+
+        # Close the gripper around the object.
+        step_result = self.checked_action(
+            "close_gripper",
+            this_agent,
+            lambda: self.close_gripper(this_agent),
+            check_slip=self.cfg.check_close_slip,
+        )
+        step_results.append(step_result)
+        if not step_result["success"]:
+            return self.summarize_steps(step_results)
+
+        if self.cfg.hold_object_during_close:
+            self.set_object_gravity(True)
+
+        # Lift the grasped object upward.
+        step_result = self.checked_action(
+            "lift_gripper",
+            this_agent,
+            lambda: self.move_gripper(
+                this_agent,
+                np.array(
+                    [0.0, 0.0, self.cfg.lift_height],
+                    dtype=np.float64,
+                ),
+            ),
+        )
+        step_results.append(step_result)
+        if not step_result["success"]:
+            return self.summarize_steps(step_results)
+
+        shake_start_pose = this_agent.gripper.get_root_pose()
+        shake_end_pose = self.make_pose(
+            np.asarray(shake_start_pose.p, dtype=np.float64)
+            + self.world_x_offset,
+            np.asarray(shake_start_pose.q, dtype=np.float64),
+        )
+
+        # Move the gripper outward along the X axis.
+        step_result = self.checked_action(
+            "move_gripper_out_x",
+            this_agent,
+            lambda: self.move_to_pose(
+                this_agent,
+                shake_start_pose,
+                shake_end_pose,
+            ),
+        )
+        step_results.append(step_result)
+        if not step_result["success"]:
+            return self.summarize_steps(step_results)
+
+        # Move the gripper back from the X-axis offset.
+        step_result = self.checked_action(
+            "move_gripper_back_x",
+            this_agent,
+            lambda: self.move_to_pose(
+                this_agent,
+                this_agent.gripper.get_root_pose(),
+                shake_start_pose,
+            ),
+        )
+        step_results.append(step_result)
+        if not step_result["success"]:
+            return self.summarize_steps(step_results)
+
+        shake_start_pose = this_agent.gripper.get_root_pose()
+        shake_end_pose = self.make_pose(
+            np.asarray(shake_start_pose.p, dtype=np.float64)
+            + self.world_y_offset,
+            np.asarray(shake_start_pose.q, dtype=np.float64),
+        )
+
+        # Move the gripper outward along the Y axis.
+        step_result = self.checked_action(
+            "move_gripper_out_y",
+            this_agent,
+            lambda: self.move_to_pose(
+                this_agent,
+                shake_start_pose,
+                shake_end_pose,
+            ),
+        )
+        step_results.append(step_result)
+        if not step_result["success"]:
+            return self.summarize_steps(step_results)
+
+        # Move the gripper back from the Y-axis offset.
+        step_result = self.checked_action(
+            "move_gripper_back_y",
+            this_agent,
+            lambda: self.move_to_pose(
+                this_agent,
+                this_agent.gripper.get_root_pose(),
+                shake_start_pose,
+            ),
+        )
+        step_results.append(step_result)
+        if not step_result["success"]:
+            return self.summarize_steps(step_results)
+
+        # Lower the grasped object back down.
+        descend_offset = np.array(
+            [0.0, 0.0, 0.01 - self.object_bottom_z()],
+            dtype=np.float64,
+        )
+        step_result = self.checked_action(
+            "descend_gripper",
+            this_agent,
+            lambda: self.move_gripper(this_agent, descend_offset),
+        )
+        step_results.append(step_result)
+        if not step_result["success"]:
+            return self.summarize_steps(step_results)
+
+        return self.summarize_steps(step_results)
+
+    def export_video(self, output_dir: str) -> None:
+        if not self.cfg.debug_mode:
+            return
+        os.makedirs(output_dir, exist_ok=True)
+        for cam_name, this_frames in self.frames.items():
+            this_output_path = os.path.join(output_dir, f"{cam_name}.mp4")
+            imageio.mimsave(
+                this_output_path, this_frames, fps=self.cfg.video_fps
+            )
+
+
+def _validate_config(cfg: EvalGraspsConfig) -> None:
+    if not cfg.urdf_paths:
+        raise ValueError("urdf_paths must be provided.")
+
+    if len(cfg.output_dirs) == 0:
+        cfg.output_dirs = [
+            os.path.join(os.path.dirname(path), "affordance")
+            for path in cfg.urdf_paths
+        ]
+
+    if len(cfg.urdf_paths) != len(cfg.output_dirs):
+        raise ValueError(
+            "urdf_paths and output_dirs must have the same length, "
+            f"got {len(cfg.urdf_paths)} and {len(cfg.output_dirs)}."
+        )
+
+
+def _set_single_config(
+    cfg: EvalGraspsConfig,
+    urdf_path: str,
+    output_dir: str,
+) -> EvalGraspsConfig:
+    return dataclasses.replace(
+        cfg,
+        urdf_paths=[urdf_path],
+        output_dirs=[output_dir],
+    )
+
+
+def _eval_grasp(
+    cfg: EvalGraspsConfig,
+    grasp_id: str,
+    grasp: dict,
+) -> dict:
+    output_dir = cfg.output_dirs[0]
+
+    mesh_info = load_mesh_info(cfg.urdf_paths[0])
+    gripper_control = GripperControlInfo(
+        **URDFFile(cfg.gripper_urdf_path).get_prismatic_joint_control_info()
+    )
+    evaluator = EvalGrasps(cfg, mesh_info, gripper_control, grasp)
+    result = evaluator.run()
+    evaluator.export_video(
+        os.path.join(output_dir, "eval_grasp_renders", grasp_id)
+    )
+    if threading.current_thread() is not threading.main_thread():
+        with _EVALUATOR_KEEPALIVE_LOCK:
+            _EVALUATOR_KEEPALIVE.append(evaluator)
+    return {
+        "grasp_id": grasp_id,
+        "output_dir": output_dir,
+        "simulation_result": result,
+    }
+
+
+def _release_thread_evaluators() -> None:
+    with _EVALUATOR_KEEPALIVE_LOCK:
+        evaluators = list(_EVALUATOR_KEEPALIVE)
+        _EVALUATOR_KEEPALIVE.clear()
+    for evaluator in evaluators:
+        del evaluator
+
+
+def _eval_grasp_task(task: tuple[EvalGraspsConfig, str, dict]) -> dict:
+    cfg, grasp_id, grasp = task
+    return _eval_grasp(cfg, grasp_id, grasp)
+
+
+def _slip_thresholds(cfg: EvalGraspsConfig) -> dict[str, float]:
+    return {
+        "translation_m": cfg.slip_translation_threshold,
+        "rotation_deg": cfg.slip_rotation_threshold_deg,
+    }
+
+
+def _is_successful_grasp_result(result: dict) -> bool:
+    simulation_result = result.get("simulation_result", {})
+    if not isinstance(simulation_result, dict):
+        return False
+    return bool(simulation_result.get("success", False))
+
+
+def _grasp_success_by_id(results: list[dict]) -> dict[str, bool]:
+    return {
+        result["grasp_id"]: _is_successful_grasp_result(result)
+        for result in results
+    }
+
+
+def _build_eval_summary(
+    cfg: EvalGraspsConfig,
+    results: list[dict],
+    elapsed_seconds: float,
+) -> dict:
+    successful_grasp_ids = [
+        result["grasp_id"]
+        for result in results
+        if _is_successful_grasp_result(result)
+    ]
+    failed_grasp_ids = [
+        result["grasp_id"]
+        for result in results
+        if not _is_successful_grasp_result(result)
+    ]
+    num_grasps = len(results)
+    num_success = len(successful_grasp_ids)
+    return {
+        "num_grasps": num_grasps,
+        "num_success": num_success,
+        "num_failure": len(failed_grasp_ids),
+        "success_rate": num_success / max(1, num_grasps),
+        "successful_grasp_ids": successful_grasp_ids,
+        "failed_grasp_ids": failed_grasp_ids,
+        "slip_thresholds": _slip_thresholds(cfg),
+        "elapsed_seconds": elapsed_seconds,
+    }
+
+
+def _run_single_eval(cfg: EvalGraspsConfig) -> None:
+    start_time = time.perf_counter()
+    output_dir = cfg.output_dirs[0]
+    os.makedirs(output_dir, exist_ok=True)
+    urdf_path = cfg.urdf_paths[0]
+    urdf = URDFFile(urdf_path)
+
+    affordance_path = urdf.get_affordance_annot_path()
+    affordance_payload = load_json(affordance_path)
+    affordances = affordance_payload.get("affordances", [])
+    grasps = {}
+    for affordance in affordances:
+        grasps.update(affordance.get("grasp_group", {}))
+
+    if not grasps:
+        return
+
+    num_workers = cfg.num_workers
+    if num_workers is None:
+        num_workers = min(len(grasps), os.cpu_count() or 1, MAX_NUM_WORKERS)
+    else:
+        num_workers = min(num_workers, len(grasps), MAX_NUM_WORKERS)
+
+    logger.info(
+        f"Running {len(grasps)} grasp poses with {num_workers} worker(s)"
+    )
+    results = []
+    if num_workers == 1:
+        for grasp_id, grasp in tqdm(grasps.items(), desc="Evaluating grasps"):
+            results.append(_eval_grasp(cfg, grasp_id, grasp))
+    else:
+        worker_cfg = dataclasses.replace(cfg, num_workers=1)
+        tasks = [
+            (worker_cfg, grasp_id, grasp) for grasp_id, grasp in grasps.items()
+        ]
+        try:
+            with concurrent.futures.ThreadPoolExecutor(
+                max_workers=num_workers
+            ) as executor:
+                futures = [
+                    executor.submit(_eval_grasp_task, task) for task in tasks
+                ]
+                for future in tqdm(
+                    concurrent.futures.as_completed(futures),
+                    total=len(futures),
+                    desc="Evaluating grasps",
+                ):
+                    results.append(future.result())
+            results.sort(
+                key=lambda result: list(grasps.keys()).index(
+                    result["grasp_id"]
+                )
+            )
+        finally:
+            _release_thread_evaluators()
+
+    elapsed_seconds = time.perf_counter() - start_time
+    summary = _build_eval_summary(cfg, results, elapsed_seconds)
+    failed_grasp_ids = set(summary["failed_grasp_ids"])
+    grasp_success_by_id = _grasp_success_by_id(results)
+    for affordance in affordance_payload.get("affordances", []):
+        grasp_group = affordance.get("grasp_group")
+        if isinstance(grasp_group, dict):
+            if cfg.debug_mode or cfg.save_failed_grasps:
+                for grasp_id, grasp in grasp_group.items():
+                    if (
+                        isinstance(grasp, dict)
+                        and grasp_id in grasp_success_by_id
+                    ):
+                        grasp["simulation_success"] = grasp_success_by_id[
+                            grasp_id
+                        ]
+                continue
+            for failed_grasp_id in failed_grasp_ids:
+                grasp_group.pop(failed_grasp_id, None)
+
+    write_json(affordance_payload, affordance_path)
+
+    logger.info(f"Grasp evaluation simulation took {elapsed_seconds:.2f}s")
+    logger.info(f"Updated grasp simulation results in {affordance_path}")
+    logger.info(
+        f"Grasp success rate: {summary['num_success']}/"
+        f"{summary['num_grasps']} ({summary['success_rate']:.2%})"
+    )
+
+
+def _run_single_eval_safe(cfg: EvalGraspsConfig) -> bool:
+    urdf_path = cfg.urdf_paths[0]
+    try:
+        _run_single_eval(cfg)
+    except Exception as exc:
+        logger.error(
+            "Grasp evaluation failed for URDF {}: {}".format(
+                urdf_path,
+                exc,
+            )
+        )
+        return False
+    return True
+
+
+def run_eval(cfg: EvalGraspsConfig) -> None:
+    _validate_config(cfg)
+    for idx, (urdf_path, output_dir) in enumerate(
+        zip(cfg.urdf_paths, cfg.output_dirs),
+        start=1,
+    ):
+        single_cfg = _set_single_config(cfg, urdf_path, output_dir)
+        logger.info(
+            f"Running grasp evaluation for URDF {idx}/{len(cfg.urdf_paths)}: "
+            f"{urdf_path}"
+        )
+        _run_single_eval_safe(single_cfg)
+
+
+def entrypoint(*args, **kwargs) -> None:
+    cfg = tyro.cli(EvalGraspsConfig)
+    run_eval(cfg)
+
+
+if __name__ == "__main__":
+    entrypoint()

embodied_gen/scripts/affordance_annot/franka_panda/coll_mesh.obj

@@ -0,0 +1,464 @@
+# https://github.com/mikedh/trimesh
+v -0.09012898 0.01673458 0.06443186 0.00000000 1.00000000 0.00000000
+v 0.08927116 0.01713458 0.06361439 0.00000000 1.00000000 0.00000000
+v 0.00055840 0.03158979 0.00621423 0.00000000 1.00000000 0.00000000
+v 0.09552484 -0.01705332 0.02212120 0.00000000 1.00000000 0.00000000
+v 0.09790768 -0.01751002 0.05166616 0.00000000 1.00000000 0.00000000
+v 0.00198662 -0.03159750 0.00115293 0.00000000 1.00000000 0.00000000
+v -0.07576962 -0.02598126 -0.00508223 0.00000000 1.00000000 0.00000000
+v 0.00057885 -0.03163592 0.00597307 0.00000000 1.00000000 0.00000000
+v 0.09680219 0.01703352 0.03032204 0.00000000 1.00000000 0.00000000
+v 0.00186074 0.03161579 0.00117971 0.00000000 1.00000000 0.00000000
+v 0.09740699 0.01758546 0.05198465 0.00000000 1.00000000 0.00000000
+v -0.09460201 0.01855551 0.05661729 0.00000000 1.00000000 0.00000000
+v 0.09190618 -0.01680383 0.00629548 0.00000000 1.00000000 0.00000000
+v 0.08753296 -0.01681192 -0.00120645 0.00000000 1.00000000 0.00000000
+v 0.09953746 0.01623047 0.05158409 0.00000000 1.00000000 0.00000000
+v 0.10398972 -0.00004070 0.00569088 0.00000000 1.00000000 0.00000000
+v 0.10374270 -0.00001689 -0.00919930 0.00000000 1.00000000 0.00000000
+v 0.10115783 -0.00361640 -0.01261032 0.00000000 1.00000000 0.00000000
+v 0.10259786 -0.00342918 -0.00896430 0.00000000 1.00000000 0.00000000
+v -0.08206502 -0.02527066 0.00519704 0.00000000 1.00000000 0.00000000
+v -0.04178420 -0.02801102 -0.00639640 0.00000000 1.00000000 0.00000000
+v -0.09280849 -0.00011291 0.06596215 0.00000000 1.00000000 0.00000000
+v -0.09371245 -0.01256706 0.06516847 0.00000000 1.00000000 0.00000000
+v -0.09127641 -0.01442229 0.06568974 0.00000000 1.00000000 0.00000000
+v 0.09070038 -0.01725433 0.06308201 0.00000000 1.00000000 0.00000000
+v 0.09070638 -0.01547137 0.06519010 0.00000000 1.00000000 0.00000000
+v -0.09025214 -0.01676757 0.06433220 0.00000000 1.00000000 0.00000000
+v 0.09160285 0.01695586 0.00556283 0.00000000 1.00000000 0.00000000
+v 0.09384751 0.01760751 0.05844849 0.00000000 1.00000000 0.00000000
+v 0.10018747 0.01250605 0.05689415 0.00000000 1.00000000 0.00000000
+v -0.10019985 0.01555056 0.05467260 0.00000000 1.00000000 0.00000000
+v -0.09849364 0.01926846 0.04494174 0.00000000 1.00000000 0.00000000
+v -0.10028528 0.01621802 0.04586977 0.00000000 1.00000000 0.00000000
+v 0.04551993 0.00191760 -0.02565943 0.00000000 1.00000000 0.00000000
+v -0.04204245 0.02801493 -0.00634960 0.00000000 1.00000000 0.00000000
+v 0.08296617 0.00381064 -0.02444934 0.00000000 1.00000000 0.00000000
+v -0.09369192 0.02067053 0.04330829 0.00000000 1.00000000 0.00000000
+v -0.08118060 0.02544764 0.00350060 0.00000000 1.00000000 0.00000000
+v 0.08358592 -0.00363651 -0.02460626 0.00000000 1.00000000 0.00000000
+v 0.08223634 -0.01653239 -0.00511811 0.00000000 1.00000000 0.00000000
+v 0.10009117 -0.01401675 0.05602695 0.00000000 1.00000000 0.00000000
+v 0.09962869 -0.01601276 0.04930143 0.00000000 1.00000000 0.00000000
+v 0.08776600 -0.00321477 -0.02388439 0.00000000 1.00000000 0.00000000
+v 0.09249580 -0.01298759 0.06571195 0.00000000 1.00000000 0.00000000
+v 0.09294532 -0.00050530 0.06595311 0.00000000 1.00000000 0.00000000
+v -0.09267219 0.01353924 0.06568788 0.00000000 1.00000000 0.00000000
+v 0.09192696 0.01342515 0.06573131 0.00000000 1.00000000 0.00000000
+v -0.09726050 -0.01922958 0.05058843 0.00000000 1.00000000 0.00000000
+v 0.08513211 0.01655853 -0.00387274 0.00000000 1.00000000 0.00000000
+v 0.10271563 0.00349515 -0.00802934 0.00000000 1.00000000 0.00000000
+v -0.09040149 0.02386882 0.00436824 0.00000000 1.00000000 0.00000000
+v -0.09373564 0.02270746 0.01434002 0.00000000 1.00000000 0.00000000
+v -0.07529767 0.02603403 -0.00503085 0.00000000 1.00000000 0.00000000
+v -0.07437764 0.02481648 -0.00715570 0.00000000 1.00000000 0.00000000
+v 0.04586986 -0.00149998 -0.02592480 0.00000000 1.00000000 0.00000000
+v -0.08025997 -0.00083407 -0.00732172 0.00000000 1.00000000 0.00000000
+v -0.07790146 0.02295881 -0.00739904 0.00000000 1.00000000 0.00000000
+v -0.08017428 -0.02276142 -0.00690954 0.00000000 1.00000000 0.00000000
+v 0.09945143 0.00003218 -0.01716121 0.00000000 1.00000000 0.00000000
+v 0.09855405 -0.01663178 0.05473394 0.00000000 1.00000000 0.00000000
+v 0.10119467 0.00360250 -0.01262764 0.00000000 1.00000000 0.00000000
+v -0.09747105 -0.00161709 0.06230734 0.00000000 1.00000000 0.00000000
+v 0.09177952 0.01571872 0.06491254 0.00000000 1.00000000 0.00000000
+v -0.09201546 -0.01844902 0.05839317 0.00000000 1.00000000 0.00000000
+v 0.08797474 -0.00062667 -0.02496160 0.00000000 1.00000000 0.00000000
+v 0.08797288 0.00307632 -0.02397873 0.00000000 1.00000000 0.00000000
+v -0.09701113 0.01980169 0.02091398 0.00000000 1.00000000 0.00000000
+v -0.10003477 0.00994118 0.05834080 0.00000000 1.00000000 0.00000000
+v -0.09906728 0.01712909 0.05430516 0.00000000 1.00000000 0.00000000
+v -0.09461535 -0.00031448 0.00757466 0.00000000 1.00000000 0.00000000
+v -0.09849606 -0.00001631 0.02708179 0.00000000 1.00000000 0.00000000
+v -0.08656162 -0.00033764 -0.00416328 0.00000000 1.00000000 0.00000000
+v -0.08825006 0.02231396 -0.00193320 0.00000000 1.00000000 0.00000000
+v -0.08335528 0.02237667 -0.00552611 0.00000000 1.00000000 0.00000000
+v -0.09092682 -0.02132529 0.00097980 0.00000000 1.00000000 0.00000000
+v -0.08543439 -0.02273309 -0.00412033 0.00000000 1.00000000 0.00000000
+v -0.08589226 -0.02449557 -0.00183273 0.00000000 1.00000000 0.00000000
+v 0.08400230 0.00184310 -0.02552490 0.00000000 1.00000000 0.00000000
+v -0.07666791 -0.02465053 -0.00693213 0.00000000 1.00000000 0.00000000
+v 0.09406284 0.01313908 0.06468318 0.00000000 1.00000000 0.00000000
+v 0.09998268 -0.00932350 0.05848920 0.00000000 1.00000000 0.00000000
+v -0.09769707 -0.01906715 0.02462748 0.00000000 1.00000000 0.00000000
+v -0.10042586 -0.00449476 0.05811909 0.00000000 1.00000000 0.00000000
+v -0.10016816 -0.01462347 0.05573492 0.00000000 1.00000000 0.00000000
+v 0.09941621 0.01580527 0.05497027 0.00000000 1.00000000 0.00000000
+v -0.09433321 0.02134224 0.00894201 0.00000000 1.00000000 0.00000000
+v -0.09099504 -0.00017374 0.00057678 0.00000000 1.00000000 0.00000000
+v -0.09179476 0.02148257 0.00268413 0.00000000 1.00000000 0.00000000
+v -0.08170268 0.02451487 -0.00505142 0.00000000 1.00000000 0.00000000
+v -0.08574020 0.02472907 -0.00123169 0.00000000 1.00000000 0.00000000
+v -0.09466784 -0.02065799 0.00953798 0.00000000 1.00000000 0.00000000
+v 0.10030148 0.00119096 0.05862313 0.00000000 1.00000000 0.00000000
+v 0.09665588 0.00046996 0.06307836 0.00000000 1.00000000 0.00000000
+v -0.09290565 0.01539656 0.06455627 0.00000000 1.00000000 0.00000000
+v 0.08254847 -0.00086753 -0.02587020 0.00000000 1.00000000 0.00000000
+v -0.09116623 -0.02355612 0.00460792 0.00000000 1.00000000 0.00000000
+v 0.09344175 -0.01461668 0.06450005 0.00000000 1.00000000 0.00000000
+v -0.09289678 -0.02302643 0.00987686 0.00000000 1.00000000 0.00000000
+v -0.09544163 -0.02182249 0.02175636 0.00000000 1.00000000 0.00000000
+v -0.09951787 -0.01819300 0.04381417 0.00000000 1.00000000 0.00000000
+v -0.09320920 -0.01604587 0.06361687 0.00000000 1.00000000 0.00000000
+v -0.09936280 -0.01699521 0.05411479 0.00000000 1.00000000 0.00000000
+v 0.06600004 -0.01099976 0.05940000 0.00000000 1.00000000 0.00000000
+v 0.06600004 -0.01099976 0.07940000 0.00000000 1.00000000 0.00000000
+v 0.05100004 -0.01099981 0.05940000 0.00000000 1.00000000 0.00000000
+v 0.05100004 -0.01099981 0.07940000 0.00000000 1.00000000 0.00000000
+v 0.06599996 0.01100024 0.05940000 0.00000000 1.00000000 0.00000000
+v 0.06599996 0.01100024 0.07940000 0.00000000 1.00000000 0.00000000
+v 0.05099996 0.01100019 0.05940000 0.00000000 1.00000000 0.00000000
+v 0.05099996 0.01100019 0.07940000 0.00000000 1.00000000 0.00000000
+v 0.05120004 -0.01099981 0.05870000 0.00000000 1.00000000 0.00000000
+v 0.05120004 -0.01099981 0.06250000 0.00000000 1.00000000 0.00000000
+v 0.04240004 -0.01099984 0.05870000 0.00000000 1.00000000 0.00000000
+v 0.04240004 -0.01099984 0.06250000 0.00000000 1.00000000 0.00000000
+v 0.05119996 0.01100019 0.05870000 0.00000000 1.00000000 0.00000000
+v 0.05119996 0.01100019 0.06250000 0.00000000 1.00000000 0.00000000
+v 0.04239996 0.01100016 0.05870000 0.00000000 1.00000000 0.00000000
+v 0.04239996 0.01100016 0.06250000 0.00000000 1.00000000 0.00000000
+v 0.06480612 -0.00874976 0.07832420 0.00000000 1.00000000 0.00000000
+v 0.05305612 -0.00874981 0.09867580 0.00000000 1.00000000 0.00000000
+v 0.05874394 -0.00874978 0.07482420 0.00000000 1.00000000 0.00000000
+v 0.04699394 -0.00874983 0.09517580 0.00000000 1.00000000 0.00000000
+v 0.06480606 0.00875024 0.07832420 0.00000000 1.00000000 0.00000000
+v 0.05305606 0.00875019 0.09867580 0.00000000 1.00000000 0.00000000
+v 0.05874388 0.00875022 0.07482420 0.00000000 1.00000000 0.00000000
+v 0.04699388 0.00875017 0.09517580 0.00000000 1.00000000 0.00000000
+v 0.05518003 -0.00874980 0.09440000 0.00000000 1.00000000 0.00000000
+v 0.05518003 -0.00874980 0.11290000 0.00000000 1.00000000 0.00000000
+v 0.03998003 -0.00874985 0.09440000 0.00000000 1.00000000 0.00000000
+v 0.03998003 -0.00874985 0.11290000 0.00000000 1.00000000 0.00000000
+v 0.05517997 0.00875020 0.09440000 0.00000000 1.00000000 0.00000000
+v 0.05517997 0.00875020 0.11290000 0.00000000 1.00000000 0.00000000
+v 0.03997997 0.00875015 0.09440000 0.00000000 1.00000000 0.00000000
+v 0.03997997 0.00875015 0.11290000 0.00000000 1.00000000 0.00000000
+v -0.05099996 -0.01100019 0.05940000 0.00000000 1.00000000 0.00000000
+v -0.05099996 -0.01100019 0.07940000 0.00000000 1.00000000 0.00000000
+v -0.06599996 -0.01100024 0.05940000 0.00000000 1.00000000 0.00000000
+v -0.06599996 -0.01100024 0.07940000 0.00000000 1.00000000 0.00000000
+v -0.05100004 0.01099981 0.05940000 0.00000000 1.00000000 0.00000000
+v -0.05100004 0.01099981 0.07940000 0.00000000 1.00000000 0.00000000
+v -0.06600004 0.01099976 0.05940000 0.00000000 1.00000000 0.00000000
+v -0.06600004 0.01099976 0.07940000 0.00000000 1.00000000 0.00000000
+v -0.04239996 -0.01100016 0.05870000 0.00000000 1.00000000 0.00000000
+v -0.04239996 -0.01100016 0.06250000 0.00000000 1.00000000 0.00000000
+v -0.05119996 -0.01100019 0.05870000 0.00000000 1.00000000 0.00000000
+v -0.05119996 -0.01100019 0.06250000 0.00000000 1.00000000 0.00000000
+v -0.04240004 0.01099984 0.05870000 0.00000000 1.00000000 0.00000000
+v -0.04240004 0.01099984 0.06250000 0.00000000 1.00000000 0.00000000
+v -0.05120004 0.01099981 0.05870000 0.00000000 1.00000000 0.00000000
+v -0.05120004 0.01099981 0.06250000 0.00000000 1.00000000 0.00000000
+v -0.05874388 -0.00875022 0.07482420 0.00000000 1.00000000 0.00000000
+v -0.04699388 -0.00875017 0.09517580 0.00000000 1.00000000 0.00000000
+v -0.06480606 -0.00875024 0.07832420 0.00000000 1.00000000 0.00000000
+v -0.05305606 -0.00875019 0.09867580 0.00000000 1.00000000 0.00000000
+v -0.05874394 0.00874978 0.07482420 0.00000000 1.00000000 0.00000000
+v -0.04699394 0.00874983 0.09517580 0.00000000 1.00000000 0.00000000
+v -0.06480612 0.00874976 0.07832420 0.00000000 1.00000000 0.00000000
+v -0.05305612 0.00874981 0.09867580 0.00000000 1.00000000 0.00000000
+v -0.03997997 -0.00875015 0.09440000 0.00000000 1.00000000 0.00000000
+v -0.03997997 -0.00875015 0.11290000 0.00000000 1.00000000 0.00000000
+v -0.05517997 -0.00875020 0.09440000 0.00000000 1.00000000 0.00000000
+v -0.05517997 -0.00875020 0.11290000 0.00000000 1.00000000 0.00000000
+v -0.03998003 0.00874985 0.09440000 0.00000000 1.00000000 0.00000000
+v -0.03998003 0.00874985 0.11290000 0.00000000 1.00000000 0.00000000
+v -0.05518003 0.00874980 0.09440000 0.00000000 1.00000000 0.00000000
+v -0.05518003 0.00874980 0.11290000 0.00000000 1.00000000 0.00000000
+f 1 2 3
+f 4 5 6
+f 7 6 8
+f 9 10 11
+f 10 3 11
+f 12 1 3
+f 13 6 14
+f 8 6 5
+f 4 6 13
+f 15 16 17
+f 18 19 13
+f 20 7 8
+f 21 6 7
+f 22 23 24
+f 25 26 27
+f 28 10 9
+f 2 29 3
+f 29 11 3
+f 30 16 15
+f 31 32 33
+f 34 35 36
+f 37 3 38
+f 6 39 40
+f 25 8 5
+f 41 42 16
+f 18 14 43
+f 22 24 44
+f 44 45 22
+f 46 22 45
+f 45 47 46
+f 20 8 48
+f 9 11 15
+f 36 10 49
+f 50 28 9
+f 10 36 35
+f 12 37 32
+f 37 12 3
+f 37 38 51
+f 37 52 32
+f 52 37 51
+f 10 35 53
+f 10 53 38
+f 10 38 3
+f 54 35 34
+f 55 56 57
+f 56 55 58
+f 57 54 34
+f 39 6 21
+f 59 18 43
+f 40 39 43
+f 14 40 43
+f 14 6 40
+f 60 25 5
+f 59 61 17
+f 42 60 5
+f 16 42 17
+f 62 22 46
+f 22 62 23
+f 1 46 63
+f 47 63 46
+f 25 64 8
+f 64 25 27
+f 64 48 8
+f 65 59 43
+f 66 36 49
+f 63 2 1
+f 33 32 67
+f 68 62 46
+f 32 69 12
+f 70 71 67
+f 53 35 54
+f 72 73 74
+f 75 76 77
+f 78 55 34
+f 55 79 58
+f 4 42 5
+f 50 15 17
+f 59 17 18
+f 7 20 77
+f 24 26 44
+f 27 26 24
+f 45 80 47
+f 41 16 81
+f 82 71 70
+f 62 83 23
+f 33 84 83
+f 49 28 61
+f 61 28 50
+f 61 50 17
+f 63 85 29
+f 85 30 15
+f 80 85 63
+f 85 80 30
+f 9 15 50
+f 85 15 11
+f 11 29 85
+f 83 62 68
+f 34 36 78
+f 70 67 86
+f 71 33 67
+f 58 76 72
+f 73 87 88
+f 72 74 56
+f 56 74 57
+f 34 55 57
+f 21 79 55
+f 21 7 79
+f 89 73 90
+f 39 21 55
+f 91 82 70
+f 84 23 83
+f 28 49 10
+f 92 80 93
+f 31 33 68
+f 68 33 83
+f 51 86 52
+f 69 32 31
+f 46 94 68
+f 94 31 68
+f 94 12 69
+f 76 75 72
+f 90 53 89
+f 86 51 88
+f 75 70 87
+f 87 70 88
+f 95 55 78
+f 39 55 95
+f 14 18 13
+f 42 41 60
+f 19 17 42
+f 19 4 13
+f 45 93 80
+f 92 93 81
+f 16 30 92
+f 92 81 16
+f 96 77 20
+f 66 59 65
+f 65 78 66
+f 59 66 61
+f 49 61 66
+f 2 63 29
+f 80 63 47
+f 80 92 30
+f 78 36 66
+f 94 69 31
+f 94 46 1
+f 12 94 1
+f 70 86 88
+f 67 52 86
+f 52 67 32
+f 57 89 54
+f 53 90 38
+f 90 51 38
+f 75 87 72
+f 72 87 73
+f 56 58 72
+f 42 4 19
+f 19 18 17
+f 97 81 44
+f 81 93 44
+f 41 97 60
+f 26 97 44
+f 98 99 91
+f 100 33 71
+f 84 33 100
+f 96 75 77
+f 95 78 65
+f 73 89 74
+f 53 54 89
+f 73 88 51
+f 90 73 51
+f 41 81 97
+f 44 93 45
+f 25 97 26
+f 101 48 64
+f 64 27 101
+f 102 48 101
+f 96 98 91
+f 48 99 20
+f 99 98 20
+f 98 96 20
+f 96 91 75
+f 84 101 23
+f 27 24 101
+f 89 57 74
+f 77 76 79
+f 79 76 58
+f 79 7 77
+f 102 84 100
+f 91 99 82
+f 48 100 99
+f 100 48 102
+f 75 91 70
+f 84 102 101
+f 24 23 101
+f 43 95 65
+f 25 60 97
+f 82 100 71
+f 43 39 95
+f 100 82 99
+f 104 106 103
+f 107 104 103
+f 103 106 105
+f 105 107 103
+f 104 110 106
+f 108 104 107
+f 108 110 104
+f 106 110 105
+f 109 107 105
+f 105 110 109
+f 109 108 107
+f 110 108 109
+f 112 114 111
+f 115 112 111
+f 111 114 113
+f 113 115 111
+f 112 118 114
+f 116 112 115
+f 116 118 112
+f 114 118 113
+f 117 115 113
+f 113 118 117
+f 117 116 115
+f 118 116 117
+f 120 122 119
+f 123 120 119
+f 119 122 121
+f 121 123 119
+f 120 126 122
+f 124 120 123
+f 124 126 120
+f 122 126 121
+f 125 123 121
+f 121 126 125
+f 125 124 123
+f 126 124 125
+f 128 130 127
+f 131 128 127
+f 127 130 129
+f 129 131 127
+f 128 134 130
+f 132 128 131
+f 132 134 128
+f 130 134 129
+f 133 131 129
+f 129 134 133
+f 133 132 131
+f 134 132 133
+f 136 138 135
+f 139 136 135
+f 135 138 137
+f 137 139 135
+f 136 142 138
+f 140 136 139
+f 140 142 136
+f 138 142 137
+f 141 139 137
+f 137 142 141
+f 141 140 139
+f 142 140 141
+f 144 146 143
+f 147 144 143
+f 143 146 145
+f 145 147 143
+f 144 150 146
+f 148 144 147
+f 148 150 144
+f 146 150 145
+f 149 147 145
+f 145 150 149
+f 149 148 147
+f 150 148 149
+f 152 154 151
+f 155 152 151
+f 151 154 153
+f 153 155 151
+f 152 158 154
+f 156 152 155
+f 156 158 152
+f 154 158 153
+f 157 155 153
+f 153 158 157
+f 157 156 155
+f 158 156 157
+f 160 162 159
+f 163 160 159
+f 159 162 161
+f 161 163 159
+f 160 166 162
+f 164 160 163
+f 164 166 160
+f 162 166 161
+f 165 163 161
+f 161 166 165
+f 165 164 163
+f 166 164 165
+

embodied_gen/scripts/affordance_annot/franka_panda/gripper.urdf

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- =================================================================================== -->
+<!-- |    This document was autogenerated by xacro from hand.urdf.xacro                | -->
+<!-- |    EDITING THIS FILE BY HAND IS NOT RECOMMENDED                                 | -->
+<!-- =================================================================================== -->
+<robot name="hand">
+  <link name="world"/>
+  <joint name="world_joint" type="fixed">
+    <parent link="world"/>
+    <child link="panda_hand"/>
+    <origin rpy="0 0 1.5708" xyz="0 0 0.0"/>
+  </joint>
+  <link name="panda_hand">
+    <visual>
+      <geometry>
+        <mesh filename="./meshes/visual/hand.dae"/>
+      </geometry>
+    </visual>
+    <collision>
+      <geometry>
+        <mesh filename="./meshes/collision/hand.stl"/>
+      </geometry>
+    </collision>
+  </link>
+  <!-- Define the hand_tcp frame -->
+  <link name="panda_hand_tcp"/>
+  <joint name="panda_hand_tcp_joint" type="fixed">
+    <origin rpy="0 0 0" xyz="0 0 0.1034"/>
+    <parent link="panda_hand"/>
+    <child link="panda_hand_tcp"/>
+  </joint>
+  <link name="panda_leftfinger">
+    <visual>
+      <geometry>
+        <mesh filename="./meshes/visual/finger.dae"/>
+      </geometry>
+    </visual>
+    <!-- screw mount -->
+    <collision>
+      <origin rpy="0 0 0" xyz="0 18.5e-3 11e-3"/>
+      <geometry>
+        <box size="22e-3 15e-3 20e-3"/>
+      </geometry>
+    </collision>
+    <!-- cartriage sledge -->
+    <collision>
+      <origin rpy="0 0 0" xyz="0 6.8e-3 2.2e-3"/>
+      <geometry>
+        <box size="22e-3 8.8e-3 3.8e-3"/>
+      </geometry>
+    </collision>
+    <!-- diagonal finger -->
+    <collision>
+      <origin rpy="0.523598775598 0 0" xyz="0 15.9e-3 28.35e-3"/>
+      <geometry>
+        <box size="17.5e-3 7e-3 23.5e-3"/>
+      </geometry>
+    </collision>
+    <!-- rubber tip with which to grasp -->
+    <collision>
+      <origin rpy="0 0 0" xyz="0 7.58e-3 45.25e-3"/>
+      <geometry>
+        <box size="17.5e-3 15.2e-3 18.5e-3"/>
+      </geometry>
+    </collision>
+  </link>
+  <link name="panda_rightfinger">
+    <visual>
+      <origin rpy="0 0 3.14159265359" xyz="0 0 0"/>
+      <geometry>
+        <mesh filename="./meshes/visual/finger.dae"/>
+      </geometry>
+    </visual>
+    <!-- screw mount -->
+    <collision>
+      <origin rpy="0 0 0" xyz="0 -18.5e-3 11e-3"/>
+      <geometry>
+        <box size="22e-3 15e-3 20e-3"/>
+      </geometry>
+    </collision>
+    <!-- cartriage sledge -->
+    <collision>
+      <origin rpy="0 0 0" xyz="0 -6.8e-3 2.2e-3"/>
+      <geometry>
+        <box size="22e-3 8.8e-3 3.8e-3"/>
+      </geometry>
+    </collision>
+    <!-- diagonal finger -->
+    <collision>
+      <origin rpy="-0.523598775598 0 0" xyz="0 -15.9e-3 28.35e-3"/>
+      <geometry>
+        <box size="17.5e-3 7e-3 23.5e-3"/>
+      </geometry>
+    </collision>
+    <!-- rubber tip with which to grasp -->
+    <collision>
+      <origin rpy="0 0 0" xyz="0 -7.58e-3 45.25e-3"/>
+      <geometry>
+        <box size="17.5e-3 15.2e-3 18.5e-3"/>
+      </geometry>
+    </collision>
+  </link>
+  <joint name="panda_finger_joint1" type="prismatic">
+    <parent link="panda_hand"/>
+    <child link="panda_leftfinger"/>
+    <origin rpy="0 0 0" xyz="0 0 0.0584"/>
+    <axis xyz="0 1 0"/>
+    <limit effort="1400" lower="0.0" upper="0.05268743" velocity="0.05"/>
+    <dynamics damping="0.3"/>
+  </joint>
+  <joint name="panda_finger_joint2" type="prismatic">
+    <parent link="panda_hand"/>
+    <child link="panda_rightfinger"/>
+    <origin rpy="0 0 0" xyz="0 0 0.0584"/>
+    <axis xyz="0 -1 0"/>
+    <limit effort="1400" lower="0.0" upper="0.05268743" velocity="0.05"/>
+    <mimic joint="panda_finger_joint1"/>
+    <dynamics damping="0.3"/>
+  </joint>
+</robot>

embodied_gen/scripts/affordance_annot/franka_panda/meshes/visual/finger.dae

@@ -0,0 +1,178 @@
+<?xml version="1.0" encoding="utf-8"?>
+<COLLADA xmlns="http://www.collada.org/2005/11/COLLADASchema" version="1.4.1">
+  <asset>
+    <contributor>
+      <author>Blender User</author>
+      <authoring_tool>Blender 2.79.0</authoring_tool>
+    </contributor>
+    <created>2018-02-20T15:00:35</created>
+    <modified>2018-02-20T15:00:35</modified>
+    <unit name="meter" meter="1"/>
+    <up_axis>Z_UP</up_axis>
+  </asset>
+  <library_images/>
+  <library_effects>
+    <effect id="Part__Feature_007-effect">
+      <profile_COMMON>
+        <technique sid="common">
+          <phong>
+            <emission>
+              <color sid="emission">0 0 0 1</color>
+            </emission>
+            <ambient>
+              <color sid="ambient">0 0 0 1</color>
+            </ambient>
+            <diffuse>
+              <color sid="diffuse">0.2509804 0.2509804 0.2509804 1</color>
+            </diffuse>
+            <specular>
+              <color sid="specular">0.5 0.5 0.5 1</color>
+            </specular>
+            <shininess>
+              <float sid="shininess">0</float>
+            </shininess>
+            <transparent opaque="A_ONE">
+              <color>1 1 1 1</color>
+            </transparent>
+            <transparency><float>1</float></transparency>
+            <index_of_refraction>
+              <float sid="index_of_refraction">1</float>
+            </index_of_refraction>
+          </phong>
+        </technique>
+      </profile_COMMON>
+    </effect>
+    <effect id="Part__Feature001_006-effect">
+      <profile_COMMON>
+        <technique sid="common">
+          <phong>
+            <emission>
+              <color sid="emission">0 0 0 1</color>
+            </emission>
+            <ambient>
+              <color sid="ambient">0 0 0 1</color>
+            </ambient>
+            <diffuse>
+              <color sid="diffuse">0.9019608 0.9215686 0.9294118 1</color>
+            </diffuse>
+            <specular>
+              <color sid="specular">0.5 0.5 0.5 1</color>
+            </specular>
+            <shininess>
+              <float sid="shininess">0</float>
+            </shininess>
+            <transparent opaque="A_ONE">
+              <color>1 1 1 1</color>
+            </transparent>
+            <transparency><float>1</float></transparency>
+            <index_of_refraction>
+              <float sid="index_of_refraction">1</float>
+            </index_of_refraction>
+          </phong>
+        </technique>
+      </profile_COMMON>
+    </effect>
+  </library_effects>
+  <library_materials>
+    <material id="Part__Feature_007-material" name="Part__Feature_007">
+      <instance_effect url="#Part__Feature_007-effect"/>
+    </material>
+    <material id="Part__Feature001_006-material" name="Part__Feature001_006">
+      <instance_effect url="#Part__Feature001_006-effect"/>
+    </material>
+  </library_materials>
+  <library_geometries>
+    <geometry id="Part__Feature_007-mesh" name="Part__Feature.007">
+      <mesh>
+        <source id="Part__Feature_007-mesh-positions">
+          <float_array id="Part__Feature_007-mesh-positions-array" count="399">0.002999246 0.01089721 0.04464477 3.59715e-4 0.01089966 0.04796832 0.002338767 0.010885 0.04695528 0.00234574 0.01088672 0.04317915 0.001025557 0.01089477 0.04214996 0.001999616 0.01089692 0.04408597 8.26939e-4 0.01089149 0.04701918 0.002051293 0.01086962 0.0458244 9.84775e-4 0.01088815 0.04306632 -0.001819312 0.009437561 0.04387903 -1.12074e-5 0.00943017 0.04711711 -6.97705e-4 0.0094316 0.04301643 -0.001464784 0.009429216 0.0465517 -0.00208646 0.009431064 0.04526871 -1.55725e-4 0.009388387 0.04323405 0.001297712 0.009390771 0.04378831 1.56458e-4 0.009388387 0.04676586 0.001741111 0.009388566 0.04558634 -0.002886593 0.009435176 0.04399472 -0.001784682 0.009434103 0.0424965 5.2098e-4 0.009434282 0.04803037 -0.001791715 0.009433507 0.04755115 1.48399e-5 0.009437739 0.04194247 -0.002975225 0.009436786 0.04570305 -0.008930683 0.009314417 0.03609037 0.008931338 0.009313642 0.03609037 -8.60488e-4 0.001913011 0.04356497 -0.001740396 0.009388566 0.04441362 -0.00152558 0.001912534 0.04591751 -0.001296997 0.009390771 0.0462116 -9.70155e-4 0.010885 0.04216766 0.004843115 -1.70612e-5 0.05371719 0.008756995 -2.97773e-5 0.04727178 0.008758902 -2.87572e-5 0.04272794 -0.002268254 -3.64761e-5 0.05374616 -0.008709371 -1.03085e-5 0.04993945 -0.00875771 -2.8976e-5 0.0472719 -0.002273738 -3.68374e-5 0.03624957 -0.002243995 -7.46945e-5 0.0427556 -0.008758783 -3.04484e-5 0.04272389 0.002263069 -8.37643e-5 0.04726266 0.00226897 -3.64764e-5 0.05374616 3.65234e-7 0.001558899 0.05380403 3.6521e-7 0.001488626 0.04499995 3.65614e-7 0.001561164 0.03619641 0.002270221 -3.43831e-5 0.0362488 0.002248227 -7.64219e-5 0.04275208 -0.002262294 -8.37643e-5 0.04726266 -0.005691945 1.10341e-5 0.05360394 0.00686866 0.009352147 0.05310285 -0.007860779 0.009355306 0.05219143 0.003445267 0.009386718 0.04705679 0.008785963 0.009348154 0.0505712 0.003923535 0.009389936 0.04573357 -7.30475e-4 0.009391903 0.04108011 0.003038406 0.009433627 0.04465281 7.34002e-4 0.009389936 0.04107677 0.002057075 0.009386718 0.04155498 0.004730045 0.009351372 0.05389988 -7.33049e-4 0.009390354 0.04892301 -0.00205636 0.009386718 0.04844492 0.007075071 -1.88821e-5 0.05276924 0.008674919 -6.99964e-6 0.05031853 0.007492721 0.009395003 0.0442506 0.007331073 0.001441657 0.04408031 0.004115462 0.00143361 0.04404103 9.13617e-4 0.001440465 0.0409246 0.002675354 0.001427888 0.04171341 -9.16098e-4 0.001442193 0.03767275 -0.004073202 0.001442134 0.04408985 -0.003944575 0.009400427 0.04425376 -0.002707123 0.009383678 0.04193902 -0.003045201 0.001419723 0.04195654 -0.007492482 0.00939387 0.03750175 -9.09494e-4 0.001442074 0.04092669 -0.004972159 0.009392738 0.0524379 -0.007140517 0.001431167 0.05044227 -0.007258474 0.009387791 0.05068916 -0.007491827 0.009394824 0.04574936 -0.004114806 0.001433432 0.04595905 -9.13103e-4 0.001440107 0.04907548 -0.002675294 0.001426517 0.04828691 -9.16344e-4 0.001443028 0.05232822 -0.005090415 0.001432299 0.05222845 0.007365286 0.009393692 0.05032676 0.004924833 0.001437306 0.05226349 0.00534445 0.009385824 0.0523557 9.15562e-4 0.001443564 0.05232697 7.49809e-4 0.009395062 0.05249238 9.59386e-4 0.001433491 0.04911512 0.004075884 0.001440107 0.04591345 0.003287315 0.001426517 0.04767566 0.007309973 0.001435518 0.0495814 0.006608247 0.00141263 0.05116909 -0.001967191 0.0108897 0.04407691 -0.002455234 0.0108962 0.04326856 -7.23478e-4 0.01089477 0.04287755 0.002154886 0.009418427 0.04456418 7.21602e-4 0.009433567 0.04298967 0.001448452 0.009429216 0.04656761 8.61216e-4 0.00191313 0.04643499 0.001526296 0.001912474 0.0440824 -0.007818162 -3.97311e-5 0.05191779 -0.008771955 2.75426e-5 0.03626441 -0.008893072 0.009342074 0.04989963 0.008762598 1.08415e-5 0.03626585 -0.005339801 0.009355187 0.05381947 -0.007331967 0.00144273 0.04407978 -0.007496535 0.009394824 0.04424685 -0.007332861 0.001443088 0.03767186 -7.55759e-4 0.009394407 0.03750163 0.00254625 0.009436607 0.04679846 0.002077639 0.009434342 0.04267549 0.007333219 0.001442193 0.03767275 0.007498383 0.00939387 0.03750687 9.16392e-4 0.001442492 0.03767257 0.003923356 0.009390354 0.04426658 7.54132e-4 0.009395062 0.03750258 0.003375649 0.00939083 0.04281467 -0.007332205 0.001443505 0.04591983 -0.003922641 0.009390354 0.04573339 -7.53554e-4 0.009394705 0.05249726 -0.003374874 0.00939083 0.0471853 0.007332324 0.001442849 0.04592007 7.34002e-4 0.009389936 0.04892319 0.007497489 0.009394824 0.04575371 0.002185642 0.00939083 0.0483753 -0.002153158 0.01088654 0.0454204 -0.001070141 0.01088356 0.04698097 -0.003009378 0.01089417 0.04527872 -0.00187093 0.01090669 0.04741126 -0.008804023 0.001558899 0.04499995 0.008809328 0.001564621 0.04499995</float_array>
+          <technique_common>
+            <accessor source="#Part__Feature_007-mesh-positions-array" count="133" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Part__Feature_007-mesh-normals">
+          <float_array id="Part__Feature_007-mesh-normals-array" count="786">0.9590276 0.08210206 0.2711559 0.9707201 -0.02025878 -0.2393575 0.356231 0.02584302 -0.9340405 0.2114398 0.06310987 -0.9753515 0.5969651 -0.02077841 0.8019981 0.8966066 0.08637297 -0.4343227 0.8202709 -0.05451494 -0.5693714 0.01862794 0.09478819 0.9953232 0.3569161 0.1740584 -0.917777 0.6076866 0.08563488 0.7895466 0.6939369 -0.0273537 0.7195162 0.9792594 0.07404083 0.1885975 0.9900662 0.03109622 0.1371198 -0.9979203 -0.0384593 -0.05173081 -0.9530383 0.1508886 -0.2625846 -0.2413043 0.07884323 0.9672415 -0.2028678 0.01909875 0.9790199 -0.8043072 -0.05650782 -0.5915207 -0.5880531 0.1500057 -0.7947906 -0.2937553 -0.05141419 -0.954497 -0.009515166 0.1474139 -0.9890291 -0.8421047 0.005896389 0.539282 -0.8765521 0.1154791 0.4672484 0.007623791 -0.9999444 0.00728625 0.003054559 -0.9999539 0.009112834 0.01089298 -0.9999382 0.002262771 0.008302092 -0.9999359 0.007699072 0.007297933 -0.9999547 -0.006123363 0.006982326 -0.9999549 -0.006440281 -0.0141775 -0.9998731 0.007279753 0.008410274 -0.9997746 0.01949483 -0.01479846 -0.999857 -0.008204162 -0.008424222 -0.999939 0.007150232 -0.006763219 -0.9999605 -0.005787611 -0.009926855 -0.9999107 -0.008956611 0.999624 0.005454719 0.02687352 0.9996895 -0.0124461 0.0215857 0.9999408 -0.004187285 0.01004832 0.9997202 -0.02283918 -0.006177306 0.9998357 -0.01812744 4.58244e-4 -0.9998302 -0.003178 0.01815414 -0.9997246 -0.01958203 0.01294118 -0.9997529 -0.02172666 -0.004701018 -0.9998528 -0.01705491 0.001882493 -0.9999096 -0.01316875 0.002750456 -0.5751125 -0.8180485 0.006493091 -0.5750488 -0.8180931 0.006525993 -0.5749478 -0.8181582 -0.007234573 -0.5759127 -0.8174836 -0.006735205 0.575049 -0.8180931 0.006525993 0.5751125 -0.8180485 0.006493151 0.5760833 -0.8173633 -0.006734192 0.5748195 -0.818247 -0.007387042 -0.002469599 -0.01878017 -0.9998206 -0.007602214 -0.02243256 -0.9997196 0.007440984 -0.02224701 -0.9997249 0.002750813 -0.01890742 -0.9998174 -8.40573e-7 -0.01367795 -0.9999065 -0.00798428 -0.007449865 0.9999404 -0.02916109 -0.0219537 0.9993337 -0.04118311 0.02231454 0.9989025 0.01138383 -0.02008819 0.9997335 0.0116266 -0.01935064 0.9997453 -0.03979802 0.9988015 -0.02849191 -0.03750216 0.998896 -0.02829426 0.03617066 0.9993457 1.13911e-6 0.01915013 0.9992586 0.03339964 -0.0110442 0.9997916 0.01717156 2.13537e-4 0.998414 -0.05629932 -0.01905494 0.9995746 0.02207905 0.05574911 0.9984449 -1.19817e-4 0.04555356 0.9989601 -0.00192207 4.14317e-5 0.9983577 -0.05728983 -3.92216e-4 0.9985226 -0.05433702 -0.05497872 0.9984876 -1.74394e-4 -0.04532593 0.9989706 -0.001876235 -0.03215342 0.9994451 0.008700311 0.04420334 0.9982572 0.03909951 0.01356661 0.9997569 0.01738047 -0.02931368 0.9995663 0.002813339 -8.40756e-4 0.9996371 0.02692854 0.02857166 0.9993905 0.02005881 -0.0197553 0.9981452 -0.05758422 0.04960417 0.9985613 0.02036315 -0.01980298 0.9991547 -0.03602528 0.03987985 0.9991744 0.007757186 -1.57562e-4 0.9995709 0.02929502 -0.03734642 0.9993024 9.92346e-5 0.04899358 0.9987992 2.78484e-4 0.001217305 0.9985316 -0.05415779 0.01685023 0.9989423 -0.04278373 0.01720976 0.9990151 -0.04089969 0.0420978 0.9989927 -0.01554173 1.35017e-4 0.9995306 0.0306375 -2.56052e-4 0.9999992 -0.001215219 0.001257061 0.9999992 -2.30649e-5 0.03529703 0.9992358 -0.01679521 -0.03647798 0.9984742 0.04145729 0.03809303 0.9983424 -0.04314595 -8.39925e-5 0.9984248 -0.0561068 -0.001366019 0.9999991 2.84488e-4 -0.03207468 0.9992364 0.02231508 0.03182566 0.9994928 0.00116384 -0.01953393 0.998728 0.04648566 -0.0483641 0.9986693 0.01790457 0.002701222 0.999723 0.02338445 -0.008154749 0.9992551 0.03772181 0.001346409 0.9999982 0.001443564 2.85219e-4 0.999999 -0.001440584 -4.26651e-4 0.9999998 7.07991e-4 -0.001589 0.9999756 0.006819844 -0.04870289 0.9987851 0.007510781 2.78449e-4 0.9987719 0.04954522 -0.001296997 0.9999992 1.20695e-4 -0.03349715 0.9994353 -0.002676308 0.009328544 0.999618 0.02601873 0.01659917 0.9988194 0.04565507 0.7971736 -0.003928363 0.6037375 0.8371688 -0.02469092 0.5463871 0.3907819 -0.02414345 0.9201667 0.349193 -0.01405209 0.9369456 -0.6207736 -0.02563965 0.7835705 -0.542501 0.001066267 0.8400545 -0.9117302 -0.01616036 0.4104716 -0.9116256 -0.01609712 0.4107064 -0.9997932 0.02033382 -3.35866e-4 -0.9997844 0.02074885 -8.37824e-4 0.01214045 0.02862757 -0.9995165 -0.004507839 0.02149677 -0.9997588 0.3398677 0.02567046 -0.940123 0.4086727 0.01358455 -0.91258 0.6901827 0.03923451 -0.7225708 0.8504014 -0.002022802 -0.5261305 0.935144 0.03257489 -0.3527673 0.9997449 0.02257227 8.67363e-4 0.9997735 0.02051991 0.005660176 -2.96537e-5 0.02086174 0.9997825 -6.34519e-4 0.02136081 0.9997717 0.006855368 0.9999764 6.32379e-4 4.84183e-5 0.9999936 0.00359565 -0.002482593 0.9999966 -9.32055e-4 -0.002998709 0.9999955 8.29423e-5 1.54639e-5 0.02138823 0.9997712 -1.39133e-4 0.02151739 0.9997684 -0.9997454 0.02247363 0.002029716 -0.9997687 0.02031034 0.00707817 -0.8811984 0.03637057 -0.4713457 -0.9005144 0.02349865 -0.4341907 -0.3984712 0.02666592 -0.9167931 -0.4344211 0.01645815 -0.9005595 0.001909852 0.02104699 -0.9997767 0.003094434 0.02054262 -0.9997842 0.9997859 0.02069485 -1.41352e-4 0.9997981 0.02008581 5.95311e-4 1.38179e-4 0.9999859 0.005308985 0.005393385 0.9999855 5.00562e-5 -0.01043295 0.9999456 5.47132e-5 2.11252e-4 0.9999458 -0.01041203 0.6565264 0.03311085 -0.7535761 0.6074793 0.01187402 -0.7942469 0.9989751 0.01611906 -0.04229778 0.998706 0.01903963 -0.04715883 0.004506647 0.02152347 0.9997582 -0.01208919 0.02863895 0.9995168 -0.3397133 0.02572649 0.9401772 -0.4084981 0.01364552 0.9126572 -0.6901832 0.03932148 0.7225656 -0.8505302 -0.001964092 0.5259227 -0.9351432 0.03258693 0.3527681 -0.9997715 0.02059018 -0.005760371 -0.9997436 0.0226224 -0.001016139 0.02383154 0.02594166 -0.9993794 0.01405942 0.02096039 -0.9996815 0.003094553 0.9999918 0.002593219 0.001917719 0.9999966 0.001798987 4.78276e-4 0.9999992 -0.001183092 -0.005550026 0.9999728 -0.004876852 -0.002536773 0.9999964 -8.84468e-4 -0.9139914 0.04412901 -0.4033268 -0.5442567 0.0384522 -0.8380371 -0.7084817 -0.007274329 -0.7056916 -0.0296927 0.02016824 -0.9993556 -0.01581388 0.01243138 -0.9997978 0.9997709 0.02093356 -0.00445789 0.999498 0.02863979 0.01354718 0.9401232 0.0257008 0.3398647 0.9126565 0.01364713 0.4084995 0.7225604 0.03932052 0.6901888 0.5259218 -0.001965582 0.8505307 0.3529133 0.03255659 0.9350895 -0.002043247 0.02258056 0.9997431 -0.005658864 0.02102994 0.9997629 -0.9999532 0.00752151 -0.006095588 -0.9993792 0.02015662 -0.02889633 0.001256287 0.9999954 -0.002805233 0.001515209 0.9999939 -0.00313121 -0.004870176 0.9999728 0.005549013 -8.41709e-4 0.9999977 0.001997113 -0.007501363 0.9999103 0.01110303 0.01065987 0.9999243 -0.006161391 0.002291321 0.9999756 0.006608426 0.00793755 0.9999635 0.003200709 -0.002152085 0.9999123 -0.01307111 0.008297443 0.9999594 0.003510475 -0.005011558 0.9999145 -0.01207667 0.003060996 0.9999685 0.007328271 0.01080811 0.9998736 -0.01166355 -0.01513278 0.9998643 0.0065158 0.0114302 0.9999113 -0.006848156 0.02179026 0.9996752 -0.01321882 0.004884779 0.9999445 -0.009344935 -0.003964126 0.9999364 -0.010562 0.01132041 0.9994015 -0.03268706 -0.00926429 0.9998297 0.01596432 -0.0349425 0.9993784 -0.004681348 0.01821058 0.9998341 3.55366e-4 4.26147e-4 0.9999064 -0.01367837 0.974332 0.0273106 0.2234531 0.9557826 0.1073004 0.2737999 0.3330882 -0.09754341 -0.9378367 0.5195872 -0.01804101 0.8542271 0.6077356 0.157705 -0.7783231 0.454423 0.08751672 0.8864765 0.9130505 -0.02745264 -0.4069218 0.8992295 0.02166306 -0.4369408 -0.7316485 0.1390356 0.6673527 0.02041035 -0.07851171 -0.9967043 -0.7062311 0.09077769 0.7021376 -0.3488763 0.1379652 -0.9269579 -0.1099019 -0.03246331 0.9934122 -0.6970786 -0.07612544 -0.7129421 -0.9202278 0.2171145 -0.3256413 -0.9950422 -0.0954045 0.02808898 -0.9590265 0.08210206 -0.2711592 -0.9707195 -0.0202586 0.2393601 -0.3562378 0.02584266 0.9340379 -0.2114403 0.06310951 0.9753514 -0.5969607 -0.02077889 -0.8020014 0.2474833 0.9674915 0.05208033 -0.2217323 0.9520062 0.2109952 0.002188146 0.9818791 0.1894964 0.03618705 0.9948542 -0.094635 -0.03970462 0.9977954 -0.0531792 0.1493319 0.9880552 -0.03803724 0.05737549 0.9980043 -0.02637308 0.03952348 0.9942676 -0.09934759 0.06763625 0.9944091 0.08109295 0.05163925 0.9962646 0.06921261 -0.5420612 0.8172764 -0.1955223 -0.05316966 0.9883101 -0.1428857 -0.04296433 0.9990067 0.01181876 -0.03037488 0.9966946 0.07534843 2.75087e-4 1 -2.00694e-4 -2.71444e-4 1 1.27208e-4 -0.006520807 -0.8174653 0.5759411 -0.008352398 -0.819939 0.5723901 -0.007724702 -0.8196955 -0.5727477 -0.006526708 -0.8180925 -0.5750496 0.007609963 -0.8185901 -0.5743277 0.007052063 -0.8178415 -0.5754005 0.007047355 -0.8173345 0.5761204 0.008122503 -0.8187863 0.574041</float_array>
+          <technique_common>
+            <accessor source="#Part__Feature_007-mesh-normals-array" count="262" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="Part__Feature_007-mesh-vertices">
+          <input semantic="POSITION" source="#Part__Feature_007-mesh-positions"/>
+        </vertices>
+        <triangles material="Part__Feature_007-material" count="262">
+          <input semantic="VERTEX" source="#Part__Feature_007-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#Part__Feature_007-mesh-normals" offset="1"/>
+          <p>26 0 27 0 28 0 27 1 29 1 28 1 29 2 16 2 28 2 28 3 16 3 100 3 14 4 27 4 26 4 13 5 127 5 12 5 127 6 128 6 12 6 98 7 96 7 11 7 12 8 128 8 10 8 11 9 96 9 9 9 96 10 94 10 9 10 9 11 94 11 13 11 94 12 127 12 13 12 18 13 23 13 129 13 18 14 129 14 95 14 21 15 1 15 130 15 21 16 20 16 1 16 19 17 18 17 95 17 19 18 95 18 30 18 22 19 19 19 30 19 22 20 30 20 4 20 23 21 21 21 130 21 23 22 130 22 129 22 40 23 31 23 41 23 40 24 61 24 31 24 62 25 61 25 40 25 32 26 62 26 40 26 105 27 33 27 46 27 105 28 46 28 45 28 47 29 34 29 48 29 47 30 48 30 102 30 47 31 102 31 35 31 47 32 35 32 36 32 37 33 38 33 39 33 37 34 39 34 103 34 132 35 62 35 32 35 132 36 52 36 62 36 25 37 52 37 132 37 33 38 25 38 132 38 105 39 25 39 33 39 131 40 36 40 35 40 104 41 131 41 35 41 24 42 39 42 131 42 24 43 103 43 39 43 24 44 131 44 104 44 40 45 41 45 42 45 43 46 40 46 42 46 44 47 45 47 46 47 44 48 46 48 43 48 47 49 43 49 42 49 47 50 42 50 34 50 44 51 43 51 38 51 37 52 44 52 38 52 24 53 37 53 103 53 44 54 37 54 24 54 25 55 45 55 44 55 25 56 105 56 45 56 25 57 44 57 24 57 42 58 58 58 106 58 42 59 106 59 48 59 42 60 48 60 34 60 31 61 42 61 41 61 31 62 58 62 42 62 18 63 71 63 70 63 18 64 19 64 71 64 52 65 63 65 125 65 126 66 111 66 20 66 106 67 77 67 50 67 114 68 25 68 117 68 106 69 75 69 77 69 63 70 25 70 114 70 52 71 25 71 63 71 25 72 24 72 117 72 117 73 24 73 110 73 73 74 24 74 108 74 108 75 24 75 104 75 50 76 77 76 104 76 126 77 51 77 111 77 49 78 84 78 86 78 77 79 78 79 104 79 106 80 121 80 75 80 49 81 52 81 84 81 22 82 71 82 19 82 51 83 53 83 111 83 22 84 54 84 71 84 111 85 53 85 55 85 106 86 88 86 121 86 78 87 108 87 104 87 53 88 116 88 55 88 22 89 56 89 54 89 112 90 57 90 22 90 22 91 57 91 56 91 116 92 118 92 55 92 106 93 58 93 88 93 88 94 59 94 121 94 78 95 120 95 108 95 55 96 118 96 112 96 60 97 21 97 122 97 112 98 118 98 57 98 73 99 110 99 24 99 53 100 125 100 116 100 21 101 23 101 122 101 52 102 125 102 84 102 59 103 21 103 60 103 122 104 23 104 120 104 58 105 86 105 88 105 59 106 20 106 21 106 56 107 117 107 54 107 88 108 124 108 59 108 54 109 117 109 110 109 120 110 70 110 108 110 120 111 23 111 70 111 124 112 20 112 59 112 125 113 63 113 116 113 23 114 18 114 70 114 49 115 86 115 58 115 126 116 20 116 124 116 52 117 49 117 61 117 52 118 61 118 62 118 49 119 31 119 61 119 49 120 58 120 31 120 50 121 102 121 48 121 106 122 50 122 48 122 104 123 35 123 102 123 50 124 104 124 102 124 63 125 113 125 64 125 114 126 113 126 63 126 116 127 64 127 65 127 63 128 64 128 116 128 66 129 56 129 57 129 67 130 66 130 57 130 67 131 57 131 118 131 65 132 67 132 118 132 65 133 118 133 116 133 115 134 56 134 66 134 115 135 117 135 56 135 113 136 114 136 115 136 115 137 114 137 117 137 67 138 115 138 66 138 113 139 115 139 67 139 64 140 67 140 65 140 64 141 113 141 67 141 109 142 110 142 73 142 68 143 110 143 109 143 54 144 68 144 74 144 110 145 68 145 54 145 72 146 70 146 71 146 72 147 69 147 70 147 74 148 71 148 54 148 74 149 72 149 71 149 70 150 107 150 108 150 70 151 69 151 107 151 109 152 108 152 107 152 109 153 73 153 108 153 72 154 68 154 109 154 72 155 109 155 107 155 74 156 68 156 72 156 69 157 72 157 107 157 76 158 77 158 83 158 77 159 75 159 83 159 119 160 77 160 76 160 119 161 78 161 77 161 119 162 120 162 78 162 79 163 120 163 119 163 80 164 59 164 60 164 81 165 80 165 60 165 81 166 60 166 122 166 79 167 81 167 122 167 79 168 122 168 120 168 59 169 82 169 121 169 59 170 80 170 82 170 75 171 82 171 83 171 121 172 82 172 75 172 79 173 119 173 76 173 81 174 79 174 76 174 83 175 81 175 76 175 83 176 80 176 81 176 82 177 80 177 83 177 93 178 84 178 92 178 85 179 86 179 93 179 86 180 84 180 93 180 86 181 87 181 88 181 86 182 85 182 87 182 87 183 124 183 88 183 89 184 124 184 87 184 90 185 53 185 51 185 91 186 90 186 51 186 91 187 51 187 126 187 89 188 91 188 126 188 89 189 126 189 124 189 123 190 53 190 90 190 123 191 125 191 53 191 84 192 123 192 92 192 125 193 123 193 84 193 85 194 91 194 89 194 85 195 89 195 87 195 92 196 90 196 91 196 92 197 123 197 90 197 93 198 92 198 91 198 93 199 91 199 85 199 96 200 95 200 94 200 94 201 95 201 129 201 96 202 30 202 95 202 127 203 94 203 129 203 96 204 4 204 30 204 8 205 4 205 96 205 127 206 129 206 130 206 5 207 4 207 8 207 3 208 4 208 5 208 128 209 127 209 130 209 0 210 3 210 5 210 1 211 6 211 128 211 1 212 128 212 130 212 0 213 5 213 7 213 2 214 0 214 7 214 1 215 7 215 6 215 2 216 7 216 1 216 111 217 55 217 0 217 111 218 0 218 2 218 112 219 22 219 4 219 20 220 111 220 2 220 112 221 4 221 3 221 20 222 2 222 1 222 112 223 3 223 0 223 55 224 112 224 0 224 97 225 5 225 98 225 128 226 6 226 10 226 5 227 8 227 98 227 10 228 6 228 99 228 8 229 96 229 98 229 6 230 7 230 99 230 99 231 7 231 97 231 7 232 5 232 97 232 100 233 17 233 101 233 17 234 15 234 101 234 15 235 14 235 101 235 101 236 14 236 26 236 16 237 17 237 100 237 27 238 9 238 13 238 15 239 97 239 98 239 14 240 98 240 11 240 10 241 29 241 12 241 99 242 17 242 16 242 29 243 27 243 12 243 12 244 27 244 13 244 10 245 16 245 29 245 27 246 11 246 9 246 27 247 14 247 11 247 99 248 97 248 17 248 10 249 99 249 16 249 17 250 97 250 15 250 15 251 98 251 14 251 100 252 101 252 26 252 100 253 26 253 28 253 38 254 43 254 131 254 38 255 131 255 39 255 47 256 36 256 131 256 43 257 47 257 131 257 132 258 32 258 40 258 132 259 40 259 43 259 132 260 43 260 46 260 33 261 132 261 46 261</p>
+        </triangles>
+      </mesh>
+    </geometry>
+    <geometry id="Part__Feature001_006-mesh" name="Part__Feature001.006">
+      <mesh>
+        <source id="Part__Feature001_006-mesh-positions">
+          <float_array id="Part__Feature001_006-mesh-positions-array" count="555">-9.00074e-4 0.009423434 0.04836726 -0.003461062 0.009425997 0.04545509 0.003367424 0.009420156 0.04579621 0.002354204 0.009420096 0.04753577 0.001209616 0.009421825 0.04820466 -0.002568781 0.009414196 0.04729557 -0.01040536 0.01838725 0.003964126 0.01030278 0.01967525 0.003999948 -0.01030677 0.0197041 0.003999948 -0.01032835 0.01741087 0.006311535 0.01033771 0.01741051 0.006348371 -0.01034963 0.002563178 0.001799941 -0.01046431 0.008072018 0.00174117 -0.01036626 0.002524316 1.33332e-4 -0.01033806 0.008028566 0.003838419 -0.01049768 0.01066809 0.003808438 -0.01037496 0.01157689 0.01777273 -0.01037907 0.01279222 0.01885205 -0.01040232 0.01741403 0.004769504 -0.01033318 0.01621478 0.01882749 -0.0105009 0.01703566 0.01771438 -0.01046431 0.02075433 0.00174117 -0.01025623 0.02079778 0.003920257 -0.01039052 0.02630412 1.63633e-4 -0.01034963 0.02626317 0.001799941 -0.005033195 0.005965054 0.003874957 0.006783962 0.007870256 0.003922104 0.01033878 0.008028566 0.003838419 -0.006688237 0.007825791 0.003912925 -0.004874587 0.002588212 0.003874957 0.004875361 0.002538204 0.003824949 0.004882395 0.006314396 0.00399816 0.01035034 0.002563178 0.001799941 0.004861891 0.002482414 0.001761496 0.0103783 0.002535223 1.52542e-4 -0.004861116 0.002482414 0.001761496 0.0103892 0.02627986 1.33333e-4 0.004900753 0.02634549 0.001760601 0.01035034 0.02626317 0.0018 -0.004838049 0.0262978 0.003838419 0.004838824 0.02625167 0.003884613 -0.004913091 0.02631509 0.001778841 -0.004740357 0.02308672 0.003991544 0.004736721 0.02311271 0.003989934 0.01039779 0.0114066 0.004751801 -0.01040315 0.01144498 0.004798948 0.01038271 0.01261192 0.0187999 0.0102685 0.02076315 0.00393176 0.01045852 0.02080255 0.001745045 0.01046502 0.008072018 0.00174117 0.0104981 0.01065367 0.00379908 0.01040905 0.01161694 0.01771855 0.01049864 0.01723229 0.004730284 0.01032787 0.01605618 0.01887345 0.0104016 0.01821219 0.003997564 0.01050156 0.01703572 0.01771444 0.007072865 0.02100592 0.001899957 0.005206525 0.0225414 0.001899957 0.005030691 0.02334862 0.003700613 0.005556464 0.02213406 0.003700196 0.00697416 0.02102053 0.003698945 0.00515145 0.006138801 0.001899957 0.006992816 0.007812917 0.001899957 0.00512129 0.005962073 0.003693938 -0.00520581 0.0225414 0.001899957 -0.007104516 0.02099138 0.001899957 -0.006963312 0.02102977 0.003688812 -0.005555689 0.02213406 0.003700196 -0.005031466 0.02334022 0.003702998 -0.005051195 0.005644857 0.001899957 -0.005777955 0.006963193 0.001899957 -0.007155239 0.007843613 0.001899957 0.0102126 0.01028144 0.004017531 -0.01020997 0.01025789 0.004015088 0.01020628 0.01744186 0.005109727 0.01019817 0.01733398 0.0177704 -0.01019358 0.01735031 0.01768088 -0.006566226 0.02081871 0.003997445 0.006602585 0.02079534 0.003997147 -0.010293 0.02316558 0.004009008 -0.01038885 0.02522027 0.01918762 0.01040047 0.02525341 0.01903659 -0.008802294 0.01565176 0.0359255 0.008803725 0.01566779 0.03590935 -0.00874871 0.01441204 0.0360046 0.008746623 0.01441162 0.0360043 -0.005330324 0.01430171 0.05381 -0.007801711 0.01423847 0.05229121 0.006546616 0.01429051 0.05324614 0.004800438 0.01433104 0.05383157 0.008537709 0.01441401 0.05053359 -0.008656799 0.01441329 0.04983228 -0.007084131 0.009504258 0.05282139 -0.008779346 0.009461343 0.05011796 -0.005467712 0.009490966 0.05374723 -0.008745193 0.009413957 0.03600448 -0.003062069 0.009426355 0.04349088 0.005491077 0.009412288 0.05355769 0.007737815 0.009533464 0.05224508 0.008802413 0.00950849 0.05020254 0.008748948 0.009413778 0.03600472 -0.009015202 0.008043587 0.03574204 0.009009778 0.008124589 0.03584498 -0.01019251 0.01739948 0.01925081 0.008962452 0.008020699 0.03557926 0.01018828 0.01739251 0.01925343 -0.01036179 0.02530467 0.006144404 0.01038175 0.02526181 0.006118535 0.01029372 0.02316558 0.004009008 -0.01047909 0.01767802 0.01932358 -0.009055435 0.015468 0.03570801 -0.009049296 0.009711623 0.03573459 -0.009055495 0.01410454 0.03572821 0.008973121 0.0141133 0.04968112 0.009049952 0.009715855 0.03573578 0.00905615 0.015468 0.03570801 0.00905627 0.01410877 0.03572702 0.01047974 0.01767796 0.01932418 -0.008394658 0.009712696 0.0514611 -0.008945405 0.01410996 0.04996031 0.008197128 0.01411491 0.05185294 0.005532205 0.009717047 0.05385756 -0.00195378 0.009417772 0.04215568 0.003167867 0.009425044 0.04377222 -2.00269e-6 0.01280522 0.04499375 1.44479e-4 0.00943315 0.04151052 0.001943349 0.009422361 0.04219353 -0.009823203 0.01750212 0.01110798 -0.008970022 0.01753544 0.00949794 -0.008382201 0.02041316 0.008978068 -0.006987035 0.02041316 0.01564162 -0.007580995 0.01771301 0.01545852 -0.007902503 0.01771277 0.008742332 -0.008936882 0.02041321 0.01448625 -0.006165742 0.01771926 0.008206784 -0.005999624 0.02041316 0.008207798 -0.009010076 0.01771265 0.01427406 -0.009712457 0.01771759 0.01274335 -0.009828627 0.02041321 0.01161444 -0.008163809 0.01741361 0.01548886 -0.002160131 0.01771426 0.01179015 -0.001917064 0.0174154 0.01287972 -0.009805202 0.01741385 0.01357632 -0.002761185 0.01771289 0.01393586 -0.003453075 0.01741337 0.01519817 -0.003756344 0.01771312 0.01503348 -0.005418896 0.01771914 0.01575213 -0.005659103 0.01741391 0.01611226 -0.002533555 0.01741403 0.009761214 -0.007441639 0.01741355 0.008155763 -0.004799664 0.01741427 0.008044362 -0.00424081 0.01770812 0.008646845 -0.002989172 0.01771265 0.009725868 -0.003062367 0.02041316 0.01448625 -0.003617048 0.02041316 0.008978068 -0.00524491 0.02041316 0.01571643 -0.002170562 0.02041321 0.01161444 0.002471983 0.01753765 0.01027405 0.003617763 0.02041316 0.008978068 0.005012929 0.02041316 0.01564162 0.004418909 0.01771301 0.01545852 0.004097461 0.01771277 0.008742332 0.003063082 0.02041316 0.01448625 0.005834221 0.01771926 0.008206784 0.006000339 0.02041316 0.008207798 0.002989888 0.01771265 0.01427406 0.002158105 0.01760274 0.01248186 0.002171337 0.02041321 0.01161444 0.002778768 0.01741474 0.01464384 0.009839832 0.01771426 0.01179015 0.009967148 0.01741391 0.01086372 0.009844422 0.01741361 0.01344197 0.009238719 0.01771289 0.01393586 0.008363068 0.01759368 0.01505017 0.006581008 0.01771914 0.01575213 0.00593394 0.01741504 0.01617604 0.006598711 0.01741325 0.00796616 0.008496105 0.01741367 0.008740007 0.004167318 0.01741486 0.008277237 0.007759153 0.01770812 0.008646845 0.009010791 0.01771265 0.009725868 0.008937597 0.02041316 0.01448625 0.008382916 0.02041316 0.008978068 0.006755053 0.02041316 0.01571643 0.009829342 0.02041321 0.01161444</float_array>
+          <technique_common>
+            <accessor source="#Part__Feature001_006-mesh-positions-array" count="185" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <source id="Part__Feature001_006-mesh-normals">
+          <float_array id="Part__Feature001_006-mesh-normals-array" count="1080">-0.6173208 -0.6997168 -0.3595991 -0.3576143 -0.707046 -0.6100803 -0.05557465 -0.6977123 -0.7142192 0.3884154 -0.7004421 -0.5987607 0.6412798 -0.6994922 -0.3153902 -3.80453e-5 -0.02722054 0.9996295 -0.001623749 -0.00173664 0.9999972 -0.001385629 0.9999968 0.002131819 -2.94082e-5 0.9996801 0.02529293 -0.9997308 -0.02070355 0.01047992 -0.996492 -0.05960285 0.05874812 -0.9995005 -0.0228253 0.0218603 -0.9997318 -0.02303814 0.002409517 -0.9999711 1.03593e-4 -0.007609546 -0.9871179 0.01438945 0.1593462 -0.9997745 0.01160097 0.01778519 -0.9955217 6.06525e-4 0.09453237 -0.9998695 0 -0.01615536 -0.9992002 0.01117813 0.03839474 -0.9936029 0.06317126 0.09361022 -0.9989078 0 -0.04672628 -0.9983385 -9.44458e-4 -0.05761367 -0.9994639 0.02053815 0.02549898 0.02691906 -0.07772469 0.9966114 -7.57925e-5 -0.03944176 0.9992219 -5.39687e-4 -0.04273873 0.9990862 -0.02465045 -0.07755041 0.9966837 -0.01240146 -5.80474e-4 0.999923 0.004887759 -0.04581922 0.9989379 -8.45258e-4 0.04984575 0.9987566 -0.0113424 -0.03047823 0.9994711 0.01459175 -0.9997453 0.017219 0 -0.999635 0.02701693 -0.004865527 -0.9987398 0.04995161 -0.01454573 -0.9996188 0.02346885 5.54909e-4 -0.9995224 -0.03089886 0 -0.9996694 -0.02571326 0.01502466 0.9998336 0.01034975 0.004553616 0.9990093 0.04427027 -0.003079414 0.9999591 0.008511543 -0.009448766 0.9996371 0.02522802 0.00111252 0.999331 -0.03655552 -0.003088533 0.9999886 0.003658115 -0.004537403 0.04749792 0.998861 8.04919e-5 0.0335403 0.9994374 9.2647e-4 -8.09439e-4 -0.9999993 -0.001456677 0.001272737 -0.9999982 0.001968502 -0.9998666 0.01621508 -0.001822233 -0.9999467 0.01016861 -0.00216782 0.007191956 0.9999718 0.002324879 -0.02130818 0.9997704 0.9947002 0.05414348 0.08740782 0.9991514 5.23699e-4 -0.04118567 0.9986065 -5.02086e-4 -0.05277365 0.9996373 -0.02062958 0.01731967 0.9995319 0.0195676 0.02351826 0.9964926 -0.05959349 0.05874836 0.9998502 -0.01730716 -4.88135e-4 0.9998542 -0.0170713 -5.9048e-4 0.9990535 -0.01702678 0.04002922 0.9873026 0.01232677 0.1583726 0.9928981 -0.01674908 0.1177833 0.9937262 0.01559793 -0.1107475 0.9998602 5.16274e-4 -0.01671421 0.9991797 0.01174086 0.03876018 0.0451585 -0.009151577 0.998938 0.01034229 0.01257103 0.9998675 -0.006676495 0.03607821 0.9993267 0.9141238 0.39574 -0.08813399 0.6350729 0.7719225 0.02860087 0.616694 0.7850795 0.05778169 0.9974451 0.06390476 0.03193026 0.9947919 0.08216506 0.06031489 0.05975353 0.9982017 -0.004800856 0.07612389 0.9967962 0.02454829 -0.006453335 -0.03733032 0.9992822 0.04496628 0.009730398 0.9989412 0.01094931 -0.01204329 0.9998676 0.6699684 -0.7369019 0.09009993 0.7559792 -0.652562 -0.05155879 0.07367104 -0.9971508 -0.0162183 0.04523348 -0.998431 0.03301161 0.9974095 -0.07126808 0.009756922 0.9968822 -0.07878315 -0.004374206 -0.04653424 -0.00969702 0.9988697 0.00358504 0.03181004 0.9994875 -0.01030498 0.01262295 0.9998673 -0.6320471 0.7742158 0.03326278 -0.6164938 0.7852315 0.05785328 -0.9135053 0.397269 -0.08766609 -0.07136505 0.9973254 -0.01578521 -0.06973493 0.9974779 -0.01322406 -0.9973001 0.06351983 0.03685021 -0.9949859 0.07914489 0.06114923 0.006362855 -0.04335838 0.9990394 0 0 1 -0.01212346 -0.0116012 0.9998593 -0.04727256 0.009681224 0.9988352 -0.8725091 -0.4809787 0.08595079 -0.7466658 -0.6630428 -0.05352085 -0.5349152 -0.8368087 0.1166919 -0.9987596 -0.04689872 0.01672834 -0.9982018 -0.0598486 -0.003362953 -0.06805241 -0.9975442 -0.01656448 -0.05555498 -0.9984475 0.004042565 8.8907e-4 -0.5465997 0.8373936 5.33059e-4 -0.5509776 0.83452 0.004123806 0.6375477 0.7703999 -0.01049071 0.8228656 0.5681393 -0.002518236 0.7106881 0.7035028 0.003334283 0.6536505 0.7567892 -0.003888607 -0.6640311 0.7476949 0.003183066 -0.7358403 0.6771478 -0.01673263 0.8151549 0.5790015 -0.373636 0.4680295 0.8008399 -0.7724587 0.6221879 0.1272386 -0.5668749 0.2445532 0.7866681 -0.6982629 0.01288533 0.7157256 -0.9592375 0.06434804 0.2751776 -0.7147101 0.6993146 0.0121932 -0.4388056 0.8982897 0.02291625 -0.5722144 0.6164847 0.5408489 0.7010007 0.001137077 0.7131597 0.5716685 0.2472016 0.7823597 0.7760108 0.6250861 0.08411097 0.3656786 0.464663 0.8064537 0.01790195 0.7870998 0.6165658 -0.8352044 -0.3911832 0.3865352 0.8707776 0.05801951 0.4882419 -0.6089326 -0.02781635 0.7927342 0.8206587 0.3920653 0.4156971 0.5498748 0.8344168 -0.03723388 0.7022116 0.7118432 0.01335102 0.7825589 0.6225079 0.009247243 0.6339415 0.5412512 0.5524178 0.825253 -0.3975813 0.4011068 0.6290233 -0.02652961 0.7769336 0.7685624 -0.03074413 0.6390359 0.3894513 -0.4363483 0.8111275 -0.00314182 -6.49825e-5 -0.9999951 0.02068835 0.03777194 -0.9990723 -3.36067e-4 0.8681395 0.4963201 0.002206206 0.8693922 0.4941177 8.46412e-4 0.07534265 0.9971574 1.67392e-5 0.0636698 0.9979711 -0.08732438 0.9910644 0.1008257 -0.002960801 0.9995301 0.03051143 -0.001022875 0.9997116 0.02399551 2.38456e-5 1 -1.64642e-4 -4.06208e-5 1 -8.76669e-5 0.05079007 0.9952879 0.08259797 -0.002142012 0.005291461 0.9999838 -0.009764373 -0.01276755 0.9998709 -2.90966e-4 -0.9998711 0.01605635 -0.01195007 -0.9999074 0.006530165 -0.001630723 -0.9999364 0.01116681 -0.008608043 -0.9999605 -0.00224334 -0.007068097 -0.9999536 0.006551086 -0.003706216 -0.9999876 0.003347218 0.001899778 -0.9999982 2.12748e-4 -8.44581e-4 -0.9999991 -0.001112341 -0.0017578 -0.9999984 -3.81976e-4 -0.003001391 -0.9999879 0.003933608 0.04073494 -0.9989163 -0.02251619 0.007122337 -0.9998478 0.01593202 0.005625069 -0.9999686 -0.005591452 0.0110715 -0.9999184 0.006386518 -0.00471729 -0.9999871 -0.001937091 1.70855e-4 -0.9999988 0.001574873 0.01087236 -0.9999189 0.006631433 -0.004614412 -0.9999826 -0.003687381 -1.05398e-5 -0.9999939 0.003507912 -1.60083e-5 -0.1229799 0.9924092 -0.004767358 -0.1871572 0.9823184 -0.005576372 -0.8699347 -0.4931353 -2.32577e-4 -0.8672547 -0.4978647 -9.39586e-4 -0.9995101 0.03128528 -3.46689e-4 -0.999222 0.03943848 0.9927443 -0.1197105 0.01132869 -0.9563636 -0.2920154 0.00978285 -0.001544773 0.9999779 0.006467223 0.002068638 0.9999976 6.48183e-4 -0.01753318 0.03230512 -0.9993243 0.003435969 -3.46711e-4 -0.999994 0.9999831 -0.005649566 -0.001454889 0.9998875 0.01003545 -0.01114994 0.9990121 0.002701461 -0.04435819 0.9997629 -0.006217002 -0.02087032 -0.9999886 -0.00428152 -0.00210607 -0.9998611 0.01174783 -0.01182723 -0.9993346 0.004062354 -0.03624898 -0.9998942 -0.004529297 -0.01382708 -0.9959966 0.01350748 0.08836561 -0.9962916 -0.005001425 0.08589476 0.1560158 -0.001218974 -0.9877539 -0.8825191 -0.006937742 -0.4702252 -0.9992199 -0.03507834 0.01814252 -0.9999691 -0.001396 0.007733643 0.9999812 -0.001430571 0.005960941 0.999244 -0.03516072 0.01659327 0.9861967 -0.03598099 -0.1616215 0.9268067 -0.005166351 -0.3755034 0.8828601 -0.002207458 -0.469631 0.99599 0.01377451 0.08839821 0.9963099 -0.01399958 0.08467978 -9.92955e-4 -0.7099062 -0.7042956 0.001225948 -0.7197995 -0.694181 -0.004333555 0.7094319 -0.7047607 -0.002025246 0.6938492 -0.7201175 5.66681e-4 0.7029646 -0.7112247 0.007812917 0.7066024 -0.7075677 -0.5236616 0.003840386 0.8519178 -0.4967814 0.02186524 0.8676003 -0.722224 -0.03209161 0.6909145 -0.897934 0.03721666 0.4385541 -0.9598154 -0.02480667 0.2795337 0.9416905 0.003191292 0.3364652 0.8854467 -0.04922211 0.4621273 0.6450628 7.23494e-4 0.7641294 0.5888193 -0.02258223 0.8079492 0.3185542 0.05585145 0.9462579 0.6454741 0.03606939 0.7629301 0.7021592 -0.638997 -0.3140944 0.7092592 -0.704945 0.00203222 0.40139 -0.669321 0.6252164 0.007280707 -0.701826 0.7123112 -0.4307134 -0.8567411 0.2836915 0.6988441 -0.7152389 0.007094681 -0.6998528 -0.7142868 7.04012e-4 0.9143519 0.003415346 -0.4049062 -0.6693444 -0.01035511 0.7428802 -0.7015902 -0.6401234 -0.3130708 0.7415134 0.5508129 0.3830968 -0.6960386 -0.7179734 0.006675958 0.6727006 0.01042085 0.7398415 0.6373302 0.02924919 0.7700356 -0.8728793 0.004739582 -0.4879134 0.5790942 0.8152195 0.008191704 0.7009998 0.7131506 0.003946483 0.8712383 0.3797509 0.3110197 0.3404745 0.8942072 0.2906386 -0.6368297 0.7211554 0.2727323 -0.7100141 0.7041722 0.00465697 -0.7232721 0.6905426 0.005329906 -0.7358887 0.5554174 0.3872717 -0.6753374 0.01095151 0.7374276 -0.6596332 0.01942574 0.7513366 -0.7151693 -0.6955538 0.06883221 -0.5688336 -0.6933217 0.4424177 0.7013344 -0.6984758 0.1423438 0.5473927 -0.6998478 0.4588838 0.215398 -0.6970678 0.6838861 -0.2572834 -0.6996731 0.6665304 0.002106964 -0.9314457 0.3638744 0.881494 -0.07933795 0.4654824 0.8730121 -0.09179598 0.4789817 0.04290962 -0.01601725 -0.9989507 0.1343826 0.03758537 -0.9902165 0.5740847 0.03054869 0.8182259 0.5090357 -0.05372262 -0.8590674 0.3075678 -0.01931774 0.9513301 0.2946367 -0.03103911 0.9551053 0.6375395 0.04316061 -0.7692078 0.908856 0.008138895 -0.4170307 0.9517405 -0.08275151 -0.2955374 0.9974929 0.013933 -0.06938272 0.3853201 -0.7972646 -0.464648 0.6791377 -0.4461136 -0.5828849 -0.4734979 -0.8706647 -0.1332018 0.5195622 -0.8197226 -0.2410601 -0.4938721 -0.7454801 -0.4476045 -0.7729855 -0.3740035 -0.5124595 0.9405061 -0.3392458 -0.01898998 -0.2958472 -0.6721335 -0.678757 -0.3007575 -0.6191048 -0.7254338 0.08517628 -0.7873173 -0.6106361 0.2099796 -0.49436 -0.8435145 -2.64102e-4 1 1.74548e-4 -1.1962e-5 1 1.26157e-4 2.06489e-4 1 -9.33148e-5 -0.001511156 0.9999989 -1.27516e-4 -0.04181706 0.9984763 0.03600627 -0.005665898 0.9997345 0.02233892 -0.002253532 0.9998073 0.01950085 0.06646537 0.9976769 -0.01493656 -0.4830842 -0.6704126 0.5631843 -0.5432407 -0.436838 0.7169812 -0.5465892 -0.8079434 0.2201545 -0.9770032 -0.09024524 0.193185 0.560274 -0.4717366 0.6808507 0.1733226 -0.8155052 0.5521872 0.03994673 -0.3244244 0.9450678 -0.1251857 -0.8410195 0.526322 -0.9616039 -0.05233085 -0.2694056 -0.7397416 0.05420136 -0.6707046 -0.3073062 -0.04552447 0.9505212 -0.2227703 0.0133779 0.9747792 -0.4903982 -0.05028861 -0.8700463 -0.3967096 0.01345318 -0.9178457 -0.6519777 0.05776602 0.7560345 -0.8745346 -0.07046216 0.479817 -0.9277643 0.02065652 0.3725948 -0.9547636 -0.02300214 -0.2964749 -8.72595e-7 -1 -9.46364e-6 -3.17071e-7 -1 0 -3.17071e-7 -1 8.62569e-7 -4.37507e-7 -1 0 0 -1 0 3.97679e-6 -1 0 0 -1 1.98224e-6 0.8691138 -0.1313883 0.476842 0.04290962 -0.01601725 -0.9989507 0.1343826 0.03758537 -0.9902165 0.6814061 0.0573436 0.7296558 0.5090351 -0.0537225 -0.8590676 0.3075684 -0.01931768 0.9513298 0.2946355 -0.03103935 0.9551055 0.6375406 0.04316031 -0.7692069 0.9068413 0.008536219 -0.4213859 0.9506452 -0.09556525 -0.295197 0.9894707 0.03842526 0.1395403 0.3696854 -0.8152374 -0.445781 -0.9627035 -0.2666468 -0.04584342 -0.5335696 -0.8323478 -0.1500031 0.6228252 -0.7435162 -0.2434592 -0.6888185 -0.4255956 -0.5868538 -0.3595518 -0.4060154 -0.8401631 0.07133811 -0.8588427 -0.5072478 0.4361646 0.05485165 -0.8981936 -3.43774e-4 1 1.10847e-4 3.18553e-4 1 -7.99342e-5 -0.2044163 0.9340437 -0.2928762 0.09703636 0.9950554 0.02118116 6.65985e-4 0.9999999 1.63433e-4 -1.12083e-4 1 -2.28791e-4 -3.81542e-6 1 -2.18706e-4 0.2618119 0.9650791 0.008770644 -0.3162638 -0.5461402 0.7756986 -0.3802565 -0.8110634 0.4445014 -0.7460662 -0.4198443 0.5168328 -0.5037703 -0.839652 0.2029784 0.5497425 -0.6634614 0.5075454 0.1725108 -0.8174732 0.5495251 0.1148756 -0.4207645 0.8998672 -0.1376492 -0.8015738 0.5818353 -0.9616038 -0.05233103 -0.2694066 -0.7876538 0.03749954 -0.6149759 -0.3073074 -0.04552465 0.9505208 -0.4896735 -0.07398062 -0.8687616 -0.3657975 0.01128739 -0.9306262 -0.6519766 0.05776649 0.7560356 -0.8745356 -0.07046252 0.4798154 -0.9277645 0.02065676 0.372594 -0.9547633 -0.02300065 -0.2964761 -3.97679e-6 -1 1.11854e-6 -1.04644e-6 -1 -6.13438e-7 1.79553e-6 -1 5.72717e-7 3.97679e-6 -1 5.59268e-7 -8.85583e-7 -1 0 0 -1 4.29807e-7</float_array>
+          <technique_common>
+            <accessor source="#Part__Feature001_006-mesh-normals-array" count="360" stride="3">
+              <param name="X" type="float"/>
+              <param name="Y" type="float"/>
+              <param name="Z" type="float"/>
+            </accessor>
+          </technique_common>
+        </source>
+        <vertices id="Part__Feature001_006-mesh-vertices">
+          <input semantic="POSITION" source="#Part__Feature001_006-mesh-positions"/>
+        </vertices>
+        <triangles material="Part__Feature001_006-material" count="362">
+          <input semantic="VERTEX" source="#Part__Feature001_006-mesh-vertices" offset="0"/>
+          <input semantic="NORMAL" source="#Part__Feature001_006-mesh-normals" offset="1"/>
+          <p>3 0 124 0 2 0 4 1 124 1 3 1 4 2 0 2 124 2 0 3 5 3 124 3 1 4 124 4 5 4 6 5 7 5 8 5 6 6 54 6 7 6 9 7 74 7 18 7 9 8 10 8 74 8 11 9 12 9 13 9 14 10 15 10 12 10 17 11 20 11 16 11 16 12 20 12 45 12 45 13 20 13 18 13 17 14 19 14 20 14 18 15 6 15 15 15 45 16 18 16 15 16 15 17 21 17 12 17 6 18 21 18 15 18 6 19 22 19 21 19 21 20 23 20 12 20 12 21 23 21 13 21 21 22 24 22 23 22 72 23 26 23 27 23 72 24 73 24 26 24 26 25 73 25 28 25 73 26 14 26 28 26 25 27 29 27 31 27 31 28 29 28 30 28 26 29 28 29 31 29 28 30 25 30 31 30 32 31 33 31 34 31 30 32 35 32 33 32 29 33 35 33 30 33 11 34 13 34 35 34 13 35 34 35 33 35 13 36 33 36 35 36 36 37 37 37 38 37 37 38 39 38 40 38 41 39 39 39 37 39 23 40 24 40 41 40 36 41 23 41 37 41 37 42 23 42 41 42 42 43 40 43 39 43 42 44 43 44 40 44 13 45 36 45 34 45 13 46 23 46 36 46 51 47 16 47 44 47 16 48 45 48 44 48 19 49 17 49 53 49 53 50 17 50 46 50 47 51 54 51 48 51 36 52 48 52 49 52 36 53 49 53 34 53 49 54 32 54 34 54 38 55 48 55 36 55 50 56 27 56 49 56 55 57 44 57 52 57 55 58 51 58 44 58 55 59 46 59 51 59 53 60 46 60 55 60 52 61 44 61 50 61 54 62 52 62 50 62 48 63 50 63 49 63 48 64 54 64 50 64 38 65 56 65 48 65 57 66 56 66 38 66 37 67 57 67 38 67 58 68 59 68 57 68 57 69 60 69 56 69 59 70 60 70 57 70 40 71 58 71 37 71 37 72 58 72 57 72 60 73 48 73 56 73 60 74 47 74 48 74 61 75 33 75 32 75 62 76 32 76 49 76 62 77 61 77 32 77 62 78 26 78 61 78 26 79 63 79 61 79 27 80 62 80 49 80 27 81 26 81 62 81 63 82 30 82 61 82 61 83 30 83 33 83 24 84 21 84 65 84 24 85 64 85 41 85 24 86 65 86 64 86 65 87 66 87 64 87 66 88 67 88 64 88 67 89 68 89 64 89 22 90 66 90 65 90 22 91 65 91 21 91 68 92 39 92 41 92 68 93 41 93 64 93 11 94 35 94 69 94 71 95 69 95 70 95 71 96 11 96 69 96 12 97 11 97 71 97 69 98 25 98 70 98 25 99 28 99 70 99 70 100 28 100 71 100 29 101 25 101 69 101 29 102 69 102 35 102 71 103 14 103 12 103 28 104 14 104 71 104 44 105 45 105 72 105 45 106 73 106 72 106 6 107 18 107 54 107 54 108 18 108 74 108 75 109 76 109 19 109 53 110 75 110 19 110 46 111 17 111 16 111 51 112 46 112 16 112 66 113 22 113 77 113 66 114 77 114 67 114 77 115 42 115 67 115 67 116 42 116 68 116 39 117 68 117 42 117 8 118 22 118 6 118 76 119 9 119 20 119 9 120 18 120 20 120 19 121 76 121 20 121 40 122 43 122 58 122 58 123 43 123 59 123 43 124 78 124 59 124 59 125 78 125 60 125 78 126 47 126 60 126 45 127 15 127 73 127 54 128 47 128 7 128 14 129 73 129 15 129 74 130 52 130 54 130 10 131 52 131 74 131 55 132 10 132 75 132 55 133 52 133 10 133 75 134 53 134 55 134 72 135 50 135 44 135 27 136 50 136 72 136 31 137 30 137 63 137 26 138 31 138 63 138 77 139 79 139 42 139 77 140 22 140 79 140 82 141 83 141 80 141 83 142 81 142 80 142 82 143 85 143 83 143 84 144 85 144 82 144 86 145 91 145 87 145 89 146 91 146 86 146 90 147 91 147 89 147 85 148 84 148 90 148 90 149 84 149 91 149 90 150 89 150 88 150 86 151 121 151 89 151 94 152 121 152 86 152 93 153 5 153 92 153 92 154 5 154 94 154 5 155 0 155 94 155 93 156 1 156 5 156 94 157 0 157 97 157 93 158 95 158 1 158 95 159 96 159 1 159 0 160 4 160 97 160 4 161 3 161 97 161 95 162 122 162 96 162 97 163 3 163 98 163 3 164 99 164 98 164 95 165 125 165 122 165 2 166 99 166 3 166 123 167 100 167 2 167 126 168 100 168 123 168 2 169 100 169 99 169 125 170 100 170 126 170 95 171 100 171 125 171 95 172 102 172 100 172 101 173 102 173 95 173 103 174 104 174 101 174 105 175 104 175 103 175 76 176 75 176 103 176 75 177 105 177 103 177 10 178 105 178 75 178 103 179 9 179 76 179 80 180 81 180 106 180 81 181 107 181 106 181 47 182 78 182 108 182 108 183 78 183 43 183 10 184 107 184 81 184 10 185 81 185 117 185 7 186 108 186 107 186 7 187 107 187 10 187 106 188 9 188 80 188 80 189 9 189 109 189 79 190 8 190 106 190 106 191 8 191 9 191 109 192 110 192 80 192 109 193 101 193 110 193 112 194 101 194 111 194 112 195 110 195 101 195 111 196 93 196 119 196 111 197 119 197 112 197 113 198 114 198 116 198 99 199 114 199 113 199 104 200 114 200 102 200 115 201 116 201 104 201 104 202 116 202 114 202 115 203 117 203 81 203 104 204 117 204 115 204 7 205 9 205 8 205 10 206 9 206 7 206 108 207 43 207 107 207 42 208 106 208 43 208 43 209 106 209 107 209 42 210 79 210 106 210 94 211 86 211 87 211 92 212 94 212 87 212 118 213 92 213 87 213 118 214 87 214 119 214 93 215 118 215 119 215 99 216 113 216 120 216 98 217 99 217 120 217 98 218 120 218 88 218 121 219 98 219 88 219 121 220 88 220 89 220 100 221 102 221 114 221 104 222 105 222 117 222 99 223 100 223 114 223 98 224 121 224 97 224 121 225 94 225 97 225 118 226 93 226 92 226 105 227 10 227 117 227 95 228 93 228 111 228 7 229 47 229 108 229 101 230 95 230 111 230 103 231 101 231 109 231 81 232 83 232 115 232 109 233 9 233 103 233 115 234 85 234 116 234 83 235 85 235 115 235 8 236 79 236 22 236 85 237 90 237 113 237 85 238 113 238 116 238 120 239 113 239 90 239 120 240 90 240 88 240 119 241 87 241 91 241 91 242 84 242 112 242 91 243 112 243 119 243 82 244 80 244 110 244 84 245 110 245 112 245 84 246 82 246 110 246 2 247 124 247 123 247 126 248 123 248 124 248 96 249 124 249 1 249 96 250 122 250 124 250 122 251 125 251 124 251 125 252 126 252 124 252 102 253 101 253 104 253 127 254 128 254 138 254 138 255 128 255 129 255 155 256 146 256 130 256 146 257 131 257 130 257 128 258 132 258 129 258 130 259 131 259 133 259 129 260 134 260 135 260 132 261 134 261 129 261 131 262 136 262 133 262 136 263 137 263 133 263 133 264 137 264 138 264 137 265 127 265 138 265 131 266 139 266 136 266 139 267 142 267 136 267 140 268 141 268 143 268 136 269 142 269 137 269 143 270 144 270 145 270 141 271 144 271 143 271 142 272 127 272 137 272 145 273 144 273 146 273 144 274 147 274 146 274 146 275 147 275 131 275 147 276 139 276 131 276 149 277 144 277 150 277 150 278 144 278 148 278 147 279 144 279 149 279 148 280 144 280 141 280 142 281 139 281 127 281 139 282 147 282 127 282 127 283 147 283 128 283 128 284 147 284 149 284 151 285 148 285 152 285 150 286 148 286 151 286 152 287 148 287 140 287 148 288 141 288 140 288 128 289 149 289 132 289 132 290 149 290 134 290 149 291 150 291 134 291 134 292 150 292 151 292 140 293 143 293 153 293 143 294 145 294 153 294 135 295 151 295 154 295 134 296 151 296 135 296 153 297 145 297 155 297 145 298 146 298 155 298 151 299 152 299 154 299 154 300 152 300 156 300 152 301 140 301 156 301 156 302 140 302 153 302 153 303 155 303 130 303 153 304 130 304 133 304 153 305 133 305 138 305 154 306 153 306 138 306 154 307 138 307 129 307 154 308 156 308 153 308 154 309 129 309 135 309 167 310 157 310 158 310 183 311 174 311 159 311 174 312 160 312 159 312 157 313 161 313 158 313 159 314 160 314 162 314 158 315 163 315 164 315 161 316 163 316 158 316 160 317 165 317 162 317 165 318 166 318 162 318 162 319 166 319 167 319 166 320 157 320 167 320 160 321 168 321 165 321 170 322 171 322 169 322 169 323 171 323 172 323 165 324 168 324 166 324 171 325 173 325 172 325 173 326 175 326 174 326 174 327 175 327 160 327 175 328 168 328 160 328 177 329 171 329 170 329 175 330 171 330 177 330 175 331 173 331 171 331 157 332 168 332 178 332 178 333 168 333 176 333 176 334 175 334 177 334 168 335 175 335 176 335 166 336 168 336 157 336 176 337 177 337 179 337 179 338 177 338 180 338 177 339 170 339 180 339 180 340 170 340 169 340 157 341 178 341 161 341 161 342 178 342 163 342 178 343 176 343 163 343 163 344 176 344 179 344 169 345 172 345 181 345 172 346 173 346 181 346 164 347 179 347 182 347 163 296 179 296 164 296 181 348 173 348 183 348 173 349 174 349 183 349 179 350 180 350 182 350 182 351 180 351 184 351 180 352 169 352 184 352 184 353 169 353 181 353 158 354 162 354 167 354 182 355 183 355 159 355 182 356 181 356 183 356 182 357 184 357 181 357 182 307 159 307 164 307 164 358 159 358 162 358 164 359 162 359 158 359</p>
+        </triangles>
+      </mesh>
+    </geometry>
+  </library_geometries>
+  <library_controllers/>
+  <library_visual_scenes>
+    <visual_scene id="Scene" name="Scene">
+      <node id="node0" name="node0" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_geometry url="#Part__Feature_007-mesh" name="node0">
+          <bind_material>
+            <technique_common>
+              <instance_material symbol="Part__Feature_007-material" target="#Part__Feature_007-material"/>
+            </technique_common>
+          </bind_material>
+        </instance_geometry>
+      </node>
+      <node id="node1" name="node1" type="NODE">
+        <matrix sid="transform">1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1</matrix>
+        <instance_geometry url="#Part__Feature001_006-mesh" name="node1">
+          <bind_material>
+            <technique_common>
+              <instance_material symbol="Part__Feature001_006-material" target="#Part__Feature001_006-material"/>
+            </technique_common>
+          </bind_material>
+        </instance_geometry>
+      </node>
+    </visual_scene>
+  </library_visual_scenes>
+  <scene>
+    <instance_visual_scene url="#Scene"/>
+  </scene>
+</COLLADA>

embodied_gen/scripts/affordance_annot/gen_grasp.py

@@ -0,0 +1,842 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+import os
+import sys
+import time
+from dataclasses import dataclass, field
+from typing import Literal
+
+from embodied_gen.utils.general import filter_warnings
+
+filter_warnings()
+
+import numpy as np
+import trimesh
+import trimesh.transformations as tra
+import tyro
+import yaml
+
+sys.path.append(".")
+from embodied_gen.utils.geometry import (
+    sample_surface_points,
+)
+from embodied_gen.utils.io_utils import (
+    URDFFile,
+    load_json,
+    load_mesh,
+    write_json,
+)
+from embodied_gen.utils.log import logger
+from embodied_gen.utils.vis_utils import show_grasps
+
+__all__ = [
+    "GraspGenHyperConfig",
+    "GraspGenXHyperConfig",
+    "GraspPoseConfig",
+    "GraspGenerator",
+    "run_grasp",
+    "entrypoint",
+]
+
+FINGER_CENTER_CACHE: dict[str, np.ndarray] = {
+    "franka_panda": np.array([0.0, 0.0, 0.1034], dtype=np.float64),
+}
+
+GRIPPER_GEOMETRY_CACHE: dict[str, dict[str, float]] = {
+    "franka_panda": {
+        "width": 0.10537486,
+        "depth": 0.10527314,
+    },
+}
+
+
+@dataclass
+class GraspGenHyperConfig:
+    gripper_config: str = (
+        "~/.cache/huggingface/hub/GraspGenModels/checkpoints/graspgen_{}.yml"
+    )
+    grasp_threshold: float = -1.0
+    num_grasps: int = 4000
+    return_topk: bool = True
+    topk_num_grasps: int = 4000
+    mesh_scale: tuple[float, float, float] = (1.0, 1.0, 1.0)
+    num_sample_points: int = 2000
+    min_grasps: int = 40
+    max_tries: int = 6
+    remove_outliers: bool = False
+
+
+@dataclass
+class GraspGenXHyperConfig:
+    checkpoint_root: str = "~/.cache/huggingface/hub/GraspGenXModels/release"
+    gen_pth: str | None = None
+    dis_pth: str | None = None
+    assets_dir: str = (
+        "thirdparty/gripper_descriptions/gripper_descriptions/assets"
+    )
+    grasp_threshold: float = -1.0
+    num_grasps: int = 4000
+    return_topk: bool = True
+    topk_num_grasps: int = 4000
+    mesh_scale: tuple[float, float, float] = (1.0, 1.0, 1.0)
+    num_sample_points: int = 2000
+    min_grasps: int = 40
+    max_tries: int = 6
+    remove_outliers: bool = False
+
+
+@dataclass
+class GraspPoseConfig:
+    urdf_paths: list[str] = field(default_factory=list)
+    model_name: str = "GraspGen"
+    gripper_name: str = "franka_panda"
+    mesh_type: Literal["collision", "visual"] = "collision"
+    update_urdf: bool = True
+    overwrite: bool = True
+    gripper_mesh_path: str = (
+        f"embodied_gen/scripts/affordance_annot/{gripper_name}/coll_mesh.obj"
+    )
+    grasps_per_part: int = 20
+    visualize_grasps: bool = False
+    visualizer_port: int = 8080
+    graspgen: GraspGenHyperConfig | None = None
+
+
+class GraspGenerator:
+    def __init__(self, cfg: GraspPoseConfig):
+        self.cfg = cfg
+        self.grasp_visualizer = None
+        self.validate_config(cfg)
+        self.modules = self.load_model()
+        self.pipeline = self.build_sampler()
+        self.finger_center = FINGER_CENTER_CACHE.get(
+            self.cfg.gripper_name,
+            np.array([0.0, 0.0, 0.0], dtype=np.float64),
+        )
+        (
+            self.local_contact_points,
+            self.local_closing_directions,
+        ) = self.build_local_contact_samples()
+
+    def validate_config(self, cfg: GraspPoseConfig) -> None:
+        cfg.model_name = cfg.model_name.lower()
+        if cfg.model_name not in {"graspgen", "graspgenx"}:
+            raise ValueError(
+                "unsupported model '{}', available models: GraspGen, GraspGenX".format(
+                    cfg.model_name
+                )
+            )
+
+        cfg.graspgen = (
+            GraspGenHyperConfig()
+            if cfg.model_name == "graspgen"
+            else GraspGenXHyperConfig()
+        )
+        if cfg.model_name == "graspgen":
+            cfg.graspgen.gripper_config = cfg.graspgen.gripper_config.format(
+                cfg.gripper_name
+            )
+
+    def load_model(self):
+        if self.cfg.model_name == "graspgen":
+            sys.path.append("thirdparty/GraspGen")
+            from grasp_gen.grasp_server import GraspGenSampler, load_grasp_cfg
+
+            return {
+                "GraspGenSampler": GraspGenSampler,
+                "model_cfg": load_grasp_cfg,
+            }
+        if self.cfg.model_name == "graspgenx":
+            sys.path.append("thirdparty/GraspGenX")
+            from graspgenx.grasp_server import GraspGenXSampler
+            from graspgenx.utils.checkpoint_io import load_model_cfg
+
+            return {
+                "GraspGenSampler": GraspGenXSampler,
+                "model_cfg": load_model_cfg,
+            }
+
+    @staticmethod
+    def _extract_checkpoint_filenames(yml_path: str) -> list[str]:
+        """Recursively collect all `checkpoint: <name>.pth` entries.
+
+        Walks a GraspGen config yaml so we know every weight file it
+        requires.
+        """
+        with open(yml_path) as f:
+            cfg = yaml.safe_load(f)
+
+        names: set[str] = set()
+
+        def _walk(node) -> None:
+            if isinstance(node, dict):
+                for key, value in node.items():
+                    if (
+                        key == "checkpoint"
+                        and isinstance(value, str)
+                        and value.strip()
+                    ):
+                        names.add(value.strip())
+                    else:
+                        _walk(value)
+            elif isinstance(node, list):
+                for item in node:
+                    _walk(item)
+
+        _walk(cfg)
+        return sorted(names)
+
+    @staticmethod
+    def _dir_has_pth(directory: str, filename: str | None) -> bool:
+        if filename:
+            return os.path.exists(os.path.join(directory, filename))
+        return os.path.isdir(directory) and any(
+            f.endswith(".pth") for f in os.listdir(directory)
+        )
+
+    def _ensure_checkpoints(
+        self,
+        is_ready: callable,
+        repo_id: str,
+        allow_patterns: str,
+        download_dir: str,
+        desc: str,
+    ) -> None:
+        """Download `desc` weights from `repo_id` unless already ready.
+
+        Re-checks afterwards so a stale/partial local cache (e.g. config
+        present but a referenced .pth missing) is retried instead of
+        silently failing deep inside third-party code.
+        """
+        if is_ready():
+            return
+
+        logger.info(
+            f"Downloading {desc} weights from Hugging Face. "
+            "First-time use may take several minutes; please wait patiently."
+        )
+        from huggingface_hub import snapshot_download
+
+        snapshot_download(
+            repo_id=repo_id,
+            allow_patterns=allow_patterns,
+            local_dir=os.path.expanduser(download_dir),
+        )
+
+        if not is_ready():
+            raise FileNotFoundError(
+                f"{desc} checkpoint(s) still missing after downloading from "
+                f"Hugging Face repo '{repo_id}'. The local cache may be from "
+                "a previous partial download; please remove it and retry, "
+                "or download manually."
+            )
+
+    def build_sampler(self):
+        if self.cfg.model_name == "graspgen":
+            gripper_config = os.path.expanduser(
+                self.cfg.graspgen.gripper_config
+            )
+            checkpoints_dir = os.path.dirname(gripper_config)
+
+            def _graspgen_ready() -> bool:
+                if not os.path.exists(gripper_config):
+                    return False
+                required = self._extract_checkpoint_filenames(gripper_config)
+                return all(
+                    os.path.exists(os.path.join(checkpoints_dir, name))
+                    for name in required
+                )
+
+            self._ensure_checkpoints(
+                _graspgen_ready,
+                "adithyamurali/GraspGenModels",
+                "checkpoints/*",
+                "~/.cache/huggingface/hub/GraspGenModels",
+                "GraspGen",
+            )
+            grasp_cfg = self.modules["model_cfg"](gripper_config)
+            return self.modules["GraspGenSampler"](grasp_cfg)
+        if self.cfg.model_name == "graspgenx":
+            checkpoint_root = os.path.expanduser(
+                self.cfg.graspgen.checkpoint_root
+            )
+            gen_dir = os.path.join(checkpoint_root, "gen")
+            dis_dir = os.path.join(checkpoint_root, "dis")
+
+            def _graspgenx_ready() -> bool:
+                return (
+                    os.path.exists(os.path.join(gen_dir, "config.yaml"))
+                    and self._dir_has_pth(gen_dir, self.cfg.graspgen.gen_pth)
+                    and self._dir_has_pth(dis_dir, self.cfg.graspgen.dis_pth)
+                )
+
+            self._ensure_checkpoints(
+                _graspgenx_ready,
+                "adithyamurali/GraspGenXModel",
+                "release/*",
+                "~/.cache/huggingface/hub/GraspGenXModels",
+                "GraspGenX",
+            )
+            model_cfg = self.modules["model_cfg"](
+                os.path.join(checkpoint_root, "gen"),
+                os.path.join(checkpoint_root, "dis"),
+                self.cfg.graspgen.gen_pth,
+                self.cfg.graspgen.dis_pth,
+            )
+            return self.modules["GraspGenSampler"](
+                model_cfg,
+                self.cfg.gripper_name,
+                assets_dir=self.cfg.graspgen.assets_dir,
+            )
+
+    def update_urdf(self, urdf_path: str | None, grasp_path: str) -> None:
+        if urdf_path is None or not self.cfg.update_urdf:
+            return
+
+        URDFFile(urdf_path).write(
+            {
+                "custom_data/affordance/affordance_annot": os.path.relpath(
+                    grasp_path,
+                    os.path.dirname(urdf_path),
+                ),
+            }
+        )
+
+    def get_part_seg_mesh_transform(self, urdf: URDFFile) -> dict:
+        return {
+            "origin_xyz": urdf.read(
+                ".//custom_data/affordance/visual_seg/origin",
+                attr="xyz",
+                default="0 0 0",
+            ),
+            "origin_rpy": urdf.read(
+                ".//custom_data/affordance/visual_seg/origin",
+                attr="rpy",
+                default="0 0 0",
+            ),
+            "scale": urdf.read(
+                ".//custom_data/affordance/visual_seg/geometry/mesh",
+                attr="scale",
+                default="1.0 1.0 1.0",
+            ),
+        }
+
+    def add_grasps_to_affordance(
+        self,
+        affordance_payload: dict,
+        grasps: np.ndarray,
+        confidences: np.ndarray,
+        part_grasp_ids: dict[int, list[int]] | None,
+    ) -> None:
+        for affordance in affordance_payload.get("affordances", []):
+            if (
+                not isinstance(affordance, dict)
+                or affordance.get("id") is None
+            ):
+                continue
+            affordance.pop("grasps", None)
+            affordance.pop("confidences", None)
+            grasp_ids = part_grasp_ids.get(int(affordance["id"]), [])
+            grasp_group = {}
+            for grasp_idx in grasp_ids:
+                grasp = grasps[grasp_idx]
+                quaternion = tra.quaternion_from_matrix(grasp[:3, :3])
+                grasp_group[f"grasp_{grasp_idx}"] = {
+                    "confidence": float(confidences[grasp_idx]),
+                    "position": grasp[:3, 3].tolist(),
+                    "orientation": {
+                        "w": float(quaternion[0]),
+                        "xyz": quaternion[1:].tolist(),
+                    },
+                }
+            affordance["grasp_group"] = grasp_group
+
+    def infer_grasps(
+        self,
+        mesh: trimesh.Trimesh,
+        mesh_path: str,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray] | None:
+        points = sample_surface_points(
+            mesh, self.cfg.graspgen.num_sample_points
+        )
+        center_transform = tra.translation_matrix(-points.mean(axis=0))
+        centered_points = tra.transform_points(
+            points, center_transform
+        ).astype(np.float32)
+        topk_limit = (
+            self.cfg.graspgen.topk_num_grasps
+            if self.cfg.graspgen.return_topk
+            else -1
+        )
+        grasps, confidences = self.modules["GraspGenSampler"].run_inference(
+            centered_points,
+            self.pipeline,
+            grasp_threshold=self.cfg.graspgen.grasp_threshold,
+            num_grasps=self.cfg.graspgen.num_grasps,
+            topk_num_grasps=topk_limit,
+            min_grasps=self.cfg.graspgen.min_grasps,
+            max_tries=self.cfg.graspgen.max_tries,
+            remove_outliers=self.cfg.graspgen.remove_outliers,
+        )
+
+        confidences = confidences.detach().cpu().numpy()
+        grasps = grasps.detach().cpu().numpy()
+        if len(grasps) == 0:
+            logger.error(f"No grasp poses generated for mesh: {mesh_path}")
+            return None
+
+        grasps = np.asarray(
+            [tra.inverse_matrix(center_transform) @ grasp for grasp in grasps]
+        )
+        return grasps, confidences
+
+    def get_grasp_centers(
+        self,
+        grasps: np.ndarray,
+    ) -> np.ndarray:
+        local_centers = np.repeat(
+            np.asarray(self.finger_center, dtype=np.float64)[None, :],
+            len(grasps),
+            axis=0,
+        )
+        grasp_center_points = (
+            np.einsum(
+                "nij,nj->ni",
+                grasps[:, :3, :3],
+                local_centers,
+            )
+            + grasps[:, :3, 3]
+        )
+        return grasp_center_points
+
+    def build_local_contact_samples(self) -> tuple[np.ndarray, np.ndarray]:
+        geometry = GRIPPER_GEOMETRY_CACHE.get(self.cfg.gripper_name)
+        if geometry is None:
+            return (
+                np.asarray(self.finger_center, dtype=np.float64)[None, :],
+                np.array([[1.0, 0.0, 0.0]], dtype=np.float64),
+            )
+
+        half_width = float(geometry["width"]) / 2.0
+        depth = float(geometry["depth"])
+        z_values = np.linspace(depth - 0.015, depth, 6, dtype=np.float64)
+        points = []
+        directions = []
+        for z_value in z_values:
+            points.extend(
+                [
+                    [-half_width, 0.0, z_value],
+                    [half_width, 0.0, z_value],
+                ]
+            )
+            directions.extend(
+                [
+                    [1.0, 0.0, 0.0],
+                    [-1.0, 0.0, 0.0],
+                ]
+            )
+        return (
+            np.asarray(points, dtype=np.float64),
+            np.asarray(directions, dtype=np.float64),
+        )
+
+    def get_grasp_contact_rays(
+        self,
+        grasps: np.ndarray,
+    ) -> tuple[np.ndarray, np.ndarray]:
+        local_contact_points = np.repeat(
+            self.local_contact_points[None, :, :],
+            len(grasps),
+            axis=0,
+        )
+        local_closing_directions = np.repeat(
+            self.local_closing_directions[None, :, :],
+            len(grasps),
+            axis=0,
+        )
+        ray_origins = (
+            np.einsum(
+                "nij,nkj->nki",
+                grasps[:, :3, :3],
+                local_contact_points,
+            )
+            + grasps[:, None, :3, 3]
+        )
+        ray_directions = np.einsum(
+            "nij,nkj->nki",
+            grasps[:, :3, :3],
+            local_closing_directions,
+        )
+        ray_norms = np.linalg.norm(ray_directions, axis=-1, keepdims=True)
+        ray_directions = np.divide(
+            ray_directions,
+            ray_norms,
+            out=np.zeros_like(ray_directions),
+            where=ray_norms > 0.0,
+        )
+        return ray_origins, ray_directions
+
+    def bind_contact_rays_to_faces(
+        self,
+        part_mesh: trimesh.Trimesh,
+        ray_origins: np.ndarray,
+        ray_directions: np.ndarray,
+    ) -> np.ndarray:
+        ray_origins = np.asarray(ray_origins, dtype=np.float64)
+        ray_directions = np.asarray(ray_directions, dtype=np.float64)
+
+        if (
+            not isinstance(part_mesh, trimesh.Trimesh)
+            or len(part_mesh.faces) == 0
+        ):
+            return np.full(len(ray_origins), -1, dtype=np.int64)
+
+        try:
+            face_ids = part_mesh.ray.intersects_first(
+                ray_origins,
+                ray_directions,
+            )
+            return np.asarray(face_ids, dtype=np.int64)
+        except Exception as exc:
+            logger.warning(
+                "Failed to raycast grasp closing directions to part mesh: "
+                f"{exc}"
+            )
+            return np.full(len(ray_origins), -1, dtype=np.int64)
+
+    def classify_grasps_by_contact(
+        self,
+        grasps: np.ndarray,
+        part_mesh: trimesh.Trimesh,
+        face_ids: np.ndarray | None,
+    ) -> tuple[np.ndarray | None, np.ndarray | None]:
+        if face_ids is None:
+            return None, None
+
+        face_ids = np.asarray(face_ids, dtype=np.int64)
+        if len(face_ids) != len(part_mesh.faces):
+            raise ValueError(
+                "face_ids length must match segmentation mesh faces, got "
+                f"{len(face_ids)} and {len(part_mesh.faces)}"
+            )
+
+        ray_origins, ray_directions = self.get_grasp_contact_rays(grasps)
+        num_grasps, num_contact_points, _ = ray_origins.shape
+        logger.info(
+            "Binding {} grasp closing rays to {} part faces.".format(
+                num_grasps * num_contact_points,
+                len(part_mesh.faces),
+            )
+        )
+        nearest_face_ids = self.bind_contact_rays_to_faces(
+            part_mesh,
+            ray_origins.reshape(-1, 3),
+            ray_directions.reshape(-1, 3),
+        ).reshape(num_grasps, num_contact_points)
+        contact_part_ids = self.parts_for_faces(
+            nearest_face_ids.reshape(-1),
+            face_ids,
+        ).reshape(num_grasps, num_contact_points)
+
+        grasp_part_ids = np.full(num_grasps, -1, dtype=np.int64)
+        contact_scores = np.zeros(num_grasps, dtype=np.float64)
+        for grasp_idx, part_ids in enumerate(contact_part_ids):
+            valid_part_ids = part_ids[part_ids >= 0]
+            if len(valid_part_ids) == 0:
+                continue
+            unique_ids, counts = np.unique(
+                valid_part_ids,
+                return_counts=True,
+            )
+            best_idx = int(np.argmax(counts))
+            grasp_part_ids[grasp_idx] = int(unique_ids[best_idx])
+            contact_scores[grasp_idx] = float(counts[best_idx]) / float(
+                num_contact_points
+            )
+
+        return grasp_part_ids, contact_scores
+
+    def parts_for_faces(
+        self,
+        nearest_face_ids: np.ndarray,
+        face_ids: np.ndarray | None,
+    ) -> np.ndarray | None:
+        if face_ids is None:
+            return None
+
+        nearest_face_ids = np.asarray(nearest_face_ids, dtype=np.int64)
+        grasp_part_ids = np.full(len(nearest_face_ids), -1, dtype=np.int64)
+        valid_mask = (nearest_face_ids >= 0) & (
+            nearest_face_ids < len(face_ids)
+        )
+        grasp_part_ids[valid_mask] = face_ids[nearest_face_ids[valid_mask]]
+        return grasp_part_ids
+
+    def pick_top_grasps(
+        self,
+        grasps: np.ndarray,
+        confidences: np.ndarray,
+        part_ids: np.ndarray | None,
+        graspable_part_ids: set[int] | None = None,
+        part_scores: np.ndarray | None = None,
+    ) -> tuple[
+        np.ndarray, np.ndarray, np.ndarray, dict[int, list[int]] | None
+    ]:
+        if part_ids is None:
+            return (
+                grasps,
+                confidences,
+                np.arange(len(grasps), dtype=np.int64),
+                None,
+            )
+
+        part_ids = np.asarray(part_ids, dtype=np.int64)
+        selected_indices = []
+        selected_part_ids = []
+        for part_id in sorted(
+            int(pid) for pid in np.unique(part_ids[part_ids >= 0])
+        ):
+            if (
+                graspable_part_ids is not None
+                and part_id not in graspable_part_ids
+            ):
+                continue
+            part_indices = np.flatnonzero(part_ids == part_id)
+            if part_scores is None:
+                rank = np.argsort(
+                    -confidences[part_indices],
+                    kind="mergesort",
+                )
+            else:
+                rank = np.lexsort(
+                    (
+                        -confidences[part_indices],
+                        -part_scores[part_indices],
+                    )
+                )
+            ranked_indices = part_indices[rank]
+            if len(ranked_indices) > self.cfg.grasps_per_part:
+                selected = ranked_indices[: self.cfg.grasps_per_part]
+            else:
+                selected = ranked_indices
+            selected_indices.extend(int(idx) for idx in selected)
+            selected_part_ids.extend([part_id] * len(selected))
+
+        selected_indices = np.asarray(selected_indices, dtype=np.int64)
+        if len(selected_indices) == 0:
+            return (
+                grasps[:0],
+                confidences[:0],
+                selected_indices,
+                {},
+            )
+
+        part_grasp_ids: dict[int, list[int]] = {}
+        for new_idx, part_id in enumerate(selected_part_ids):
+            part_grasp_ids.setdefault(part_id, []).append(new_idx)
+
+        return (
+            grasps[selected_indices],
+            confidences[selected_indices],
+            selected_indices,
+            part_grasp_ids,
+        )
+
+    def select_grasps(
+        self,
+        grasps: np.ndarray,
+        confidences: np.ndarray,
+        part_mesh: trimesh.Trimesh,
+        face_ids: np.ndarray,
+        affordance_payload: dict,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray, dict[int, list[int]]]:
+        original_count = len(grasps)
+
+        # Raycast from fingertip samples along the gripper closing direction.
+        grasp_center_points = self.get_grasp_centers(grasps)
+        grasp_part_ids, contact_scores = self.classify_grasps_by_contact(
+            grasps,
+            part_mesh,
+            face_ids,
+        )
+
+        affordances = affordance_payload.get("affordances", [])
+        graspable_part_ids = {
+            int(affordance["id"])
+            for affordance in affordances
+            if isinstance(affordance, dict)
+            and affordance.get("id") is not None
+            and affordance.get("graspable") is True
+        }
+
+        # Select top grasps per part
+        grasps, confidences, selected_indices, part_grasp_ids = (
+            self.pick_top_grasps(
+                grasps,
+                confidences,
+                grasp_part_ids,
+                graspable_part_ids,
+                contact_scores,
+            )
+        )
+        grasp_center_points = grasp_center_points[selected_indices]
+        if len(grasps) == 0:
+            logger.info(
+                "Selected per-part grasps: {} -> 0 grasps across 0 parts".format(
+                    original_count,
+                )
+            )
+            return grasps, confidences, grasp_center_points, part_grasp_ids
+
+        logger.info(
+            "Selected per-part grasps: {} -> {} grasps across {} parts, confidences range from {:.4f} to {:.4f}".format(
+                original_count,
+                len(grasps),
+                len(part_grasp_ids),
+                np.min(confidences),
+                np.max(confidences),
+            )
+        )
+        return grasps, confidences, grasp_center_points, part_grasp_ids
+
+    def process(
+        self,
+        urdf_path: str,
+    ) -> bool:
+        try:
+            return self._process_impl(urdf_path)
+        except Exception as exc:
+            logger.error(
+                "Grasp generation failed for URDF {}: {}".format(
+                    urdf_path,
+                    exc,
+                )
+            )
+            return False
+
+    def _process_impl(
+        self,
+        urdf_path: str,
+    ) -> bool:
+        urdf = URDFFile(urdf_path)
+        mesh_path = urdf.get_mesh_path(self.cfg.mesh_type)
+        mesh_transform = urdf.get_mesh_transform(self.cfg.mesh_type)
+        seg_mesh_path = urdf.get_mesh_part_seg_path()
+        seg_mesh_transform = self.get_part_seg_mesh_transform(urdf)
+        affordance_path = urdf.get_affordance_annot_path()
+        affordance_payload = load_json(affordance_path)
+
+        if not self.cfg.overwrite:
+            has_existing_grasp_group = any(
+                isinstance(affordance, dict) and "grasp_group" in affordance
+                for affordance in affordance_payload.get("affordances", [])
+            )
+            if has_existing_grasp_group:
+                logger.info(
+                    f"Skip existing grasp poses in affordance JSON: {affordance_path}"
+                )
+                return True
+
+        logger.info(f"Generating grasps for mesh: {mesh_path}")
+        mesh = load_mesh(
+            mesh_path,
+            apply_origin=True,
+            apply_scale=True,
+            **mesh_transform,
+        )
+
+        seg_mesh, face_ids = load_mesh(
+            seg_mesh_path,
+            apply_origin=True,
+            apply_scale=True,
+            **seg_mesh_transform,
+        )
+
+        grasp_result = self.infer_grasps(mesh, mesh_path)
+        if grasp_result is None:
+            return False
+        grasps, confidences = grasp_result
+        grasps, confidences, grasp_center_points, part_grasp_ids = (
+            self.select_grasps(
+                grasps,
+                confidences,
+                seg_mesh,
+                face_ids,
+                affordance_payload,
+            )
+        )
+
+        self.add_grasps_to_affordance(
+            affordance_payload,
+            grasps,
+            confidences,
+            part_grasp_ids,
+        )
+        write_json(affordance_payload, affordance_path)
+        logger.info(f"Saved predicted grasp poses to {affordance_path}")
+
+        self.update_urdf(urdf_path, affordance_path)
+        logger.info(
+            "Grasp generation succeeded: {} -> {} ({} grasps)".format(
+                mesh_path,
+                affordance_path,
+                len(grasps),
+            )
+        )
+        if self.cfg.visualize_grasps:
+            gripper_mesh = load_mesh(self.cfg.gripper_mesh_path)
+            self.grasp_visualizer = show_grasps(
+                mesh,
+                grasps,
+                confidences,
+                self.cfg.gripper_name,
+                self.cfg.model_name,
+                grasp_center_points=grasp_center_points,
+                visualizer=self.grasp_visualizer,
+                visualizer_port=self.cfg.visualizer_port,
+                gripper_info=self.pipeline.get_gripper_info()
+                if self.cfg.model_name == "graspgenx"
+                else None,
+                gripper_mesh=gripper_mesh,
+            )
+        return True
+
+
+def run_grasp(cfg: GraspPoseConfig) -> None:
+    generator = GraspGenerator(cfg)
+    for urdf_path in cfg.urdf_paths:
+        generator.process(urdf_path)
+
+    if cfg.visualize_grasps and generator.grasp_visualizer is not None:
+        logger.info(
+            "Keeping grasp visualization alive at http://localhost:{} "
+            "(press Ctrl+C to exit).".format(cfg.visualizer_port)
+        )
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            logger.info("Stopping grasp visualization.")
+
+
+def entrypoint(*args, **kwargs) -> None:
+    cfg = tyro.cli(GraspPoseConfig)
+    run_grasp(cfg)
+
+
+if __name__ == "__main__":
+    entrypoint()

embodied_gen/scripts/affordance_annot/part_seg.py

@@ -0,0 +1,697 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+
+import os
+import shutil
+import sys
+from dataclasses import asdict, dataclass, field
+from typing import Literal
+
+import json_repair
+from embodied_gen.utils.general import filter_warnings
+from embodied_gen.utils.gpt_clients import GPT_CLIENT
+
+filter_warnings()
+
+import numpy as np
+import trimesh
+import tyro
+from huggingface_hub import snapshot_download
+from embodied_gen.utils.general import set_seed
+from embodied_gen.utils.geometry import (
+    EnclosedFaceLabelFillConfig,
+    SmoothFaceLabelMergeConfig,
+    fill_small_enclosed_face_labels,
+    merge_smooth_face_labels,
+    normalize_mesh,
+)
+from embodied_gen.utils.io_utils import URDFFile, load_mesh, save_mesh
+from embodied_gen.utils.log import logger
+from embodied_gen.utils.process_media import render_asset3d
+from embodied_gen.utils.vis_utils import PALETTE, collect_colors, render_grid
+from embodied_gen.validators.quality_checkers import PartSegChecker
+
+__all__ = [
+    "FaceIdPostProcessConfig",
+    "PartSegConfig",
+    "PartSegmenter",
+    "entrypoint",
+]
+
+
+@dataclass
+class P3SAMConfig:
+    threshold: float = 0.95
+    post_process: bool = True
+    save_mid_res: bool = False
+    show_info: bool = True
+    is_parallel: bool = False
+    seed: int = 42
+    clean_mesh_flag: bool = False
+    prompt_bs: int = 8  # Lower this for reduced GPU memory usage.
+
+
+@dataclass
+class FaceIdPostProcessConfig:
+    enabled: bool = True
+    max_smooth_angle_deg: float = 5.0
+    vertex_merge_tolerance: float = 0.0
+    min_component_area_ratio: float = 0.0
+    min_component_faces: int = 1
+    preserve_negative: bool = False
+    fill_enclosed_components: bool = True
+    max_enclosed_component_area_ratio: float = 0.005
+    max_enclosed_component_faces: int = 100
+    min_enclosure_neighbor_ratio: float = 0.8
+
+
+@dataclass
+class PartSegConfig:
+    urdf_paths: list[str] = field(default_factory=list)
+    output_dirs: list[str] = field(default_factory=list)
+    model_name: str = "p3sam"
+    thirdparty_root: str = ""
+    mesh_type: Literal["visual", "collision"] = "visual"
+    merge_retries: int = 3
+    p3sam: P3SAMConfig = field(default_factory=P3SAMConfig)
+    face_id_postprocess: FaceIdPostProcessConfig = field(
+        default_factory=FaceIdPostProcessConfig
+    )
+    grid_num_images: int = 6
+    grid_rows: int = 2
+    grid_cols: int = 3
+    grid_image_size: int = 512
+    debug_mode: bool = False
+    overwrite: bool = True
+
+
+class PartSegmenter:
+    def __init__(self, cfg: PartSegConfig):
+        self.validate_config(cfg)
+        self.cfg = cfg
+        self.seg_checker = PartSegChecker(GPT_CLIENT)
+        self.model = self.import_model()
+        self.pipeline = self.build_pipeline(self.model)
+
+    def validate_config(self, cfg: PartSegConfig) -> None:
+        if cfg.model_name != "p3sam":
+            raise ValueError(
+                "unsupported model '{}', available models: p3sam".format(
+                    cfg.model_name
+                )
+            )
+
+        if cfg.model_name == "p3sam":
+            cfg.thirdparty_root = "thirdparty/Hunyuan3D-Part"
+
+        if not cfg.urdf_paths:
+            raise ValueError("urdf_paths must be provided.")
+
+        if len(cfg.output_dirs) == 0:
+            cfg.output_dirs = [
+                os.path.join(os.path.dirname(path), "affordance")
+                for path in cfg.urdf_paths
+            ]
+        if len(cfg.urdf_paths) != len(cfg.output_dirs):
+            raise ValueError(
+                "urdf-derived mesh paths and output_dirs must have the same length, "
+                f"got {len(cfg.urdf_paths)} and {len(cfg.output_dirs)}."
+            )
+
+    def import_model(self):
+        if self.cfg.model_name == "p3sam":
+            p3sam_root = os.path.join(self.cfg.thirdparty_root, "P3-SAM")
+            p3sam_demo = os.path.join(p3sam_root, "demo")
+            for path in [p3sam_demo, p3sam_root]:
+                if path not in sys.path:
+                    sys.path.append(path)
+            from embodied_gen.utils.monkey_patch.p3sam import (
+                monkey_patch_p3sam,
+            )
+
+            monkey_patch_p3sam()
+            from auto_mask import AutoMask
+
+            return AutoMask
+
+        raise ValueError("unsupported model '{}'".format(self.cfg.model_name))
+
+    def build_pipeline(self, model):
+        if self.cfg.model_name == "p3sam":
+            ckpt_path = os.path.expanduser(
+                "~/.cache/huggingface/hub/P3-SAM/p3sam/p3sam.safetensors"
+            )
+            if not os.path.exists(ckpt_path):
+                download_dir = os.path.expanduser(
+                    "~/.cache/huggingface/hub/P3-SAM"
+                )
+                logger.info(
+                    "Downloading P3-SAM weights from Hugging Face to {}. "
+                    "First-time use may take several minutes; please wait patiently.".format(
+                        ckpt_path
+                    )
+                )
+                snapshot_download(
+                    repo_id="tencent/Hunyuan3D-Part",
+                    allow_patterns="p3sam/*",
+                    local_dir=download_dir,
+                )
+            sonata_path = os.path.expanduser(
+                "~/.cache/huggingface/hub/sonata/sonata.pth"
+            )
+            if not os.path.exists(sonata_path):
+                logger.info(
+                    "Downloading Sonata weights from Hugging Face to {}. "
+                    "First-time use may take several minutes; please wait patiently.".format(
+                        sonata_path
+                    )
+                )
+            return model(
+                ckpt_path=ckpt_path,
+                threshold=self.cfg.p3sam.threshold,
+                post_process=self.cfg.p3sam.post_process,
+            )
+
+        raise ValueError("unsupported model '{}'".format(self.cfg.model_name))
+
+    def build_texture(
+        self,
+        mesh: trimesh.Trimesh,
+        face_colors: np.ndarray,
+        min_cell: int = 16,
+        max_tex: int = 8192,
+    ) -> trimesh.Trimesh:
+        if len(face_colors) != len(mesh.faces):
+            raise ValueError(
+                f"face_colors length must match mesh faces, got {len(face_colors)} and {len(mesh.faces)}"
+            )
+
+        from PIL import Image, ImageDraw
+
+        faces = np.asarray(mesh.faces, dtype=np.int64)
+        vertices = np.asarray(mesh.vertices, dtype=np.float64)
+        n_faces = len(faces)
+        grid = int(np.ceil(np.sqrt(n_faces)))
+        textured_size = 1 << int(np.ceil(np.log2(max(1, grid * min_cell))))
+        textured_size = min(max_tex, max(min_cell, textured_size))
+        cell = textured_size / grid
+
+        image = Image.new(
+            "RGBA", (textured_size, textured_size), (255, 255, 255, 255)
+        )
+        draw = ImageDraw.Draw(image)
+        uv = np.zeros((n_faces * 3, 2), dtype=np.float64)
+        local_uv = np.asarray(
+            [
+                [0.18, 0.18],
+                [0.82, 0.18],
+                [0.18, 0.82],
+            ],
+            dtype=np.float64,
+        )
+
+        for face_idx, color in enumerate(face_colors):
+            row, col = divmod(face_idx, grid)
+            rgba = tuple(int(channel) for channel in color)
+            x0 = int(np.floor(col * cell))
+            y0 = int(np.floor(row * cell))
+            x1 = int(np.ceil((col + 1) * cell))
+            y1 = int(np.ceil((row + 1) * cell))
+            draw.rectangle((x0, y0, x1, y1), fill=rgba)
+            uv[face_idx * 3 : face_idx * 3 + 3, 0] = (
+                col + local_uv[:, 0]
+            ) / grid
+            uv[face_idx * 3 : face_idx * 3 + 3, 1] = (
+                1.0 - (row + local_uv[:, 1]) / grid
+            )
+
+        textured_mesh = trimesh.Trimesh(
+            vertices=vertices[faces.reshape(-1)],
+            faces=np.arange(n_faces * 3, dtype=np.int64).reshape(n_faces, 3),
+            process=False,
+        )
+        material = trimesh.visual.texture.SimpleMaterial(
+            image=image,
+            diffuse=[255, 255, 255, 255],
+            name="part_segmentation",
+        )
+        textured_mesh.visual = trimesh.visual.texture.TextureVisuals(
+            uv=uv, material=material
+        )
+        return textured_mesh
+
+    def remap_to_palette(self, face_ids: np.ndarray) -> np.ndarray:
+        face_ids = np.asarray(face_ids)
+        mapped_ids = np.full(face_ids.shape, -1, dtype=np.int64)
+        unique_ids = np.unique(face_ids[face_ids >= 0])
+        if len(unique_ids) > len(PALETTE):
+            return None
+
+        for palette_idx, part_id in enumerate(unique_ids):
+            palette_id = PALETTE[palette_idx][0]
+            mapped_ids[face_ids == part_id] = palette_id
+        return mapped_ids
+
+    def export_seg_mesh(
+        self,
+        mesh,
+        face_ids: np.ndarray,
+        output_dir: str,
+        mesh_transform: dict | None = None,
+    ) -> None:
+        output_path = os.path.join(output_dir, "mesh_part_seg.glb")
+        palette_colors = {
+            palette_id: color for palette_id, color, _ in PALETTE
+        }
+
+        face_colors = np.zeros((len(face_ids), 4), dtype=np.uint8)
+        face_colors[:, 3] = 255
+        for idx, part_id in enumerate(face_ids):
+            if part_id < 0:
+                face_colors[idx, :3] = np.array([0, 0, 0], dtype=np.uint8)
+            else:
+                face_colors[idx, :3] = palette_colors[int(part_id)]
+
+        color_mesh = self.build_texture(mesh.copy(), face_colors)
+        color_mesh.metadata["face_ids"] = face_ids.tolist()
+        if mesh_transform is None:
+            save_mesh(
+                color_mesh, output_path, apply_origin=False, apply_scale=False
+            )
+        else:
+            save_mesh(
+                color_mesh,
+                output_path,
+                apply_origin=True,
+                apply_scale=True,
+                **mesh_transform,
+            )
+        return output_path
+
+    def count_parts(self, face_ids: np.ndarray) -> int:
+        valid_ids = np.asarray(face_ids)[np.asarray(face_ids) >= 0]
+        return int(len(np.unique(valid_ids)))
+
+    def postprocess_face_ids(
+        self,
+        mesh: trimesh.Trimesh,
+        face_ids: np.ndarray | None,
+    ) -> np.ndarray | None:
+        if face_ids is None or not self.cfg.face_id_postprocess.enabled:
+            return face_ids
+
+        merge_cfg = SmoothFaceLabelMergeConfig(
+            max_smooth_angle_deg=self.cfg.face_id_postprocess.max_smooth_angle_deg,
+            vertex_merge_tolerance=self.cfg.face_id_postprocess.vertex_merge_tolerance,
+            min_component_area_ratio=self.cfg.face_id_postprocess.min_component_area_ratio,
+            min_component_faces=self.cfg.face_id_postprocess.min_component_faces,
+            preserve_negative=self.cfg.face_id_postprocess.preserve_negative,
+        )
+        face_ids, stats = merge_smooth_face_labels(mesh, face_ids, merge_cfg)
+        if stats["faces_changed"] > 0:
+            logger.info(
+                "Part seg face_id postprocess changed "
+                f"{stats['faces_changed']} faces across "
+                f"{stats['components_changed']} smooth components."
+            )
+        if self.cfg.face_id_postprocess.fill_enclosed_components:
+            fill_cfg = EnclosedFaceLabelFillConfig(
+                max_component_area_ratio=(
+                    self.cfg.face_id_postprocess.max_enclosed_component_area_ratio
+                ),
+                max_component_faces=(
+                    self.cfg.face_id_postprocess.max_enclosed_component_faces
+                ),
+                min_enclosure_neighbor_ratio=(
+                    self.cfg.face_id_postprocess.min_enclosure_neighbor_ratio
+                ),
+                vertex_merge_tolerance=(
+                    self.cfg.face_id_postprocess.vertex_merge_tolerance
+                ),
+            )
+            face_ids, stats = fill_small_enclosed_face_labels(
+                mesh,
+                face_ids,
+                fill_cfg,
+            )
+            if stats["faces_changed"] > 0:
+                logger.info(
+                    "Part seg face_id postprocess filled "
+                    f"{stats['faces_changed']} enclosed faces across "
+                    f"{stats['components_filled']} components."
+                )
+        return face_ids
+
+    def update_urdf(
+        self,
+        urdf_path: str,
+        seg_mesh_path: str,
+        n_parts: int,
+        check_info: str,
+        mesh_transform: dict | None = None,
+    ) -> None:
+        urdf_dir = os.path.dirname(urdf_path)
+        seg_mesh_file = (
+            os.path.relpath(
+                seg_mesh_path,
+                urdf_dir,
+            )
+            if seg_mesh_path
+            else None
+        )
+        origin_attrs = {"xyz": "0 0 0", "rpy": "0 0 0"}
+        mesh_attrs = {"filename": seg_mesh_file, "scale": "1 1 1"}
+        if mesh_transform:
+            origin_attrs = {
+                "xyz": str(mesh_transform["origin_xyz"]),
+                "rpy": str(mesh_transform["origin_rpy"]),
+            }
+            mesh_attrs["scale"] = str(mesh_transform["scale"])
+
+        updates = {
+            "custom_data/affordance/part_count": n_parts,
+            "custom_data/affordance/visual_seg": {
+                "text": None,
+                "clear_attrs": True,
+                "clear_children": True,
+            },
+            "custom_data/affordance/visual_seg/origin": {
+                "attrs": origin_attrs,
+            },
+            "custom_data/affordance/visual_seg/geometry/mesh": {
+                "attrs": mesh_attrs,
+            },
+            "custom_data/quality/PartSegChecker": check_info,
+        }
+
+        URDFFile(urdf_path).write(updates)
+
+    def render_video(
+        self, mesh_path: str, output_dir: str, output_subdir: str = "renders"
+    ) -> list[str]:
+        return render_asset3d(
+            mesh_path,
+            output_root=output_dir,
+            distance=5.0,
+            num_images=128,
+            elevation=(45.0,),
+            gen_color_mp4=True,
+            output_subdir=output_subdir,
+            pbr_light_factor=1.5,
+            pbr_metallic=False,
+        )
+
+    def render_grid(
+        self,
+        mesh_path: str,
+        output_dir: str,
+        output_subdir: str = "renders",
+    ) -> tuple[str, list[str]]:
+        grid_path, view_paths = render_grid(
+            mesh_path,
+            output_dir,
+            output_subdir=output_subdir,
+            num_images=self.cfg.grid_num_images,
+            grid_rows=self.cfg.grid_rows,
+            grid_cols=self.cfg.grid_cols,
+            view_size=self.cfg.grid_image_size,
+        )
+        return grid_path, view_paths
+
+    def render_seg_result(
+        self,
+        mesh: trimesh.Trimesh,
+        face_ids: np.ndarray,
+        output_dir: str,
+        mesh_transform: dict | None = None,
+    ) -> tuple[str, str, str]:
+        seg_mesh_path = self.export_seg_mesh(
+            mesh,
+            face_ids,
+            output_dir,
+            mesh_transform,
+        )
+        mask_grid_path, _ = self.render_grid(
+            seg_mesh_path,
+            output_dir,
+            output_subdir="part_seg_renders",
+        )
+        color_names = collect_colors(face_ids)
+        logger.info(f"Part seg face colors: {color_names}")
+        return seg_mesh_path, mask_grid_path, color_names
+
+    def apply_merge_hints(
+        self,
+        face_ids: np.ndarray,
+        check_info: str,
+    ) -> tuple[np.ndarray, bool]:
+        merge_groups = self.parse_merge_groups(check_info)
+        if not merge_groups:
+            return face_ids, False
+
+        merged_face_ids = np.asarray(face_ids).copy()
+        color_to_id = {
+            color_name.lower(): palette_id
+            for palette_id, _, color_name in PALETTE
+        }
+        applied_groups = 0
+
+        for group in merge_groups:
+            color_names = group.get("colors", [])
+            palette_ids = []
+            for color_name in color_names:
+                palette_id = color_to_id.get(str(color_name).strip().lower())
+                if palette_id is not None and palette_id not in palette_ids:
+                    palette_ids.append(palette_id)
+
+            active_ids = [
+                palette_id
+                for palette_id in palette_ids
+                if np.any(merged_face_ids == palette_id)
+            ]
+            if len(active_ids) < 2:
+                continue
+
+            target_id = max(
+                active_ids,
+                key=lambda palette_id: int(
+                    np.count_nonzero(merged_face_ids == palette_id)
+                ),
+            )
+            changed_faces = 0
+            for palette_id in active_ids:
+                if palette_id == target_id:
+                    continue
+                source_mask = merged_face_ids == palette_id
+                changed_faces += int(np.count_nonzero(source_mask))
+                merged_face_ids[source_mask] = target_id
+
+            applied_groups += 1
+            logger.info(
+                "Applied PartSegChecker merge group for %s: colors=%s, "
+                "target_palette_id=%s, faces_changed=%s",
+                group.get("target_part", "unknown part"),
+                color_names,
+                target_id,
+                changed_faces,
+            )
+
+        return merged_face_ids, applied_groups > 0
+
+    def parse_merge_groups(self, check_info: str) -> list[dict]:
+        if not isinstance(check_info, str):
+            return []
+
+        json_start = check_info.find("{")
+        json_end = check_info.rfind("}")
+        if json_start < 0 or json_end <= json_start:
+            return []
+
+        try:
+            parsed = json_repair.loads(check_info[json_start : json_end + 1])
+        except Exception as exc:
+            logger.warning(
+                f"Failed to parse PartSegChecker merge hints: {exc}"
+            )
+            return []
+
+        merge_groups = parsed.get("merge_groups", [])
+        if not isinstance(merge_groups, list):
+            return []
+
+        valid_groups = []
+        for group in merge_groups:
+            if not isinstance(group, dict):
+                continue
+            colors = group.get("colors", [])
+            if not isinstance(colors, list) or len(colors) < 2:
+                continue
+            valid_groups.append(group)
+        return valid_groups
+
+    def infer_seg(self, mesh: trimesh.Trimesh, output_dir: str) -> bool:
+        unit_mesh = normalize_mesh(mesh)
+        if self.cfg.model_name == "p3sam":
+            set_seed(self.cfg.p3sam.seed)
+            os.makedirs(output_dir, exist_ok=True)
+            _, face_ids, _ = self.pipeline.predict_aabb(
+                unit_mesh,
+                save_path=output_dir,
+                **asdict(self.cfg.p3sam),
+            )
+        else:
+            raise ValueError(
+                "unsupported model '{}'".format(self.cfg.model_name)
+            )
+        face_ids = self.remap_to_palette(face_ids)
+        return face_ids
+
+    def process(self, urdf_path: str, output_dir: str) -> bool:
+        try:
+            return self._process_impl(urdf_path, output_dir)
+        except Exception as exc:
+            logger.error(
+                "Part segmentation failed for URDF {}: {}".format(
+                    urdf_path,
+                    exc,
+                )
+            )
+            return False
+
+    def _process_impl(self, urdf_path: str, output_dir: str) -> bool:
+        seg_mesh_path = os.path.join(output_dir, "mesh_part_seg.glb")
+        mask_grid_path = None
+        if not self.cfg.overwrite and os.path.exists(seg_mesh_path):
+            logger.info(
+                f"Skip existing part segmentation result: {seg_mesh_path}"
+            )
+            return True
+
+        urdf = URDFFile(urdf_path)
+        category = urdf.get_category()
+        mesh_path = urdf.get_mesh_path(self.cfg.mesh_type)
+        mesh_transform = {}
+        if urdf_path is not None:
+            mesh_transform = urdf.get_mesh_transform(self.cfg.mesh_type)
+        mesh = load_mesh(
+            mesh_path,
+            apply_origin=True,
+            apply_scale=True,
+            **mesh_transform,
+        )
+        rgb_grid_path, _ = self.render_grid(mesh_path, output_dir)
+
+        face_ids = self.infer_seg(mesh, output_dir)
+        face_ids = self.postprocess_face_ids(mesh, face_ids)
+
+        if face_ids is None:
+            logger.error("Part seg failed due to exceeding palette size. ")
+            success, check_info = (
+                False,
+                f"NO: part number exceeds palette size {len(PALETTE)}",
+            )
+            seg_mesh_path = None
+        else:
+            seg_mesh_path, mask_grid_path, color_names = (
+                self.render_seg_result(
+                    mesh,
+                    face_ids,
+                    output_dir,
+                    mesh_transform if urdf_path is not None else None,
+                )
+            )
+            success, check_info = self.seg_checker(
+                category,
+                color_names,
+                rgb_grid_path,
+                mask_grid_path,
+            )
+            self.retry_count = 0
+            while not success and self.retry_count < self.cfg.merge_retries:
+                merged_face_ids, merge_applied = self.apply_merge_hints(
+                    face_ids,
+                    check_info,
+                )
+                if merge_applied:
+                    face_ids = merged_face_ids
+                    # 备份mask_grid_path
+                    mask_grid_path_bak = mask_grid_path.replace(
+                        "affordance_grid",
+                        f"affordance_grid_{self.retry_count}",
+                    )
+                    if os.path.exists(mask_grid_path):
+                        shutil.copy2(mask_grid_path, mask_grid_path_bak)
+                    seg_mesh_path, mask_grid_path, color_names = (
+                        self.render_seg_result(
+                            mesh,
+                            face_ids,
+                            output_dir,
+                            mesh_transform if urdf_path is not None else None,
+                        )
+                    )
+                    success, check_info = self.seg_checker(
+                        category,
+                        color_names,
+                        rgb_grid_path,
+                        mask_grid_path,
+                    )
+                self.retry_count += 1
+
+        if success:
+            logger.info(
+                f"Part seg successful for {mesh_path} with {self.count_parts(face_ids)} parts. "
+            )
+        else:
+            logger.error(
+                f"Part seg failed for {mesh_path}. Checker info: {check_info}"
+            )
+        self.update_urdf(
+            urdf_path,
+            seg_mesh_path,
+            self.count_parts(face_ids) if face_ids is not None else 0,
+            check_info,
+            mesh_transform if urdf_path is not None else None,
+        )
+        if self.cfg.debug_mode:
+            self.render_video(mesh_path, output_dir)
+            if seg_mesh_path:
+                self.render_video(
+                    seg_mesh_path, output_dir, output_subdir="part_seg_renders"
+                )
+        else:
+            grid_dirs = {os.path.dirname(rgb_grid_path)}
+            if mask_grid_path:
+                grid_dirs.add(os.path.dirname(mask_grid_path))
+            for grid_dir in grid_dirs:
+                if grid_dir:
+                    shutil.rmtree(grid_dir, ignore_errors=True)
+        return success
+
+
+def run_part_seg(cfg: PartSegConfig) -> None:
+    segmenter = PartSegmenter(cfg)
+    for urdf_path, output_dir in zip(cfg.urdf_paths, cfg.output_dirs):
+        segmenter.process(urdf_path, output_dir)
+
+
+def entrypoint(*args, **kwargs) -> None:
+    cfg = tyro.cli(PartSegConfig)
+    run_part_seg(cfg)
+
+
+if __name__ == "__main__":
+    entrypoint()

embodied_gen/scripts/affordance_annot/partsemantics_annot.py

@@ -0,0 +1,438 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+import json
+import os
+import shutil
+from dataclasses import dataclass, field
+from typing import Literal
+
+import json_repair
+import tyro
+from embodied_gen.utils.general import filter_warnings
+
+filter_warnings()
+
+
+from embodied_gen.utils.gpt_clients import GPT_CLIENT
+from embodied_gen.utils.io_utils import URDFFile, load_mesh
+from embodied_gen.utils.log import logger
+from embodied_gen.utils.vis_utils import (
+    PALETTE,
+    collect_colors,
+    render_grid,
+    visualize_partsemantics,
+)
+from embodied_gen.validators.quality_checkers import PartSemanticsChecker
+
+__all__ = [
+    "PartSemanticsAnnotConfig",
+    "PartSemanticsAnnotator",
+    "run_partsemantics_annot",
+    "entrypoint",
+]
+
+
+@dataclass
+class PartSemanticsAnnotConfig:
+    urdf_paths: list[str] = field(default_factory=list)
+    output_dirs: list[str] = field(default_factory=list)
+    mesh_type: Literal["visual", "collision"] = "visual"
+    max_tokens: int = 10240
+    max_repairs: int = 2
+    visualize: bool = False
+    vis_fps: int = 12
+    vis_frames_per_part: int = 36
+    vis_view_size: int = 1080
+    grid_num_images: int = 6
+    grid_rows: int = 2
+    grid_cols: int = 3
+    grid_image_size: int = 512
+    debug_mode: bool = False
+    overwrite: bool = True
+
+
+class PartSemanticsAnnotator:
+    def __init__(self, cfg: PartSemanticsAnnotConfig):
+        self.validate_config(cfg)
+        self.cfg = cfg
+        self.gpt_client = GPT_CLIENT
+        self.checker = PartSemanticsChecker(GPT_CLIENT)
+        self.system_prompt = (
+            "You are an expert annotator for 3D object affordances. You will receive two aligned multi-view grid images of the same object: "
+            "the first grid is the RGB render, and the second grid is a colored part mask where each color denotes one segmented part. "
+            "You will also receive the object category and the list of colors that appear in the mask.\n"
+            "Your task is to infer affordance information for each meaningful colored part.\n"
+            "For every annotated part, provide:\n"
+            "1. A concise self-contained part name. Prefer the natural standalone part name when it is clear, e.g. \"lampshade\" or \"light bulb\"; add the object category only when the name would otherwise be ambiguous, e.g. \"stem of apple\" rather than \"stem\".\n"
+            "2. Whether the part is realistically useful for robotic grasping with a gripper.\n"
+            "3. If it is graspable, concrete robotic grasp scenarios with confidence scores.\n"
+            "4. Functional labels: concrete short phrases describing what the part can be used for and what functional role it provides.\n"
+            "5. Semantic description: a concise natural-language description of the part, including its role, RGB appearance color, material type, surface finish, tactile texture, shape, relative size/position, and any visible markings when inferable.\n"
+            "Use the RGB grid to understand physical appearance and the mask grid to map parts to colors. "
+            "The mask color is only an ID for the segmented part; do not describe mask colors as physical object colors. "
+            "Only use mask colors from the provided color list. Do not invent mask colors. "
+            "If a colored region has no clear affordance, still include it when it is a distinct physical part, with conservative functional labels. "
+            "Return only valid JSON. Do not wrap the JSON in Markdown or code fences."
+        )
+        self.user_prompt = (
+            "Object category: {category}\n"
+            "Mask color list: {color_names}\n"
+            "Image inputs:\n"
+            "- Image 1: RGB multi-view grid of the object.\n"
+            "- Image 2: part mask multi-view grid aligned with Image 1. Different colors indicate different segmented parts.\n\n"
+            "Annotate the affordance of the visible colored parts. Match each part to exactly one color from the color list.\n"
+            "For each part, include these fields:\n"
+            "- \"part_name\": concise semantic name of the part. Use natural standalone names when they are already clear, such as \"lampshade\", \"light bulb\", \"keyboard\", \"wheel\", or \"mug handle\". Use \"part of object\" only when the standalone part name is ambiguous or too generic, such as \"stem of apple\", \"blade of knife\", or \"base of lamp\".\n"
+            "- \"mask_color\": one mask color from the provided color list. This is the segmentation color, not the physical RGB color.\n"
+            "- \"graspable\": true or false.\n"
+            "- \"grasp_scenarios\": list of dicts, each with \"scenario\" and \"confidence\"; each \"confidence\" belongs to that same scenario and is a float from 0.0 to 1.0 estimating how likely a robot gripper would choose this part for that scenario. Use accurate, distinguishable confidences when multiple parts share the same scenario. Do not give high confidence to theoretically possible but uncommon grasps. Use an empty list if graspable is false.\n"
+            "- \"functional_labels\": list of 2 to 6 concrete short phrases describing what this part can be used to do and what functional role it provides.\n"
+            "- \"semantic_description\": one concise but complete sentence describing the part's RGB appearance color, material type, surface finish, tactile texture, shape, relative size, location, and any visible markings when inferable. Do not mention the mask color unless it is also the real RGB appearance.\n\n"
+            "Guidelines:\n"
+            "- Use the RGB grid for appearance and the mask grid for color-to-part mapping.\n"
+            "- Treat grasping as robotic gripper grasping, not human hand grasping.\n"
+            "- A part is graspable only if it is a plausible and useful place for a robot gripper to hold, pick up, stabilize, pull, or manipulate the object.\n"
+            "- If a part is only theoretically graspable but normally poor or uncommon for grasping, keep \"graspable\" True only when there is a realistic scenario, and assign low confidence. For example, an apple stem may be graspable in a delicate stem-picking scenario but is low confidence for lifting the apple.\n"
+            "- If a part is functional but not graspable, set \"graspable\" to False and still describe its function.\n"
+            "- Functional labels should describe what the part can be used for or what function it enables, such as \"support\", \"contain\", \"cut\", \"press\", \"cover\", \"connect\", \"stabilize\", or \"indicate orientation\".\n"
+            "- Semantic descriptions should cover visible material and texture cues when inferable: material type such as metal, plastic, ceramic, rubber, fabric, wood, glass, or food skin; surface finish such as glossy, matte, translucent, reflective, or dull; tactile texture such as soft, hard, smooth, rough, fine-grained, pebbled, ribbed, woven, or granular; inherent patterns or special markings such as wood grain, fabric weave, seams, engraved text, logos, printed icons, labels, or scratches.\n"
+            "- Keep semantic descriptions concise, usually one sentence under 35 words, and do not invent material or markings that are not visually supported.\n"
+            "- Do not assign affordances to background regions.\n"
+            "- Do not include colors that are not in the color list.\n\n"
+            "Output format: Return exactly one JSON object with this schema:\n"
+            "{{\"affordances\": [{{\"part_name\": \"mug handle\", \"mask_color\": \"Red\", \"graspable\": true, \"grasp_scenarios\": [{{\"scenario\": \"grasp the handle to lift the mug\", \"confidence\": 0.92}}, {{\"scenario\": \"hold the handle to stabilize the mug while pouring\", \"confidence\": 0.84}}], \"functional_labels\": [\"provide a side grip\", \"lift the mug without touching the body\", \"stabilize the mug while pouring\"], \"semantic_description\": \"Curved glossy ceramic handle with a hard smooth surface, matching the mug body and sized for side gripping.\"}}, "
+            "{{\"part_name\": \"stem of apple\", \"mask_color\": \"Green\", \"graspable\": true, \"grasp_scenarios\": [{{\"scenario\": \"delicately grasp the stem to orient the apple\", \"confidence\": 0.28}}, {{\"scenario\": \"lift the apple by the stem\", \"confidence\": 0.12}}], \"functional_labels\": [\"connect to branch\", \"indicate top orientation\"], \"semantic_description\": \"Small thin brown woody stem with a hard rough fibrous texture protruding from the apple top.\"}}, "
+            "{{\"part_name\": \"body of apple\", \"mask_color\": \"Blue\", \"graspable\": true, \"grasp_scenarios\": [{{\"scenario\": \"grasp the apple body to pick it up\", \"confidence\": 0.88}}], \"functional_labels\": [\"contain edible flesh\", \"support biting\", \"main grasp surface\"], \"semantic_description\": \"Large rounded red apple body with glossy smooth food skin, firm texture, and subtle natural color speckles.\"}}]}}\n"
+            "If the target object cannot be identified, output exactly: {{\"affordances\": []}}"
+        )
+
+    def validate_config(self, cfg: PartSemanticsAnnotConfig) -> None:
+        if not cfg.urdf_paths:
+            raise ValueError("urdf_paths must be provided.")
+
+        if len(cfg.output_dirs) == 0:
+            cfg.output_dirs = [
+                os.path.join(os.path.dirname(path), "affordance")
+                for path in cfg.urdf_paths
+            ]
+
+        if len(cfg.urdf_paths) != len(cfg.output_dirs):
+            raise ValueError(
+                "urdf_paths and output_dirs must have the same length, "
+                f"got {len(cfg.urdf_paths)} and {len(cfg.output_dirs)}."
+            )
+
+        if cfg.grid_num_images != cfg.grid_rows * cfg.grid_cols:
+            raise ValueError(
+                "grid_num_images must equal grid_rows * grid_cols, "
+                f"got {cfg.grid_num_images} and "
+                f"{cfg.grid_rows} * {cfg.grid_cols}."
+            )
+
+    def check_requires(self, urdf_path: str) -> tuple[str, str]:
+        urdf = URDFFile(urdf_path)
+        seg_mesh_path = urdf.get_mesh_part_seg_path()
+        if not os.path.exists(seg_mesh_path):
+            raise FileNotFoundError(
+                f"Part segmentation result not found. Run part segmentation before "
+                f"partsemantics annotation. Missing: {seg_mesh_path}"
+            )
+        return seg_mesh_path
+
+    def parse_response(self, response: str) -> dict:
+        answer = str(response).strip()
+        parsed = json.loads(answer)
+        return parsed
+
+    def add_palette_ids(self, payload: dict) -> dict:
+        color_to_id = {
+            color_name: palette_id for palette_id, _, color_name in PALETTE
+        }
+        for partsemantics in payload.get("affordances", []):
+            if isinstance(partsemantics, dict):
+                partsemantics["id"] = color_to_id.get(
+                    partsemantics.get("mask_color")
+                )
+        return payload
+
+    def check_response(
+        self, response: str, rgb_grid_path: str, mask_grid_path: str
+    ) -> dict:
+        passed, message = self.checker(
+            response,
+            rgb_grid_path,
+            mask_grid_path,
+        )
+        check_info = {
+            "success": passed,
+            "message": message,
+        }
+        if not passed:
+            feedback = self._parse_checker_message(message)
+            modified_response = (
+                feedback.get("modified_response")
+                if isinstance(feedback, dict)
+                else None
+            )
+            if isinstance(modified_response, str):
+                check_info["modified_response"] = modified_response.strip()
+            elif modified_response is not None:
+                check_info["modified_response"] = json.dumps(
+                    modified_response,
+                    ensure_ascii=False,
+                )
+        return check_info
+
+    def _parse_checker_message(self, checker_message: str) -> dict | None:
+        if not isinstance(checker_message, str):
+            return None
+
+        answer = checker_message.strip()
+        try:
+            feedback = json_repair.loads(answer)
+        except (json.JSONDecodeError, ValueError, TypeError):
+            json_start = answer.find("{")
+            json_end = answer.rfind("}")
+            if json_start < 0 or json_end <= json_start:
+                return None
+            try:
+                feedback = json_repair.loads(answer[json_start : json_end + 1])
+            except (json.JSONDecodeError, ValueError, TypeError):
+                return None
+
+        return feedback if isinstance(feedback, dict) else None
+
+    def _quality_check_for_save(
+        self, quality_check: dict | None
+    ) -> dict | None:
+        if quality_check is None:
+            return None
+        if not isinstance(quality_check, dict):
+            return {"success": None, "message": str(quality_check)}
+
+        message = quality_check.get("message", "")
+        feedback = self._parse_checker_message(message)
+        if isinstance(feedback, dict) and feedback.get("reason") is not None:
+            message = str(feedback["reason"]).strip()
+        elif isinstance(message, str) and message.strip().startswith("NO:"):
+            message = message.strip()[3:].strip()
+
+        return {
+            "success": quality_check.get("success"),
+            "message": message,
+        }
+
+    def save_annotation(
+        self, response: str, output_dir: str, quality_check: dict | None = None
+    ) -> str:
+        annotation_path = os.path.join(output_dir, "affordance_annot.json")
+        if self.cfg.debug_mode:
+            raw_output_path = os.path.join(
+                output_dir, "affordance_annot_raw.txt"
+            )
+            with open(raw_output_path, "w", encoding="utf-8") as f:
+                f.write(str(response))
+
+        try:
+            payload = self.parse_response(response)
+            payload = self.add_palette_ids(payload)
+        except (json.JSONDecodeError, ValueError, TypeError) as exc:
+            payload = {
+                "status": "parse failed",
+                "affordances": [],
+                "parse_error": str(exc),
+            }
+
+        saved_quality_check = self._quality_check_for_save(quality_check)
+        if saved_quality_check is not None:
+            payload["quality_check"] = saved_quality_check
+
+        with open(annotation_path, "w", encoding="utf-8") as f:
+            json.dump(payload, f, ensure_ascii=False, indent=2)
+        return annotation_path
+
+    def update_urdf(self, urdf_path: str, annotation_path: str) -> None:
+        if urdf_path is None:
+            return
+
+        URDFFile(urdf_path).write(
+            {
+                "custom_data/affordance/affordance_annot": os.path.relpath(
+                    annotation_path,
+                    os.path.dirname(urdf_path),
+                ),
+            }
+        )
+
+    def render_grid(
+        self,
+        mesh_path: str,
+        output_dir: str,
+        output_subdir: str = "renders",
+    ) -> tuple[str, list[str]]:
+        grid_path, view_paths = render_grid(
+            mesh_path,
+            output_dir,
+            output_subdir=output_subdir,
+            num_images=self.cfg.grid_num_images,
+            grid_rows=self.cfg.grid_rows,
+            grid_cols=self.cfg.grid_cols,
+            view_size=self.cfg.grid_image_size,
+        )
+        return grid_path, view_paths
+
+    def _process_once(
+        self,
+        rgb_grid_path: str,
+        mask_grid_path: str,
+        color_names: str,
+        category: str,
+    ) -> tuple[bool, dict, str]:
+        response = self.gpt_client.query(
+            text_prompt=self.user_prompt.format(
+                category=category,
+                color_names=color_names,
+            ),
+            image_base64=[rgb_grid_path, mask_grid_path],
+            system_role=self.system_prompt,
+            params={"max_tokens": self.cfg.max_tokens},
+        )
+        check_info = {"success": False, "message": "NO: checker was not run"}
+        success = False
+        max_checks = self.cfg.max_repairs + 1
+        for check_idx in range(max_checks):
+            logger.info(
+                "PartSemantics quality check: attempt "
+                f"{check_idx + 1}/{max_checks}"
+            )
+            check_info = self.check_response(
+                response,
+                rgb_grid_path,
+                mask_grid_path,
+            )
+            success = check_info.get("success")
+            if success:
+                return success, check_info, response
+
+            if check_idx == max_checks - 1:
+                break
+
+            modified_response = check_info.get("modified_response")
+            if modified_response is None:
+                break
+
+            response = modified_response
+            logger.warning(
+                "PartSemantics checker failed; retrying with modified_response. "
+            )
+
+        return success, check_info, response
+
+    def process(self, urdf_path: str, output_dir: str) -> bool:
+        try:
+            return self._process_impl(urdf_path, output_dir)
+        except Exception as exc:
+            logger.error(
+                "PartSemantics annotation failed for URDF {}: {}".format(
+                    urdf_path,
+                    exc,
+                )
+            )
+            return False
+
+    def _process_impl(self, urdf_path: str, output_dir: str) -> bool:
+        annotation_path = os.path.join(output_dir, "affordance_annot.json")
+        if not self.cfg.overwrite and os.path.exists(annotation_path):
+            logger.info(
+                f"Skip existing PartSemantics annotation: {annotation_path}"
+            )
+            return True
+
+        urdf = URDFFile(urdf_path)
+        mesh_path = urdf.get_mesh_path(self.cfg.mesh_type)
+        seg_mesh_path = self.check_requires(urdf_path)
+
+        logger.info("Processing PartSemantics annotation...")
+        rgb_grid_path, _ = self.render_grid(mesh_path, output_dir)
+        mask_grid_path, _ = self.render_grid(
+            seg_mesh_path, output_dir, output_subdir="part_seg_renders"
+        )
+
+        _, face_ids = load_mesh(
+            seg_mesh_path, apply_origin=False, apply_scale=False
+        )
+        color_names = collect_colors(face_ids)
+        logger.info(f"Mask colors: {color_names}")
+
+        category = urdf.get_category()
+        success, check_info, response = self._process_once(
+            rgb_grid_path,
+            mask_grid_path,
+            color_names,
+            category,
+        )
+        if success:
+            logger.info(
+                "PartSemantics annotation passed quality check."
+                f"{check_info.get('message')}"
+            )
+        else:
+            logger.error(
+                "PartSemantics annotation failed quality check after "
+                f"{self.cfg.max_repairs} repair attempts;\nsaving last result. "
+            )
+
+        annotation_path = self.save_annotation(
+            response, output_dir, check_info
+        )
+        self.update_urdf(urdf_path, annotation_path)
+        if self.cfg.visualize:
+            visualize_partsemantics(
+                mesh_path,
+                seg_mesh_path,
+                annotation_path,
+                fps=self.cfg.vis_fps,
+                frames_per_part=self.cfg.vis_frames_per_part,
+                view_size=self.cfg.vis_view_size,
+            )
+
+        if not self.cfg.debug_mode:
+            for grid_dir in {
+                os.path.dirname(rgb_grid_path),
+                os.path.dirname(mask_grid_path),
+            }:
+                if grid_dir:
+                    shutil.rmtree(grid_dir, ignore_errors=True)
+
+        return success
+
+
+def run_partsemantics_annot(cfg: PartSemanticsAnnotConfig) -> None:
+    annotator = PartSemanticsAnnotator(cfg)
+    for urdf_path, output_dir in zip(
+        annotator.cfg.urdf_paths, annotator.cfg.output_dirs
+    ):
+        annotator.process(urdf_path, output_dir)
+
+
+def entrypoint() -> None:
+    cfg = tyro.cli(PartSemanticsAnnotConfig)
+    run_partsemantics_annot(cfg)
+
+
+if __name__ == "__main__":
+    entrypoint()

embodied_gen/scripts/compose_layout.py

@@ -21,7 +21,6 @@ from dataclasses import dataclass
 
 import tyro
 from embodied_gen.scripts.simulate_sapien import entrypoint as sim_cli
-from embodied_gen.utils.enum import LayoutInfo
 from embodied_gen.utils.geometry import bfs_placement, compose_mesh_scene
 from embodied_gen.utils.log import logger
 

embodied_gen/scripts/deformable_sim/genesis_cloth_converter.py

@@ -0,0 +1,282 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+
+import json
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import trimesh
+import tyro
+from scipy.spatial.transform import Rotation
+
+
+@dataclass
+class GenesisClothConvertConfig:
+    input_path: str
+    output_dir: str
+    scale: float | None = None
+    overwrite: bool = False
+
+
+DEFAULT_CLOTH_MATERIAL: dict[str, float | bool] = {
+    "rho": 0.2,
+    "static_friction": 0.5,
+    "kinetic_friction": 0.4,
+    "stretch_compliance": 1e-9,
+    "bending_compliance": 1e-6,
+    "stretch_relaxation": 0.5,
+    "bending_relaxation": 0.2,
+    "air_resistance": 1e-3,
+    "particle_size": 0.02,
+    "self_collision": True,
+}
+
+
+def convert_cloth_to_genesis(
+    input_path: str,
+    output_dir: str,
+    scale: float | None = None,
+    overwrite: bool = False,
+) -> str:
+    """Convert one URDF visual mesh to a Genesis cloth asset package.
+
+    Args:
+        input_path: URDF path containing a visual mesh reference.
+        output_dir: Directory where the ``genesis`` package is written.
+        scale: Optional uniform scale recorded in the manifest and used by the
+            simulator. The exported mesh itself is not rescaled.
+        overwrite: Whether to replace an existing Genesis package.
+
+    Returns:
+        Path to the generated manifest JSON file.
+    """
+
+    urdf_path = Path(input_path)
+    if not urdf_path.exists():
+        raise FileNotFoundError(f"Input URDF does not exist: {urdf_path}")
+    if urdf_path.suffix.lower() != ".urdf":
+        raise ValueError(f"input_path must point to a URDF file: {urdf_path}")
+
+    source_mesh, urdf_transform = _resolve_urdf_visual_mesh(urdf_path)
+    package_root = Path(output_dir)
+    genesis_dir = package_root / "genesis"
+    if genesis_dir.exists() and not overwrite:
+        raise FileExistsError(
+            f"Genesis cloth package already exists: {genesis_dir}. "
+            "Pass overwrite=True to replace it."
+        )
+    genesis_dir.mkdir(parents=True, exist_ok=True)
+
+    mesh = _load_mesh(source_mesh)
+    mesh, warnings = _clean_mesh(mesh)
+    mesh.apply_transform(urdf_transform["matrix"])
+    warnings.append("applied URDF visual origin transform to cloth mesh")
+
+    cloth_mesh_path = genesis_dir / "cloth_mesh.obj"
+    material_path = genesis_dir / "cloth_material.json"
+    manifest_path = genesis_dir / "manifest.json"
+
+    mesh.export(cloth_mesh_path)
+    _write_json(material_path, DEFAULT_CLOTH_MATERIAL)
+
+    mesh_stats = _mesh_stats(mesh)
+    warnings.extend(_mesh_warnings(mesh_stats))
+    manifest = {
+        "asset_name": source_mesh.stem,
+        "source_urdf": _relative_path(urdf_path, package_root),
+        "source_mesh": _relative_path(source_mesh, package_root),
+        "cloth_mesh": _relative_path(cloth_mesh_path, package_root),
+        "material": _relative_path(material_path, package_root),
+        "scale": 1.0 if scale is None else float(scale),
+        "up_axis": "z",
+        "urdf_visual_origin": urdf_transform["origin"],
+        "mesh_stats": mesh_stats,
+        "warnings": warnings,
+    }
+    _write_json(manifest_path, manifest)
+    return str(manifest_path)
+
+
+def entrypoint(**kwargs) -> str:
+    if kwargs:
+        cfg = GenesisClothConvertConfig(**kwargs)
+    else:
+        cfg = tyro.cli(GenesisClothConvertConfig)
+
+    manifest_path = convert_cloth_to_genesis(
+        input_path=cfg.input_path,
+        output_dir=cfg.output_dir,
+        scale=cfg.scale,
+        overwrite=cfg.overwrite,
+    )
+    print(manifest_path)
+    return manifest_path
+
+
+def _resolve_urdf_visual_mesh(urdf_path: Path) -> tuple[Path, dict[str, Any]]:
+    root = ET.parse(urdf_path).getroot()
+    for visual_tag in root.findall(".//visual"):
+        mesh_tag = visual_tag.find("geometry/mesh")
+        if mesh_tag is None:
+            continue
+        filename = mesh_tag.get("filename")
+        if not filename:
+            raise ValueError(
+                f"Visual mesh in URDF has no filename: {urdf_path}"
+            )
+
+        source_mesh = Path(filename)
+        if not source_mesh.is_absolute():
+            source_mesh = urdf_path.parent / source_mesh
+        if not source_mesh.exists():
+            raise FileNotFoundError(
+                f"Visual mesh does not exist: {source_mesh}"
+            )
+
+        origin_tag = visual_tag.find("origin")
+        xyz, rpy = _parse_origin(origin_tag)
+        matrix = np.eye(4, dtype=float)
+        matrix[:3, :3] = Rotation.from_euler("xyz", rpy).as_matrix()
+        matrix[:3, 3] = xyz
+        return source_mesh, {
+            "matrix": matrix,
+            "origin": {
+                "urdf": urdf_path.name,
+                "xyz": [round(float(value), 6) for value in xyz],
+                "rpy": [round(float(value), 6) for value in rpy],
+            },
+        }
+
+    raise ValueError(f"No visual mesh found in URDF: {urdf_path}")
+
+
+def _parse_origin(
+    origin_tag: ET.Element | None,
+) -> tuple[np.ndarray, np.ndarray]:
+    if origin_tag is None:
+        return np.zeros(3, dtype=float), np.zeros(3, dtype=float)
+    xyz = np.fromiter(
+        (float(value) for value in origin_tag.get("xyz", "0 0 0").split()),
+        dtype=float,
+        count=3,
+    )
+    rpy = np.fromiter(
+        (float(value) for value in origin_tag.get("rpy", "0 0 0").split()),
+        dtype=float,
+        count=3,
+    )
+    return xyz, rpy
+
+
+def _load_mesh(source_mesh: Path) -> trimesh.Trimesh:
+    loaded = trimesh.load(source_mesh, force="mesh")
+    if isinstance(loaded, trimesh.Scene):
+        meshes = [
+            geometry
+            for geometry in loaded.geometry.values()
+            if isinstance(geometry, trimesh.Trimesh)
+        ]
+        if not meshes:
+            raise ValueError(f"No mesh geometry found in scene: {source_mesh}")
+        loaded = trimesh.util.concatenate(meshes)
+    if not isinstance(loaded, trimesh.Trimesh):
+        raise TypeError(
+            f"Expected a Trimesh from {source_mesh}, got {type(loaded)}"
+        )
+    if loaded.vertices.size == 0 or loaded.faces.size == 0:
+        raise ValueError(f"Source mesh is empty: {source_mesh}")
+    return loaded
+
+
+def _clean_mesh(mesh: trimesh.Trimesh) -> tuple[trimesh.Trimesh, list[str]]:
+    mesh = mesh.copy()
+    warnings: list[str] = []
+    original_vertices = len(mesh.vertices)
+    original_faces = len(mesh.faces)
+
+    if not mesh.is_watertight:
+        warnings.append(
+            "mesh is not watertight; this is usually acceptable for cloth"
+        )
+
+    mesh.remove_unreferenced_vertices()
+    if hasattr(mesh, "nondegenerate_faces"):
+        mesh.update_faces(mesh.nondegenerate_faces())
+    else:
+        mesh.remove_degenerate_faces()
+    mesh.merge_vertices()
+    mesh.remove_unreferenced_vertices()
+
+    if (
+        len(mesh.vertices) != original_vertices
+        or len(mesh.faces) != original_faces
+    ):
+        warnings.append(
+            "mesh cleanup changed topology from "
+            f"{original_vertices} vertices/{original_faces} faces to "
+            f"{len(mesh.vertices)} vertices/{len(mesh.faces)} faces"
+        )
+    if len(mesh.vertices) == 0 or len(mesh.faces) == 0:
+        raise ValueError("Mesh cleanup produced an empty cloth mesh")
+    return mesh, warnings
+
+
+def _mesh_stats(mesh: trimesh.Trimesh) -> dict[str, Any]:
+    bbox_min, bbox_max = mesh.bounds
+    extents = np.asarray(mesh.extents, dtype=float)
+    return {
+        "vertices": int(len(mesh.vertices)),
+        "faces": int(len(mesh.faces)),
+        "bbox_min": bbox_min.astype(float).round(6).tolist(),
+        "bbox_max": bbox_max.astype(float).round(6).tolist(),
+        "extents": extents.round(6).tolist(),
+        "watertight": bool(mesh.is_watertight),
+    }
+
+
+def _mesh_warnings(mesh_stats: dict[str, Any]) -> list[str]:
+    warnings: list[str] = []
+    if mesh_stats["faces"] > 20000:
+        warnings.append(
+            "mesh has more than 20000 faces; Genesis cloth simulation may be slow"
+        )
+    extents = np.asarray(mesh_stats["extents"], dtype=float)
+    if np.any(extents <= 1e-6):
+        warnings.append("mesh has a near-zero bounding-box extent")
+    if float(extents.max()) > 10.0:
+        warnings.append(
+            "mesh bounding box is larger than 10 meters; check scale"
+        )
+    return warnings
+
+
+def _relative_path(path: Path, root: Path) -> str:
+    try:
+        return path.relative_to(root).as_posix()
+    except ValueError:
+        return path.as_posix()
+
+
+def _write_json(path: Path, data: dict[str, Any]) -> None:
+    path.write_text(json.dumps(data, indent=2) + "\n")
+
+
+if __name__ == "__main__":
+    entrypoint()

embodied_gen/scripts/deformable_sim/render_mesh_displacement_heatmap.py

@@ -0,0 +1,551 @@
+import argparse
+import json
+import math
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--video-path", required=True)
+    parser.add_argument("--mesh-path", required=True)
+    parser.add_argument("--particle-positions", required=True)
+    parser.add_argument("--sim-config", required=True)
+    parser.add_argument("--output-image", required=True)
+    parser.add_argument("--output-video", required=True)
+    parser.add_argument("--tmp-video", required=True)
+    args = parser.parse_args()
+
+    render_mesh_displacement_heatmap(
+        video_path=Path(args.video_path),
+        mesh_path=Path(args.mesh_path),
+        particle_positions_path=Path(args.particle_positions),
+        sim_config_path=Path(args.sim_config),
+        output_image_path=Path(args.output_image),
+        output_video_path=Path(args.output_video),
+        tmp_video_path=Path(args.tmp_video),
+    )
+
+
+def render_mesh_displacement_heatmap(
+    video_path: Path,
+    mesh_path: Path,
+    particle_positions_path: Path,
+    sim_config_path: Path,
+    output_image_path: Path,
+    output_video_path: Path,
+    tmp_video_path: Path,
+) -> None:
+    data = np.load(particle_positions_path)
+    positions = data["positions"].astype(np.float32)
+    rest_positions = data["rest_positions"].astype(np.float32)
+    config = json.loads(sim_config_path.read_text())
+
+    if positions.ndim != 3 or positions.shape[2] != 3:
+        raise ValueError(
+            f"Invalid particle positions shape: {positions.shape}"
+        )
+    if rest_positions.shape != positions.shape[1:]:
+        raise ValueError(
+            "rest_positions must have shape "
+            f"{positions.shape[1:]}, got {rest_positions.shape}"
+        )
+    capture = cv2.VideoCapture(str(video_path))
+    if not capture.isOpened():
+        raise RuntimeError(f"Could not open video: {video_path}")
+
+    fps = capture.get(cv2.CAP_PROP_FPS) or float(config.get("fps", 30))
+    width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    writer = cv2.VideoWriter(
+        str(tmp_video_path),
+        cv2.VideoWriter_fourcc(*"mp4v"),
+        fps,
+        (width, height),
+    )
+    if not writer.isOpened():
+        raise RuntimeError(f"Could not write video: {tmp_video_path}")
+
+    displacement = np.linalg.norm(
+        positions - rest_positions[None, :, :], axis=2
+    )
+    scale = (
+        float(np.percentile(displacement, 95)) if displacement.size else 1.0
+    )
+    scale = max(scale, 1e-6)
+
+    camera_pos = np.asarray(config["camera_pos"], dtype=np.float32)
+    camera_lookat = np.asarray(config["camera_lookat"], dtype=np.float32)
+    camera_fov = float(config["camera_fov"])
+    inset_bbox = _compute_global_inset_bbox(
+        positions=positions,
+        camera_pos=camera_pos,
+        camera_lookat=camera_lookat,
+        camera_fov=camera_fov,
+        image_size=(width, height),
+    )
+
+    snapshot_index = min(
+        positions.shape[0] - 1,
+        max(0, int(round(fps)) - 1),
+    )
+
+    frame_index = 0
+    snapshot_frame = None
+    try:
+        while frame_index < positions.shape[0]:
+            ok, frame_bgr = capture.read()
+            if not ok:
+                break
+
+            frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+            heatmap = _compose_displacement_frame(
+                frame_rgb=frame_rgb,
+                positions=positions[frame_index],
+                displacement=displacement[frame_index],
+                scale=scale,
+                camera_pos=camera_pos,
+                camera_lookat=camera_lookat,
+                camera_fov=camera_fov,
+                inset_bbox=inset_bbox,
+            )
+            if frame_index == snapshot_index:
+                snapshot_frame = heatmap
+            writer.write(cv2.cvtColor(heatmap, cv2.COLOR_RGB2BGR))
+            frame_index += 1
+    finally:
+        capture.release()
+        writer.release()
+
+    if frame_index == 0 or snapshot_frame is None:
+        raise RuntimeError("No frames were written to mesh displacement video")
+
+    output_image_path.parent.mkdir(parents=True, exist_ok=True)
+    output_video_path.parent.mkdir(parents=True, exist_ok=True)
+    cv2.imwrite(
+        str(output_image_path), cv2.cvtColor(snapshot_frame, cv2.COLOR_RGB2BGR)
+    )
+
+
+def _compose_displacement_frame(
+    frame_rgb: np.ndarray,
+    positions: np.ndarray,
+    displacement: np.ndarray,
+    scale: float,
+    camera_pos: np.ndarray,
+    camera_lookat: np.ndarray,
+    camera_fov: float,
+    inset_bbox: tuple[int, int, int, int],
+) -> np.ndarray:
+    height, width = frame_rgb.shape[:2]
+    pixels, depths = _project_points(
+        points=positions,
+        camera_pos=camera_pos,
+        camera_lookat=camera_lookat,
+        camera_fov=camera_fov,
+        image_size=(width, height),
+    )
+    normalized = np.clip(displacement / scale, 0.0, 1.0)
+    scalar_layer, weight_layer = _rasterize_particle_scalar_field(
+        pixels=pixels,
+        depths=depths,
+        normalized=normalized,
+        image_size=(width, height),
+    )
+    scalar_blur, weight_blur = _smooth_scalar_field(scalar_layer, weight_layer)
+    return _compose_rgb_with_inset(
+        frame_rgb=frame_rgb,
+        scalar_field=scalar_blur,
+        weight_field=weight_blur,
+        scale=scale,
+        inset_bbox=inset_bbox,
+    )
+
+
+def _compute_global_inset_bbox(
+    positions: np.ndarray,
+    camera_pos: np.ndarray,
+    camera_lookat: np.ndarray,
+    camera_fov: float,
+    image_size: tuple[int, int],
+) -> tuple[int, int, int, int]:
+    width, height = image_size
+    pad = 28
+    flat = positions.reshape(-1, 3)
+    pixels, depths = _project_points(
+        points=flat,
+        camera_pos=camera_pos,
+        camera_lookat=camera_lookat,
+        camera_fov=camera_fov,
+        image_size=image_size,
+    )
+    valid = depths > 1e-5
+    if not np.any(valid):
+        return (0, 0, width, height)
+    px = pixels[valid, 0]
+    py = pixels[valid, 1]
+    x0 = max(0, int(np.floor(px.min())) - pad)
+    x1 = min(width, int(np.ceil(px.max())) + pad)
+    y0 = max(0, int(np.floor(py.min())) - pad)
+    y1 = min(height, int(np.ceil(py.max())) + pad)
+    if x1 <= x0:
+        x1 = min(width, x0 + 1)
+    if y1 <= y0:
+        y1 = min(height, y0 + 1)
+    return (x0, y0, x1, y1)
+
+
+def _rasterize_particle_scalar_field(
+    pixels: np.ndarray,
+    depths: np.ndarray,
+    normalized: np.ndarray,
+    image_size: tuple[int, int],
+) -> tuple[np.ndarray, np.ndarray]:
+    width, height = image_size
+    scalar_layer = np.zeros((height, width), dtype=np.float32)
+    weight_layer = np.zeros((height, width), dtype=np.float32)
+    radius = max(5, int(round(min(width, height) / 140.0)))
+    for particle_index in np.argsort(depths)[::-1]:
+        if depths[particle_index] <= 1e-5:
+            continue
+
+        x_value, y_value = np.rint(pixels[particle_index]).astype(np.int32)
+        if (
+            x_value < -radius
+            or x_value >= width + radius
+            or y_value < -radius
+            or y_value >= height + radius
+        ):
+            continue
+
+        center = (int(x_value), int(y_value))
+        cv2.circle(
+            scalar_layer, center, radius, float(normalized[particle_index]), -1
+        )
+        cv2.circle(weight_layer, center, radius, 1.0, -1)
+
+    return scalar_layer, weight_layer
+
+
+def _smooth_scalar_field(
+    scalar_layer: np.ndarray,
+    weight_layer: np.ndarray,
+) -> tuple[np.ndarray, np.ndarray]:
+    height, width = scalar_layer.shape
+    radius = max(5, int(round(min(width, height) / 140.0)))
+    sigma = max(1.2, float(radius) * 0.55)
+    scalar_blur = cv2.GaussianBlur(scalar_layer * weight_layer, (0, 0), sigma)
+    weight_blur = cv2.GaussianBlur(weight_layer, (0, 0), sigma)
+    scalar_blur = scalar_blur / np.maximum(weight_blur, 1e-6)
+    hard_mask = _close_mask(weight_layer > 0.0, radius=max(4, radius * 2))
+    scalar_blur[~hard_mask] = 0.0
+    weight_blur[~hard_mask] = 0.0
+    return scalar_blur, weight_blur
+
+
+def _close_mask(mask: np.ndarray, radius: int) -> np.ndarray:
+    kernel_size = max(3, radius * 2 + 1)
+    kernel = cv2.getStructuringElement(
+        cv2.MORPH_ELLIPSE,
+        (kernel_size, kernel_size),
+    )
+    closed = cv2.morphologyEx(mask.astype(np.uint8), cv2.MORPH_CLOSE, kernel)
+    return closed.astype(bool)
+
+
+def _compose_rgb_with_inset(
+    frame_rgb: np.ndarray,
+    scalar_field: np.ndarray,
+    weight_field: np.ndarray,
+    scale: float,
+    inset_bbox: tuple[int, int, int, int],
+) -> np.ndarray:
+    height, width = frame_rgb.shape[:2]
+    x0, y0, x1, y1 = inset_bbox
+
+    heat_bgr = cv2.applyColorMap(
+        (np.clip(scalar_field, 0.0, 1.0) * 255).astype(np.uint8),
+        cv2.COLORMAP_TURBO,
+    )
+    heat_layer = cv2.cvtColor(heat_bgr, cv2.COLOR_BGR2RGB)
+
+    gray = cv2.cvtColor(frame_rgb, cv2.COLOR_RGB2GRAY)
+    gray_rgb = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
+    hard_mask = weight_field > 0.0
+    alpha = np.where(hard_mask, 0.82, 0.0).astype(np.float32)
+    inset = (
+        gray_rgb.astype(np.float32) * 0.68
+        + frame_rgb.astype(np.float32) * 0.12
+    )
+    inset = (
+        inset * (1.0 - alpha[:, :, None])
+        + heat_layer.astype(np.float32) * alpha[:, :, None]
+    )
+    inset = np.clip(inset[y0:y1, x0:x1], 0, 255).astype(np.uint8)
+
+    inset_width = 250
+    crop_height, crop_width = inset.shape[:2]
+    inset_height = max(1, int(crop_height * inset_width / max(crop_width, 1)))
+    inset = cv2.resize(
+        inset, (inset_width, inset_height), interpolation=cv2.INTER_AREA
+    )
+
+    legend_width = 30
+    legend_gap = 10
+    label_width = 54
+    margin = 28
+    panel_pad = 12
+    panel_width = (
+        inset_width + legend_gap + legend_width + label_width + panel_pad * 2
+    )
+    panel_height = inset_height + panel_pad * 2
+    panel_x = width - panel_width - margin
+    panel_y = margin
+
+    canvas = frame_rgb.copy()
+    panel = np.full((panel_height, panel_width, 3), 247, dtype=np.uint8)
+    panel = (panel.astype(np.float32) * 0.92).astype(np.uint8)
+    cv2.rectangle(
+        panel,
+        (0, 0),
+        (panel_width - 1, panel_height - 1),
+        (160, 168, 178),
+        1,
+    )
+
+    ix = panel_pad
+    iy = panel_pad
+    panel[iy : iy + inset_height, ix : ix + inset_width] = inset
+
+    bar_x = ix + inset_width + legend_gap
+    bar = np.linspace(1.0, 0.0, inset_height, dtype=np.float32)[:, None]
+    bar_bgr = cv2.applyColorMap(
+        (bar * 255).astype(np.uint8), cv2.COLORMAP_TURBO
+    )
+    bar_rgb = cv2.cvtColor(bar_bgr, cv2.COLOR_BGR2RGB)
+    panel[iy : iy + inset_height, bar_x : bar_x + legend_width] = np.repeat(
+        bar_rgb,
+        legend_width,
+        axis=1,
+    )
+    text_x = bar_x + legend_width + 4
+    cv2.putText(
+        panel,
+        f"{scale:.3f}m",
+        (text_x, iy + 12),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.36,
+        (35, 40, 48),
+        1,
+        cv2.LINE_AA,
+    )
+    cv2.putText(
+        panel,
+        "0",
+        (text_x, iy + inset_height),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.36,
+        (35, 40, 48),
+        1,
+        cv2.LINE_AA,
+    )
+    canvas[
+        panel_y : panel_y + panel_height, panel_x : panel_x + panel_width
+    ] = panel
+    return canvas
+
+
+def _project_points(
+    points: np.ndarray,
+    camera_pos: np.ndarray,
+    camera_lookat: np.ndarray,
+    camera_fov: float,
+    image_size: tuple[int, int],
+) -> tuple[np.ndarray, np.ndarray]:
+    width, height = image_size
+    forward = _normalize(camera_lookat - camera_pos)
+    world_up = np.array([0.0, 0.0, 1.0], dtype=np.float32)
+    right = np.cross(forward, world_up)
+    if np.linalg.norm(right) < 1e-6:
+        world_up = np.array([0.0, 1.0, 0.0], dtype=np.float32)
+        right = np.cross(forward, world_up)
+    right = _normalize(right)
+    up = _normalize(np.cross(right, forward))
+
+    relative = points - camera_pos[None, :]
+    cam_x = relative @ right
+    cam_y = relative @ up
+    cam_z = relative @ forward
+    focal = 0.5 * float(height) / math.tan(math.radians(camera_fov) * 0.5)
+    pixels = np.stack(
+        [
+            width * 0.5 + focal * cam_x / np.maximum(cam_z, 1e-6),
+            height * 0.5 - focal * cam_y / np.maximum(cam_z, 1e-6),
+        ],
+        axis=1,
+    )
+    return pixels, cam_z
+
+
+def _draw_legend(image: np.ndarray, scale: float) -> None:
+    height, width = image.shape[:2]
+    bar_height = min(240, max(120, height // 4))
+    bar_width = 26
+    margin = 28
+    x0 = width - margin - bar_width - 52
+    y0 = margin
+
+    panel = image[
+        y0 - 10 : y0 + bar_height + 18, x0 - 10 : x0 + bar_width + 52
+    ]
+    panel[:] = (panel.astype(np.float32) * 0.35 + 245.0 * 0.65).astype(
+        np.uint8
+    )
+    cv2.rectangle(
+        image,
+        (x0 - 10, y0 - 10),
+        (x0 + bar_width + 52, y0 + bar_height + 18),
+        (155, 164, 176),
+        1,
+    )
+
+    values = np.linspace(1.0, 0.0, bar_height, dtype=np.float32)[:, None]
+    colors_bgr = cv2.applyColorMap(
+        (values * 255).astype(np.uint8),
+        cv2.COLORMAP_TURBO,
+    )
+    colors_rgb = cv2.cvtColor(colors_bgr, cv2.COLOR_BGR2RGB)
+    image[y0 : y0 + bar_height, x0 : x0 + bar_width] = np.repeat(
+        colors_rgb,
+        bar_width,
+        axis=1,
+    )
+    cv2.putText(
+        image,
+        f"{scale:.3f}m",
+        (x0 + bar_width + 6, y0 + 12),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.38,
+        (35, 40, 48),
+        1,
+        cv2.LINE_AA,
+    )
+    cv2.putText(
+        image,
+        "0",
+        (x0 + bar_width + 6, y0 + bar_height),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.38,
+        (35, 40, 48),
+        1,
+        cv2.LINE_AA,
+    )
+
+
+def _load_obj_mesh(mesh_path: Path) -> tuple[np.ndarray, np.ndarray]:
+    vertices: list[list[float]] = []
+    triangles: list[list[int]] = []
+    for line in mesh_path.read_text(errors="ignore").splitlines():
+        if line.startswith("v "):
+            _, x_value, y_value, z_value, *_ = line.split()
+            vertices.append([float(x_value), float(y_value), float(z_value)])
+            continue
+        if not line.startswith("f "):
+            continue
+
+        indices = [
+            _parse_obj_index(token, len(vertices))
+            for token in line.split()[1:]
+        ]
+        if len(indices) < 3:
+            continue
+        for offset in range(1, len(indices) - 1):
+            triangles.append(
+                [indices[0], indices[offset], indices[offset + 1]]
+            )
+
+    if not vertices:
+        raise ValueError(f"No vertices found in OBJ mesh: {mesh_path}")
+    if not triangles:
+        raise ValueError(f"No faces found in OBJ mesh: {mesh_path}")
+    return (
+        np.asarray(vertices, dtype=np.float32),
+        np.asarray(triangles, dtype=np.int32),
+    )
+
+
+def _map_mesh_faces_to_particles(
+    mesh_vertices: np.ndarray,
+    mesh_faces: np.ndarray,
+    rest_positions: np.ndarray,
+    init_height: float,
+    mesh_scale: float,
+) -> np.ndarray:
+    world_vertices = mesh_vertices * float(mesh_scale)
+    world_vertices[:, 2] += float(init_height)
+    vertex_to_particle = _nearest_indices(
+        queries=world_vertices,
+        points=rest_positions,
+    )
+    particle_faces = vertex_to_particle[mesh_faces]
+    unique_counts = np.asarray(
+        [len(set(face.tolist())) for face in particle_faces],
+        dtype=np.int32,
+    )
+    particle_faces = particle_faces[unique_counts == 3]
+    if particle_faces.size == 0:
+        raise ValueError(
+            "No non-degenerate particle faces remained after mapping"
+        )
+    return np.unique(particle_faces, axis=0).astype(np.int32)
+
+
+def _nearest_indices(
+    queries: np.ndarray,
+    points: np.ndarray,
+    chunk_size: int = 1024,
+) -> np.ndarray:
+    nearest: list[np.ndarray] = []
+    points_sq = np.sum(points * points, axis=1)[None, :]
+    for start in range(0, queries.shape[0], chunk_size):
+        chunk = queries[start : start + chunk_size]
+        distances = (
+            np.sum(chunk * chunk, axis=1)[:, None]
+            + points_sq
+            - 2.0 * chunk @ points.T
+        )
+        nearest.append(np.argmin(distances, axis=1).astype(np.int32))
+    return np.concatenate(nearest, axis=0)
+
+
+def _parse_obj_index(token: str, vertex_count: int) -> int:
+    raw = int(token.split("/")[0])
+    if raw < 0:
+        return vertex_count + raw
+    return raw - 1
+
+
+def _is_triangle_outside_image(
+    triangle: np.ndarray,
+    width: int,
+    height: int,
+) -> bool:
+    return (
+        triangle[:, 0].max() < 0
+        or triangle[:, 0].min() >= width
+        or triangle[:, 1].max() < 0
+        or triangle[:, 1].min() >= height
+    )
+
+
+def _normalize(vector: np.ndarray) -> np.ndarray:
+    norm = float(np.linalg.norm(vector))
+    if norm <= 1e-8:
+        raise ValueError("Cannot normalize near-zero vector")
+    return vector / norm
+
+
+if __name__ == "__main__":
+    main()

embodied_gen/scripts/deformable_sim/simulate_genesis_cloth.py

@@ -0,0 +1,608 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+import json
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import tyro
+from tqdm import tqdm
+from embodied_gen.utils.log import logger
+
+DEFAULT_CAMERA_FOV = 45
+
+
+@dataclass
+class GenesisClothSimConfig:
+    asset_path: str = "outputs/cloth"
+    output_dir: str | None = None
+    init_height: float = 1.0
+    duration_seconds: float = 6.0
+    sim_steps: int | None = None
+    shake: bool = True
+    shake_steps: int | None = None
+    shake_amplitude: float = 0.08
+    device: str = "cpu"
+    headless: bool = True
+    fps: int = 30
+    render_interval: int = 1
+    camera_res: tuple[int, int] = (512, 512)
+    gravity: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    background_color: tuple[float, float, float] = (0.78, 0.82, 0.88)
+    ambient_light: tuple[float, float, float] = (0.55, 0.55, 0.55)
+    floor_size: tuple[float, float] = (6.0, 6.0)
+    floor_tile_size: tuple[float, float] = (0.5, 0.5)
+    floor_color: tuple[float, float, float, float] = (0.72, 0.72, 0.68, 1.0)
+    backdrop: bool = False
+    backdrop_color: tuple[float, float, float, float] = (0.80, 0.84, 0.90, 1.0)
+
+
+def simulate_genesis_cloth(
+    asset_path: str = "outputs/cloth",
+    output_dir: str | None = None,
+    init_height: float = 1.0,
+    duration_seconds: float = 6.0,
+    sim_steps: int | None = None,
+    shake: bool = True,
+    shake_steps: int | None = None,
+    shake_amplitude: float = 0.08,
+    device: str = "cpu",
+    headless: bool = True,
+    fps: int = 30,
+    render_interval: int = 1,
+    camera_res: tuple[int, int] = (512, 512),
+    gravity: tuple[float, float, float] = (0.0, 0.0, 0.0),
+    background_color: tuple[float, float, float] = (0.78, 0.82, 0.88),
+    ambient_light: tuple[float, float, float] = (0.55, 0.55, 0.55),
+    floor_size: tuple[float, float] = (6.0, 6.0),
+    floor_tile_size: tuple[float, float] = (0.5, 0.5),
+    floor_color: tuple[float, float, float, float] = (0.72, 0.72, 0.68, 1.0),
+    backdrop: bool = False,
+    backdrop_color: tuple[float, float, float, float] = (
+        0.80,
+        0.84,
+        0.90,
+        1.0,
+    ),
+) -> str:
+    """Run a Genesis cloth drop-and-shake demo.
+
+    Args:
+        asset_path: Directory containing ``genesis/manifest.json``.
+        output_dir: Directory for simulation outputs. If unset, writes to
+            ``asset_path/genesis_sim``.
+        init_height: Height in meters for the cloth initial position.
+        duration_seconds: Default output video duration when ``sim_steps`` is not
+            set. Defaults to 6 seconds.
+        sim_steps: Optional number of Genesis simulation steps to run. If unset,
+            it is derived from ``duration_seconds * fps * render_interval``.
+        shake: Whether to apply a visible nonuniform particle displacement.
+        shake_steps: Number of steps that receive the shake motion. If unset,
+            all simulation steps are shaken.
+        shake_amplitude: Maximum displacement magnitude in meters.
+        device: Genesis backend name: ``"cpu"``, ``"cuda"``, or ``"auto"``.
+        headless: Whether to run Genesis without opening the viewer.
+            Genesis 0.4.7 uses Scene(show_viewer=False) for headless mode.
+        fps: Output video frames per second.
+        render_interval: Render every N simulation steps.
+        camera_res: Output camera resolution as ``(width, height)``. Defaults
+            to 512x512.
+        gravity: Gravity vector. Defaults to zero for the wind-sway demo so
+            the shirt does not visibly sag before the lower edge starts moving.
+        background_color: RGB color for the renderer background.
+        ambient_light: RGB ambient light color.
+        floor_size: Visible floor plane size in meters.
+        floor_tile_size: Visual tile size for the floor plane.
+        floor_color: RGBA floor material color.
+        backdrop: Whether to add a vertical background plane behind the cloth.
+        backdrop_color: RGBA backdrop material color.
+
+    Returns:
+        Path to the generated video file.
+    """
+
+    if duration_seconds <= 0:
+        raise ValueError("duration_seconds must be positive")
+    if fps <= 0:
+        raise ValueError("fps must be positive")
+    if render_interval <= 0:
+        raise ValueError("render_interval must be positive")
+    if sim_steps is None:
+        sim_steps = max(
+            1, int(round(duration_seconds * fps * render_interval))
+        )
+    if sim_steps <= 0:
+        raise ValueError("sim_steps must be positive")
+    if shake_steps is None:
+        shake_steps = sim_steps
+    if shake_steps < 0:
+        raise ValueError("shake_steps must be non-negative")
+
+    asset_dir = Path(asset_path)
+    manifest_path = asset_dir / "genesis" / "manifest.json"
+    manifest = _read_json(manifest_path)
+    material_config = _read_json(asset_dir / manifest["material"])
+    cloth_mesh_path = asset_dir / manifest["cloth_mesh"]
+    if not cloth_mesh_path.exists():
+        raise FileNotFoundError(
+            f"Converted cloth mesh not found: {cloth_mesh_path}"
+        )
+
+    sim_output_dir = (
+        Path(output_dir) if output_dir else asset_dir / "genesis_sim"
+    )
+    sim_output_dir.mkdir(parents=True, exist_ok=True)
+    logger.info(f"Genesis cloth outputs will be saved to {sim_output_dir}")
+    video_path = sim_output_dir / "video.mp4"
+    summary_path = sim_output_dir / "run_summary.json"
+    config_path = sim_output_dir / "sim_config.json"
+    particle_positions_path = sim_output_dir / "particle_positions.npz"
+
+    import genesis as gs
+
+    backend_name, backend_warning = _init_genesis_backend(gs, device)
+
+    pbd_options = gs.options.PBDOptions(
+        particle_size=float(material_config.get("particle_size", 0.02)),
+        gravity=tuple(float(value) for value in gravity),
+    )
+    camera_pos, camera_lookat = _front_camera_pose(manifest, init_height)
+    scene = gs.Scene(
+        show_viewer=not headless,
+        sim_options=gs.options.SimOptions(
+            dt=1.0 / float(fps * render_interval),
+            gravity=tuple(float(value) for value in gravity),
+        ),
+        pbd_options=pbd_options,
+        vis_options=gs.options.VisOptions(
+            background_color=tuple(float(value) for value in background_color),
+            ambient_light=tuple(float(value) for value in ambient_light),
+            shadow=True,
+            plane_reflection=False,
+        ),
+    )
+    _add_scene_floor_and_backdrop(
+        gs=gs,
+        scene=scene,
+        camera_pos=camera_pos,
+        camera_lookat=camera_lookat,
+        floor_size=floor_size,
+        floor_tile_size=floor_tile_size,
+        floor_color=floor_color,
+        backdrop=backdrop,
+        backdrop_color=backdrop_color,
+    )
+    cloth = scene.add_entity(
+        morph=gs.morphs.Mesh(
+            file=str(cloth_mesh_path),
+            pos=(0.0, 0.0, float(init_height)),
+            scale=float(manifest.get("scale", 1.0)),
+            convexify=False,
+        ),
+        material=gs.materials.PBD.Cloth(
+            rho=float(material_config.get("rho", 0.2)),
+            static_friction=float(material_config.get("static_friction", 0.5)),
+            kinetic_friction=float(
+                material_config.get("kinetic_friction", 0.4)
+            ),
+            stretch_compliance=float(
+                material_config.get("stretch_compliance", 1e-6)
+            ),
+            bending_compliance=float(
+                material_config.get("bending_compliance", 1e-4)
+            ),
+            stretch_relaxation=float(
+                material_config.get("stretch_relaxation", 0.3)
+            ),
+            bending_relaxation=float(
+                material_config.get("bending_relaxation", 0.1)
+            ),
+            air_resistance=float(material_config.get("air_resistance", 1e-3)),
+        ),
+    )
+    camera = scene.add_camera(
+        res=camera_res,
+        pos=camera_pos,
+        lookat=camera_lookat,
+        fov=DEFAULT_CAMERA_FOV,
+    )
+    scene.build()
+
+    config = {
+        "asset_path": str(asset_dir),
+        "manifest": str(manifest_path),
+        "manifest_scale": float(manifest.get("scale", 1.0)),
+        "init_height": init_height,
+        "duration_seconds": duration_seconds,
+        "sim_steps": sim_steps,
+        "shake": shake,
+        "shake_steps": shake_steps,
+        "shake_amplitude": shake_amplitude,
+        "device": device,
+        "resolved_backend": backend_name,
+        "backend_warning": backend_warning,
+        "headless": headless,
+        "fps": fps,
+        "render_interval": render_interval,
+        "camera_res": list(camera_res),
+        "camera_pos": list(camera_pos),
+        "camera_lookat": list(camera_lookat),
+        "camera_fov": DEFAULT_CAMERA_FOV,
+        "gravity": list(gravity),
+        "background_color": list(background_color),
+        "ambient_light": list(ambient_light),
+        "floor_size": list(floor_size),
+        "floor_tile_size": list(floor_tile_size),
+        "floor_color": list(floor_color),
+        "backdrop": backdrop,
+        "backdrop_color": list(backdrop_color),
+    }
+    _write_json(config_path, config)
+
+    rest_positions = cloth.get_particles_pos().clone()
+    particle_frames = []
+    rendered_frames = 0
+    camera.start_recording()
+    for step in tqdm(range(sim_steps), desc="Genesis Cloth Simulation"):
+        if shake and step < shake_steps:
+            _shake_cloth_particles(
+                gs,
+                cloth,
+                rest_positions,
+                step,
+                shake_steps,
+                shake_amplitude,
+            )
+        scene.step()
+        if step % render_interval == 0:
+            particle_frames.append(_tensor_to_numpy(cloth.get_particles_pos()))
+            camera.render()
+            rendered_frames += 1
+    _save_camera_recording(camera, video_path, fps)
+    _save_particle_positions(
+        particle_positions_path=particle_positions_path,
+        particle_frames=particle_frames,
+        rest_positions=rest_positions,
+        fps=fps,
+        render_interval=render_interval,
+    )
+
+    summary = {
+        "video": str(video_path),
+        "particle_positions": str(particle_positions_path),
+        "rendered_frames": rendered_frames,
+        "particles": int(cloth.n_particles),
+        "sim_steps": sim_steps,
+        "duration_seconds": duration_seconds,
+        "requested_device": device,
+        "resolved_backend": backend_name,
+        "backend_warning": backend_warning,
+        "status": "completed",
+    }
+    _write_json(summary_path, summary)
+    logger.info(
+        "Genesis cloth simulation outputs: "
+        f"video {video_path}, particles {particle_positions_path}, "
+        f"config {config_path}, summary {summary_path}"
+    )
+    return str(video_path)
+
+
+def entrypoint(**kwargs) -> str:
+    if kwargs:
+        cfg = GenesisClothSimConfig(**kwargs)
+    else:
+        cfg = tyro.cli(GenesisClothSimConfig)
+
+    return simulate_genesis_cloth(
+        asset_path=cfg.asset_path,
+        output_dir=cfg.output_dir,
+        init_height=cfg.init_height,
+        duration_seconds=cfg.duration_seconds,
+        sim_steps=cfg.sim_steps,
+        shake=cfg.shake,
+        shake_steps=cfg.shake_steps,
+        shake_amplitude=cfg.shake_amplitude,
+        device=cfg.device,
+        headless=cfg.headless,
+        fps=cfg.fps,
+        render_interval=cfg.render_interval,
+        camera_res=cfg.camera_res,
+        gravity=cfg.gravity,
+        background_color=cfg.background_color,
+        ambient_light=cfg.ambient_light,
+        floor_size=cfg.floor_size,
+        floor_tile_size=cfg.floor_tile_size,
+        floor_color=cfg.floor_color,
+        backdrop=cfg.backdrop,
+        backdrop_color=cfg.backdrop_color,
+    )
+
+
+def _shake_cloth_particles(
+    gs: Any,
+    cloth: Any,
+    rest_positions: Any,
+    step: int,
+    shake_steps: int,
+    amplitude: float,
+) -> None:
+    if amplitude <= 0.0 or shake_steps <= 0:
+        return
+
+    positions = cloth.get_particles_pos().clone()
+    min_values = rest_positions.min(dim=0).values
+    max_values = rest_positions.max(dim=0).values
+    height = gs.torch.clamp(max_values[2] - min_values[2], min=1e-6)
+    y_values = rest_positions[:, 1]
+    z_values = rest_positions[:, 2]
+
+    top_ratio = gs.torch.clamp((max_values[2] - z_values) / height, 0.0, 1.0)
+    anchor_mask = top_ratio < 0.01
+    wind_strength = (
+        gs.torch.clamp((top_ratio - 0.005) / 0.995, 0.0, 1.0) ** 1.1
+    )
+
+    progress = float(step) / max(float(shake_steps), 1.0)
+    phase = 2.0 * math.pi * 2.2 * progress
+    traveling_phase = phase - 0.85 * top_ratio
+    center_y = rest_positions[:, 1].mean()
+    width = gs.torch.clamp(max_values[1] - min_values[1], min=1e-6)
+    across = (y_values - center_y) / width
+
+    offsets = gs.torch.zeros_like(rest_positions)
+    offsets[:, 0] = (
+        float(amplitude) * 2.25 * gs.torch.sin(traveling_phase) * wind_strength
+    )
+    offsets[:, 1] = (
+        float(amplitude)
+        * 0.04
+        * gs.torch.sin(traveling_phase * 1.10 + across)
+        * wind_strength
+    )
+    offsets[:, 2] = (
+        float(amplitude)
+        * 0.12
+        * gs.torch.sin(traveling_phase * 1.15 + across)
+        * wind_strength
+    )
+
+    target_positions = rest_positions + offsets
+    blend = (0.58 * wind_strength).unsqueeze(1)
+    positions = positions + (target_positions - positions) * blend
+    positions[anchor_mask] = rest_positions[anchor_mask]
+    cloth.set_particles_pos(positions)
+
+
+def _add_scene_floor_and_backdrop(
+    gs: Any,
+    scene: Any,
+    camera_pos: tuple[float, float, float],
+    camera_lookat: tuple[float, float, float],
+    floor_size: tuple[float, float],
+    floor_tile_size: tuple[float, float],
+    floor_color: tuple[float, float, float, float],
+    backdrop: bool,
+    backdrop_color: tuple[float, float, float, float],
+) -> None:
+    scene.add_entity(
+        morph=gs.morphs.Plane(
+            pos=(0.0, 0.0, 0.0),
+            plane_size=tuple(float(value) for value in floor_size),
+            tile_size=tuple(float(value) for value in floor_tile_size),
+        ),
+        material=gs.materials.Rigid(),
+        surface=gs.surfaces.Rough(
+            color=tuple(float(value) for value in floor_color)
+        ),
+        name="floor",
+    )
+
+    if not backdrop:
+        return
+
+    normal = _horizontal_unit_vector(
+        (
+            camera_pos[0] - camera_lookat[0],
+            camera_pos[1] - camera_lookat[1],
+            0.0,
+        )
+    )
+    camera_distance = math.sqrt(
+        (camera_pos[0] - camera_lookat[0]) ** 2
+        + (camera_pos[1] - camera_lookat[1]) ** 2
+        + (camera_pos[2] - camera_lookat[2]) ** 2
+    )
+    backdrop_distance = max(1.5, camera_distance * 0.72)
+    backdrop_pos = (
+        camera_lookat[0] - normal[0] * backdrop_distance,
+        camera_lookat[1] - normal[1] * backdrop_distance,
+        camera_lookat[2],
+    )
+    backdrop_size = (
+        max(float(floor_size[0]), float(floor_size[1])),
+        max(float(floor_size[0]), float(floor_size[1])) * 0.7,
+    )
+    scene.add_entity(
+        morph=gs.morphs.Plane(
+            pos=backdrop_pos,
+            normal=normal,
+            plane_size=backdrop_size,
+            collision=False,
+        ),
+        material=gs.materials.Rigid(),
+        surface=gs.surfaces.Rough(
+            color=tuple(float(value) for value in backdrop_color)
+        ),
+        name="backdrop",
+    )
+
+
+def _horizontal_unit_vector(
+    vector: tuple[float, float, float],
+) -> tuple[float, float, float]:
+    length = math.sqrt(vector[0] ** 2 + vector[1] ** 2)
+    if length <= 1e-6:
+        return (1.0, 0.0, 0.0)
+    return (vector[0] / length, vector[1] / length, 0.0)
+
+
+def _save_camera_recording(camera: Any, video_path: Path, fps: int) -> None:
+    from moviepy.video.io.ImageSequenceClip import ImageSequenceClip
+
+    if not camera._in_recording:
+        raise RuntimeError("Camera recording was not started.")
+    if not camera._recorded_imgs:
+        raise RuntimeError("No frames were recorded.")
+
+    video_path.parent.mkdir(parents=True, exist_ok=True)
+    clip = ImageSequenceClip(list(camera._recorded_imgs), fps=fps)
+    try:
+        clip.write_videofile(
+            str(video_path),
+            fps=fps,
+            logger=None,
+            codec="libx264",
+            preset="ultrafast",
+        )
+    finally:
+        close = getattr(clip, "close", None)
+        if close is not None:
+            close()
+        camera._recorded_t_prev = -1
+        camera._recorded_imgs.clear()
+        camera._in_recording = False
+
+
+def _save_particle_positions(
+    particle_positions_path: Path,
+    particle_frames: list[Any],
+    rest_positions: Any,
+    fps: int,
+    render_interval: int,
+) -> None:
+    import numpy as np
+
+    if not particle_frames:
+        raise RuntimeError("No particle frames were recorded.")
+
+    particle_positions_path.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(
+        particle_positions_path,
+        positions=np.stack(particle_frames, axis=0).astype(np.float32),
+        rest_positions=_tensor_to_numpy(rest_positions).astype(np.float32),
+        fps=np.array(fps, dtype=np.int32),
+        render_interval=np.array(render_interval, dtype=np.int32),
+    )
+
+
+def _tensor_to_numpy(tensor: Any) -> Any:
+    array = tensor.detach() if hasattr(tensor, "detach") else tensor
+    array = array.cpu() if hasattr(array, "cpu") else array
+    array = array.numpy() if hasattr(array, "numpy") else array
+    return array
+
+
+def _collar_handle_weights(gs: Any, rest_positions: Any) -> Any:
+    min_values = rest_positions.min(dim=0).values
+    max_values = rest_positions.max(dim=0).values
+    center = rest_positions.mean(dim=0)
+    width = gs.torch.clamp(max_values[1] - min_values[1], min=1e-6)
+    height = gs.torch.clamp(max_values[2] - min_values[2], min=1e-6)
+
+    y_values = rest_positions[:, 1]
+    z_values = rest_positions[:, 2]
+    top_start = max_values[2] - 0.32 * height
+    top_weights = gs.torch.clamp(
+        (z_values - top_start) / (0.32 * height), 0.0, 1.0
+    )
+
+    left_center = center[1] - 0.22 * width
+    right_center = center[1] + 0.22 * width
+    sigma = 0.12 * width
+    left_weights = gs.torch.exp(-0.5 * ((y_values - left_center) / sigma) ** 2)
+    right_weights = gs.torch.exp(
+        -0.5 * ((y_values - right_center) / sigma) ** 2
+    )
+    side_weights = gs.torch.clamp(left_weights + right_weights, 0.0, 1.0)
+    return top_weights * side_weights
+
+
+def _front_camera_pose(
+    manifest: dict[str, Any], init_height: float
+) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
+    stats = manifest.get("mesh_stats", {})
+    bbox_min = stats.get("bbox_min", [-0.5, -0.5, -0.5])
+    bbox_max = stats.get("bbox_max", [0.5, 0.5, 0.5])
+    extents = stats.get("extents", [1.0, 1.0, 1.0])
+
+    center = [
+        0.5 * (float(bbox_min[index]) + float(bbox_max[index]))
+        for index in range(3)
+    ]
+    width = float(extents[1])
+    height = float(extents[2])
+    depth = max(float(extents[0]), 0.05)
+    distance = max(width, height) * 2.45 + depth
+
+    lookat = (center[0], center[1], center[2] + float(init_height))
+    pos = (
+        center[0] + distance,
+        center[1] - 0.22 * distance,
+        lookat[2] + 0.04 * height,
+    )
+    return pos, lookat
+
+
+def _init_genesis_backend(gs: Any, device: str) -> tuple[str, str | None]:
+    normalized = device.lower()
+    if normalized == "cpu":
+        gs.init(backend=gs.cpu, logging_level="warning")
+        return "cpu", None
+    if normalized == "cuda":
+        gs.init(backend=gs.cuda, logging_level="warning")
+        return "cuda", None
+    if normalized != "auto":
+        raise ValueError(
+            f"Unsupported Genesis backend: {device}. Use 'cpu', 'cuda', or 'auto'."
+        )
+
+    try:
+        gs.init(backend=gs.cuda, logging_level="warning")
+        return "cuda", None
+    except Exception as exc:
+        warning = (
+            "Genesis CUDA backend is unavailable; falling back to CPU. "
+            f"Original error: {type(exc).__name__}: {exc}"
+        )
+        gs.init(backend=gs.cpu, logging_level="warning")
+        return "cpu", warning
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        raise FileNotFoundError(f"Required JSON file does not exist: {path}")
+    return json.loads(path.read_text())
+
+
+def _write_json(path: Path, data: dict[str, Any]) -> None:
+    path.write_text(json.dumps(data, indent=2) + "\n")
+
+
+if __name__ == "__main__":
+    entrypoint()

embodied_gen/scripts/gen_texture.py

@@ -100,7 +100,7 @@ def entrypoint() -> None:
             pipeline=PIPELINE,
             seed=cfg.seed,
         )
-        textured_mesh = backproject_api(
+        backproject_api(
             delight_model=DELIGHT,
             imagesr_model=IMAGESR_MODEL,
             mesh_path=mesh_path,

embodied_gen/scripts/imageto3d.py

@@ -29,6 +29,11 @@ from embodied_gen.data.utils import delete_dir
 # from embodied_gen.models.sr_model import ImageRealESRGAN
 # from embodied_gen.models.delight_model import DelightingModel
 from embodied_gen.models.gs_model import GaussianOperator
+from embodied_gen.models.hunyuan3d import (
+    HunyuanConfig,
+    load_credentials,
+    process_image,
+)
 from embodied_gen.models.segment_model import RembgRemover
 from embodied_gen.scripts.render_gs import entrypoint as render_gs_api
 from embodied_gen.utils.gpt_clients import GPT_CLIENT
@@ -49,19 +54,47 @@ from embodied_gen.validators.quality_checkers import (
 from embodied_gen.validators.urdf_convertor import URDFGenerator
 
 # random.seed(0)
-IMAGE3D_MODEL = "SAM3D"  # TRELLIS or SAM3D
-logger.info(f"Loading {IMAGE3D_MODEL} as Image3D Models...")
-if IMAGE3D_MODEL == "TRELLIS":
-    from thirdparty.TRELLIS.trellis.pipelines import TrellisImageTo3DPipeline
-
-    PIPELINE = TrellisImageTo3DPipeline.from_pretrained(
-        "microsoft/TRELLIS-image-large"
-    )
-    # PIPELINE.cuda()
-elif IMAGE3D_MODEL == "SAM3D":
-    from embodied_gen.models.sam3d import Sam3dInference
+IMAGE3D_MODEL = "SAM3D"  # default backend; SAM3D, TRELLIS, or HUNYUAN3D
+SUPPORTED_IMAGE3D_MODELS = ("SAM3D", "TRELLIS", "HUNYUAN3D")
+
+
+_PIPELINE_CACHE: dict = {}
+
+
+def _build_image3d_pipeline(name: str):
+    """Lazily instantiate (and cache) the local image-to-3D pipeline.
+
+    The cache preserves the pre-refactor invariant that the local backend
+    is loaded once per process: ``textto3d.py`` calls ``entrypoint`` in a
+    per-node loop, and re-loading weights each call would regress runtime.
+    Returns ``None`` for backends that have no local model (HUNYUAN3D).
+    """
+    if name == "HUNYUAN3D":
+        return None
+    if name in _PIPELINE_CACHE:
+        return _PIPELINE_CACHE[name]
+    if name == "TRELLIS":
+        logger.info("Loading TRELLIS as Image3D Models...")
+        from thirdparty.TRELLIS.trellis.pipelines import (
+            TrellisImageTo3DPipeline,
+        )
+
+        pipeline = TrellisImageTo3DPipeline.from_pretrained(
+            "microsoft/TRELLIS-image-large"
+        )
+    elif name == "SAM3D":
+        logger.info("Loading SAM3D as Image3D Models...")
+        from embodied_gen.models.sam3d import Sam3dInference
+
+        pipeline = Sam3dInference()
+    else:
+        raise ValueError(
+            f"Unsupported image3d backend {name!r}; "
+            f"expected one of {SUPPORTED_IMAGE3D_MODELS}."
+        )
+    _PIPELINE_CACHE[name] = pipeline
+    return pipeline
 
-    PIPELINE = Sam3dInference()
 
 # DELIGHT = DelightingModel()
 # IMAGESR_MODEL = ImageRealESRGAN(outscale=4)
@@ -109,6 +142,17 @@ def parse_args():
     )
     parser.add_argument("--disable_decompose_convex", action="store_true")
     parser.add_argument("--texture_size", type=int, default=2048)
+    parser.add_argument(
+        "--image3d_model",
+        type=str,
+        default=IMAGE3D_MODEL,
+        help=(
+            "Image-to-3D backend. One of "
+            f"{', '.join(SUPPORTED_IMAGE3D_MODELS)} (case-insensitive). "
+            "HUNYUAN3D calls Tencent Hunyuan3D Pro API and requires "
+            "TENCENT_SECRET_ID/TENCENT_SECRET_KEY in the environment."
+        ),
+    )
     args, unknown = parser.parse_known_args()
 
     return args
@@ -120,9 +164,31 @@ def entrypoint(**kwargs):
         if hasattr(args, k) and v is not None:
             setattr(args, k, v)
 
-    assert (
-        args.image_path or args.image_root
-    ), "Please provide either --image_path or --image_root."
+    args.image3d_model = str(args.image3d_model).strip().upper()
+    if args.image3d_model not in SUPPORTED_IMAGE3D_MODELS:
+        raise ValueError(
+            f"Unsupported --image3d_model {args.image3d_model!r}; "
+            f"expected one of {SUPPORTED_IMAGE3D_MODELS}."
+        )
+
+    hunyuan_config = None
+    hunyuan_credentials = None
+    if args.image3d_model == "HUNYUAN3D":
+        # Fail fast on missing creds before any local model load or network I/O.
+        hunyuan_credentials = load_credentials()
+        hunyuan_config = HunyuanConfig()
+        logger.info(
+            "HUNYUAN3D backend: action=%s host=%s result_format=%s",
+            hunyuan_config.image_action,
+            hunyuan_config.host,
+            hunyuan_config.result_format,
+        )
+
+    pipeline = _build_image3d_pipeline(args.image3d_model)
+
+    assert args.image_path or args.image_root, (
+        "Please provide either --image_path or --image_root."
+    )
     if not args.image_path:
         args.image_path = glob(os.path.join(args.image_root, "*.png"))
         args.image_path += glob(os.path.join(args.image_root, "*.jpg"))
@@ -151,6 +217,19 @@ def entrypoint(**kwargs):
             seg_image = RBG_REMOVER(image) if image.mode != "RGBA" else image
             seg_image.save(seg_path)
 
+            if args.image3d_model == "HUNYUAN3D":
+                process_image(
+                    args=args,
+                    idx=idx,
+                    image_path=image_path,
+                    output_root=output_root,
+                    filename=filename,
+                    hunyuan_config=hunyuan_config,
+                    hunyuan_credentials=hunyuan_credentials,
+                    checkers=CHECKERS,
+                )
+                continue
+
             seed = args.seed
             asset_node = "unknown"
             gs_model = None
@@ -161,10 +240,10 @@ def entrypoint(**kwargs):
                     f"Try: {try_idx + 1}/{args.n_retry}, Seed: {seed}, Prompt: {seg_path}"
                 )
                 try:
-                    outputs = image3d_model_infer(PIPELINE, seg_image, seed)
+                    outputs = image3d_model_infer(pipeline, seg_image, seed)
                 except Exception as e:
                     logger.error(
-                        f"[Image3D Failed] process {image_path}: {e}, retry: {try_idx+1}/{args.n_retry}"
+                        f"[Image3D Failed] process {image_path}: {e}, retry: {try_idx + 1}/{args.n_retry}"
                     )
                     seed = (
                         random.randint(0, 100000) if seed is not None else None
@@ -290,10 +369,14 @@ def entrypoint(**kwargs):
             )
 
             # Quality check and update .urdf file.
-            mesh_out = f"{urdf_root}/{urdf_convertor.output_mesh_dir}/{filename}.obj"  # noqa
+            mesh_out = (
+                f"{urdf_root}/{urdf_convertor.output_mesh_dir}/{filename}.obj"  # noqa
+            )
             trimesh.load(mesh_out).export(mesh_out.replace(".obj", ".glb"))
 
-            image_dir = f"{urdf_root}/{urdf_convertor.output_render_dir}/image_color"  # noqa
+            image_dir = (
+                f"{urdf_root}/{urdf_convertor.output_render_dir}/image_color"  # noqa
+            )
             image_paths = glob(f"{image_dir}/*.png")
             images_list = []
             for checker in CHECKERS:

embodied_gen/scripts/parallel_sim.py

@@ -29,7 +29,7 @@ import torch
 import tyro
 from mani_skill.utils.wrappers import RecordEpisode
 from tqdm import tqdm
-import embodied_gen.envs.pick_embodiedgen
+import embodied_gen.envs.pick_embodiedgen  # noqa: F401
 from embodied_gen.utils.enum import LayoutInfo, Scene3DItemEnum
 from embodied_gen.utils.log import logger
 from embodied_gen.utils.simulation import FrankaPandaGrasper

embodied_gen/scripts/room_gen/custom_solve.gin

@@ -27,3 +27,4 @@ compose_indoors.skirting_floor_enabled = False
 compose_indoors.skirting_ceiling_enabled = False
 BlueprintSolidifier.enable_open = False
 
+compose_indoors.room_doors_enabled = False

embodied_gen/scripts/room_gen/export_scene.py

@@ -20,7 +20,6 @@ import logging
 import math
 import os
 import shutil
-import subprocess
 from collections import defaultdict
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
@@ -547,12 +546,12 @@ def apply_baked_tex(obj, paramDict={}):
             principled_bsdf_node.inputs["Metallic"].default_value = paramDict[
                 mat.name
             ]["Metallic"]
-            principled_bsdf_node.inputs["Sheen Weight"].default_value = (
-                paramDict[mat.name]["Sheen Weight"]
-            )
-            principled_bsdf_node.inputs["Coat Weight"].default_value = (
-                paramDict[mat.name]["Coat Weight"]
-            )
+            principled_bsdf_node.inputs[
+                "Sheen Weight"
+            ].default_value = paramDict[mat.name]["Sheen Weight"]
+            principled_bsdf_node.inputs[
+                "Coat Weight"
+            ].default_value = paramDict[mat.name]["Coat Weight"]
 
 
 def create_glass_shader(node_tree, export_usd):
@@ -783,9 +782,9 @@ def bake_special_emit(
         logger.debug(
             f"Removing added link:\t{n.name}: {from_soc.name} => {to_soc.name}"
         )
-        for l in n.node_tree.links:
-            if l.from_socket == from_soc and l.to_socket == to_soc:
-                n.node_tree.links.remove(l)
+        for link in n.node_tree.links:
+            if link.from_socket == from_soc and link.to_socket == to_soc:
+                n.node_tree.links.remove(link)
                 logger.debug(
                     f"Removed link:\t{n.name}: {from_soc.name} => {to_soc.name}"
                 )
@@ -1182,9 +1181,9 @@ def export_sim_ready(
 ) -> Dict[str, List[Path]]:
     """Exports both the visual and collision assets for a geometry."""
     if not visual_only:
-        assert (
-            coacd is not None
-        ), "coacd is required to export simulation assets."
+        assert coacd is not None, (
+            "coacd is required to export simulation assets."
+        )
 
     asset_exports = defaultdict(list)
     export_name = name if name is not None else obj.name
@@ -1626,7 +1625,7 @@ def main(args):
 
         bpy.ops.wm.open_mainfile(filepath=str(blendfile))
 
-        folder = export_scene(
+        export_scene(
             blendfile,
             args.output_folder,
             format=args.format,

embodied_gen/scripts/room_gen/gen_room.py

@@ -81,6 +81,11 @@ class GenRoomArgs:
     complexity: Complexity = Complexity.simple
     """Complexity level: minimalist, simple, medium, or detail."""
 
+    prompt: str | None = None
+    """Natural-language task/scene description. When set, room_type and
+    complexity are inferred from it via a GPT router, overriding the
+    explicit values."""
+
 
 def run_command(cmd: list[str], task_name: str):
     """Helper: Use Popen to allow killing the child process on Ctrl+C.
@@ -114,6 +119,22 @@ def run_command(cmd: list[str], task_name: str):
 
 
 def generate_room(cfg: GenRoomArgs):
+    if cfg.prompt:
+        # Deferred import: GPT routing deps are only needed in prompt mode.
+        from embodied_gen.scripts.room_gen.route_room import (
+            InfinigenGenRouter,
+        )
+        from embodied_gen.utils.gpt_clients import GPT_CLIENT
+
+        router = InfinigenGenRouter(gpt_client=GPT_CLIENT)
+        room_name, complexity = router.query(cfg.prompt)
+        cfg.room_type = RoomType(room_name)
+        cfg.complexity = Complexity(complexity)
+        logger.info(
+            f"Router mapped prompt {cfg.prompt!r} to room={room_name}, "
+            f"complexity={complexity}."
+        )
+
     room_type = cfg.room_type.value
     seed = cfg.seed
     if seed is None:

embodied_gen/scripts/room_gen/gen_trajectory.py

@@ -0,0 +1,306 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+from dataclasses import dataclass
+from importlib import import_module
+from pathlib import Path
+
+import numpy as np
+import tyro
+from shapely.geometry import Polygon
+from shapely.ops import unary_union
+
+# The spatial-computing package name contains a hyphen, so it cannot be
+# imported with a normal ``import`` statement; use importlib instead.
+_SC = "embodied_gen.skills.spatial-computing.core"
+UrdfSemanticInfoCollector = import_module(
+    f"{_SC}.collector"
+).UrdfSemanticInfoCollector
+RoamTrajectoryGenerator = import_module(
+    f"{_SC}.trajectory"
+).RoamTrajectoryGenerator
+FloorplanVisualizer = import_module(f"{_SC}.visualizer").FloorplanVisualizer
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class GenTrajectoryArgs:
+    """Configuration for roaming-trajectory generation."""
+
+    urdf_path: str
+    """Path to the input URDF scene file."""
+
+    output_dir: str = "outputs/trajectory"
+    """Directory for the trajectory JSON and floorplan PNG."""
+
+    clearance: float = 0.4
+    """Minimum clearance (m) from walls; keep small so doorways stay passable."""
+
+    obstacle_clearance: float = 0.5
+    """Minimum clearance (m) from furniture/objects (doors/walls excluded)."""
+
+    resolution: float = 0.05
+    """Occupancy-grid cell size in meters (smaller = finer, slower)."""
+
+    num_waypoints: int = 8
+    """Number of roam waypoints to visit across the navigable space."""
+
+    speed: float = 0.5
+    """Constant roaming speed (m/s). Sets the spacing with --time_step."""
+
+    time_step: float = 0.1
+    """Time between consecutive waypoints (s). Spacing = speed * time_step."""
+
+    turn_radius: float = 0.8
+    """Target turning-arc radius (m); larger gives wider, rounder turns."""
+
+    endpoint_clearance: float = 1.5
+    """Minimum distance (m) the start and end keep from walls/obstacles."""
+
+    arrow_stride: int = 10
+    """Draw a heading arrow every N points in the PNG (0 disables)."""
+
+    remove_doors: bool = False
+    """Hide door footprints in the floorplan image and animation."""
+
+    animate: bool = False
+    """Also render a per-frame floorplan animation (frames/ + trajectory.mp4)."""
+
+    anim_frame_stride: int = 1
+    """Animate every Nth waypoint. Match the render --frame_stride to sync."""
+
+    anim_fps: float = 0.0
+    """Animation frame rate. 0 = auto (real-time from speed / stride)."""
+
+    anim_dpi: int = 100
+    """Resolution (dpi) of the animation frames."""
+
+    start_xy: tuple[float, float] | None = None
+    """Optional world (x, y) start; defaults to the largest free region."""
+
+    mesh_sample_num: int = 5000
+    """Number of points sampled per mesh when parsing the URDF."""
+
+    seed: int | None = None
+    """Optional RNG seed for reproducible roaming."""
+
+
+def generate_trajectory(cfg: GenTrajectoryArgs) -> None:
+    """Run the roaming-trajectory pipeline and write outputs.
+
+    Args:
+        cfg: Parsed CLI configuration.
+    """
+    output_dir = Path(cfg.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    collector = UrdfSemanticInfoCollector(mesh_sample_num=cfg.mesh_sample_num)
+    collector.collect(cfg.urdf_path)
+
+    generator = RoamTrajectoryGenerator.from_collector(
+        collector,
+        clearance=cfg.clearance,
+        resolution=cfg.resolution,
+        obstacle_clearance=cfg.obstacle_clearance,
+    )
+    result = generator.generate(
+        start_xy=cfg.start_xy,
+        num_waypoints=cfg.num_waypoints,
+        point_spacing=cfg.speed * cfg.time_step,
+        turn_radius=cfg.turn_radius,
+        endpoint_clearance=cfg.endpoint_clearance,
+        seed=cfg.seed,
+    )
+
+    stem = Path(cfg.urdf_path).stem
+    json_path = output_dir / f"{stem}_trajectory.json"
+    png_path = output_dir / f"{stem}_trajectory.png"
+
+    # Points are equidistant, so timestamps follow constant-speed motion:
+    # t = cumulative arc length / speed.
+    xy = result.points[:, :2]
+    seg = np.linalg.norm(np.diff(xy, axis=0), axis=1)
+    times = np.concatenate([[0.0], np.cumsum(seg)]) / cfg.speed
+    waypoints = [
+        {
+            "x": round(float(x), 4),
+            "y": round(float(y), 4),
+            "rot": round(float(r), 2),
+            "t": round(float(t), 3),
+        }
+        for (x, y, r), t in zip(result.points, times)
+    ]
+
+    payload = {
+        "num_waypoints": len(waypoints),
+        "clearance": result.clearance,
+        "min_clearance": round(result.min_clearance, 4),
+        "length": round(result.length, 4),
+        "speed": cfg.speed,
+        "time_step": cfg.time_step,
+        "reachable_rooms": result.reachable_rooms,
+        "rot_convention": (
+            "0 deg points +Y (12 o'clock); counter-clockwise positive; "
+            "tangent to the roaming curve (forward heading); range [0, 360)."
+        ),
+        "waypoints": waypoints,
+    }
+    json_path.write_text(json.dumps(payload, indent=2, ensure_ascii=False))
+
+    footprints, occ_area = visible_footprints(collector, cfg.remove_doors)
+
+    FloorplanVisualizer.plot(
+        collector.rooms,
+        footprints,
+        occ_area,
+        str(png_path),
+        trajectory=result.points,
+        arrow_stride=cfg.arrow_stride,
+    )
+
+    logger.info("Trajectory waypoints : %s", json_path)
+    logger.info("Floorplan overlay    : %s", png_path)
+    logger.info(
+        "Length %.2fm, min clearance %.2fm, reaches rooms: %s",
+        result.length,
+        result.min_clearance,
+        ", ".join(result.reachable_rooms) or "(none)",
+    )
+
+    if cfg.animate:
+        fps = cfg.anim_fps
+        if fps <= 0.0:
+            fps = (1.0 / cfg.time_step) / max(1, cfg.anim_frame_stride)
+        animate_floorplan(
+            rooms=collector.rooms,
+            footprints=footprints,
+            occ_area=occ_area,
+            points=result.points,
+            output_dir=output_dir,
+            frame_stride=cfg.anim_frame_stride,
+            fps=fps,
+            dpi=cfg.anim_dpi,
+        )
+
+
+def visible_footprints(collector, remove_doors: bool):
+    """Return footprints and occupied area for floorplan drawing.
+
+    When ``remove_doors`` is set, door footprints are excluded and the
+    occupied area is recomputed without them so doors do not appear.
+
+    Args:
+        collector: Parsed scene collector.
+        remove_doors: Whether to hide door footprints.
+
+    Returns:
+        Tuple of (footprints dict, occupied-area geometry).
+    """
+    if not remove_doors:
+        return collector.footprints, collector.occ_area
+
+    footprints = {
+        key: poly
+        for key, poly in collector.footprints.items()
+        if "door" not in key.lower()
+    }
+    occ_area = (
+        unary_union(list(footprints.values())) if footprints else Polygon()
+    )
+    return footprints, occ_area
+
+
+def animate_floorplan(
+    rooms: dict,
+    footprints: dict,
+    occ_area,
+    points: np.ndarray,
+    output_dir: Path,
+    frame_stride: int,
+    fps: float,
+    dpi: int,
+) -> None:
+    """Render a floorplan animation that follows the trajectory progress.
+
+    Each frame shows the traveled path in red, a green dot at the current
+    position, and a red heading arrow; the future path is hidden. Frame
+    indices match the render frames (same stride) for easy pairing.
+
+    Args:
+        rooms: Room-name to floor-polygon map.
+        footprints: Object-name to footprint-polygon map (to draw).
+        occ_area: Occupied-area geometry overlay.
+        points: (N, 3) array of (x, y, rot_deg) waypoints.
+        output_dir: Directory to write ``frames/`` and ``trajectory.mp4``.
+        frame_stride: Render every Nth waypoint.
+        fps: Output video frame rate.
+        dpi: Resolution of each frame.
+    """
+    frames_dir = output_dir / "frames"
+    frames_dir.mkdir(parents=True, exist_ok=True)
+
+    for i in range(0, len(points), max(1, frame_stride)):
+        FloorplanVisualizer.plot(
+            rooms,
+            footprints,
+            occ_area,
+            str(frames_dir / f"frame_{i:04d}.png"),
+            trajectory=points,
+            current_index=i,
+            dpi=dpi,
+        )
+
+    video_path = output_dir / "trajectory.mp4"
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-framerate",
+        f"{max(fps, 1.0):g}",
+        "-pattern_type",
+        "glob",
+        "-i",
+        str(frames_dir / "frame_*.png"),
+        "-vf",
+        "pad=ceil(iw/2)*2:ceil(ih/2)*2",
+        "-c:v",
+        "libx264",
+        "-pix_fmt",
+        "yuv420p",
+        str(video_path),
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"ffmpeg failed for {video_path}:\n{result.stderr}")
+
+    logger.info("Trajectory animation : %s", video_path)
+
+
+def main() -> None:
+    """CLI entry point."""
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    cfg = tyro.cli(GenTrajectoryArgs)
+    generate_trajectory(cfg)
+
+
+if __name__ == "__main__":
+    main()

embodied_gen/scripts/room_gen/render_usd.py

@@ -18,11 +18,15 @@
 from __future__ import annotations
 
 import argparse
+import csv
+import json
 import logging
 import math
 import shutil
+import subprocess
 import tempfile
 from collections.abc import Callable
+from dataclasses import dataclass
 from pathlib import Path
 
 import bpy
@@ -32,6 +36,31 @@ from mathutils import Euler, Matrix, Vector
 
 logger = logging.getLogger(__name__)
 
+DOOR_KEYWORDS = ("door",)
+"""Object-name keywords used to identify door meshes for removal."""
+
+CAMERA_TRAJECTORY_CSV_FIELDS = (
+    "frame",
+    "time_sec",
+    "x",
+    "y",
+    "z",
+    "roll_x_deg",
+    "pitch_y_deg",
+    "yaw_z_deg",
+)
+"""Required fields for a camera trajectory CSV."""
+
+
+@dataclass(frozen=True)
+class CameraTrajectoryFrame:
+    """One fully specified camera pose from a trajectory CSV."""
+
+    frame_index: int
+    time_sec: float
+    xyz: tuple[float, float, float]
+    rotation_deg: tuple[float, float, float]
+
 
 def build_arg_parser() -> argparse.ArgumentParser:
     """Build the CLI parser for USD rendering."""
@@ -61,6 +90,16 @@ def build_arg_parser() -> argparse.ArgumentParser:
         "--depth_mode",
         choices=("normalized", "metric"),
         default="normalized",
+        help=(
+            "normalized: per-frame min-max (default); metric: fixed "
+            "0..--depth_max mapping, consistent across frames."
+        ),
+    )
+    parser.add_argument(
+        "--depth_max",
+        type=float,
+        default=10.0,
+        help="Max depth (m) mapped to white in metric depth mode.",
     )
     parser.add_argument(
         "--resolution",
@@ -75,14 +114,20 @@ def build_arg_parser() -> argparse.ArgumentParser:
         type=float,
         nargs=3,
         metavar=("X", "Y", "Z"),
-        required=True,
+        help=(
+            "Required for single-frame mode; ignored with --trajectory_json "
+            "or --trajectory_csv."
+        ),
     )
     parser.add_argument(
         "--camera_rotation_deg",
         type=float,
         nargs=3,
         metavar=("RX", "RY", "RZ"),
-        required=True,
+        help=(
+            "Required for single-frame mode; ignored with --trajectory_json "
+            "or --trajectory_csv."
+        ),
     )
     parser.add_argument(
         "--flow_camera_xyz",
@@ -100,6 +145,113 @@ def build_arg_parser() -> argparse.ArgumentParser:
     parser.add_argument("--exposure", type=float, default=2.2)
     parser.add_argument("--world_strength", type=float, default=8.0)
     parser.add_argument("--fill_light_energy", type=float, default=14000.0)
+    parser.add_argument(
+        "--remove_doors",
+        action="store_true",
+        help="Remove all door meshes from the USD before rendering.",
+    )
+
+    # Trajectory modes: roaming JSON follows (x, y, rot) waypoints with a GLB
+    # offset, while camera CSV uses a complete 6DoF camera pose per row.
+    trajectory_group = parser.add_mutually_exclusive_group()
+    trajectory_group.add_argument(
+        "--trajectory_json",
+        type=Path,
+        default=None,
+        help=(
+            "Trajectory JSON ({waypoints:[{x,y,rot,...}]}). When set, renders "
+            "one frame per waypoint instead of a single frame."
+        ),
+    )
+    trajectory_group.add_argument(
+        "--trajectory_csv",
+        type=Path,
+        default=None,
+        help=(
+            "Camera trajectory CSV with fields frame,time_sec,x,y,z,"
+            "roll_x_deg,pitch_y_deg,yaw_z_deg. Each row is rendered as one "
+            "frame using its full camera pose."
+        ),
+    )
+    parser.add_argument(
+        "--camera_z",
+        type=float,
+        default=1.36,
+        help="Camera height (m) for trajectory mode.",
+    )
+    parser.add_argument(
+        "--camera_pitch",
+        type=float,
+        default=80.0,
+        help="Camera pitch deg (rotation_deg[0]) for trajectory mode.",
+    )
+    parser.add_argument(
+        "--camera_roll",
+        type=float,
+        default=0.0,
+        help="Camera roll deg (rotation_deg[1]) for trajectory mode.",
+    )
+    parser.add_argument(
+        "--glb_offset_xyz",
+        type=float,
+        nargs=3,
+        default=(0.0012, 0.345, -1.36),
+        metavar=("DX", "DY", "DZ"),
+        help=(
+            "GLB position minus camera position at yaw=0 (world frame). The "
+            "horizontal part rotates with the camera yaw (rot); DZ is fixed."
+        ),
+    )
+    parser.add_argument(
+        "--glb_base_rotation_deg",
+        type=float,
+        nargs=3,
+        default=(-90.0, 0.0, 90.0),
+        metavar=("RX", "RY", "RZ"),
+        help=(
+            "GLB rotation deg at yaw=0; the Z component gets + rot per frame."
+        ),
+    )
+    parser.add_argument(
+        "--frame_stride",
+        type=int,
+        default=1,
+        help="Render every Nth waypoint/CSV row in trajectory mode.",
+    )
+    parser.add_argument(
+        "--frame_indices",
+        type=int,
+        nargs="+",
+        default=None,
+        metavar="INDEX",
+        help=(
+            "Render only these trajectory frame/waypoint indices. "
+            "When set, --frame_stride is ignored."
+        ),
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help=(
+            "Re-render trajectory frames even if they already exist "
+            "(default: skip existing frames for per-frame resume)."
+        ),
+    )
+    parser.add_argument(
+        "--make_video",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Stitch trajectory RGB frames into an mp4 (default: on).",
+    )
+    parser.add_argument(
+        "--video_fps",
+        type=float,
+        default=0.0,
+        help=(
+            "Video frame rate. 0 = auto from JSON time_step or CSV time_sec "
+            "and --frame_stride for real-time playback."
+        ),
+    )
     return parser
 
 
@@ -120,6 +272,7 @@ class RenderUsd:
         output_dir: Path,
         render_passes: tuple[str, ...] | list[str],
         depth_mode: str,
+        depth_max: float,
         resolution: tuple[int, int] | list[int],
         samples: int,
         camera_xyz: tuple[float, float, float] | list[float],
@@ -132,17 +285,21 @@ class RenderUsd:
         exposure: float,
         world_strength: float,
         fill_light_energy: float,
+        remove_doors: bool = False,
     ) -> None:
         """Initialize renderer configuration independent of CLI parsing."""
         self.usd_path = usd_path
         self.glb_path = self.normalize_optional_path(glb_path)
         self.glb_xyz = tuple(glb_xyz) if glb_xyz is not None else None
         self.glb_rotation_deg = (
-            tuple(glb_rotation_deg) if glb_rotation_deg is not None else None
+            list(glb_rotation_deg) if glb_rotation_deg is not None else None
         )
+        if self.glb_rotation_deg is not None:
+            self.glb_rotation_deg[0] += 90
         self.output_dir = output_dir
         self.render_passes = tuple(render_passes)
         self.depth_mode = depth_mode
+        self.depth_max = depth_max
         self.resolution = tuple(resolution)
         self.samples = samples
         self.camera_xyz = tuple(camera_xyz)
@@ -159,6 +316,12 @@ class RenderUsd:
         self.exposure = exposure
         self.world_strength = world_strength
         self.fill_light_energy = fill_light_energy
+        self.remove_doors = remove_doors
+        # Trajectory frame layout: route each pass to frames_<pass>/
+        # frame_<idx>.<ext> under frame_base_dir instead of output_dir.
+        self.frame_layout = False
+        self.frame_base_dir: Path | None = None
+        self.frame_index = 0
         self.temp_dir: Path | None = None
 
     @classmethod
@@ -172,6 +335,7 @@ class RenderUsd:
             output_dir=args.output_dir,
             render_passes=args.render_passes,
             depth_mode=args.depth_mode,
+            depth_max=args.depth_max,
             resolution=args.resolution,
             samples=args.samples,
             camera_xyz=args.camera_xyz,
@@ -182,6 +346,7 @@ class RenderUsd:
             exposure=args.exposure,
             world_strength=args.world_strength,
             fill_light_energy=args.fill_light_energy,
+            remove_doors=args.remove_doors,
         )
 
     @property
@@ -203,7 +368,17 @@ class RenderUsd:
         return Path(normalized)
 
     def build_output_path(self, filename: str) -> Path:
-        """Build a normalized output path under the render directory."""
+        """Build a normalized output path under the render directory.
+
+        In trajectory frame layout, each pass is routed to its own
+        ``frames_<pass>/frame_<idx>.<ext>`` directory under
+        ``frame_base_dir``; otherwise the file lives directly in
+        ``output_dir``.
+        """
+        if self.frame_layout and self.frame_base_dir is not None:
+            name = Path(filename)
+            subdir = self.frame_base_dir / f"frames_{name.stem}"
+            return subdir / f"frame_{self.frame_index:04d}{name.suffix}"
         return self.output_dir / filename
 
     def build_temp_path(self, filename: str) -> Path:
@@ -308,19 +483,43 @@ class RenderUsd:
             raise FileNotFoundError(f"USD file not found: {self.usd_path}")
         bpy.ops.wm.usd_import(filepath=str(self.usd_path))
 
-    def validate_glb_args(self) -> None:
+    def remove_door_objects(self) -> int:
+        """Delete any object whose name contains a door keyword."""
+        removed = 0
+        for obj in list(self.scene.objects):
+            if any(kw in obj.name.lower() for kw in DOOR_KEYWORDS):
+                bpy.data.objects.remove(obj, do_unlink=True)
+                removed += 1
+        logger.info("Removed %d door objects.", removed)
+        return removed
+
+    def validate_glb_args(self, *, allow_path_only: bool = False) -> None:
         """Normalize optional GLB arguments and ensure all-or-none usage."""
         has_glb_path = self.glb_path is not None
         has_glb_xyz = self.glb_xyz is not None
         has_glb_rotation = self.glb_rotation_deg is not None
-        if len({has_glb_path, has_glb_xyz, has_glb_rotation}) != 1:
+        if not has_glb_path:
+            if has_glb_xyz or has_glb_rotation:
+                raise ValueError(
+                    "--glb_xyz and --glb_rotation_deg require --glb_path."
+                )
+            return
+        if allow_path_only and not has_glb_xyz and not has_glb_rotation:
+            self.validate_glb_path()
+            return
+        if not has_glb_xyz or not has_glb_rotation:
             raise ValueError(
                 "--glb_path, --glb_xyz, and --glb_rotation_deg must be "
-                "provided together."
+                "provided together, unless trajectory rendering follows the "
+                "camera with --glb_offset_xyz/--glb_base_rotation_deg."
             )
-        if not has_glb_path:
-            return
 
+        self.validate_glb_path()
+
+    def validate_glb_path(self) -> None:
+        """Ensure the optional GLB path points to an existing .glb file."""
+        if self.glb_path is None:
+            return
         if not self.glb_path.exists():
             raise FileNotFoundError(f"GLB file not found: {self.glb_path}")
         if self.glb_path.suffix.lower() != ".glb":
@@ -566,17 +765,43 @@ class RenderUsd:
         self.scene.render.resolution_y = self.resolution[1]
         self.scene.render.image_settings.file_format = "PNG"
         self.scene.render.film_transparent = False
+        self.scene.render.use_persistent_data = False
+
+        # Adaptive sampling + denoising keep quality high at low sample counts.
+        self.scene.cycles.use_adaptive_sampling = True
+        self.scene.cycles.use_denoising = True
+
+        self.enable_gpu_devices()
 
+    def enable_gpu_devices(self) -> None:
+        """Enable Cycles GPU devices, preferring OptiX then CUDA."""
         prefs = bpy.context.preferences.addons["cycles"].preferences
-        prefs.compute_device_type = "CUDA"
-        prefs.get_devices()
-        cuda_devices = [
-            device for device in prefs.devices if device.type == "CUDA"
-        ]
-        if not cuda_devices:
-            raise RuntimeError("No CUDA device found in Blender Cycles.")
-        for device in prefs.devices:
-            device.use = device.type == "CUDA"
+        for backend in ("OPTIX", "CUDA"):
+            try:
+                prefs.compute_device_type = backend
+            except TypeError:
+                continue
+            prefs.get_devices()
+            gpu_devices = [d for d in prefs.devices if d.type == backend]
+            if not gpu_devices:
+                continue
+
+            for device in prefs.devices:
+                device.use = device.type == backend
+            try:
+                self.scene.cycles.denoiser = (
+                    "OPTIX" if backend == "OPTIX" else "OPENIMAGEDENOISE"
+                )
+            except (TypeError, AttributeError):
+                pass
+            logger.info(
+                "Cycles GPU backend: %s (%d device(s)).",
+                backend,
+                len(gpu_devices),
+            )
+            return
+
+        raise RuntimeError("No OptiX/CUDA GPU device found in Blender Cycles.")
 
     def configure_color_management(self) -> None:
         self.scene.view_settings.exposure = self.exposure
@@ -602,6 +827,7 @@ class RenderUsd:
             "color_depth": self.scene.render.image_settings.color_depth,
             "use_nodes": self.scene.use_nodes,
             "samples": self.scene.cycles.samples,
+            "use_denoising": self.scene.cycles.use_denoising,
         }
         if include_filepath:
             state["filepath"] = self.scene.render.filepath
@@ -627,6 +853,7 @@ class RenderUsd:
         self.scene.render.image_settings.color_depth = state["color_depth"]
         self.scene.use_nodes = state["use_nodes"]
         self.scene.cycles.samples = state["samples"]
+        self.scene.cycles.use_denoising = state["use_denoising"]
         if "filepath" in state:
             self.scene.render.filepath = state["filepath"]
         if "material_override" in state:
@@ -652,6 +879,9 @@ class RenderUsd:
         self.scene.view_settings.gamma = 1.0
         self.scene.use_nodes = use_nodes
         self.scene.cycles.samples = samples
+        # Auxiliary passes (normal/mesh/seg/flow depth) must not be denoised:
+        # denoising would blur normals and corrupt integer index passes.
+        self.scene.cycles.use_denoising = False
         self.scene.render.image_settings.file_format = "PNG"
         self.scene.render.image_settings.color_mode = color_mode
         self.scene.render.image_settings.color_depth = color_depth
@@ -785,6 +1015,7 @@ class RenderUsd:
         depth_mode: str,
     ) -> bpy.types.Node:
         """Build the compositor node that converts raw depth to a previewable map."""
+        del camera  # Mapping uses self.depth_max, not the camera clip range.
         if depth_mode == "normalized":
             normalize = tree.nodes.new(type="CompositorNodeNormalize")
             tree.links.new(render_layers.outputs["Depth"], normalize.inputs[0])
@@ -794,8 +1025,9 @@ class RenderUsd:
             raise ValueError(f"Unsupported depth mode: {depth_mode}")
 
         depth_map = tree.nodes.new(type="CompositorNodeMapRange")
-        depth_map.inputs["From Min"].default_value = camera.clip_start
-        depth_map.inputs["From Max"].default_value = camera.clip_end
+        # Fixed 0..depth_max mapping keeps depth consistent across frames.
+        depth_map.inputs["From Min"].default_value = 0.0
+        depth_map.inputs["From Max"].default_value = self.depth_max
         depth_map.inputs["To Min"].default_value = 0.0
         depth_map.inputs["To Max"].default_value = 1.0
         depth_map.use_clamp = True
@@ -861,6 +1093,7 @@ class RenderUsd:
         self, temp_path: Path, output_path: Path
     ) -> None:
         """Convert the grayscale depth temp image into the final colored preview."""
+        output_path.parent.mkdir(parents=True, exist_ok=True)
         if output_path.exists():
             output_path.unlink()
         if not temp_path.exists():
@@ -1097,8 +1330,8 @@ class RenderUsd:
         output_path: Path,
         instance_seg: np.ndarray,
     ) -> None:
-        output_path.parent.mkdir(parents=True, exist_ok=True)
         vis_output_path = self.get_instance_seg_vis_output_path(output_path)
+        vis_output_path.parent.mkdir(parents=True, exist_ok=True)
 
         visualization = self.build_instance_seg_visualization(
             instance_seg=instance_seg,
@@ -1255,10 +1488,15 @@ class RenderUsd:
         flow: np.ndarray,
         valid_mask: np.ndarray,
     ) -> None:
-        output_path.parent.mkdir(parents=True, exist_ok=True)
         flow_output_path = self.get_flow_output_path(output_path)
         flow_valid_output_path = self.get_flow_valid_output_path(output_path)
         flow_vis_output_path = self.get_flow_vis_output_path(output_path)
+        for path in (
+            flow_output_path,
+            flow_valid_output_path,
+            flow_vis_output_path,
+        ):
+            path.parent.mkdir(parents=True, exist_ok=True)
 
         self.save_numpy_array(flow_output_path, flow)
         self.save_numpy_array(flow_valid_output_path, valid_mask)
@@ -1437,6 +1675,7 @@ class RenderUsd:
         composite_output_path = self.get_composite_output_path(
             tuple(render_pass_name for render_pass_name, _ in composite_images)
         )
+        composite_output_path.parent.mkdir(parents=True, exist_ok=True)
         composite_image = self.build_composite_image(
             [image for _, image in composite_images],
             [render_pass_name for render_pass_name, _ in composite_images],
@@ -1560,6 +1799,8 @@ class RenderUsd:
         self.output_dir.mkdir(parents=True, exist_ok=True)
         self.clear_scene()
         self.import_usd()
+        if self.remove_doors:
+            self.remove_door_objects()
         self.validate_glb_args()
         imported_glb_objects = self.import_glb_asset()
         self.place_glb_asset(imported_glb_objects)
@@ -1595,10 +1836,764 @@ class RenderUsd:
 
         logger.info("Rendered outputs to %s", self.output_dir)
 
+    def compute_trajectory_frame_transforms(
+        self,
+        x: float,
+        y: float,
+        rot_deg: float,
+        *,
+        camera_z: float,
+        camera_pitch: float,
+        camera_roll: float,
+        glb_offset_xyz: tuple[float, float, float],
+        glb_base_rotation_deg: tuple[float, float, float],
+    ) -> tuple[Vector, Euler, Matrix]:
+        """Compute per-frame camera and GLB transforms for one waypoint.
+
+        The camera sits at (x, y, camera_z) and yaws by ``rot_deg`` (its
+        heading). The GLB keeps a fixed offset relative to the camera: the
+        horizontal offset rotates with the yaw and its yaw adds ``rot_deg``,
+        while its height stays on the floor.
+
+        Args:
+            x: Waypoint X (m).
+            y: Waypoint Y (m).
+            rot_deg: Waypoint heading in degrees (camera/GLB yaw).
+            camera_z: Camera height (m).
+            camera_pitch: Camera pitch deg (rotation_deg[0]).
+            camera_roll: Camera roll deg (rotation_deg[1]).
+            glb_offset_xyz: GLB-minus-camera offset at yaw=0 (world frame).
+            glb_base_rotation_deg: GLB rotation deg at yaw=0.
+
+        Returns:
+            Tuple of (camera_location, camera_euler, glb_world_transform).
+        """
+        camera_location = Vector((x, y, camera_z))
+        camera_euler = Euler(
+            self.get_rotation_radians((camera_pitch, camera_roll, rot_deg)),
+            "XYZ",
+        )
+
+        yaw = math.radians(rot_deg)
+        cos_yaw, sin_yaw = math.cos(yaw), math.sin(yaw)
+        off_x, off_y, off_z = glb_offset_xyz
+        glb_xyz = (
+            x + off_x * cos_yaw - off_y * sin_yaw,
+            y + off_x * sin_yaw + off_y * cos_yaw,
+            camera_z + off_z,
+        )
+        base_rx, base_ry, base_rz = glb_base_rotation_deg
+        glb_rotation_deg = (base_rx + 90.0, base_ry, base_rz + rot_deg)
+        glb_transform = self.build_camera_matrix_world(
+            glb_xyz, glb_rotation_deg
+        )
+        return camera_location, camera_euler, glb_transform
+
+    def compute_camera_follow_glb_transform(
+        self,
+        camera_xyz: tuple[float, float, float],
+        camera_rotation_deg: tuple[float, float, float],
+        *,
+        glb_offset_xyz: tuple[float, float, float],
+        glb_base_rotation_deg: tuple[float, float, float],
+    ) -> Matrix:
+        """Compute a GLB transform from the default camera-follow offset."""
+        _, _, glb_transform = self.compute_trajectory_frame_transforms(
+            camera_xyz[0],
+            camera_xyz[1],
+            camera_rotation_deg[2],
+            camera_z=camera_xyz[2],
+            camera_pitch=camera_rotation_deg[0],
+            camera_roll=camera_rotation_deg[1],
+            glb_offset_xyz=glb_offset_xyz,
+            glb_base_rotation_deg=glb_base_rotation_deg,
+        )
+        return glb_transform
+
+    def frame_outputs_exist(self) -> bool:
+        """Whether every requested pass output for the current frame exists.
+
+        Used for per-frame resume: a frame is skipped only when all its
+        requested pass preview outputs are already on disk.
+        """
+        rgb_path = self.get_rgb_output_path()
+        for pass_name, occurrence in self.iter_render_pass_occurrences():
+            preview = self.get_preview_output_path(
+                rgb_path, pass_name, occurrence
+            )
+            if preview is None or not preview.exists():
+                return False
+        return True
+
+    def run_trajectory(
+        self,
+        *,
+        waypoints: list[tuple[float, float, float]],
+        camera_z: float,
+        camera_pitch: float,
+        camera_roll: float,
+        glb_offset_xyz: tuple[float, float, float],
+        glb_base_rotation_deg: tuple[float, float, float],
+        frame_stride: int,
+        frame_indices: list[int] | None = None,
+        make_video: bool = False,
+        video_fps: float = 10.0,
+        overwrite: bool = False,
+    ) -> None:
+        """Render one frame per trajectory waypoint following the camera path.
+
+        The scene (USD, GLB, lighting, world) is set up once; each frame only
+        repositions the camera and GLB, then renders into a shared ``frames/``
+        directory with a ``frame_<idx>_`` filename prefix. When ``make_video``
+        is set, the RGB frames are stitched into an mp4.
+
+        Args:
+            waypoints: List of (x, y, rot_deg) waypoints.
+            camera_z: Camera height (m).
+            camera_pitch: Camera pitch deg (rotation_deg[0]).
+            camera_roll: Camera roll deg (rotation_deg[1]).
+            glb_offset_xyz: GLB-minus-camera offset at yaw=0 (world frame).
+            glb_base_rotation_deg: GLB rotation deg at yaw=0.
+            frame_stride: Render every Nth waypoint.
+            frame_indices: Optional zero-based waypoint indices to render.
+            make_video: Stitch the RGB frames into an mp4 after rendering.
+            video_fps: Frame rate of the stitched video.
+            overwrite: Re-render every frame; if False, frames whose pass
+                outputs already exist are skipped (per-frame resume).
+        """
+        if not waypoints:
+            raise ValueError("Trajectory contains no waypoints.")
+        if self.glb_path is None:
+            raise ValueError(
+                "--glb_path is required for trajectory rendering."
+            )
+        if not self.glb_path.exists():
+            raise FileNotFoundError(f"GLB file not found: {self.glb_path}")
+        if self.glb_path.suffix.lower() != ".glb":
+            raise ValueError(
+                f"Expected a .glb asset, but got: {self.glb_path}"
+            )
+
+        base_output_dir = self.output_dir
+        base_output_dir.mkdir(parents=True, exist_ok=True)
+
+        self.clear_scene()
+        self.import_usd()
+        if self.remove_doors:
+            self.remove_door_objects()
+        imported_glb_objects = self.import_glb_asset()
+        root_objects = self.get_imported_root_objects(imported_glb_objects)
+        original_matrices = {
+            obj.as_pointer(): obj.matrix_world.copy() for obj in root_objects
+        }
+
+        min_corner, max_corner = self.get_scene_bbox()
+        center = (min_corner + max_corner) * 0.5
+        diagonal = (max_corner - min_corner).length
+        camera = self.create_camera()
+        self.ensure_lighting(diagonal, center, max_corner.z)
+        world_created = self.ensure_world()
+        self.add_fill_light(
+            diagonal, center, max_corner.z, energy=self.fill_light_energy
+        )
+        if world_created:
+            self.add_light_rig(
+                diagonal,
+                center,
+                max_corner.z,
+                area_energy=1500.0,
+                sun_energy=0.35,
+                prefix="Fill",
+            )
+        self.configure_color_management()
+        self.configure_cycles()
+
+        if frame_indices is None:
+            frames = list(enumerate(waypoints))[:: max(1, frame_stride)]
+        else:
+            invalid_indices = sorted(
+                {
+                    index
+                    for index in frame_indices
+                    if index < 0 or index >= len(waypoints)
+                }
+            )
+            if invalid_indices:
+                raise ValueError(
+                    "Trajectory frame indices out of range "
+                    f"[0, {len(waypoints) - 1}]: {invalid_indices}"
+                )
+            frames = [
+                (index, waypoints[index])
+                for index in dict.fromkeys(frame_indices)
+            ]
+        self.frame_layout = True
+        self.frame_base_dir = base_output_dir
+
+        # The highest already-rendered frame is the one most likely left
+        # half-written by an interrupted run, so re-render it even on resume.
+        last_existing = -1
+        if not overwrite:
+            for frame_idx, _ in frames:
+                self.frame_index = frame_idx
+                if self.frame_outputs_exist():
+                    last_existing = frame_idx
+
+        with tempfile.TemporaryDirectory(
+            prefix="render_usd_traj_", dir=None
+        ) as temp_dir:
+            self.temp_dir = Path(temp_dir)
+            for frame_idx, (x, y, rot_deg) in frames:
+                self.frame_index = frame_idx
+                # Per-frame resume: skip complete frames, but always redo the
+                # last existing one (possibly a truncated/corrupt write).
+                if (
+                    not overwrite
+                    and frame_idx != last_existing
+                    and self.frame_outputs_exist()
+                ):
+                    logger.info("Skip existing frame %04d", frame_idx)
+                    continue
+
+                cam_loc, cam_euler, glb_transform = (
+                    self.compute_trajectory_frame_transforms(
+                        x,
+                        y,
+                        rot_deg,
+                        camera_z=camera_z,
+                        camera_pitch=camera_pitch,
+                        camera_roll=camera_roll,
+                        glb_offset_xyz=glb_offset_xyz,
+                        glb_base_rotation_deg=glb_base_rotation_deg,
+                    )
+                )
+                camera.location = cam_loc
+                camera.rotation_euler = cam_euler
+                for obj in root_objects:
+                    obj.matrix_world = (
+                        glb_transform @ original_matrices[obj.as_pointer()]
+                    )
+                bpy.context.view_layer.update()
+
+                self.render(self.get_rgb_output_path())
+                logger.info(
+                    "Rendered frame %04d at (%.3f, %.3f, rot=%.1f)",
+                    frame_idx,
+                    x,
+                    y,
+                    rot_deg,
+                )
+            self.temp_dir = None
+
+        self.frame_layout = False
+        self.frame_base_dir = None
+        self.output_dir = base_output_dir
+        logger.info(
+            "Rendered %d trajectory frames to %s",
+            len(frames),
+            base_output_dir,
+        )
+
+        if make_video:
+            self.stitch_pass_videos(base_output_dir, fps=video_fps)
+
+    def run_camera_trajectory(
+        self,
+        *,
+        frames: list[CameraTrajectoryFrame],
+        glb_offset_xyz: tuple[float, float, float],
+        glb_base_rotation_deg: tuple[float, float, float],
+        frame_stride: int,
+        frame_indices: list[int] | None = None,
+        make_video: bool = False,
+        video_fps: float = 10.0,
+        overwrite: bool = False,
+    ) -> None:
+        """Render fully specified camera poses loaded from a trajectory CSV.
+
+        Args:
+            frames: Camera frames with output index, timestamp, and 6DoF pose.
+            glb_offset_xyz: Local XYZ offset applied to GLB assets.
+            glb_base_rotation_deg: Base XYZ Euler rotation applied to GLB assets.
+            frame_stride: Render every Nth CSV row.
+            frame_indices: Optional CSV ``frame`` values to render.
+            make_video: Stitch rendered image passes into mp4 files.
+            video_fps: Frame rate of the stitched videos.
+            overwrite: Re-render complete frames instead of resuming.
+        """
+        if not frames:
+            raise ValueError("Camera trajectory contains no frames.")
+
+        base_output_dir = self.output_dir
+        base_output_dir.mkdir(parents=True, exist_ok=True)
+
+        self.clear_scene()
+        self.import_usd()
+        if self.remove_doors:
+            self.remove_door_objects()
+        self.validate_glb_args(allow_path_only=True)
+        imported_glb_objects = self.import_glb_asset()
+        glb_follows_camera = (
+            self.glb_path is not None
+            and self.glb_xyz is None
+            and self.glb_rotation_deg is None
+        )
+        root_objects: list[bpy.types.Object] = []
+        original_matrices: dict[int, Matrix] = {}
+        if glb_follows_camera:
+            root_objects = self.get_imported_root_objects(imported_glb_objects)
+            original_matrices = {
+                obj.as_pointer(): obj.matrix_world.copy()
+                for obj in root_objects
+            }
+        else:
+            self.place_glb_asset(imported_glb_objects)
+
+        min_corner, max_corner = self.get_scene_bbox()
+        center = (min_corner + max_corner) * 0.5
+        diagonal = (max_corner - min_corner).length
+        camera = self.create_camera()
+        self.ensure_lighting(diagonal, center, max_corner.z)
+        world_created = self.ensure_world()
+        self.add_fill_light(
+            diagonal, center, max_corner.z, energy=self.fill_light_energy
+        )
+        if world_created:
+            self.add_light_rig(
+                diagonal,
+                center,
+                max_corner.z,
+                area_energy=1500.0,
+                sun_energy=0.35,
+                prefix="Fill",
+            )
+        self.configure_color_management()
+        self.configure_cycles()
+
+        if frame_indices is None:
+            selected_frames = frames[:: max(1, frame_stride)]
+        else:
+            frames_by_index = {frame.frame_index: frame for frame in frames}
+            invalid_indices = sorted(
+                {
+                    index
+                    for index in frame_indices
+                    if index not in frames_by_index
+                }
+            )
+            if invalid_indices:
+                raise ValueError(
+                    "Camera trajectory frame indices not found: "
+                    f"{invalid_indices}"
+                )
+            selected_frames = [
+                frames_by_index[index]
+                for index in dict.fromkeys(frame_indices)
+            ]
+
+        self.frame_layout = True
+        self.frame_base_dir = base_output_dir
+
+        last_existing = -1
+        if not overwrite:
+            for frame in selected_frames:
+                self.frame_index = frame.frame_index
+                if self.frame_outputs_exist():
+                    last_existing = frame.frame_index
+
+        with tempfile.TemporaryDirectory(
+            prefix="render_usd_camera_traj_", dir=None
+        ) as temp_dir:
+            self.temp_dir = Path(temp_dir)
+            for frame in selected_frames:
+                self.frame_index = frame.frame_index
+                if (
+                    not overwrite
+                    and frame.frame_index != last_existing
+                    and self.frame_outputs_exist()
+                ):
+                    logger.info("Skip existing frame %04d", frame.frame_index)
+                    continue
+
+                camera.location = Vector(frame.xyz)
+                camera.rotation_euler = Euler(
+                    self.get_rotation_radians(frame.rotation_deg),
+                    "XYZ",
+                )
+                if glb_follows_camera:
+                    glb_transform = self.compute_camera_follow_glb_transform(
+                        frame.xyz,
+                        frame.rotation_deg,
+                        glb_offset_xyz=glb_offset_xyz,
+                        glb_base_rotation_deg=glb_base_rotation_deg,
+                    )
+                    for obj in root_objects:
+                        obj.matrix_world = (
+                            glb_transform @ original_matrices[obj.as_pointer()]
+                        )
+                bpy.context.view_layer.update()
+
+                self.render(self.get_rgb_output_path())
+                logger.info(
+                    "Rendered frame %04d at "
+                    "(%.3f, %.3f, %.3f), rotation=(%.2f, %.2f, %.2f)",
+                    frame.frame_index,
+                    *frame.xyz,
+                    *frame.rotation_deg,
+                )
+            self.temp_dir = None
+
+        self.frame_layout = False
+        self.frame_base_dir = None
+        self.output_dir = base_output_dir
+        logger.info(
+            "Rendered %d camera trajectory frames to %s",
+            len(selected_frames),
+            base_output_dir,
+        )
+
+        if make_video:
+            self.stitch_pass_videos(base_output_dir, fps=video_fps)
+
+    def stitch_pass_videos(self, base_dir: Path, *, fps: float) -> None:
+        """Stitch each ``frames_<pass>/`` image sequence into ``<pass>.mp4``.
+
+        Scans ``base_dir`` for ``frames_<pass>`` directories, orders the
+        ``frame_*.png`` images, and writes one video per pass next to them
+        (e.g. ``frames_render_rgb/`` -> ``render_rgb.mp4``) using ffmpeg.
+
+        Args:
+            base_dir: Trajectory output directory containing the frame dirs.
+            fps: Output frame rate (clamped to a small positive minimum).
+        """
+        fps = max(fps, 1.0)
+        for frames_subdir in sorted(base_dir.glob("frames_*")):
+            if not frames_subdir.is_dir():
+                continue
+            frame_paths = sorted(frames_subdir.glob("frame_*.png"))
+            if not frame_paths:
+                continue
+
+            pass_name = frames_subdir.name[len("frames_") :]
+            output_path = base_dir / f"{pass_name}.mp4"
+            self.encode_frames_to_video(frames_subdir, output_path, fps)
+            logger.info(
+                "Stitched %d frames into %s (%.2f fps).",
+                len(frame_paths),
+                output_path,
+                fps,
+            )
+
+    @staticmethod
+    def encode_frames_to_video(
+        frames_dir: Path, output_path: Path, fps: float
+    ) -> None:
+        """Encode a ``frame_*.png`` sequence into an mp4 via ffmpeg.
+
+        Uses the system ffmpeg (h264/yuv420p) and a glob input pattern so
+        non-contiguous frame indices (e.g. with --frame_stride) work. Even
+        dimensions are enforced for yuv420p compatibility.
+
+        Args:
+            frames_dir: Directory holding the ``frame_*.png`` images.
+            output_path: Destination mp4 path.
+            fps: Output frame rate.
+        """
+        cmd = [
+            "ffmpeg",
+            "-y",
+            "-framerate",
+            f"{fps:g}",
+            "-pattern_type",
+            "glob",
+            "-i",
+            str(frames_dir / "frame_*.png"),
+            "-vf",
+            "pad=ceil(iw/2)*2:ceil(ih/2)*2",
+            "-c:v",
+            "libx264",
+            "-pix_fmt",
+            "yuv420p",
+            str(output_path),
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            raise RuntimeError(
+                f"ffmpeg failed for {output_path}:\n{result.stderr}"
+            )
+
+
+def load_trajectory_waypoints(
+    trajectory_json: Path,
+) -> list[tuple[float, float, float]]:
+    """Load (x, y, rot) waypoints from a trajectory JSON file.
+
+    Accepts either a dict with a ``waypoints`` key or a bare list of records.
+
+    Args:
+        trajectory_json: Path to the trajectory JSON.
+
+    Returns:
+        List of (x, y, rot_deg) tuples.
+    """
+    data = json.loads(Path(trajectory_json).read_text())
+    records = data["waypoints"] if isinstance(data, dict) else data
+    return [
+        (float(rec["x"]), float(rec["y"]), float(rec["rot"]))
+        for rec in records
+    ]
+
+
+def load_camera_trajectory_csv(
+    trajectory_csv: Path,
+) -> list[CameraTrajectoryFrame]:
+    """Load full camera poses from a trajectory CSV file.
+
+    Args:
+        trajectory_csv: CSV containing the required camera trajectory fields.
+
+    Returns:
+        Camera frames in CSV row order.
+    """
+    trajectory_csv = Path(trajectory_csv)
+    if not trajectory_csv.exists():
+        raise FileNotFoundError(
+            f"Camera trajectory CSV not found: {trajectory_csv}"
+        )
+
+    frames: list[CameraTrajectoryFrame] = []
+    seen_indices: set[int] = set()
+    previous_frame_index: int | None = None
+    previous_time_sec: float | None = None
+    with trajectory_csv.open(newline="", encoding="utf-8-sig") as csv_file:
+        reader = csv.DictReader(csv_file)
+        fieldnames = set(reader.fieldnames or ())
+        missing_fields = [
+            field
+            for field in CAMERA_TRAJECTORY_CSV_FIELDS
+            if field not in fieldnames
+        ]
+        if missing_fields:
+            raise ValueError(
+                f"Camera trajectory CSV is missing fields: {missing_fields}"
+            )
+
+        for row_number, row in enumerate(reader, start=2):
+            try:
+                frame_index = int(row["frame"])
+                values = {
+                    field: float(row[field])
+                    for field in CAMERA_TRAJECTORY_CSV_FIELDS[1:]
+                }
+            except (TypeError, ValueError) as exc:
+                raise ValueError(
+                    "Invalid camera trajectory value at CSV row "
+                    f"{row_number}: {exc}"
+                ) from exc
+
+            if frame_index < 0:
+                raise ValueError(
+                    f"Camera frame must be non-negative at CSV row "
+                    f"{row_number}: {frame_index}"
+                )
+            if frame_index in seen_indices:
+                raise ValueError(
+                    f"Duplicate camera frame at CSV row {row_number}: "
+                    f"{frame_index}"
+                )
+            non_finite_fields = [
+                field
+                for field, value in values.items()
+                if not math.isfinite(value)
+            ]
+            if non_finite_fields:
+                raise ValueError(
+                    f"Non-finite values at CSV row {row_number}: "
+                    f"{non_finite_fields}"
+                )
+            if (
+                previous_frame_index is not None
+                and frame_index <= previous_frame_index
+            ):
+                raise ValueError(
+                    "Camera frames must be strictly increasing at CSV row "
+                    f"{row_number}: {frame_index} <= {previous_frame_index}"
+                )
+            if (
+                previous_time_sec is not None
+                and values["time_sec"] <= previous_time_sec
+            ):
+                raise ValueError(
+                    "Camera timestamps must be strictly increasing at CSV "
+                    f"row {row_number}: {values['time_sec']} <= "
+                    f"{previous_time_sec}"
+                )
+
+            seen_indices.add(frame_index)
+            previous_frame_index = frame_index
+            previous_time_sec = values["time_sec"]
+            frames.append(
+                CameraTrajectoryFrame(
+                    frame_index=frame_index,
+                    time_sec=values["time_sec"],
+                    xyz=(values["x"], values["y"], values["z"]),
+                    rotation_deg=(
+                        values["roll_x_deg"],
+                        values["pitch_y_deg"],
+                        values["yaw_z_deg"],
+                    ),
+                )
+            )
+
+    return frames
+
+
+def resolve_video_fps(
+    video_fps: float, trajectory_json: Path, frame_stride: int
+) -> float:
+    """Resolve the video frame rate, auto-deriving real-time fps if 0.
+
+    Args:
+        video_fps: Requested fps; 0 means auto.
+        trajectory_json: Trajectory JSON (read for ``time_step``).
+        frame_stride: Waypoint stride used during rendering.
+
+    Returns:
+        A positive frame rate.
+    """
+    if video_fps > 0.0:
+        return video_fps
+
+    data = json.loads(Path(trajectory_json).read_text())
+    time_step = data.get("time_step") if isinstance(data, dict) else None
+    if not time_step or time_step <= 0.0:
+        return 10.0
+    return (1.0 / time_step) / max(1, frame_stride)
+
+
+def resolve_csv_video_fps(
+    video_fps: float,
+    frames: list[CameraTrajectoryFrame],
+    frame_stride: int,
+) -> float:
+    """Resolve video fps from CSV timestamps when no fps is specified."""
+    if video_fps > 0.0:
+        return video_fps
+
+    time_deltas = [
+        current.time_sec - previous.time_sec
+        for previous, current in zip(frames, frames[1:])
+        if current.time_sec > previous.time_sec
+    ]
+    if not time_deltas:
+        return 10.0
+
+    time_step = float(np.median(time_deltas))
+    return (1.0 / time_step) / max(1, frame_stride)
+
+
+def run_trajectory_render(args: argparse.Namespace) -> None:
+    """Render a trajectory from parsed CLI arguments."""
+    waypoints = load_trajectory_waypoints(args.trajectory_json)
+    if not waypoints:
+        raise ValueError(f"No waypoints found in {args.trajectory_json}.")
+
+    first_x, first_y, first_rot = waypoints[0]
+    renderer = RenderUsd(
+        usd_path=args.usd_path,
+        glb_path=args.glb_path,
+        glb_xyz=None,
+        glb_rotation_deg=None,
+        output_dir=args.output_dir,
+        render_passes=args.render_passes,
+        depth_mode=args.depth_mode,
+        depth_max=args.depth_max,
+        resolution=args.resolution,
+        samples=args.samples,
+        camera_xyz=(first_x, first_y, args.camera_z),
+        camera_rotation_deg=(args.camera_pitch, args.camera_roll, first_rot),
+        flow_camera_xyz=args.flow_camera_xyz,
+        flow_camera_rotation_deg=args.flow_camera_rotation_deg,
+        focal_length_mm=args.focal_length_mm,
+        exposure=args.exposure,
+        world_strength=args.world_strength,
+        fill_light_energy=args.fill_light_energy,
+        remove_doors=args.remove_doors,
+    )
+    renderer.run_trajectory(
+        waypoints=waypoints,
+        camera_z=args.camera_z,
+        camera_pitch=args.camera_pitch,
+        camera_roll=args.camera_roll,
+        glb_offset_xyz=tuple(args.glb_offset_xyz),
+        glb_base_rotation_deg=tuple(args.glb_base_rotation_deg),
+        frame_stride=args.frame_stride,
+        frame_indices=args.frame_indices,
+        make_video=args.make_video,
+        video_fps=resolve_video_fps(
+            args.video_fps, args.trajectory_json, args.frame_stride
+        ),
+        overwrite=args.overwrite,
+    )
+
+
+def run_camera_trajectory_render(args: argparse.Namespace) -> None:
+    """Render a full-pose camera trajectory from parsed CLI arguments."""
+    frames = load_camera_trajectory_csv(args.trajectory_csv)
+    if not frames:
+        raise ValueError(f"No frames found in {args.trajectory_csv}.")
+
+    first_frame = frames[0]
+    renderer = RenderUsd(
+        usd_path=args.usd_path,
+        glb_path=args.glb_path,
+        glb_xyz=args.glb_xyz,
+        glb_rotation_deg=args.glb_rotation_deg,
+        output_dir=args.output_dir,
+        render_passes=args.render_passes,
+        depth_mode=args.depth_mode,
+        depth_max=args.depth_max,
+        resolution=args.resolution,
+        samples=args.samples,
+        camera_xyz=first_frame.xyz,
+        camera_rotation_deg=first_frame.rotation_deg,
+        flow_camera_xyz=args.flow_camera_xyz,
+        flow_camera_rotation_deg=args.flow_camera_rotation_deg,
+        focal_length_mm=args.focal_length_mm,
+        exposure=args.exposure,
+        world_strength=args.world_strength,
+        fill_light_energy=args.fill_light_energy,
+        remove_doors=args.remove_doors,
+    )
+    renderer.run_camera_trajectory(
+        frames=frames,
+        glb_offset_xyz=tuple(args.glb_offset_xyz),
+        glb_base_rotation_deg=tuple(args.glb_base_rotation_deg),
+        frame_stride=args.frame_stride,
+        frame_indices=args.frame_indices,
+        make_video=args.make_video,
+        video_fps=resolve_csv_video_fps(
+            args.video_fps, frames, args.frame_stride
+        ),
+        overwrite=args.overwrite,
+    )
+
 
 def main() -> None:
     logging.basicConfig(level=logging.INFO)
     args = _parse_args()
+    if args.trajectory_json is not None:
+        run_trajectory_render(args)
+        return
+    if args.trajectory_csv is not None:
+        run_camera_trajectory_render(args)
+        return
+
+    if args.camera_xyz is None or args.camera_rotation_deg is None:
+        build_arg_parser().error(
+            "--camera_xyz and --camera_rotation_deg are required unless "
+            "--trajectory_json or --trajectory_csv is given."
+        )
     RenderUsd.from_args(args).run()
 
 

embodied_gen/scripts/room_gen/route_room.py

@@ -113,6 +113,11 @@ class InfinigenGenRouter:
         """
         filled_prompt = self.prompt.format(prompt=task_description)
         response_text = self.gpt_client.query(text_prompt=filled_prompt)
+        if response_text is None:
+            raise RuntimeError(
+                "GPT router got no response. Check the GPT agent setup in "
+                "embodied_gen/utils/gpt_config.yaml and network access."
+            )
         parsed = json_repair.loads(response_text)
 
         room_list = parsed[0]

embodied_gen/scripts/textto3d.py

@@ -17,6 +17,7 @@
 import argparse
 import os
 import random
+import types
 from collections import defaultdict
 
 import numpy as np
@@ -25,12 +26,17 @@ from PIL import Image
 from embodied_gen.models.image_comm_model import build_hf_image_pipeline
 from embodied_gen.models.segment_model import RembgRemover
 from embodied_gen.models.text_model import PROMPT_APPEND
+from embodied_gen.scripts.imageto3d import (
+    IMAGE3D_MODEL,
+    SUPPORTED_IMAGE3D_MODELS,
+)
 from embodied_gen.scripts.imageto3d import entrypoint as imageto3d_api
 from embodied_gen.utils.gpt_clients import GPT_CLIENT
 from embodied_gen.utils.log import logger
 from embodied_gen.utils.process_media import (
     check_object_edge_truncated,
     combine_images_to_grid,
+    parse_text_prompts,
     render_asset3d,
 )
 from embodied_gen.validators.quality_checkers import (
@@ -43,12 +49,32 @@ from embodied_gen.validators.quality_checkers import (
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 random.seed(0)
 
-logger.info("Loading TEXT2IMG_MODEL...")
-SEMANTIC_CHECKER = SemanticConsistChecker(GPT_CLIENT)
-SEG_CHECKER = ImageSegChecker(GPT_CLIENT)
+# TXTGEN_CHECKER drives the final text↔3D quality gate for every backend
+# (SAM3D / TRELLIS / HUNYUAN3D), so it stays eager.
 TXTGEN_CHECKER = TextGenAlignChecker(GPT_CLIENT)
-PIPE_IMG = build_hf_image_pipeline(os.environ.get("TEXT_MODEL", "sd35"))
-BG_REMOVER = RembgRemover()
+
+# The text-to-image stack (PIPE_IMG, BG_REMOVER, SEMANTIC_CHECKER, SEG_CHECKER)
+# is only used on the SAM3D / TRELLIS path. HUNYUAN3D goes directly from prompt to 3D
+SEMANTIC_CHECKER = None
+SEG_CHECKER = None
+PIPE_IMG = None
+BG_REMOVER = None
+
+
+def _ensure_text2img_stack() -> None:
+    """Construct the text-to-image pipeline + image-stage checkers once.
+
+    Called from the SAM3D / TRELLIS path before any ``text_to_image`` run.
+    Idempotent: subsequent calls return immediately.
+    """
+    global SEMANTIC_CHECKER, SEG_CHECKER, PIPE_IMG, BG_REMOVER
+    if PIPE_IMG is not None:
+        return
+    logger.info("Loading TEXT2IMG_MODEL...")
+    SEMANTIC_CHECKER = SemanticConsistChecker(GPT_CLIENT)
+    SEG_CHECKER = ImageSegChecker(GPT_CLIENT)
+    PIPE_IMG = build_hf_image_pipeline(os.environ.get("TEXT_MODEL", "sd35"))
+    BG_REMOVER = RembgRemover()
 
 
 __all__ = [
@@ -66,6 +92,7 @@ def text_to_image(
     image_hw: tuple[int, int] = (1024, 1024),
     seed: int = None,
 ) -> bool:
+    _ensure_text2img_stack()
     select_image = None
     success_flag = False
     assert save_path.endswith(".png"), "Image save path must end with `.png`."
@@ -130,48 +157,115 @@ def text_to_3d(**kwargs) -> dict:
         if hasattr(args, k) and v is not None:
             setattr(args, k, v)
 
+    args.image3d_model = str(args.image3d_model).strip().upper()
+    if args.image3d_model not in SUPPORTED_IMAGE3D_MODELS:
+        raise ValueError(
+            f"Unsupported --image3d_model {args.image3d_model!r}; "
+            f"expected one of {SUPPORTED_IMAGE3D_MODELS}."
+        )
+
+    hunyuan_cfg = None
+    hunyuan_creds = None
+    process_prompt = None
+    if args.image3d_model == "HUNYUAN3D":
+        from embodied_gen.models.hunyuan3d import (
+            HunyuanConfig,
+            load_credentials,
+            process_prompt,
+        )
+
+        # Fail fast on missing creds before any network I/O.
+        hunyuan_creds = load_credentials()
+        hunyuan_cfg = HunyuanConfig()
+        logger.info(
+            "HUNYUAN3D text-to-3D backend: action=%s host=%s result_format=%s",
+            hunyuan_cfg.image_action,
+            hunyuan_cfg.host,
+            hunyuan_cfg.result_format,
+        )
+
+    args.prompts = parse_text_prompts(args.prompts)
     if args.asset_names is None or len(args.asset_names) == 0:
         args.asset_names = [f"sample3d_{i}" for i in range(len(args.prompts))]
-    img_save_dir = os.path.join(args.output_root, "images")
     asset_save_dir = os.path.join(args.output_root, "asset3d")
-    os.makedirs(img_save_dir, exist_ok=True)
     os.makedirs(asset_save_dir, exist_ok=True)
+    # HUNYUAN3D path skips text-to-image entirely; the images/ dir only
+    # exists when the local SAM3D / TRELLIS pipeline produces conditioning
+    # images.
+    img_save_dir = os.path.join(args.output_root, "images")
+    if args.image3d_model != "HUNYUAN3D":
+        os.makedirs(img_save_dir, exist_ok=True)
     results = defaultdict(dict)
-    for prompt, node in zip(args.prompts, args.asset_names):
+    for idx, (prompt, node) in enumerate(zip(args.prompts, args.asset_names)):
         success_flag = False
         n_pipe_retry = args.n_pipe_retry
         seed_img = args.seed_img
         seed_3d = args.seed_3d
+        # Tencent Pro API is charged per submit; force a single attempt to
+        # avoid silently multiplying cost when --n_pipe_retry > 1.
+        if args.image3d_model == "HUNYUAN3D" and n_pipe_retry > 1:
+            logger.warning(
+                "HUNYUAN3D mode: --n_pipe_retry forced to 1 (Tencent API "
+                "is charged per submit); user passed %d.",
+                n_pipe_retry,
+            )
+            n_pipe_retry = 1
         while success_flag is False and n_pipe_retry > 0:
             logger.info(
                 f"GEN pipeline for node {node}\n"
-                f"Try round: {args.n_pipe_retry-n_pipe_retry+1}/{args.n_pipe_retry}, Prompt: {prompt}"
+                f"Try round: {args.n_pipe_retry - n_pipe_retry + 1}/{args.n_pipe_retry}, Prompt: {prompt}"
             )
-            # Text-to-image GEN
             save_node = node.replace(" ", "_")
-            gen_image_path = f"{img_save_dir}/{save_node}.png"
-            textgen_flag = text_to_image(
-                prompt,
-                gen_image_path,
-                args.n_image_retry,
-                args.img_denoise_step,
-                args.text_guidance_scale,
-                args.n_img_sample,
-                seed=seed_img,
-            )
-
-            # Asset 3D GEN
             node_save_dir = f"{asset_save_dir}/{save_node}"
             asset_type = node if "sample3d_" not in node else None
-            imageto3d_api(
-                image_path=[gen_image_path],
-                output_root=node_save_dir,
-                asset_type=[asset_type],
-                seed=random.randint(0, 100000) if seed_3d is None else seed_3d,
-                n_retry=args.n_asset_retry,
-                keep_intermediate=args.keep_intermediate,
-                disable_decompose_convex=args.disable_decompose_convex,
-            )
+
+            if args.image3d_model == "HUNYUAN3D":
+                hunyuan_args = types.SimpleNamespace(
+                    asset_type=[asset_type],
+                    version=None,
+                    height_range=None,
+                    mass_range=None,
+                    disable_decompose_convex=args.disable_decompose_convex,
+                    keep_intermediate=args.keep_intermediate,
+                )
+                process_prompt(
+                    args=hunyuan_args,
+                    idx=0,
+                    prompt=prompt,
+                    output_root=node_save_dir,
+                    filename=save_node,
+                    hunyuan_config=hunyuan_cfg,
+                    hunyuan_credentials=hunyuan_creds,
+                    checkers=[],
+                )
+            else:
+                # Text-to-image GEN (SAM3D / TRELLIS path).
+                gen_image_path = f"{img_save_dir}/{save_node}.png"
+                text_to_image(
+                    prompt,
+                    gen_image_path,
+                    args.n_image_retry,
+                    args.img_denoise_step,
+                    args.text_guidance_scale,
+                    args.n_img_sample,
+                    seed=seed_img,
+                )
+
+                # Asset 3D GEN
+                imageto3d_api(
+                    image_path=[gen_image_path],
+                    output_root=node_save_dir,
+                    asset_type=[asset_type],
+                    seed=(
+                        random.randint(0, 100000)
+                        if seed_3d is None
+                        else seed_3d
+                    ),
+                    n_retry=args.n_asset_retry,
+                    keep_intermediate=args.keep_intermediate,
+                    disable_decompose_convex=args.disable_decompose_convex,
+                    image3d_model=args.image3d_model,
+                )
             mesh_path = f"{node_save_dir}/result/mesh/{save_node}.obj"
             image_path = render_asset3d(
                 mesh_path,
@@ -182,6 +276,21 @@ def text_to_3d(**kwargs) -> dict:
                 no_index_file=True,
             )
             image_path = combine_images_to_grid(image_path)
+            if not image_path:
+                logger.error(
+                    f"Node {node}: 3D asset generation produced no mesh, "
+                    f"skip QA and retry round."
+                )
+                results["assets"][node] = f"asset3d/{save_node}/result"
+                results["quality"][node] = "NO: mesh generation failed."
+                n_pipe_retry -= 1
+                seed_img = (
+                    random.randint(0, 100000) if seed_img is not None else None
+                )
+                seed_3d = (
+                    random.randint(0, 100000) if seed_3d is not None else None
+                )
+                continue
             check_text = asset_type if asset_type is not None else prompt
             qa_flag, qa_result = TXTGEN_CHECKER(check_text, image_path)
             logger.warning(
@@ -272,6 +381,18 @@ def parse_args():
     )
     parser.add_argument("--keep_intermediate", action="store_true")
     parser.add_argument("--disable_decompose_convex", action="store_true")
+    parser.add_argument(
+        "--image3d_model",
+        type=str,
+        default=IMAGE3D_MODEL,
+        help=(
+            "Image-to-3D backend selector forwarded to imageto3d. One of "
+            f"{', '.join(SUPPORTED_IMAGE3D_MODELS)} (case-insensitive). "
+            "HUNYUAN3D skips the text-to-image stage entirely and calls "
+            "Tencent Hunyuan3D Pro text-to-3D directly; it requires "
+            "TENCENT_SECRET_ID/TENCENT_SECRET_KEY in the environment."
+        ),
+    )
 
     args, unknown = parser.parse_known_args()
 

embodied_gen/skills/README.md

@@ -4,7 +4,7 @@ This directory is the canonical home for EmbodiedGen reusable skills.
 
 The root of `embodied_gen/skills` only contains generic skill source.
 Runtime-specific packaging should live in adapter subdirectories such as
-`embodied_gen/skills/claude_adapter/`.
+`embodied_gen/skills/claude_plugin/`.
 
 ## Included generic skills
 
@@ -14,7 +14,7 @@ Runtime-specific packaging should live in adapter subdirectories such as
 - `layout-creator`
 - `sim-runner`
 - `asset-converter`
-- `asset-scale`
+- `asset-process`
 - `room-creator`
 - `spatial-computing`
 
@@ -23,31 +23,31 @@ Runtime-specific packaging should live in adapter subdirectories such as
 Claude-compatible slash commands and plugin manifest are under:
 
 ```text
-embodied_gen/skills/claude_adapter/
+embodied_gen/skills/claude_plugin/
 ```
 
 The local marketplace manifest is:
 
 ```text
-embodied_gen/skills/claude_adapter/.claude-plugin/marketplace.json
+embodied_gen/skills/claude_plugin/.claude-plugin/marketplace.json
 ```
 
 The actual Claude plugin package is:
 
 ```text
-embodied_gen/skills/claude_adapter/plugins/embodiedgen-skills/
+embodied_gen/skills/claude_plugin/plugins/embodiedgen/
 ```
 
 Current commands include:
 
-- `/embodiedgen-skills:assets`
-- `/embodiedgen-skills:background`
-- `/embodiedgen-skills:layout`
-- `/embodiedgen-skills:sim`
-- `/embodiedgen-skills:convert`
-- `/embodiedgen-skills:process`
-- `/embodiedgen-skills:room`
-- `/embodiedgen-skills:spatial`
+- `/embodiedgen:gen_assets`
+- `/embodiedgen:gen_bg`
+- `/embodiedgen:gen_layout`
+- `/embodiedgen:sim`
+- `/embodiedgen:convert`
+- `/embodiedgen:process`
+- `/embodiedgen:gen_indoor`
+- `/embodiedgen:vibe3d`
 
 ## Local install for Claude
 
@@ -58,5 +58,5 @@ bash install/install_agent_plugin.sh
 ## Notes
 
 - Generic skills stay in their original directories under `embodied_gen/skills/`.
-- Claude-specific files live only under `embodied_gen/skills/claude_adapter/`.
+- Claude-specific files live only under `embodied_gen/skills/claude_plugin/`.
 - This keeps the skill source portable for Codex, Copilot, and other runtimes.

embodied_gen/skills/asset-process/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: asset-process
+description: Scale and rotate complete URDF-based 3D assets, including OBJ, GLB, collision meshes, Gaussian splats, and height metadata. Use this skill whenever a user asks to resize, rotate, reorient, or otherwise transform an EmbodiedGen asset while keeping its related files synchronized.
+---
+
+# Asset Processing
+
+## Overview
+
+Use this skill to scale or rotate an asset and all of its supported geometry
+files consistently. Rotation is provided as XYZ Euler angles in degrees and is
+applied around the asset's local origin.
+
+The input URDF may use either supported asset layout:
+
+```text
+<asset_dir>/result/<asset_name>.urdf
+<asset_dir>/<asset_name>.urdf
+```
+
+The mesh directory must be beside the URDF as `mesh/`.
+
+Normal mode copies the complete asset directly to `<output_dir>`. Pass the
+full target asset directory, including the desired asset directory name.
+Inplace mode modifies the source asset.
+
+After processing, the tool calculates the transformed mesh's Y-axis extent and
+writes that value to `min_height`, `max_height`, and `real_height` in the URDF.
+It uses the main OBJ first, then the GLB, then the collision OBJ.
+
+## CLI Examples
+
+### Scale Only
+
+```bash
+python -m embodied_gen.skills.asset-process.asset_process \
+  --urdf-path outputs/assets/red_box/result/red_box.urdf \
+  --scale-factor 0.8 \
+  --output-dir outputs/processed
+```
+
+### Rotate Only
+
+```bash
+python -m embodied_gen.skills.asset-process.asset_process \
+  --urdf-path outputs/assets/red_box/result/red_box.urdf \
+  --rot-xyz 90 0 45 \
+  --output-dir outputs/processed
+```
+
+### Scale and Rotate
+
+```bash
+python -m embodied_gen.skills.asset-process.asset_process \
+  --urdf-path outputs/test_wuwen/facial_cleanser_001/facial_cleanser_001.urdf \
+  --scale-factor 1.0 \
+  --rot-xyz 0 90 0 \
+  --keep-urdf-raw-rot \
+  --output-dir outputs/test_wuwen/facial_cleanser_001_processed
+```
+
+`--keep-urdf-raw-rot` is optional. When enabled, the inverse baked rotation is
+composed into visual and collision `origin rpy` values so their effective
+rotation remains unchanged. It is disabled by default.
+
+### Process Inplace
+
+```bash
+python -m embodied_gen.skills.asset-process.asset_process \
+  --urdf-path outputs/assets/red_box/result/red_box.urdf \
+  --scale-factor 0.8 \
+  --rot-xyz 0 0 90 \
+  --inplace
+```
+
+Inplace mode modifies the original asset files.
+
+## Parameters
+
+| Parameter | Default | Meaning |
+|-----------|---------|---------|
+| `urdf_path` | Required | Input URDF path |
+| `scale_factor` | `1.0` | Positive uniform scaling factor |
+| `rot_xyz` | `0 0 0` | XYZ roll, pitch, yaw in degrees |
+| `keep_urdf_raw_rot` | `False` | Preserve the original effective URDF rotation |
+| `inplace` | `False` | Modify source files directly |
+| `output_dir` | `None` | Complete target asset directory; required outside inplace mode |
+
+## Processed Files
+
+- `mesh/<name>.obj`
+- `mesh/<name>.glb`
+- `mesh/<name>_collision.obj`
+- `mesh/<name>_gs.ply` (optional; skipped when absent)
+- `<name>.urdf`
+
+Rotation is always baked into the asset files. URDF visual and collision
+`origin rpy` values are updated only when `keep_urdf_raw_rot` is enabled.
+
+For Python API details, read
+`embodied_gen/skills/asset-process/asset_process.py`.

embodied_gen/skills/asset-process/__init__.py

@@ -0,0 +1,36 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+"""Asset processing skills for EmbodiedGen."""
+
+from importlib import import_module
+
+__all__ = [
+    "AssetProcessConfig",
+    "AssetProcessor",
+    "entrypoint",
+    "process_asset",
+]
+
+
+def __getattr__(name: str) -> object:
+    """Lazily expose asset processing APIs without import side effects."""
+    if name not in __all__:
+        msg = f"module {__name__!r} has no attribute {name!r}"
+        raise AttributeError(msg)
+
+    module = import_module(f"{__name__}.asset_process")
+    return getattr(module, name)

embodied_gen/skills/asset-process/asset_process.py

@@ -0,0 +1,443 @@
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+"""Asset processing utilities for scaling and rotating 3D assets."""
+
+import math
+import shutil
+import warnings
+import xml.etree.ElementTree as ET
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from importlib import import_module
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+import trimesh
+import tyro
+from scipy.spatial.transform import Rotation
+from embodied_gen.utils.log import logger
+
+__all__ = [
+    "AssetProcessConfig",
+    "AssetProcessor",
+    "entrypoint",
+    "process_asset",
+]
+
+URDF_HEIGHT_FIELDS = ("min_height", "max_height", "real_height")
+URDF_RESULT_DIR = "result"
+MESH_DIR = "mesh"
+HEIGHT_AXIS = 1
+
+
+@dataclass
+class AssetProcessConfig:
+    """Configuration for asset scaling and rotation.
+
+    Args:
+        urdf_path: Path to the URDF file to process.
+        scale_factor: Positive uniform scaling factor.
+        rot_xyz: XYZ Euler rotation in degrees.
+        keep_urdf_raw_rot: Whether to preserve the original URDF rotation.
+        inplace: Whether to modify the source asset directly.
+        output_dir: Target asset directory used when ``inplace`` is false.
+    """
+
+    urdf_path: str
+    scale_factor: float = 1.0
+    rot_xyz: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    keep_urdf_raw_rot: bool = False
+    inplace: bool = False
+    output_dir: Optional[str] = None
+
+
+class AssetProcessor:
+    """Scale and rotate mesh, collision, and Gaussian-splat asset files."""
+
+    def __init__(
+        self,
+        urdf_path: str | Path,
+        scale_factor: float = 1.0,
+        rot_xyz: tuple[float, float, float] = (0.0, 0.0, 0.0),
+        keep_urdf_raw_rot: bool = False,
+        output_dir: Optional[str | Path] = None,
+        inplace: bool = False,
+    ) -> None:
+        """Initialize an asset processor.
+
+        Args:
+            urdf_path: Path to the URDF file to process.
+            scale_factor: Positive uniform scaling factor.
+            rot_xyz: XYZ Euler rotation in degrees.
+            keep_urdf_raw_rot: Whether to preserve the original visual and
+                collision rotation after baking the asset rotation.
+            output_dir: Target asset directory used when ``inplace`` is false.
+            inplace: Whether to modify the source asset directly.
+
+        Raises:
+            FileNotFoundError: If the URDF file does not exist.
+            ValueError: If the transform or output configuration is invalid.
+        """
+        self.urdf_path = Path(urdf_path)
+        self.scale_factor = float(scale_factor)
+        self.rot_xyz = tuple(float(value) for value in rot_xyz)
+        self.keep_urdf_raw_rot = keep_urdf_raw_rot
+        self.inplace = inplace
+
+        if not self.urdf_path.is_file():
+            raise FileNotFoundError(f"URDF file not found: {self.urdf_path}")
+        if not math.isfinite(self.scale_factor) or self.scale_factor <= 0:
+            raise ValueError(
+                f"Scale factor must be positive and finite, got: "
+                f"{self.scale_factor}"
+            )
+        if len(self.rot_xyz) != 3 or not all(
+            math.isfinite(value) for value in self.rot_xyz
+        ):
+            raise ValueError(
+                "rot_xyz must contain three finite degree values, got: "
+                f"{self.rot_xyz}"
+            )
+
+        if self.urdf_path.parent.name == URDF_RESULT_DIR:
+            self.asset_dir = self.urdf_path.parent.parent
+            self.result_dir = Path(URDF_RESULT_DIR)
+        else:
+            self.asset_dir = self.urdf_path.parent
+            self.result_dir = Path()
+        self.node_name = self.urdf_path.stem
+        self.rotation = Rotation.from_euler("xyz", self.rot_xyz, degrees=True)
+        self.rotation_transform = np.eye(4)
+        self.rotation_transform[:3, :3] = self.rotation.as_matrix()
+
+        if self.inplace:
+            self.output_dir = self.asset_dir.parent
+        else:
+            if output_dir is None:
+                raise ValueError("output_dir is required when inplace=False")
+            self.output_dir = Path(output_dir)
+            if self.output_dir.resolve() == self.asset_dir.resolve():
+                raise ValueError(
+                    "output_dir must differ from the source asset directory; "
+                    "use inplace=True to modify the source asset"
+                )
+
+    def process(self) -> Path:
+        """Run the complete asset processing workflow.
+
+        Returns:
+            Path to the processed URDF file.
+        """
+        if self.inplace:
+            output_asset_dir = self.asset_dir
+            output_urdf_path = self.urdf_path
+        else:
+            output_asset_dir = self.output_dir
+            output_urdf_path = self._copy_asset_structure(output_asset_dir)
+
+        self._process_asset_files_parallel(output_asset_dir)
+        actual_height = self._calculate_actual_height(output_asset_dir)
+        self._write_urdf_height(output_urdf_path, actual_height)
+        if self.keep_urdf_raw_rot:
+            self._update_urdf_origins(output_urdf_path)
+
+        logger.info(
+            "Processed %s with scale=%s, rot_xyz=%s -> %s",
+            self.asset_dir,
+            self.scale_factor,
+            self.rot_xyz,
+            output_asset_dir,
+        )
+        return output_urdf_path
+
+    def _copy_asset_structure(self, output_asset_dir: Path) -> Path:
+        """Copy the complete source asset to the output directory."""
+        shutil.rmtree(output_asset_dir, ignore_errors=True)
+        shutil.copytree(self.asset_dir, output_asset_dir)
+        return output_asset_dir / self.result_dir / f"{self.node_name}.urdf"
+
+    def _process_asset_files_parallel(self, output_asset_dir: Path) -> None:
+        """Apply the configured transform to every supported asset format."""
+        mesh_dir = output_asset_dir / self.result_dir / MESH_DIR
+
+        # Keep the legacy asset-scale processing paths separate because each
+        # format has different loading and export behavior.
+        tasks = [
+            (mesh_dir / f"{self.node_name}.obj", self._scale_obj_mesh),
+            (mesh_dir / f"{self.node_name}.glb", self._scale_glb_mesh),
+            (
+                mesh_dir / f"{self.node_name}_collision.obj",
+                self._scale_collision_mesh,
+            ),
+            (
+                mesh_dir / f"{self.node_name}_gs.ply",
+                self._scale_gaussian_splat,
+            ),
+        ]
+
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = [executor.submit(task, path) for path, task in tasks]
+            for future in futures:
+                future.result()  # Propagate any exceptions
+
+    def _scale_obj_mesh(self, mesh_path: Path) -> None:
+        """Scale and rotate an OBJ mesh."""
+        if not mesh_path.exists():
+            return
+
+        mesh = trimesh.load(str(mesh_path))
+        mesh.apply_scale(self.scale_factor)
+        self._apply_mesh_rotation(mesh)
+        mesh.export(str(mesh_path))
+
+    def _scale_glb_mesh(self, mesh_path: Path) -> None:
+        """Scale and rotate every geometry in a GLB scene."""
+        if not mesh_path.exists():
+            return
+
+        mesh = trimesh.load(str(mesh_path))
+        for mesh_part in mesh.geometry.values():
+            mesh_part.apply_scale(self.scale_factor)
+            self._apply_mesh_rotation(mesh_part)
+        mesh.export(str(mesh_path))
+
+    def _scale_collision_mesh(self, mesh_path: Path) -> None:
+        """Scale and rotate a potentially multi-object collision OBJ."""
+        if not mesh_path.exists():
+            return
+
+        meshes = self._load_collision_obj(str(mesh_path))
+        scene = trimesh.Scene()
+        for mesh_part in meshes:
+            mesh_part.apply_scale(self.scale_factor)
+            self._apply_mesh_rotation(mesh_part)
+            scene.add_geometry(mesh_part)
+        scene.export(str(mesh_path))
+
+    def _scale_gaussian_splat(self, mesh_path: Path) -> None:
+        """Scale and rotate a Gaussian splatting model."""
+        if not mesh_path.exists():
+            return
+
+        gaussian_operator = import_module(
+            "embodied_gen.models.gs_model"
+        ).GaussianOperator
+        gs_model = gaussian_operator.load_from_ply(str(mesh_path))
+        gs_model.rescale(self.scale_factor)
+        if not self._is_identity_rotation:
+            instance_pose = gaussian_operator.trans_to_quatpose(
+                self.rotation.as_matrix()
+            )
+            gs_model = gs_model.get_gaussians(instance_pose=instance_pose)
+        gs_model.save_to_ply(str(mesh_path))
+
+    @property
+    def _is_identity_rotation(self) -> bool:
+        """Return whether the configured rotation is an identity operation."""
+        return np.allclose(self.rotation.as_matrix(), np.eye(3))
+
+    def _apply_mesh_rotation(self, mesh: trimesh.Trimesh) -> None:
+        """Apply the configured rotation after the legacy scale operation."""
+        if self._is_identity_rotation:
+            return
+        mesh.apply_transform(self.rotation_transform)
+
+    def _calculate_actual_height(self, output_asset_dir: Path) -> float:
+        """Calculate Y-axis height from the best available transformed mesh."""
+        mesh_dir = output_asset_dir / self.result_dir / MESH_DIR
+        candidates = (
+            mesh_dir / f"{self.node_name}.obj",
+            mesh_dir / f"{self.node_name}.glb",
+            mesh_dir / f"{self.node_name}_collision.obj",
+        )
+        for mesh_path in candidates:
+            if not mesh_path.exists():
+                continue
+            scene = trimesh.load(str(mesh_path), force="scene")
+            geometry = scene.to_geometry()
+            if len(geometry.vertices) == 0:
+                continue
+            height = float(np.ptp(geometry.vertices[:, HEIGHT_AXIS]))
+            if not math.isfinite(height):
+                raise ValueError(
+                    f"Calculated non-finite height from mesh: {mesh_path}"
+                )
+            return height
+
+        candidate_text = ", ".join(str(path) for path in candidates)
+        raise FileNotFoundError(
+            "No mesh is available for height calculation. Expected one of: "
+            f"{candidate_text}"
+        )
+
+    @staticmethod
+    def _write_urdf_height(urdf_path: Path, height: float) -> None:
+        """Write actual mesh height to all URDF height metadata fields."""
+        tree = ET.parse(str(urdf_path))
+        root = tree.getroot()
+        link = root.find("link")
+        if link is None:
+            raise ValueError(f"No link element found in URDF: {urdf_path}")
+
+        extra_info = link.find("extra_info")
+        if extra_info is None:
+            extra_info = ET.SubElement(link, "extra_info")
+
+        value = f"{height:.4f}"
+        for field in URDF_HEIGHT_FIELDS:
+            element = extra_info.find(field)
+            if element is None:
+                element = ET.SubElement(extra_info, field)
+            element.text = value
+
+        tree.write(str(urdf_path), encoding="utf-8", xml_declaration=True)
+
+    def _update_urdf_origins(self, urdf_path: Path) -> None:
+        """Append the inverse baked rotation to visual/collision origins."""
+        if self._is_identity_rotation:
+            return
+
+        tree = ET.parse(str(urdf_path))
+        root = tree.getroot()
+        inverse_rotation = self.rotation.inv().as_matrix()
+
+        for link in root.findall(".//link"):
+            for geometry_tag in ("visual", "collision"):
+                for geometry in link.findall(geometry_tag):
+                    origin = geometry.find("origin")
+                    if origin is None:
+                        origin = ET.SubElement(
+                            geometry,
+                            "origin",
+                            attrib={"xyz": "0 0 0"},
+                        )
+
+                    current_rpy = np.fromstring(
+                        origin.get("rpy", "0 0 0"),
+                        sep=" ",
+                    )
+                    if current_rpy.size != 3:
+                        raise ValueError(
+                            f"Invalid rpy in URDF origin: {urdf_path}"
+                        )
+
+                    current_rotation = Rotation.from_euler(
+                        "xyz",
+                        current_rpy,
+                        degrees=False,
+                    ).as_matrix()
+                    updated_rotation = current_rotation @ inverse_rotation
+                    with warnings.catch_warnings():
+                        warnings.simplefilter("ignore", UserWarning)
+                        updated_rpy = Rotation.from_matrix(
+                            updated_rotation
+                        ).as_euler("xyz", degrees=False)
+                    origin.set(
+                        "rpy",
+                        " ".join(f"{value:.4f}" for value in updated_rpy),
+                    )
+
+        tree.write(str(urdf_path), encoding="utf-8", xml_declaration=True)
+
+    @staticmethod
+    def _load_collision_obj(filepath: str) -> list[trimesh.Trimesh]:
+        """Robustly load collision OBJ with multiple objects.
+
+        Handles OBJ files with multiple objects/groups by parsing manually
+        to avoid issues with trimesh's default loader.
+
+        Args:
+            filepath: Path to collision OBJ file.
+
+        Returns:
+            List of trimesh objects, one per object group in the file.
+        """
+        vertices = []
+        meshes = []
+        current_faces = []
+
+        # Use lazy iteration instead of readlines() for memory efficiency
+        with open(filepath, "r") as f:
+            for line in f:
+                if line.startswith("v "):
+                    parts = line.split()
+                    vertices.append(
+                        [float(parts[1]), float(parts[2]), float(parts[3])]
+                    )
+                elif line.startswith("f "):
+                    parts = line.split()
+                    face = [int(p.split("/")[0]) - 1 for p in parts[1:]]
+                    current_faces.append(face)
+                elif line.startswith("o ") or line.startswith("g "):
+                    if current_faces and vertices:
+                        m = trimesh.Trimesh(
+                            vertices=vertices,
+                            faces=current_faces,
+                            process=False,
+                        )
+                        m.remove_unreferenced_vertices()
+                        meshes.append(m)
+                    current_faces = []
+
+        # Flush final mesh
+        if current_faces and vertices:
+            m = trimesh.Trimesh(
+                vertices=vertices, faces=current_faces, process=False
+            )
+            m.remove_unreferenced_vertices()
+            meshes.append(m)
+
+        return meshes
+
+
+def process_asset(
+    urdf_path: str | Path,
+    scale_factor: float = 1.0,
+    rot_xyz: tuple[float, float, float] = (0.0, 0.0, 0.0),
+    keep_urdf_raw_rot: bool = False,
+    output_dir: Optional[str | Path] = None,
+    inplace: bool = False,
+) -> Path:
+    """Scale and rotate a complete URDF-based asset."""
+    processor = AssetProcessor(
+        urdf_path=urdf_path,
+        scale_factor=scale_factor,
+        rot_xyz=rot_xyz,
+        keep_urdf_raw_rot=keep_urdf_raw_rot,
+        output_dir=output_dir,
+        inplace=inplace,
+    )
+    return processor.process()
+
+
+def entrypoint() -> None:
+    """Run the asset processing CLI."""
+    config = tyro.cli(AssetProcessConfig)
+    output_urdf = process_asset(
+        urdf_path=config.urdf_path,
+        scale_factor=config.scale_factor,
+        rot_xyz=config.rot_xyz,
+        keep_urdf_raw_rot=config.keep_urdf_raw_rot,
+        output_dir=config.output_dir,
+        inplace=config.inplace,
+    )
+    logger.info(f"Processed asset successfully: {output_urdf}")
+
+
+if __name__ == "__main__":
+    entrypoint()

embodied_gen/skills/asset-retrieval/scripts/retrieve_asset.py

@@ -1,4 +1,19 @@
-#!/usr/bin/env python3
+# Project EmbodiedGen
+#
+# Copyright (c) 2025 Horizon Robotics. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
 """Retrieve EmbodiedGen asset URDF paths from a CSV index."""
 
 from __future__ import annotations