update

common.py

@@ -15,7 +15,7 @@
 # permissions and limitations under the License.
 
 import spaces
-from embodied_gen.utils.monkey_patches import monkey_path_trellis
+from embodied_gen.utils.monkey_patch.trellis import monkey_path_trellis
 
 monkey_path_trellis()
 

embodied_gen/data/utils.py

@@ -963,6 +963,6 @@ def model_device_ctx(
 
         if verbose:
             model_names = [m.__class__.__name__ for m in models]
-            logger.debug(
+            logger.info(
                 f"[model_device_ctx] {model_names} to cuda: {to_cuda_time:.1f}s, to cpu: {to_cpu_time:.1f}s"
             )

embodied_gen/models/sam3d.py

@@ -14,7 +14,7 @@
 # implied. See the License for the specific language governing
 # permissions and limitations under the License.
 
-from embodied_gen.utils.monkey_patches import monkey_patch_sam3d
+from embodied_gen.utils.monkey_patch.sam3d import monkey_patch_sam3d
 
 monkey_patch_sam3d()
 import os
@@ -22,8 +22,7 @@ import sys
 
 import numpy as np
 from hydra.utils import instantiate
-# from modelscope import snapshot_download
-from huggingface_hub import snapshot_download
+from modelscope import snapshot_download
 from omegaconf import OmegaConf
 from PIL import Image
 
@@ -31,7 +30,7 @@ current_file_path = os.path.abspath(__file__)
 current_dir = os.path.dirname(current_file_path)
 sys.path.append(os.path.join(current_dir, "../.."))
 from loguru import logger
-from thirdparty.sam3d.sam3d_objects.pipeline.inference_pipeline_pointmap import (
+from sam3d_objects.pipeline.inference_pipeline_pointmap import (
     InferencePipelinePointMap,
 )
 
@@ -66,8 +65,7 @@ class Sam3dInference:
         self, local_dir: str = "weights/sam-3d-objects", compile: bool = False
     ) -> None:
         if not os.path.exists(local_dir):
-            # snapshot_download("facebook/sam-3d-objects", local_dir=local_dir)
-            snapshot_download("jetjodh/sam-3d-objects", local_dir=local_dir)
+            snapshot_download("facebook/sam-3d-objects", local_dir=local_dir)
         config_file = os.path.join(local_dir, "checkpoints/pipeline.yaml")
         config = OmegaConf.load(config_file)
         config.rendering_engine = "nvdiffrast"

embodied_gen/models/text_model.py

@@ -53,7 +53,7 @@ __all__ = [
 ]
 
 PROMPT_APPEND = (
-    "Angled 3D view of one {object}, centered, no cropping, no occlusion, isolated product photo, "
+    "Angled 3D view of one {object}, centered, no cropping, no occlusion, isolated product photo, placed horizontally, "
     "no surroundings, high-quality appearance, vivid colors, on a plain clean surface, 3D style revealing multiple surfaces"
 )
 PROMPT_KAPPEND = "Single {object}, in the center of the image, white background, 3D style, best quality"

embodied_gen/scripts/gen_room.py

@@ -0,0 +1,69 @@
+# 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 signal
+import subprocess
+import sys
+from pathlib import Path
+
+from embodied_gen.utils.log import logger
+
+
+def get_blender_python_path():
+    """Resolve path to Blender's bundled Python binary from env or default location."""
+    env_path = os.environ.get("BLENDER_PYTHON_BIN")
+    if env_path and os.path.exists(env_path):
+        return env_path
+
+    default_relative_path = Path(
+        "thirdparty/infinigen/blender/4.2/python/bin/python3.11"
+    )
+    if default_relative_path.exists():
+        return str(default_relative_path.resolve())
+
+    logger.error("Error: Could not find Blender Python binary.")
+    logger.error("Please set the BLENDER_PYTHON_BIN environment variable.")
+    sys.exit(1)
+
+
+def entrypoint():
+    """Entry point wrapper to execute script within Blender's Python environment."""
+    blender_python = get_blender_python_path()
+    args = sys.argv[1:]
+    process = subprocess.Popen([blender_python] + args, start_new_session=True)
+    try:
+        return_code = process.wait()
+        sys.exit(return_code)
+
+    except KeyboardInterrupt:
+        try:
+            os.killpg(os.getpgid(process.pid), signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+        logger.error("\nProgram interrupted by user (Cmd+C). Exiting.")
+        sys.exit(130)
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        try:
+            os.killpg(os.getpgid(process.pid), signal.SIGKILL)
+        except Exception:
+            pass
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    entrypoint()

embodied_gen/scripts/imageto3d.py

@@ -105,7 +105,7 @@ def parse_args():
     parser.add_argument(
         "--n_retry",
         type=int,
-        default=2,
+        default=3,
     )
     parser.add_argument("--disable_decompose_convex", action="store_true")
     parser.add_argument("--texture_size", type=int, default=2048)
@@ -153,6 +153,7 @@ def entrypoint(**kwargs):
 
             seed = args.seed
             asset_node = "unknown"
+            gs_model = None
             if isinstance(args.asset_type, list) and args.asset_type[idx]:
                 asset_node = args.asset_type[idx]
             for try_idx in range(args.n_retry):
@@ -163,7 +164,10 @@ def entrypoint(**kwargs):
                     outputs = image3d_model_infer(PIPELINE, seg_image, seed)
                 except Exception as e:
                     logger.error(
-                        f"[Pipeline Failed] process {image_path}: {e}, skip."
+                        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
                     )
                     continue
 
@@ -208,6 +212,10 @@ def entrypoint(**kwargs):
 
                 seed = random.randint(0, 100000) if seed is not None else None
 
+            if gs_model is None:
+                logger.error(f"Exceed image3d retry num, skip {image_path}.")
+                continue
+
             # Render the video for generated 3D asset.
             color_images = render_video(gs_model, r=1.85)["color"]
             normal_images = render_video(mesh_model, r=1.85)["normal"]

embodied_gen/scripts/parallel_sim.py

@@ -15,7 +15,7 @@
 # permissions and limitations under the License.
 
 
-from embodied_gen.utils.monkey_patches import monkey_patch_maniskill
+from embodied_gen.utils.monkey_patch.maniskill import monkey_patch_maniskill
 
 monkey_patch_maniskill()
 import json

embodied_gen/scripts/room_gen/custom_solve.gin

@@ -0,0 +1,29 @@
+FloorPlanSolver.n_divide_trials = 25
+FloorPlanSolver.iters_mult = 50
+
+home_room_constraints.has_fewer_rooms = False
+
+compose_indoors.place_cameras = False
+
+solve_objects.addition_weight_scalar = 3.0
+compose_indoors.solve_steps_large = 30
+compose_indoors.solve_steps_medium = 20
+compose_indoors.solve_steps_small = 5
+
+compose_indoors.invisible_room_ceilings_enabled = False
+compose_indoors.hide_other_rooms_enabled = True
+
+compose_indoors.terrain_enabled = False
+
+compose_indoors.pose_cameras_enabled = False
+compose_indoors.animate_cameras_enabled = False
+compose_indoors.overhead_cam_enabled = True
+
+compose_indoors.nature_backdrop_enabled = False
+
+compose_indoors.lights_off_chance = 0.0
+
+compose_indoors.skirting_floor_enabled = False
+compose_indoors.skirting_ceiling_enabled = False
+BlueprintSolidifier.enable_open = False
+

embodied_gen/scripts/room_gen/export_scene.py

@@ -0,0 +1,1516 @@
+# 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.
+# Some code comes from: https://github.com/princeton-vl/infinigen/blob/main/infinigen/tools/export.py
+
+import argparse
+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
+
+import bpy
+import coacd
+import gin
+import numpy as np
+import trimesh
+from infinigen.core.util import blender as butil
+
+logger = logging.getLogger(__name__)
+
+FORMAT_CHOICES = ["fbx", "obj", "usdc", "usda", "stl", "ply"]
+BAKE_TYPES = {
+    "DIFFUSE": "Base Color",
+    "ROUGHNESS": "Roughness",
+    "NORMAL": "Normal",
+}  # "EMIT":"Emission Color" #  "GLOSSY": "Specular IOR Level", "TRANSMISSION":"Transmission Weight" don"t export
+SPECIAL_BAKE = {"METAL": "Metallic", "TRANSMISSION": "Transmission Weight"}
+ALL_BAKE = BAKE_TYPES | SPECIAL_BAKE
+
+
+def apply_all_modifiers(obj):
+    for mod in obj.modifiers:
+        if mod is None:
+            continue
+        try:
+            obj.select_set(True)
+            bpy.context.view_layer.objects.active = obj
+            bpy.ops.object.modifier_apply(modifier=mod.name)
+            logger.info(f"Applied modifier {mod} on {obj}")
+            obj.select_set(False)
+        except RuntimeError:
+            logger.info(f"Can't apply {mod} on {obj}")
+            obj.select_set(False)
+            return
+
+
+def realizeInstances(obj):
+    for mod in obj.modifiers:
+        if mod is None or mod.type != "NODES":
+            continue
+        geo_group = mod.node_group
+        outputNode = geo_group.nodes["Group Output"]
+
+        logger.info(f"Realizing instances on {mod}")
+        link = outputNode.inputs[0].links[0]
+        from_socket = link.from_socket
+        geo_group.links.remove(link)
+        realizeNode = geo_group.nodes.new(type="GeometryNodeRealizeInstances")
+        geo_group.links.new(realizeNode.inputs[0], from_socket)
+        geo_group.links.new(outputNode.inputs[0], realizeNode.outputs[0])
+
+
+def remove_shade_smooth(obj):
+    for mod in obj.modifiers:
+        if mod is None or mod.type != "NODES":
+            continue
+        geo_group = mod.node_group
+        outputNode = geo_group.nodes["Group Output"]
+        if geo_group.nodes.get("Set Shade Smooth"):
+            logger.info("Removing shade smooth on " + obj.name)
+            smooth_node = geo_group.nodes["Set Shade Smooth"]
+        else:
+            continue
+
+        link = smooth_node.inputs[0].links[0]
+        from_socket = link.from_socket
+        geo_group.links.remove(link)
+        geo_group.links.new(outputNode.inputs[0], from_socket)
+
+
+def check_material_geonode(node_tree):
+    if node_tree.nodes.get("Set Material"):
+        logger.info("Found set material!")
+        return True
+
+    for node in node_tree.nodes:
+        if node.type == "GROUP" and check_material_geonode(node.node_tree):
+            return True
+
+    return False
+
+
+def handle_geo_modifiers(obj, export_usd):
+    has_geo_nodes = False
+    for mod in obj.modifiers:
+        if mod is None or mod.type != "NODES":
+            continue
+        has_geo_nodes = True
+
+    if has_geo_nodes and not obj.data.materials:
+        mat = bpy.data.materials.new(name=f"{mod.name} shader")
+        obj.data.materials.append(mat)
+        mat.use_nodes = True
+        mat.node_tree.nodes.remove(mat.node_tree.nodes["Principled BSDF"])
+
+    if not export_usd:
+        realizeInstances(obj)
+
+
+def split_glass_mats():
+    split_objs = []
+    for obj in bpy.data.objects:
+        if obj.hide_render or obj.hide_viewport:
+            continue
+        if any(
+            exclude in obj.name
+            for exclude in [
+                "BowlFactory",
+                "CupFactory",
+                "OvenFactory",
+                "BottleFactory",
+            ]
+        ):
+            continue
+        for slot in obj.material_slots:
+            mat = slot.material
+            if mat is None:
+                continue
+            if (
+                "shader_glass" in mat.name or "shader_lamp_bulb" in mat.name
+            ) and len(obj.material_slots) >= 2:
+                logger.info(f"Splitting {obj}")
+                obj.select_set(True)
+                bpy.context.view_layer.objects.active = obj
+                bpy.ops.object.mode_set(mode="EDIT")
+                bpy.ops.mesh.separate(type="MATERIAL")
+                bpy.ops.object.mode_set(mode="OBJECT")
+                obj.select_set(False)
+                split_objs.append(obj.name)
+                break
+
+    matches = [
+        obj
+        for split_obj in split_objs
+        for obj in bpy.data.objects
+        if split_obj in obj.name
+    ]
+    for match in matches:
+        if len(match.material_slots) == 0 or match.material_slots[0] is None:
+            continue
+        mat = match.material_slots[0].material
+        if mat is None:
+            continue
+        if "shader_glass" in mat.name or "shader_lamp_bulb" in mat.name:
+            match.name = f"{match.name}_SPLIT_GLASS"
+
+
+def clean_names(obj=None):
+    if obj is not None:
+        obj.name = (obj.name).replace(" ", "_")
+        obj.name = (obj.name).replace(".", "_")
+
+        if obj.type == "MESH":
+            for uv_map in obj.data.uv_layers:
+                uv_map.name = uv_map.name.replace(".", "_")
+
+        for mat in bpy.data.materials:
+            if mat is None:
+                continue
+            mat.name = (mat.name).replace(" ", "_")
+            mat.name = (mat.name).replace(".", "_")
+
+        for slot in obj.material_slots:
+            mat = slot.material
+            if mat is None:
+                continue
+            mat.name = (mat.name).replace(" ", "_")
+            mat.name = (mat.name).replace(".", "_")
+        return
+
+    for obj in bpy.data.objects:
+        obj.name = (obj.name).replace(" ", "_")
+        obj.name = (obj.name).replace(".", "_")
+
+        if obj.type == "MESH":
+            for uv_map in obj.data.uv_layers:
+                uv_map.name = uv_map.name.replace(
+                    ".", "_"
+                )  # if uv has "." in name the node will export wrong in USD
+
+    for mat in bpy.data.materials:
+        if mat is None:
+            continue
+        mat.name = (mat.name).replace(" ", "_")
+        mat.name = (mat.name).replace(".", "_")
+
+
+def remove_obj_parents(obj=None):
+    if obj is not None:
+        old_location = obj.matrix_world.to_translation()
+        obj.parent = None
+        obj.matrix_world.translation = old_location
+        return
+
+    for obj in bpy.data.objects:
+        old_location = obj.matrix_world.to_translation()
+        obj.parent = None
+        obj.matrix_world.translation = old_location
+
+
+def delete_objects():
+    logger.info("Deleting placeholders collection")
+    collection_name = "placeholders"
+    collection = bpy.data.collections.get(collection_name)
+
+    if collection:
+        for scene in bpy.data.scenes:
+            if collection.name in scene.collection.children:
+                scene.collection.children.unlink(collection)
+
+        for obj in collection.objects:
+            bpy.data.objects.remove(obj, do_unlink=True)
+
+        def delete_child_collections(parent_collection):
+            for child_collection in parent_collection.children:
+                delete_child_collections(child_collection)
+                bpy.data.collections.remove(child_collection)
+
+        delete_child_collections(collection)
+        bpy.data.collections.remove(collection)
+
+    if bpy.data.objects.get("Grid"):
+        bpy.data.objects.remove(bpy.data.objects["Grid"], do_unlink=True)
+
+    if bpy.data.objects.get("atmosphere"):
+        bpy.data.objects.remove(bpy.data.objects["atmosphere"], do_unlink=True)
+
+    if bpy.data.objects.get("KoleClouds"):
+        bpy.data.objects.remove(bpy.data.objects["KoleClouds"], do_unlink=True)
+
+
+def rename_all_meshes(obj=None):
+    if obj is not None:
+        if obj.data and obj.data.users == 1:
+            obj.data.name = obj.name
+        return
+
+    for obj in bpy.data.objects:
+        if obj.data and obj.data.users == 1:
+            obj.data.name = obj.name
+
+
+def update_visibility():
+    outliner_area = next(
+        a for a in bpy.context.screen.areas if a.type == "OUTLINER"
+    )
+    space = outliner_area.spaces[0]
+    space.show_restrict_column_viewport = (
+        True  # Global visibility (Monitor icon)
+    )
+    collection_view = {}
+    obj_view = {}
+    for collection in bpy.data.collections:
+        collection_view[collection] = collection.hide_render
+        collection.hide_viewport = False  # reenables viewports for all
+        collection.hide_render = False  # enables renders for all collections
+
+    # disables viewports and renders for all objs
+    for obj in bpy.data.objects:
+        obj_view[obj] = obj.hide_render
+        obj.hide_viewport = True
+        obj.hide_render = True
+        obj.hide_set(0)
+
+    return collection_view, obj_view
+
+
+def uv_unwrap(obj):
+    obj.select_set(True)
+    bpy.context.view_layer.objects.active = obj
+
+    obj.data.uv_layers.new(name="ExportUV")
+    bpy.context.object.data.uv_layers["ExportUV"].active = True
+
+    logger.info("UV Unwrapping")
+    bpy.ops.object.mode_set(mode="EDIT")
+    bpy.ops.mesh.select_all(action="SELECT")
+    try:
+        bpy.ops.uv.smart_project(angle_limit=0.7)
+    except RuntimeError:
+        logger.info("UV Unwrap failed, skipping mesh")
+        bpy.ops.object.mode_set(mode="OBJECT")
+        obj.select_set(False)
+        return False
+    bpy.ops.object.mode_set(mode="OBJECT")
+    obj.select_set(False)
+    return True
+
+
+def bakeVertexColors(obj):
+    logger.info(f"Baking vertex color on {obj}")
+    bpy.ops.object.select_all(action="DESELECT")
+    obj.select_set(True)
+    bpy.context.view_layer.objects.active = obj
+    vertColor = bpy.context.object.data.color_attributes.new(
+        name="VertColor", domain="CORNER", type="BYTE_COLOR"
+    )
+    bpy.context.object.data.attributes.active_color = vertColor
+    bpy.ops.object.bake(
+        type="DIFFUSE", pass_filter={"COLOR"}, target="VERTEX_COLORS"
+    )
+    obj.select_set(False)
+
+
+def apply_baked_tex(obj, paramDict={}):
+    bpy.context.view_layer.objects.active = obj
+    bpy.context.object.data.uv_layers["ExportUV"].active_render = True
+    for uv_layer in reversed(obj.data.uv_layers):
+        if "ExportUV" not in uv_layer.name:
+            logger.info(f"Removed extraneous UV Layer {uv_layer}")
+            obj.data.uv_layers.remove(uv_layer)
+
+    for slot in obj.material_slots:
+        mat = slot.material
+        if mat is None:
+            continue
+        mat.use_nodes = True
+        nodes = mat.node_tree.nodes
+        logger.info("Reapplying baked texs on " + mat.name)
+
+        # delete all nodes except baked nodes and bsdf
+        excludedNodes = [type + "_node" for type in ALL_BAKE]
+        excludedNodes.extend(["Material Output", "Principled BSDF"])
+        for n in nodes:
+            if n.name not in excludedNodes:
+                nodes.remove(
+                    n
+                )  # deletes an arbitrary principled BSDF in the case of a mix, which is handled below
+
+        output = nodes["Material Output"]
+
+        # stick baked texture in material
+        if nodes.get("Principled BSDF") is None:  # no bsdf
+            logger.info("No BSDF, creating new one")
+            principled_bsdf_node = nodes.new("ShaderNodeBsdfPrincipled")
+        elif (
+            len(output.inputs[0].links) != 0
+            and output.inputs[0].links[0].from_node.bl_idname
+            == "ShaderNodeBsdfPrincipled"
+        ):  # trivial bsdf graph
+            logger.info("Trivial shader graph, using old BSDF")
+            principled_bsdf_node = nodes["Principled BSDF"]
+        else:
+            logger.info("Non-trivial shader graph, creating new BSDF")
+            nodes.remove(
+                nodes["Principled BSDF"]
+            )  # shader graph was a mix of bsdfs
+            principled_bsdf_node = nodes.new("ShaderNodeBsdfPrincipled")
+
+        links = mat.node_tree.links
+
+        # create the new shader node links
+        links.new(output.inputs[0], principled_bsdf_node.outputs[0])
+        for type in ALL_BAKE:
+            if not nodes.get(type + "_node"):
+                continue
+            tex_node = nodes[type + "_node"]
+            if type == "NORMAL":
+                normal_node = nodes.new("ShaderNodeNormalMap")
+                links.new(normal_node.inputs["Color"], tex_node.outputs[0])
+                links.new(
+                    principled_bsdf_node.inputs[ALL_BAKE[type]],
+                    normal_node.outputs[0],
+                )
+                continue
+            links.new(
+                principled_bsdf_node.inputs[ALL_BAKE[type]],
+                tex_node.outputs[0],
+            )
+
+        # bring back cleared param values
+        if mat.name in 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"]
+            )
+
+
+def create_glass_shader(node_tree, export_usd):
+    nodes = node_tree.nodes
+    if nodes.get("Glass BSDF"):
+        color = nodes["Glass BSDF"].inputs[0].default_value
+        roughness = nodes["Glass BSDF"].inputs[1].default_value
+        ior = nodes["Glass BSDF"].inputs[2].default_value
+
+    if nodes.get("Principled BSDF"):
+        nodes.remove(nodes["Principled BSDF"])
+
+    principled_bsdf_node = nodes.new("ShaderNodeBsdfPrincipled")
+
+    if nodes.get("Glass BSDF"):
+        principled_bsdf_node.inputs["Base Color"].default_value = color
+        principled_bsdf_node.inputs["Roughness"].default_value = roughness
+        principled_bsdf_node.inputs["IOR"].default_value = ior
+    else:
+        principled_bsdf_node.inputs["Roughness"].default_value = 0
+
+    principled_bsdf_node.inputs["Transmission Weight"].default_value = 1
+    if export_usd:
+        principled_bsdf_node.inputs["Alpha"].default_value = 0
+    node_tree.links.new(
+        principled_bsdf_node.outputs[0], nodes["Material Output"].inputs[0]
+    )
+
+
+def process_glass_materials(obj, export_usd):
+    for slot in obj.material_slots:
+        mat = slot.material
+        if mat is None or not mat.use_nodes:
+            continue
+        nodes = mat.node_tree.nodes
+        outputNode = nodes["Material Output"]
+        if nodes.get("Glass BSDF"):
+            if (
+                outputNode.inputs[0].links[0].from_node.bl_idname
+                == "ShaderNodeBsdfGlass"
+            ):
+                logger.info(f"Creating glass material on {obj.name}")
+            else:
+                logger.info(
+                    f"Non-trivial glass material on {obj.name}, material export will be inaccurate"
+                )
+            create_glass_shader(mat.node_tree, export_usd)
+        elif "glass" in mat.name or "shader_lamp_bulb" in mat.name:
+            logger.info(f"Creating glass material on {obj.name}")
+            create_glass_shader(mat.node_tree, export_usd)
+
+
+def bake_pass(
+    obj, dest: Path, img_size, bake_type, export_usd, export_name=None
+):
+    if export_name is None:
+        img = bpy.data.images.new(
+            f"{obj.name}_{bake_type}", img_size, img_size
+        )
+        clean_name = (
+            (obj.name).replace(" ", "_").replace(".", "_").replace("/", "_")
+        )
+        clean_name = (
+            clean_name.replace("(", "_").replace(")", "").replace("-", "_")
+        )
+        file_path = dest / f"{clean_name}_{bake_type}.png"
+    else:
+        img = bpy.data.images.new(
+            f"{export_name}_{bake_type}", img_size, img_size
+        )
+        file_path = dest / f"{export_name}_{bake_type}.png"
+    dest = dest / "textures"
+
+    bake_obj = False
+    bake_exclude_mats = {}
+
+    # materials are stored as stack so when removing traverse the reversed list
+    for index, slot in reversed(list(enumerate(obj.material_slots))):
+        mat = slot.material
+        if mat is None:
+            bpy.context.object.active_material_index = index
+            bpy.ops.object.material_slot_remove()
+            continue
+
+        logger.info(mat.name)
+        mat.use_nodes = True
+        nodes = mat.node_tree.nodes
+
+        output = nodes["Material Output"]
+
+        img_node = nodes.new("ShaderNodeTexImage")
+        img_node.name = f"{bake_type}_node"
+        img_node.image = img
+        img_node.select = True
+        nodes.active = img_node
+        img_node.select = True
+
+        if len(output.inputs["Displacement"].links) != 0:
+            bake_obj = True
+
+        if len(output.inputs[0].links) == 0:
+            logger.info(
+                f"{mat.name} has no surface output, not using baked textures"
+            )
+            bake_exclude_mats[mat] = img_node
+            continue
+
+        # surface_node = output.inputs[0].links[0].from_node
+        # if (
+        #     bake_type in ALL_BAKE
+        #     and surface_node.bl_idname == "ShaderNodeBsdfPrincipled"
+        #     and len(surface_node.inputs[ALL_BAKE[bake_type]].links) == 0
+        # ):  # trivial bsdf graph
+        #     logger.info(
+        #         f"{mat.name} has no procedural input for {bake_type}, not using baked textures"
+        #     )
+        #     bake_exclude_mats[mat] = img_node
+        #     continue
+
+        bake_obj = True
+
+    if bake_type in SPECIAL_BAKE:
+        internal_bake_type = "EMIT"
+    else:
+        internal_bake_type = bake_type
+
+    if bake_obj:
+        logger.info(f"Baking {bake_type} pass")
+        bpy.ops.object.bake(
+            type=internal_bake_type,
+            pass_filter={"COLOR"},
+            save_mode="EXTERNAL",
+        )
+        img.filepath_raw = str(file_path)
+        img.save()
+        logger.info(f"Saving to {file_path}")
+    else:
+        logger.info(
+            f"No necessary materials to bake on {obj.name}, skipping bake"
+        )
+
+    for mat, img_node in bake_exclude_mats.items():
+        mat.node_tree.nodes.remove(img_node)
+
+
+def bake_special_emit(
+    obj, dest, img_size, export_usd, bake_type, export_name=None
+):
+    # If at least one material has both a BSDF and non-zero bake type value, then bake
+    should_bake = False
+
+    # (Root node, From Socket, To Socket)
+    links_removed = []
+    links_added = []
+
+    for slot in obj.material_slots:
+        mat = slot.material
+        if mat is None:
+            logger.warn("No material on mesh, skipping...")
+            continue
+        if not mat.use_nodes:
+            logger.warn("Material has no nodes, skipping...")
+            continue
+
+        nodes = mat.node_tree.nodes
+        principled_bsdf_node = None
+        root_node = None
+        logger.info(f"{mat.name} has {len(nodes)} nodes: {nodes}")
+        for node in nodes:
+            if node.type != "GROUP":
+                continue
+
+            for subnode in node.node_tree.nodes:
+                logger.info(
+                    f" [{subnode.type}] {subnode.name} {subnode.bl_idname}"
+                )
+                if subnode.type == "BSDF_PRINCIPLED":
+                    logger.debug(f" BSDF_PRINCIPLED: {subnode.inputs}")
+                    principled_bsdf_node = subnode
+                    root_node = node
+
+        if nodes.get("Principled BSDF"):
+            principled_bsdf_node = nodes["Principled BSDF"]
+            root_node = mat
+        elif not principled_bsdf_node:
+            logger.warn("No Principled BSDF, skipping...")
+            continue
+        elif ALL_BAKE[bake_type] not in principled_bsdf_node.inputs:
+            logger.warn(f"No {bake_type} input, skipping...")
+            continue
+
+        # Here, we"ve found the proper BSDF and bake type input. Set up the scene graph
+        # for baking.
+        outputSoc = principled_bsdf_node.outputs[0].links[0].to_socket
+
+        # Remove the BSDF link to Output first
+        link = principled_bsdf_node.outputs[0].links[0]
+        from_socket, to_socket = link.from_socket, link.to_socket
+        logger.debug(f"Removing link: {from_socket.name} => {to_socket.name}")
+        root_node.node_tree.links.remove(link)
+        links_removed.append((root_node, from_socket, to_socket))
+
+        # Get bake_type value
+        bake_input = principled_bsdf_node.inputs[ALL_BAKE[bake_type]]
+        bake_val = bake_input.default_value
+        logger.info(f"{bake_type} value: {bake_val}")
+
+        if bake_val > 0:
+            should_bake = True
+
+        # Make a color input matching the metallic value
+        col = root_node.node_tree.nodes.new("ShaderNodeRGB")
+        col.outputs[0].default_value = (bake_val, bake_val, bake_val, 1.0)
+
+        # Link the color to output
+        new_link = root_node.node_tree.links.new(col.outputs[0], outputSoc)
+        links_added.append((root_node, col.outputs[0], outputSoc))
+        logger.debug(
+            f"Linking {col.outputs[0].name} to {outputSoc.name}({outputSoc.bl_idname}): {new_link}"
+        )
+
+    # After setting up all materials, bake if applicable
+    if should_bake:
+        bake_pass(obj, dest, img_size, bake_type, export_usd, export_name)
+
+    # After baking, undo the temporary changes to the scene graph
+    for n, from_soc, to_soc in links_added:
+        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)
+                logger.debug(
+                    f"Removed link:\t{n.name}: {from_soc.name} => {to_soc.name}"
+                )
+
+    for n, from_soc, to_soc in links_removed:
+        logger.debug(
+            f"Adding back link:\t{n.name}: {from_soc.name} => {to_soc.name}"
+        )
+        n.node_tree.links.new(from_soc, to_soc)
+
+
+def remove_params(mat, node_tree):
+    nodes = node_tree.nodes
+    paramDict = {}
+    if nodes.get("Material Output"):
+        output = nodes["Material Output"]
+    elif nodes.get("Group Output"):
+        output = nodes["Group Output"]
+    else:
+        raise ValueError("Could not find material output node")
+
+    if (
+        nodes.get("Principled BSDF")
+        and output.inputs[0].links[0].from_node.bl_idname
+        == "ShaderNodeBsdfPrincipled"
+    ):
+        principled_bsdf_node = nodes["Principled BSDF"]
+        metal = principled_bsdf_node.inputs[
+            "Metallic"
+        ].default_value  # store metallic value and set to 0
+        sheen = principled_bsdf_node.inputs["Sheen Weight"].default_value
+        clearcoat = principled_bsdf_node.inputs["Coat Weight"].default_value
+        paramDict[mat.name] = {
+            "Metallic": metal,
+            "Sheen Weight": sheen,
+            "Coat Weight": clearcoat,
+        }
+        principled_bsdf_node.inputs["Metallic"].default_value = 0
+        principled_bsdf_node.inputs["Sheen Weight"].default_value = 0
+        principled_bsdf_node.inputs["Coat Weight"].default_value = 0
+        return paramDict
+
+    for node in nodes:
+        if node.type == "GROUP":
+            paramDict = remove_params(mat, node.node_tree)
+            if len(paramDict) != 0:
+                return paramDict
+
+    return paramDict
+
+
+def process_interfering_params(obj):
+    for slot in obj.material_slots:
+        mat = slot.material
+        if mat is None or not mat.use_nodes:
+            continue
+        paramDict = remove_params(mat, mat.node_tree)
+    return paramDict
+
+
+def skipBake(obj):
+    if not obj.data.materials:
+        logger.info("No material on mesh, skipping...")
+        return True
+
+    if len(obj.data.vertices) == 0:
+        logger.info("Mesh has no vertices, skipping ...")
+        return True
+
+    return False
+
+
+def triangulate_mesh(obj: bpy.types.Object):
+    logger.debug("Triangulating Mesh")
+    if obj.type == "MESH":
+        view_state = obj.hide_viewport
+        obj.hide_viewport = False
+        bpy.context.view_layer.objects.active = obj
+        obj.select_set(True)
+        bpy.ops.object.mode_set(mode="EDIT")
+        bpy.ops.mesh.select_all(action="SELECT")
+        logger.debug(f"Triangulating {obj}")
+        bpy.ops.mesh.quads_convert_to_tris()
+        bpy.ops.object.mode_set(mode="OBJECT")
+        obj.select_set(False)
+        obj.hide_viewport = view_state
+
+
+def triangulate_meshes():
+    logger.debug("Triangulating Meshes")
+    for obj in bpy.context.scene.objects:
+        if obj.type == "MESH":
+            view_state = obj.hide_viewport
+            obj.hide_viewport = False
+            bpy.context.view_layer.objects.active = obj
+            obj.select_set(True)
+            bpy.ops.object.mode_set(mode="EDIT")
+            bpy.ops.mesh.select_all(action="SELECT")
+            logger.debug(f"Triangulating {obj}")
+            bpy.ops.mesh.quads_convert_to_tris()
+            bpy.ops.object.mode_set(mode="OBJECT")
+            obj.select_set(False)
+            obj.hide_viewport = view_state
+
+
+def adjust_wattages():
+    logger.info("Adjusting light wattage")
+    for obj in bpy.context.scene.objects:
+        if obj.type == "LIGHT" and obj.data.type == "POINT":
+            light = obj.data
+            if hasattr(light, "energy") and hasattr(light, "shadow_soft_size"):
+                X = light.energy
+                r = light.shadow_soft_size
+                # candelas * 1000 / (4 * math.pi * r**2). additionally units come out of blender at 1/100 scale
+                new_wattage = (
+                    (X * 20 / (4 * math.pi))
+                    * 1000
+                    / (4 * math.pi * r**2)
+                    * 100
+                )
+                light.energy = new_wattage
+
+
+def set_center_of_mass():
+    logger.info("Resetting center of mass of objects")
+    for obj in bpy.context.scene.objects:
+        if not obj.hide_render:
+            view_state = obj.hide_viewport
+            obj.hide_viewport = False
+            obj.select_set(True)
+            bpy.context.view_layer.objects.active = obj
+            bpy.ops.object.origin_set(type="ORIGIN_GEOMETRY", center="MEDIAN")
+            obj.select_set(False)
+            obj.hide_viewport = view_state
+
+
+def duplicate_node_groups(node_tree, group_map=None):
+    if group_map is None:
+        group_map = {}
+
+    for node in node_tree.nodes:
+        if node.type == "GROUP":
+            group = node.node_tree
+            if group not in group_map:
+                group_copy = group.copy()
+                group_copy.name = f"{group.name}_copy"
+                group_map[group] = group_copy
+
+                duplicate_node_groups(group_copy, group_map)
+            else:
+                group_copy = group_map[group]
+
+            node.node_tree = group_copy
+
+    return group_map
+
+
+def deep_copy_material(original_material, new_name_suffix="_deepcopy"):
+    new_mat = original_material.copy()
+    new_mat.name = original_material.name + new_name_suffix
+    if new_mat.use_nodes and new_mat.node_tree:
+        duplicate_node_groups(new_mat.node_tree)
+    return new_mat
+
+
+def bake_object(obj, dest, img_size, export_usd, export_name=None):
+    if not uv_unwrap(obj):
+        return
+
+    bpy.ops.object.select_all(action="DESELECT")
+
+    with butil.SelectObjects(obj):
+        for slot in obj.material_slots:
+            mat = slot.material
+            if mat is not None:
+                slot.material = deep_copy_material(
+                    mat
+                )  # we duplicate in the case of distinct meshes sharing materials
+
+        process_glass_materials(obj, export_usd)
+
+        for bake_type in SPECIAL_BAKE:
+            bake_special_emit(
+                obj, dest, img_size, export_usd, bake_type, export_name
+            )
+
+        # bake_normals(obj, dest, img_size, export_usd)
+        paramDict = process_interfering_params(obj)
+        for bake_type in BAKE_TYPES:
+            bake_pass(obj, dest, img_size, bake_type, export_usd, export_name)
+
+        apply_baked_tex(obj, paramDict)
+
+
+def bake_scene(folderPath: Path, image_res, vertex_colors, export_usd):
+    for obj in bpy.data.objects:
+        logger.info("---------------------------")
+        logger.info(obj.name)
+
+        if obj.type != "MESH" or obj not in list(
+            bpy.context.view_layer.objects
+        ):
+            logger.info("Not mesh, skipping ...")
+            continue
+
+        if skipBake(obj):
+            continue
+
+        if format == "stl":
+            continue
+
+        obj.hide_render = False
+        obj.hide_viewport = False
+
+        if vertex_colors:
+            bakeVertexColors(obj)
+        else:
+            bake_object(obj, folderPath, image_res, export_usd)
+
+        obj.hide_render = True
+        obj.hide_viewport = True
+
+
+def run_blender_export(
+    exportPath: Path, format: str, vertex_colors: bool, individual_export: bool
+):
+    assert exportPath.parent.exists()
+    exportPath = str(exportPath)
+
+    if format == "obj":
+        if vertex_colors:
+            bpy.ops.wm.obj_export(
+                filepath=exportPath,
+                export_colors=True,
+                export_eval_mode="DAG_EVAL_RENDER",
+                export_selected_objects=individual_export,
+            )
+        else:
+            bpy.ops.wm.obj_export(
+                filepath=exportPath,
+                path_mode="COPY",
+                export_materials=True,
+                export_pbr_extensions=False,
+                export_eval_mode="DAG_EVAL_RENDER",
+                export_selected_objects=individual_export,
+                export_triangulated_mesh=True,
+                export_normals=False,
+            )
+
+    if format == "fbx":
+        if vertex_colors:
+            bpy.ops.export_scene.fbx(
+                filepath=exportPath,
+                colors_type="SRGB",
+                use_selection=individual_export,
+            )
+        else:
+            bpy.ops.export_scene.fbx(
+                filepath=exportPath,
+                path_mode="COPY",
+                embed_textures=True,
+                use_selection=individual_export,
+            )
+
+    if format == "stl":
+        bpy.ops.export_mesh.stl(
+            filepath=exportPath, use_selection=individual_export
+        )
+
+    if format == "ply":
+        bpy.ops.wm.ply_export(
+            filepath=exportPath, export_selected_objects=individual_export
+        )
+
+    if format in ["usda", "usdc"]:
+        bpy.ops.wm.usd_export(
+            filepath=exportPath,
+            export_textures=True,
+            # use_instancing=True,
+            overwrite_textures=True,
+            selected_objects_only=individual_export,
+            root_prim_path="/World",
+        )
+
+
+def export_scene(
+    input_blend: Path,
+    output_folder: Path,
+    pipeline_folder=None,
+    task_uniqname=None,
+    **kwargs,
+):
+    folder = output_folder / f"export_{os.path.splitext(input_blend.name)[0]}"
+    folder.mkdir(exist_ok=True, parents=True)
+    export_curr_scene(folder, **kwargs)
+
+    if pipeline_folder is not None and task_uniqname is not None:
+        (pipeline_folder / "logs" / f"FINISH_{task_uniqname}").touch()
+
+    return folder
+
+
+# side effects: will remove parents of inputted obj and clean its name, hides viewport of all objects
+def export_single_obj(
+    obj: bpy.types.Object,
+    output_folder: Path,
+    format="usdc",
+    image_res=1024,
+    vertex_colors=False,
+):
+    export_usd = format in ["usda", "usdc"]
+
+    export_folder = output_folder
+    export_folder.mkdir(parents=True, exist_ok=True)
+    export_file = export_folder / output_folder.with_suffix(f".{format}").name
+
+    logger.info(f"Exporting to directory {export_folder=}")
+
+    remove_obj_parents(obj)
+    rename_all_meshes(obj)
+
+    collection_views, obj_views = update_visibility()
+
+    bpy.context.scene.render.engine = "CYCLES"
+    bpy.context.scene.cycles.device = "GPU"
+    bpy.context.scene.cycles.samples = 1  # choose render sample
+    # Set the tile size
+    bpy.context.scene.cycles.tile_x = image_res
+    bpy.context.scene.cycles.tile_y = image_res
+
+    if obj.type != "MESH" or obj not in list(bpy.context.view_layer.objects):
+        raise ValueError("Object not mesh")
+
+    if export_usd:
+        apply_all_modifiers(obj)
+    else:
+        realizeInstances(obj)
+        apply_all_modifiers(obj)
+
+    if not skipBake(obj) and format != "stl":
+        if vertex_colors:
+            bakeVertexColors(obj)
+        else:
+            obj.hide_render = False
+            obj.hide_viewport = False
+            bake_object(obj, export_folder / "textures", image_res, export_usd)
+            obj.hide_render = True
+            obj.hide_viewport = True
+
+    for collection, status in collection_views.items():
+        collection.hide_render = status
+
+    for obj, status in obj_views.items():
+        obj.hide_render = status
+
+    clean_names(obj)
+
+    old_loc = obj.location.copy()
+    obj.location = (0, 0, 0)
+
+    if (
+        obj.type != "MESH"
+        or obj.hide_render
+        or len(obj.data.vertices) == 0
+        or obj not in list(bpy.context.view_layer.objects)
+    ):
+        raise ValueError("Object is not mesh or hidden from render")
+
+    export_subfolder = export_folder / obj.name
+    export_subfolder.mkdir(exist_ok=True)
+    export_file = export_subfolder / f"{obj.name}.{format}"
+
+    logger.info(f"Exporting file to {export_file=}")
+    obj.hide_viewport = False
+    obj.select_set(True)
+    run_blender_export(
+        export_file, format, vertex_colors, individual_export=True
+    )
+    obj.select_set(False)
+    obj.location = old_loc
+
+    return export_file
+
+
+def export_sim_ready(
+    obj: bpy.types.Object,
+    output_folder: Path,
+    image_res: int = 1024,
+    translation: Tuple = (0, 0, 0),
+    name: Optional[str] = None,
+    visual_only: bool = False,
+    collision_only: bool = False,
+    separate_asset_dirs: bool = True,
+) -> 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."
+
+    asset_exports = defaultdict(list)
+    export_name = name if name is not None else obj.name
+
+    if separate_asset_dirs:
+        visual_export_folder = output_folder / "visual"
+        collision_export_folder = output_folder / "collision"
+    else:
+        visual_export_folder = output_folder
+        collision_export_folder = output_folder
+
+    texture_export_folder = output_folder / "textures"
+
+    visual_export_folder.mkdir(parents=True, exist_ok=True)
+    collision_export_folder.mkdir(parents=True, exist_ok=True)
+
+    logger.info(f"Exporting to directory {output_folder=}")
+
+    collection_views, obj_views = update_visibility()
+
+    bpy.context.scene.render.engine = "CYCLES"
+    bpy.context.scene.cycles.device = "GPU"
+    bpy.context.scene.cycles.samples = 1  # choose render sample
+    # Set the tile size
+    bpy.context.scene.cycles.tile_x = image_res
+    bpy.context.scene.cycles.tile_y = image_res
+
+    if obj.type != "MESH" or obj not in list(bpy.context.view_layer.objects):
+        raise ValueError("Object not mesh")
+
+    # export the textures
+    if not skipBake(obj):
+        texture_export_folder.mkdir(parents=True, exist_ok=True)
+        obj.hide_render = False
+        obj.hide_viewport = False
+        bake_object(obj, texture_export_folder, image_res, False, export_name)
+        obj.hide_render = True
+        obj.hide_viewport = True
+
+    for collection, status in collection_views.items():
+        collection.hide_render = status
+
+    for obj_tmp, status in obj_views.items():
+        obj_tmp.hide_render = status
+
+    # translating object
+    old_loc = obj.location.copy()
+    obj.location = (
+        old_loc[0] + translation[0],
+        old_loc[1] + translation[1],
+        old_loc[2] + translation[2],
+    )
+
+    if (
+        obj.type != "MESH"
+        or obj.hide_render
+        or len(obj.data.vertices) == 0
+        or obj not in list(bpy.context.view_layer.objects)
+    ):
+        raise ValueError("Object is not mesh or hidden from render")
+
+    # export the mesh assets
+    visual_export_file = visual_export_folder / f"{export_name}.obj"
+
+    logger.info(f"Exporting file to {visual_export_file=}")
+    obj.hide_viewport = False
+    obj.select_set(True)
+
+    # export visual asset
+    with butil.SelectObjects(obj, active=1):
+        bpy.ops.wm.obj_export(
+            filepath=str(visual_export_file),
+            up_axis="Z",
+            forward_axis="Y",
+            export_selected_objects=True,
+            export_triangulated_mesh=True,  # required for coacd to run properly
+        )
+    if not collision_only:
+        asset_exports["visual"].append(visual_export_file)
+
+    if visual_only:
+        obj.select_set(False)
+        obj.location = old_loc
+        return asset_exports
+
+    clone = butil.deep_clone_obj(obj)
+    parts = butil.split_object(clone)
+
+    part_export_obj_file = visual_export_folder / f"{export_name}_part.obj"
+    part_export_mtl_file = visual_export_folder / f"{export_name}_part.mtl"
+
+    collision_count = 0
+    for part in parts:
+        with butil.SelectObjects(part, active=1):
+            bpy.ops.wm.obj_export(
+                filepath=str(part_export_obj_file),
+                up_axis="Z",
+                forward_axis="Y",
+                export_selected_objects=True,
+                export_triangulated_mesh=True,  # required for coacd to run properly
+            )
+
+        # export the collision meshes
+        mesh_tri = trimesh.load(
+            str(part_export_obj_file),
+            merge_norm=True,
+            merge_tex=True,
+            force="mesh",
+        )
+        trimesh.repair.fix_inversion(mesh_tri)
+        preprocess_mode = "off"
+        if not mesh_tri.is_volume:
+            print(
+                mesh_tri.is_watertight,
+                mesh_tri.is_winding_consistent,
+                np.isfinite(mesh_tri.center_mass).all(),
+                mesh_tri.volume > 0.0,
+            )
+            preprocess_mode = "on"
+
+            if len(mesh_tri.vertices) < 4:
+                logger.warning(
+                    f"Mesh is not a volume. Only has {len(mesh_tri.vertices)} vertices."
+                )
+                # raise ValueError(f"Mesh is not a volume. Only has {len(mesh_tri.vertices)} vertices.")
+        mesh = coacd.Mesh(mesh_tri.vertices, mesh_tri.faces)
+
+        subparts = coacd.run_coacd(
+            mesh=mesh,
+            threshold=0.05,
+            max_convex_hull=-1,
+            preprocess_mode=preprocess_mode,
+            mcts_max_depth=3,
+        )
+        export_name = export_name.replace("vis", "col")
+        for vs, fs in subparts:
+            collision_export_file = (
+                collision_export_folder
+                / f"{export_name}_col{collision_count}.obj"
+            )
+            subpart_mesh = trimesh.Trimesh(vs, fs)
+
+            # if subpart_mesh.is_empty:
+            #     raise ValueError(
+            #         "Warning: Collision mesh is completely outside the bounds of the original mesh."
+            #     )
+            subpart_mesh.export(str(collision_export_file))
+            asset_exports["collision"].append(collision_export_file)
+            collision_count += 1
+
+    # delete temporary part files
+    part_export_obj_file.unlink(missing_ok=True)
+    part_export_mtl_file.unlink(missing_ok=True)
+
+    obj.select_set(False)
+    obj.location = old_loc
+    butil.delete(clone)
+
+    return asset_exports
+
+
+@gin.configurable
+def export_curr_scene(
+    output_folder: Path,
+    format="usdc",
+    image_res=1024,
+    vertex_colors=False,
+    individual_export=False,
+    omniverse_export=False,
+    pipeline_folder=None,
+    task_uniqname=None,
+    deconvex=False,
+    center_scene=False,
+    align_quat=(0.7071, 0, 0, 0.7071),  # xyzw
+) -> Path:
+    export_usd = format in ["usda", "usdc"]
+    export_folder = output_folder
+    export_folder.mkdir(exist_ok=True)
+    export_file = export_folder / output_folder.with_suffix(f".{format}").name
+    logger.info(f"Exporting to directory {export_folder=}")
+
+    remove_obj_parents()
+    delete_objects()
+    triangulate_meshes()
+    if omniverse_export:
+        split_glass_mats()
+    rename_all_meshes()
+
+    # remove 0 polygon meshes
+    for obj in bpy.data.objects:
+        if obj.type == "MESH" and len(obj.data.polygons) == 0:
+            logger.info(f"{obj.name} has no faces, removing...")
+            bpy.data.objects.remove(obj, do_unlink=True)
+
+    if center_scene:
+        from mathutils import Vector
+
+        positions = []
+        view_objs = set(bpy.context.view_layer.objects)
+        for obj in bpy.data.objects:
+            if (
+                obj.type == "MESH"
+                and obj.data
+                and obj.data.vertices
+                and obj.data.polygons
+                and not obj.hide_render
+                and obj in view_objs
+            ):
+                pos = np.array(obj.matrix_world.translation)
+                if not np.allclose(pos, 0):
+                    positions.append(pos)
+
+        if len(positions) > 0:
+            positions = np.stack(positions)
+            center = (positions.min(axis=0) + positions.max(axis=0)) * 0.5
+            center[2] = positions[:, 2].min()  # Set floor to 0 among z-axis.
+            for obj in bpy.data.objects:
+                pos = np.array(obj.matrix_world.translation)
+                if not np.allclose(pos, 0):
+                    obj.location -= Vector(center)
+
+    scatter_cols = []
+    if export_usd:
+        if bpy.data.collections.get("scatter"):
+            scatter_cols.append(bpy.data.collections["scatter"])
+        if bpy.data.collections.get("scatters"):
+            scatter_cols.append(bpy.data.collections["scatters"])
+        for col in scatter_cols:
+            for obj in col.all_objects:
+                remove_shade_smooth(obj)
+
+    collection_views, obj_views = update_visibility()
+    for obj in bpy.data.objects:
+        if obj.type != "MESH" or obj not in list(
+            bpy.context.view_layer.objects
+        ):
+            continue
+        if export_usd:
+            apply_all_modifiers(obj)
+        else:
+            realizeInstances(obj)
+            apply_all_modifiers(obj)
+
+    bpy.context.scene.render.engine = "CYCLES"
+    bpy.context.scene.cycles.device = "GPU"
+    bpy.context.scene.cycles.samples = 1  # choose render sample
+    # Set the tile size
+    bpy.context.scene.cycles.tile_x = image_res
+    bpy.context.scene.cycles.tile_y = image_res
+
+    # iterate through all objects and bake them
+    bake_scene(
+        folderPath=export_folder / "textures",
+        image_res=image_res,
+        vertex_colors=vertex_colors,
+        export_usd=export_usd,
+    )
+
+    for collection, status in collection_views.items():
+        collection.hide_render = status
+
+    for obj, status in obj_views.items():
+        obj.hide_render = status
+
+    clean_names()
+
+    for obj in bpy.data.objects:
+        obj.hide_viewport = obj.hide_render
+
+    if omniverse_export:
+        adjust_wattages()
+        set_center_of_mass()
+
+    if individual_export:
+        import math
+        import xml.etree.ElementTree as ET
+        from xml.dom import minidom
+
+        import trimesh
+        from scipy.spatial.transform import Rotation
+        from embodied_gen.data.convex_decomposer import decompose_convex_mesh
+
+        urdf_root = ET.Element("robot", name="multi_object_scene")
+        ET.SubElement(urdf_root, "link", name="base")
+        object_info = []
+        bpy.ops.object.select_all(action="DESELECT")
+        objects = list(bpy.data.objects)
+        for obj in objects:
+            if (
+                obj.type != "MESH"
+                or obj.data is None
+                or len(obj.data.vertices) == 0
+                or len(obj.data.polygons) == 0
+                or obj.hide_render
+                or obj not in list(bpy.context.view_layer.objects)
+            ):
+                continue
+
+            obj_name = obj.name.replace("/", "_").replace("-", "_")
+            obj_name = obj_name.replace("(", "_").replace(")", "")
+            obj.name = obj_name
+            export_subfolder = export_folder / obj_name
+            export_subfolder.mkdir(exist_ok=True, parents=True)
+            export_file = export_subfolder / f"{obj_name}.{format}"
+
+            if "skirtingboard" in obj_name.lower():
+                logger.info(f"Skipping skirting board {obj_name}")
+                continue
+
+            logger.info(f"Exporting file to {export_file=}")
+            obj.hide_viewport = False
+
+            position = obj.matrix_world.to_translation()
+            rotation = Rotation.from_quat(align_quat)
+            rotation = rotation.as_euler("xyz", degrees=False)
+
+            obj.select_set(True)
+            bpy.context.view_layer.objects.active = obj
+            bpy.ops.object.location_clear()
+
+            face_count = len(obj.data.polygons)
+            if face_count > 1000:
+                if face_count > 1000000:
+                    ratio = 0.005
+                elif face_count > 100000:
+                    ratio = 0.02
+                elif face_count > 10000:
+                    ratio = 0.1
+                else:
+                    ratio = 0.2
+                angle_threshold = math.radians(5)
+                bpy.ops.object.mode_set(mode="OBJECT")
+                dec_mod = obj.modifiers.new(name="Decimate", type="DECIMATE")
+                dec_mod.decimate_type = "DISSOLVE"
+                dec_mod.angle_limit = angle_threshold
+                dec_mod.use_collapse_triangulate = False
+                dec_mod.ratio = ratio
+                bpy.ops.object.modifier_apply(modifier=dec_mod.name)
+
+            run_blender_export(
+                export_file, format, vertex_colors, individual_export
+            )
+            obj.select_set(False)
+
+            mesh = trimesh.load(export_file)
+            if isinstance(mesh, trimesh.Scene) and len(mesh.geometry) == 0:
+                shutil.rmtree(export_file.parent)
+                continue
+
+            object_info.append(
+                {
+                    "name": obj_name,
+                    "mesh_path": f"{obj_name}/{obj_name}.{format}",
+                    "mesh_abs_path": str(export_file),
+                    "xyz": tuple(position),
+                    "rpy": tuple(rotation),
+                }
+            )
+
+        for obj in object_info:
+            link = ET.SubElement(urdf_root, "link", name=obj["name"])
+            visual = ET.SubElement(link, "visual")
+            geom = ET.SubElement(visual, "geometry")
+            ET.SubElement(
+                geom, "mesh", filename=obj["mesh_path"], scale="1 1 1"
+            )
+            if deconvex:
+                print("Deconvexing mesh for collision, waiting...")
+                d_params = dict(
+                    threshold=0.05, max_convex_hull=128, verbose=False
+                )
+                mesh_path = obj["mesh_abs_path"]
+                output_path = mesh_path.replace(".obj", "_collision.obj")
+                decompose_convex_mesh(mesh_path, output_path, **d_params)
+                collision_mesh = obj["mesh_path"].replace(
+                    ".obj", "_collision.obj"
+                )
+                collision = ET.SubElement(link, "collision")
+                geom2 = ET.SubElement(collision, "geometry")
+                ET.SubElement(
+                    geom2, "mesh", filename=collision_mesh, scale="1 1 1"
+                )
+
+            joint = ET.SubElement(
+                urdf_root, "joint", name=f"joint_{obj['name']}", type="fixed"
+            )
+            ET.SubElement(joint, "parent", link="base")
+            ET.SubElement(joint, "child", link=obj["name"])
+            ET.SubElement(
+                joint,
+                "origin",
+                xyz="%.4f %.4f %.4f" % obj["xyz"],
+                rpy="%.4f %.4f %.4f" % obj["rpy"],
+            )
+
+        urdf_str = minidom.parseString(ET.tostring(urdf_root)).toprettyxml(
+            indent="  "
+        )
+        urdf_path = export_folder / "scene.urdf"
+        with open(urdf_path, "w") as f:
+            f.write(urdf_str)
+        logger.info(f"URDF exported to {urdf_path}")
+
+        return urdf_path
+    else:
+        logger.info(f"Exporting file to {export_file=}")
+        run_blender_export(
+            export_file, format, vertex_colors, individual_export
+        )
+
+        return export_file
+
+
+def main(args):
+    args.output_folder.mkdir(exist_ok=True)
+    targets = sorted(list(args.input_folder.iterdir()))
+    for blendfile in targets:
+        if blendfile.stem == "solve_state":
+            shutil.copy(blendfile, args.output_folder / "solve_state.json")
+
+        if not blendfile.suffix == ".blend":
+            print(f"Skipping non-blend file {blendfile}")
+            continue
+
+        bpy.ops.wm.open_mainfile(filepath=str(blendfile))
+
+        folder = export_scene(
+            blendfile,
+            args.output_folder,
+            format=args.format,
+            image_res=args.resolution,
+            vertex_colors=args.vertex_colors,
+            individual_export=args.individual,
+            omniverse_export=args.omniverse,
+            deconvex=args.deconvex,
+            center_scene=args.center_scene,
+        )
+        # wanted to use shutil here but kept making corrupted files
+        subprocess.call(
+            ["zip", "-r", str(folder.with_suffix(".zip")), str(folder)]
+        )
+
+    bpy.ops.wm.quit_blender()
+
+
+def make_args():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--input_folder", type=Path)
+    parser.add_argument("--output_folder", type=Path)
+
+    parser.add_argument("-f", "--format", type=str, choices=FORMAT_CHOICES)
+
+    parser.add_argument("-v", "--vertex_colors", action="store_true")
+    parser.add_argument("-r", "--resolution", default=1024, type=int)
+    parser.add_argument("-i", "--individual", action="store_true")
+    parser.add_argument("-o", "--omniverse", action="store_true")
+    parser.add_argument("--deconvex", action="store_true")
+    parser.add_argument("--center_scene", action="store_true")
+
+    args = parser.parse_args()
+
+    if args.format not in FORMAT_CHOICES:
+        raise ValueError("Unsupported or invalid file format.")
+
+    if args.vertex_colors and args.format not in ["ply", "fbx", "obj"]:
+        raise ValueError("File format does not support vertex colors.")
+
+    if args.format == "ply" and not args.vertex_colors:
+        raise ValueError(".ply export must use vertex colors.")
+
+    return args
+
+
+if __name__ == "__main__":
+    args = make_args()
+    main(args)

embodied_gen/scripts/room_gen/gen_room.py

@@ -0,0 +1,253 @@
+# 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 random
+import shutil
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from enum import Enum
+
+import tyro
+from embodied_gen.utils.log import logger
+
+EXEC_PYTHON = os.environ.get(
+    "BLENDER_PYTHON",
+    "thirdparty/infinigen/blender/4.2/python/bin/python3.11",
+)
+
+
+class RoomType(str, Enum):
+    bedroom = "Bedroom"
+    livingRoom = "LivingRoom"
+    kitchen = "Kitchen"
+    bathroom = "Bathroom"
+    diningRoom = "DiningRoom"
+    office = "Office"
+    house = "House"
+
+
+class Complexity(str, Enum):
+    minimalist = "minimalist"
+    simple = "simple"
+    medium = "medium"
+    detail = "detail"
+
+
+@dataclass
+class GenRoomArgs:
+    """Configuration for single-seed Infinigen room generation and export."""
+
+    output_root: str
+    """The base output directory for generated rooms."""
+
+    room_type: RoomType = RoomType.kitchen
+    """The type of room to generate."""
+
+    seed: int = None
+    """The specific seed number to generate."""
+
+    # Task Switches (Default to True, use flags like --no-gen to disable)
+    gen: bool = True
+    """Whether to run the indoor generation task (generate_indoors)."""
+
+    urdf: bool = True
+    """Whether to export to URDF (requires generation output)."""
+
+    usd: bool = True
+    """Whether to export to USD (requires generation output)."""
+
+    custom_params: str = "embodied_gen/scripts/room_gen/custom_solve.gin"
+
+    large_scene: bool = False
+    """If True, has_fewer_rooms=False for large scene generation."""
+
+    complexity: Complexity = Complexity.simple
+    """Complexity level: minimalist, simple, medium, or detail."""
+
+
+def run_command(cmd: list[str], task_name: str):
+    """Helper: Use Popen to allow killing the child process on Ctrl+C.
+
+    Includes execution time logging.
+    """
+    logger.info(f"--> Running {task_name}...")
+    start_time = time.time()
+    process = subprocess.Popen(cmd, env=None)
+    try:
+        return_code = process.wait()
+        if return_code != 0:
+            raise subprocess.CalledProcessError(return_code, cmd)
+
+        elapsed_mins = (time.time() - start_time) / 60
+        logger.info(
+            f"--> {task_name} successfully in {elapsed_mins:.1f} mins."
+        )
+
+    except KeyboardInterrupt:
+        logger.warning(f"\n[Interrupted] Stopping {task_name}...")
+        process.kill()
+        process.wait()
+        sys.exit(0)
+
+    except subprocess.CalledProcessError as e:
+        logger.info(
+            f"Error occurred during {task_name}. Exit code: {e.returncode}"
+        )
+        sys.exit(1)
+
+
+def generate_room(cfg: GenRoomArgs):
+    room_type = cfg.room_type.value
+    seed = cfg.seed
+    if seed is None:
+        seed = random.randint(0, 100000)
+
+    blender_dir = f"{cfg.output_root}/{room_type}_seed{seed}/blender"
+    logger.info(
+        f"{room_type} | Seed {seed}: Gen={cfg.gen}, URDF={cfg.urdf}, USD={cfg.usd}"
+    )
+
+    # Complexity configuration mapping
+    complexity_config = {
+        Complexity.minimalist: {
+            "compose_indoors.solve_large_enabled": False,
+            "compose_indoors.solve_medium_enabled": False,
+            "compose_indoors.solve_small_enabled": False,
+        },
+        Complexity.simple: {
+            "compose_indoors.solve_large_enabled": True,
+            "compose_indoors.solve_medium_enabled": False,
+            "compose_indoors.solve_small_enabled": False,
+        },
+        Complexity.medium: {
+            "compose_indoors.solve_large_enabled": True,
+            "compose_indoors.solve_medium_enabled": True,
+            "compose_indoors.solve_small_enabled": False,
+        },
+        Complexity.detail: {
+            "compose_indoors.solve_large_enabled": True,
+            "compose_indoors.solve_medium_enabled": True,
+            "compose_indoors.solve_small_enabled": True,
+        },
+    }
+
+    # Get complexity settings
+    complexity_settings = complexity_config[cfg.complexity]
+    time_cost_info = {
+        Complexity.minimalist: "~1mins",
+        Complexity.simple: "~10mins",
+        Complexity.medium: "~20mins",
+        Complexity.detail: "~70mins",
+    }
+    logger.info(
+        f"Complexity: {cfg.complexity.value} (estimated time: {time_cost_info[cfg.complexity]})"
+    )
+
+    if cfg.gen:
+        dst_gin = "thirdparty/infinigen/infinigen_examples/configs_indoor/custom_solve.gin"
+        shutil.copy(cfg.custom_params, dst_gin)
+        cmd_generate = [
+            EXEC_PYTHON,
+            "embodied_gen/scripts/room_gen/run_generate_indoors.py",
+            "--seed",
+            str(seed),
+            "--task",
+            "coarse",
+            "--output_folder",
+            blender_dir,
+            "-g",
+            "custom_solve.gin",
+        ]
+        if room_type == "House":
+            has_fewer_rooms_value = "False" if cfg.large_scene else "True"
+            cmd_generate.append("-p")
+            cmd_generate.append(
+                f'home_room_constraints.has_fewer_rooms={has_fewer_rooms_value}'
+            )
+        else:
+            cmd_generate.append("-p")
+            cmd_generate.append(
+                f'restrict_solving.restrict_parent_rooms=["{room_type}"]'
+            )
+            cmd_generate.append("restrict_solving.solve_max_rooms=1")
+            if room_type == "Office":
+                cmd_generate.append("home_room_constraints.office_only=True")
+        cmd_generate.append(
+            f"compose_indoors.solve_large_enabled={complexity_settings['compose_indoors.solve_large_enabled']}"
+        )
+        cmd_generate.append(
+            f"compose_indoors.solve_medium_enabled={complexity_settings['compose_indoors.solve_medium_enabled']}"
+        )
+        cmd_generate.append(
+            f"compose_indoors.solve_small_enabled={complexity_settings['compose_indoors.solve_small_enabled']}"
+        )
+        run_command(cmd_generate, "Room Generation")
+
+    if cfg.urdf:
+        if not os.path.exists(blender_dir) and not cfg.gen:
+            logger.warning(f"Warning: {blender_dir} not found. Skipping URDF.")
+        else:
+            cmd_export_urdf = [
+                EXEC_PYTHON,
+                "embodied_gen/scripts/room_gen/export_scene.py",
+                "--input_folder",
+                blender_dir,
+                "--output_folder",
+                f"{cfg.output_root}/{room_type}_seed{seed}/urdf",
+                "-f",
+                "obj",
+                "-r",
+                "512",
+                "--individual",
+                "--deconvex",
+                "--center_scene",
+            ]
+            run_command(cmd_export_urdf, "Export URDF")
+
+    if cfg.usd:
+        if not os.path.exists(blender_dir) and not cfg.gen:
+            logger.warning(f"Warning: {blender_dir} not found. Skipping USD.")
+        else:
+            cmd_export_usd = [
+                EXEC_PYTHON,
+                "embodied_gen/scripts/room_gen/export_scene.py",
+                "--input_folder",
+                blender_dir,
+                "--output_folder",
+                f"{cfg.output_root}/{room_type}_seed{seed}/usd",
+                "-f",
+                "usdc",
+                "-r",
+                "512",
+                "--omniverse",
+                "--center_scene",
+            ]
+            run_command(cmd_export_usd, "Export USD")
+
+    logger.info(f"\n=== Completed {room_type} Seed {seed} ===")
+
+
+if __name__ == "__main__":
+    try:
+        cfg = tyro.cli(GenRoomArgs)
+        generate_room(cfg)
+    except KeyboardInterrupt:
+        logger.info("\nProgram interrupted by user (Cmd+C). Exiting.")
+        sys.exit(0)

embodied_gen/scripts/room_gen/route_room.py

@@ -0,0 +1,135 @@
+# 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 random
+
+import json_repair
+from embodied_gen.utils.gpt_clients import GPT_CLIENT, GPTclient
+from embodied_gen.utils.log import logger
+
+__all__ = [
+    "InfinigenGenRouter",
+    "DEFAULT_ROUTER_PROMPT",
+]
+
+DEFAULT_ROUTER_PROMPT = """
+You are given a natural-language description of a household task or an indoor
+scene involving objects.
+
+Select all rooms from the predefined list below where this task or scene could
+plausibly occur:
+["Bedroom", "LivingRoom", "Kitchen", "Bathroom", "DiningRoom", "Office"]
+
+Rules:
+1. Output must be a valid JSON nested array (2D list).
+   Format: [["Room_List"], "Complexity_Level"]
+
+2. Room Selection Logic (Index 0):
+   - Standard Case: If the task is contained within specific rooms, select
+     the relevant room name(s).
+   - Special Case: If the task involves moving objects between different rooms
+     (navigation/transport) or implies generating/referencing a complete house
+     layout, use ["House"].
+   - If no rooms are suitable and it is not a "House" case, randomly select
+     one room.
+
+3. Complexity Evaluation Logic (Index 1):
+   - General Rule: Default to "medium".
+   - Overrides (Apply these only if the description fits the specific
+     criteria below):
+     - "minimalist": If explicitly stated as minimalist.
+     - "simple": If the scene is explicitly described as "simple", "basic".
+     - "detail": If the scene is described as "complex", "detailed".
+
+4. Do not include any explanations or additional text.
+
+Example 1:
+Task: minimalist/empty Bedroom.
+Answer: [["Bedroom"], "minimalist"]
+
+Example 2:
+Task: Wiping the table in an simple room.
+Answer: [["DiningRoom", "Kitchen"], "simple"]
+
+Example 3:
+Task: Take the vase from the living room shelf and navigate to the bedroom
+to pack it.
+Answer: [["House"], "medium"]
+
+Example 4:
+Task: Put the apple into the fruit bowl in a complex/detailed env.
+Answer: [["Kitchen", "DiningRoom", "LivingRoom"], "detail"]
+
+Task: {prompt}
+Answer:
+"""
+
+
+class InfinigenGenRouter:
+    """Router that maps task descriptions to room(s) and complexity via GPT."""
+
+    def __init__(
+        self,
+        gpt_client: GPTclient,
+        prompt: str | None = None,
+    ) -> None:
+        """Initialize the router.
+
+        Args:
+            gpt_client: Client used to query the LLM.
+            prompt: Optional custom system/template prompt. Uses
+                DEFAULT_ROUTER_PROMPT if None.
+
+        """
+        self.gpt_client = gpt_client
+        self.prompt = prompt if prompt is not None else DEFAULT_ROUTER_PROMPT
+
+    def query(self, task_description: str) -> tuple[str, str]:
+        """Map a task description to a room and complexity level.
+
+        Args:
+            task_description: Natural-language description of the task or scene.
+
+        Returns:
+            Tuple of (room_name, complexity_level). room_name is one room
+            chosen at random from the list of rooms returned by the LLM.
+
+        """
+        filled_prompt = self.prompt.format(prompt=task_description)
+        response_text = self.gpt_client.query(text_prompt=filled_prompt)
+        parsed = json_repair.loads(response_text)
+
+        room_list = parsed[0]
+        complexity = parsed[1]
+        room_name = random.choice(room_list)
+
+        return room_name, complexity
+
+
+def main() -> None:
+    """Demo: run the router on a sample task."""
+    agent = InfinigenGenRouter(gpt_client=GPT_CLIENT)
+    room, complexity = agent.query(
+        "Put the apple into the fruit bowl, complex env"
+    )
+    logger.info(f"Room: {room}, Complexity: {complexity}.")
+
+
+if __name__ == "__main__":
+    main()

embodied_gen/scripts/room_gen/run_generate_indoors.py

@@ -0,0 +1,31 @@
+# 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.
+
+
+# Wrapper to run infinigen_examples.generate_indoors with correct gin registration.
+# Importing (rather than python -m) ensures the module loads with full module path,
+# avoiding the "Ambiguous selector 'compose_indoors'" error from __main__.
+from embodied_gen.utils.monkey_patch.infinigen import (
+    add_run_main_to_module,
+    monkey_patch_infinigen,
+)
+
+monkey_patch_infinigen()
+
+import infinigen_examples.generate_indoors as gi
+
+add_run_main_to_module(gi)
+gi._run_main()

embodied_gen/scripts/room_gen/visualize_floorplan.py

@@ -0,0 +1,1186 @@
+# 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 logging
+import os
+import random
+import re
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from shutil import copy2, copytree
+from typing import TYPE_CHECKING, Literal
+
+import matplotlib.pyplot as plt
+import numpy as np
+import trimesh
+import tyro
+from scipy.spatial.transform import Rotation as R
+from shapely.affinity import translate
+from shapely.geometry import MultiPoint, MultiPolygon, Point, Polygon
+from shapely.ops import unary_union
+
+if TYPE_CHECKING:
+    from matplotlib.axes import Axes
+
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    level=logging.INFO,
+)
+logger = logging.getLogger(__name__)
+
+# Type aliases
+Geometry = Polygon | MultiPolygon
+
+# Constants
+DEFAULT_MESH_SAMPLE_NUM = 50000
+DEFAULT_IGNORE_ITEMS = ("ceiling", "light", "exterior")
+DEFAULT_ROTATION_RPY = (1.57, 0.0, 0.0)
+DEFAULT_MAX_PLACEMENT_ATTEMPTS = 2000
+
+__all__ = [
+    "points_to_polygon",
+    "get_actionable_surface",
+    "FloorplanVisualizer",
+    "UrdfSemanticInfoCollector",
+    "Scene3DGenConfig",
+]
+
+
+@dataclass
+class Scene3DGenConfig:
+    """Configuration for 3D scene generation and floorplan visualization."""
+
+    urdf_path: str
+    """Path to the input URDF scene file."""
+
+    output_path: str
+    """Path to save the floorplan visualization image."""
+
+    # Optional paths
+    usd_path: str | None = None
+    """Optional path to the USD scene file for USD export."""
+
+    asset_path: str | None = None
+    """Optional path to the asset mesh to add to the scene."""
+
+    # Instance configuration
+    instance_key: str = "inserted_object"
+    """Unique key for the added instance."""
+
+    in_room: str | None = None
+    """Optional room name to constrain asset placement."""
+
+    on_instance: str | None = None
+    """Optional instance name to place the asset on top of."""
+
+    place_strategy: Literal["top", "random"] = "random"
+    """Placement strategy for the asset."""
+
+    rotation_rpy: tuple[float, float, float] = DEFAULT_ROTATION_RPY
+    """Rotation in roll-pitch-yaw (radians)."""
+
+    # Collector configuration
+    ignore_items: list[str] = field(
+        default_factory=lambda: list(DEFAULT_IGNORE_ITEMS)
+    )
+    """List of item name patterns to ignore during parsing."""
+
+    mesh_sample_num: int = DEFAULT_MESH_SAMPLE_NUM
+    """Number of points to sample from meshes."""
+
+    max_placement_attempts: int = DEFAULT_MAX_PLACEMENT_ATTEMPTS
+    """Maximum attempts for asset placement."""
+
+    # Output flags
+    update_urdf: bool = True
+    """Whether to update and save the URDF file."""
+
+    update_usd: bool = True
+    """Whether to update and save the USD file."""
+
+
+def points_to_polygon(
+    points: np.ndarray,
+    smooth_thresh: float = 0.2,
+    scanline_step: float = 0.01,
+) -> Polygon:
+    """Convert point clouds into polygon contours using sweep line algorithm.
+
+    Args:
+        points: Array of 2D points with shape (N, 2).
+        smooth_thresh: Buffer threshold for smoothing the polygon.
+        scanline_step: Step size for the scanline sweep.
+
+    Returns:
+        A Shapely Polygon representing the contour of the point cloud.
+
+    """
+    if len(points) == 0:
+        return Polygon()
+
+    ys = points[:, 1]
+    y_min, y_max = ys.min(), ys.max()
+    y_values = np.arange(y_min, y_max + scanline_step, scanline_step)
+
+    upper: list[list[float]] = []
+    lower: list[list[float]] = []
+
+    for y in y_values:
+        pts_in_strip = points[(ys >= y) & (ys < y + scanline_step)]
+        if len(pts_in_strip) == 0:
+            continue
+
+        xs = pts_in_strip[:, 0]
+        upper.append([xs.max(), y])
+        lower.append([xs.min(), y])
+
+    contour = upper + lower[::-1]
+    if len(contour) < 3:
+        return Polygon()
+
+    poly = Polygon(contour)
+    return poly.buffer(smooth_thresh).buffer(-smooth_thresh)
+
+
+def get_actionable_surface(
+    mesh: trimesh.Trimesh,
+    tol_angle: int = 10,
+    tol_z: float = 0.02,
+    area_tolerance: float = 0.15,
+    place_strategy: Literal["top", "random"] = "random",
+) -> tuple[float, Geometry]:
+    """Extract the actionable (placeable) surface from a mesh.
+
+    Finds upward-facing surfaces and returns the best one based on the
+    placement strategy.
+
+    Args:
+        mesh: The input trimesh object.
+        tol_angle: Angle tolerance in degrees for detecting up-facing normals.
+        tol_z: Z-coordinate tolerance for clustering faces.
+        area_tolerance: Tolerance for selecting candidate surfaces by area.
+        place_strategy: Either "top" (highest surface) or "random".
+
+    Returns:
+        A tuple of (z_height, surface_polygon) representing the selected
+        actionable surface.
+
+    """
+    up_vec = np.array([0, 0, 1])
+    dots = np.dot(mesh.face_normals, up_vec)
+    valid_mask = dots > np.cos(np.deg2rad(tol_angle))
+
+    if not np.any(valid_mask):
+        logger.warning(
+            "No up-facing surfaces found. Falling back to bounding box top."
+        )
+        verts = mesh.vertices[:, :2]
+        return mesh.bounds[1][2], MultiPoint(verts).convex_hull
+
+    valid_faces_indices = np.where(valid_mask)[0]
+    face_z = mesh.triangles_center[valid_mask][:, 2]
+    face_areas = mesh.area_faces[valid_mask]
+
+    z_clusters = _cluster_faces_by_z(
+        face_z, face_areas, valid_faces_indices, tol_z
+    )
+
+    if not z_clusters:
+        return mesh.bounds[1][2], MultiPoint(mesh.vertices[:, :2]).convex_hull
+
+    selected_z, selected_data = _select_surface_cluster(
+        z_clusters, area_tolerance, place_strategy
+    )
+
+    cluster_faces = mesh.faces[selected_data["indices"]]
+    temp_mesh = trimesh.Trimesh(vertices=mesh.vertices, faces=cluster_faces)
+    samples, _ = trimesh.sample.sample_surface(temp_mesh, 10000)
+
+    if len(samples) < 3:
+        logger.warning(
+            f"Failed to sample enough points on layer Z={selected_z}. "
+            "Returning empty polygon."
+        )
+        return selected_z, Polygon()
+
+    surface_poly = MultiPoint(samples[:, :2]).convex_hull
+    return selected_z, surface_poly
+
+
+def _cluster_faces_by_z(
+    face_z: np.ndarray,
+    face_areas: np.ndarray,
+    face_indices: np.ndarray,
+    tol_z: float,
+) -> dict[float, dict]:
+    """Cluster mesh faces by their Z coordinate.
+
+    Args:
+        face_z: Z coordinates of face centers.
+        face_areas: Areas of each face.
+        face_indices: Original indices of the faces.
+        tol_z: Tolerance for Z clustering.
+
+    Returns:
+        Dictionary mapping Z values to cluster data (area and indices).
+
+    """
+    z_clusters: dict[float, dict] = {}
+
+    for i, z in enumerate(face_z):
+        key = round(z / tol_z) * tol_z
+
+        if key not in z_clusters:
+            z_clusters[key] = {"area": 0.0, "indices": []}
+
+        z_clusters[key]["area"] += face_areas[i]
+        z_clusters[key]["indices"].append(face_indices[i])
+
+    return z_clusters
+
+
+def _select_surface_cluster(
+    z_clusters: dict[float, dict],
+    area_tolerance: float,
+    place_strategy: Literal["top", "random"],
+) -> tuple[float, dict]:
+    """Select the best surface cluster based on strategy.
+
+    Args:
+        z_clusters: Dictionary of Z clusters with area and indices.
+        area_tolerance: Tolerance for candidate selection by area.
+        place_strategy: Either "top" or "random".
+
+    Returns:
+        Tuple of (selected_z, cluster_data).
+
+    """
+    max_area = max(c["area"] for c in z_clusters.values())
+    candidates = [
+        (z, data)
+        for z, data in z_clusters.items()
+        if data["area"] >= max_area * (1.0 - area_tolerance)
+    ]
+
+    if not candidates:
+        best_item = max(z_clusters.items(), key=lambda x: x[1]["area"])
+        candidates = [best_item]
+
+    if place_strategy == "random":
+        selected_z, selected_data = random.choice(candidates)
+        logger.info(
+            f"Strategy 'random': Selected Z={selected_z:.3f} "
+            f"(Area={selected_data['area']:.3f}) "
+            f"from {len(candidates)} candidates."
+        )
+    else:
+        candidates.sort(key=lambda x: x[0], reverse=True)
+        selected_z, selected_data = candidates[0]
+        logger.info(
+            f"Strategy 'top': Selected highest Z={selected_z:.3f} "
+            f"(Area={selected_data['area']:.3f})"
+        )
+
+    return selected_z, selected_data
+
+
+class FloorplanVisualizer:
+    """Static utility class for visualizing floorplans."""
+
+    @staticmethod
+    def draw_poly(ax: Axes, poly: Geometry, **kwargs) -> None:
+        """Draw a polygon or multi-polygon on matplotlib axes.
+
+        Args:
+            ax: Matplotlib axes object.
+            poly: Shapely Polygon or MultiPolygon to draw.
+            **kwargs: Additional arguments passed to ax.fill().
+
+        """
+        if poly.is_empty:
+            return
+
+        geoms = poly.geoms if hasattr(poly, "geoms") else [poly]
+
+        color = kwargs.pop("color", None)
+        if color is None:
+            cmap = plt.get_cmap("tab10")
+            colors = [cmap(i) for i in range(len(geoms))]
+        else:
+            colors = [color] * len(geoms)
+
+        for i, p in enumerate(geoms):
+            if p.is_empty:
+                continue
+            x, y = p.exterior.xy
+            ax.fill(x, y, facecolor=colors[i], **kwargs)
+
+    @classmethod
+    def plot(
+        cls,
+        rooms: dict[str, Geometry],
+        footprints: dict[str, Geometry],
+        occ_area: Geometry,
+        save_path: str,
+    ) -> None:
+        """Generate and save a floorplan visualization.
+
+        Args:
+            rooms: Dictionary mapping room names to floor polygons.
+            footprints: Dictionary mapping object names to footprint polygons.
+            occ_area: Union of all occupied areas.
+            save_path: Path to save the output image.
+
+        """
+        fig, ax = plt.subplots(figsize=(10, 10))
+        ax.set_aspect("equal")
+        cmap_rooms = plt.get_cmap("Pastel1")
+
+        cls._draw_room_floors(ax, rooms, cmap_rooms)
+        cls._draw_occupied_area(ax, occ_area)
+        cls._draw_footprint_outlines(ax, footprints)
+        cls._draw_footprint_labels(ax, footprints)
+        cls._draw_room_labels(ax, rooms)
+        cls._configure_axes(ax, rooms, occ_area)
+
+        plt.tight_layout()
+        plt.savefig(save_path, dpi=300)
+        plt.close(fig)
+        logger.info(f"Saved floorplan to: {save_path}")
+
+    @classmethod
+    def _draw_room_floors(
+        cls,
+        ax: Axes,
+        rooms: dict[str, Geometry],
+        cmap: plt.cm.ScalarMappable,
+    ) -> None:
+        """Draw colored room floor polygons (Layer 1)."""
+        for i, (name, poly) in enumerate(rooms.items()):
+            color = cmap(i % cmap.N)
+            cls.draw_poly(
+                ax,
+                poly,
+                color=color,
+                alpha=0.6,
+                edgecolor="black",
+                linestyle="--",
+                zorder=1,
+            )
+
+    @classmethod
+    def _draw_occupied_area(cls, ax: Axes, occ_area: Geometry) -> None:
+        """Draw the occupied area overlay (Layer 2)."""
+        cls.draw_poly(
+            ax,
+            occ_area,
+            color="tab:blue",
+            alpha=0.3,
+            lw=0,
+            zorder=2,
+        )
+
+    @staticmethod
+    def _draw_footprint_outlines(
+        ax: Axes,
+        footprints: dict[str, Geometry],
+    ) -> None:
+        """Draw footprint outlines (Layer 3)."""
+        for poly in footprints.values():
+            if poly.is_empty:
+                continue
+            geoms = poly.geoms if hasattr(poly, "geoms") else [poly]
+            for p in geoms:
+                ax.plot(*p.exterior.xy, "--", lw=0.8, color="gray", zorder=3)
+
+    @staticmethod
+    def _draw_footprint_labels(
+        ax: Axes,
+        footprints: dict[str, Geometry],
+    ) -> None:
+        """Draw footprint text labels (Layer 4)."""
+        for name, poly in footprints.items():
+            if poly.is_empty:
+                continue
+            ax.text(
+                poly.centroid.x,
+                poly.centroid.y,
+                name,
+                fontsize=5,
+                ha="center",
+                va="center",
+                bbox={
+                    "facecolor": "white",
+                    "alpha": 0.5,
+                    "edgecolor": "none",
+                    "pad": 0.1,
+                },
+                zorder=4,
+            )
+
+    @staticmethod
+    def _draw_room_labels(ax: Axes, rooms: dict[str, Geometry]) -> None:
+        """Draw room text labels (Layer 5)."""
+        for name, poly in rooms.items():
+            if poly.is_empty:
+                continue
+            label = name.replace("_floor", "")
+            ax.text(
+                poly.centroid.x,
+                poly.centroid.y,
+                label,
+                fontsize=9,
+                color="black",
+                weight="bold",
+                ha="center",
+                va="center",
+                bbox={
+                    "facecolor": "lightgray",
+                    "alpha": 0.7,
+                    "edgecolor": "black",
+                    "boxstyle": "round,pad=0.3",
+                },
+                zorder=5,
+            )
+
+    @staticmethod
+    def _configure_axes(
+        ax: Axes,
+        rooms: dict[str, Geometry],
+        occ_area: Geometry,
+    ) -> None:
+        """Configure axes limits and labels."""
+        total_geom = unary_union(list(rooms.values()) + [occ_area])
+
+        if total_geom.is_empty:
+            minx, miny, maxx, maxy = -1, -1, 1, 1
+        else:
+            minx, miny, maxx, maxy = total_geom.bounds
+
+        margin_x = max((maxx - minx) * 0.05, 0.5)
+        margin_y = max((maxy - miny) * 0.05, 0.5)
+
+        ax.set_xlim(minx - margin_x, maxx + margin_x)
+        ax.set_ylim(miny - margin_y, maxy + margin_y)
+        ax.set_title("Floorplan Analysis", fontsize=14)
+        ax.set_xlabel("X (m)")
+        ax.set_ylabel("Y (m)")
+
+
+class UrdfSemanticInfoCollector:
+    """Collector for URDF semantic information.
+
+    Parses URDF files to extract room layouts, object footprints, and
+    provides methods for adding new instances and updating URDF/USD files.
+
+    Attributes:
+        mesh_sample_num: Number of points to sample from meshes.
+        ignore_items: List of item name patterns to ignore.
+        instances: Dictionary of instance name to footprint polygon.
+        instance_meta: Dictionary of instance metadata (mesh path, pose).
+        rooms: Dictionary of room polygons.
+        footprints: Dictionary of object footprints.
+        occ_area: Union of all occupied areas.
+        floor_union: Union of all floor polygons.
+
+    """
+
+    def __init__(
+        self,
+        mesh_sample_num: int = DEFAULT_MESH_SAMPLE_NUM,
+        ignore_items: list[str] | None = None,
+    ) -> None:
+        """Initialize the collector.
+
+        Args:
+            mesh_sample_num: Number of points to sample from meshes.
+            ignore_items: List of item name patterns to ignore during parsing.
+
+        """
+        self.mesh_sample_num = mesh_sample_num
+        self.ignore_items = ignore_items or list(DEFAULT_IGNORE_ITEMS)
+
+        self.instances: dict[str, Polygon] = {}
+        self.instance_meta: dict[str, dict] = {}
+        self.rooms: dict[str, Geometry] = {}
+        self.footprints: dict[str, Geometry] = {}
+        self.occ_area: Geometry = Polygon()
+        self.floor_union: Geometry = Polygon()
+
+        self.urdf_path: str = ""
+        self._tree: ET.ElementTree | None = None
+        self._root: ET.Element | None = None
+
+    def _get_transform(
+        self,
+        joint_elem: ET.Element,
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Extract transform (xyz, rpy) from a joint element.
+
+        Args:
+            joint_elem: XML Element representing a URDF joint.
+
+        Returns:
+            Tuple of (xyz, rpy) arrays.
+
+        """
+        origin = joint_elem.find("origin")
+        if origin is not None:
+            xyz = np.fromstring(origin.attrib.get("xyz", "0 0 0"), sep=" ")
+            rpy = np.fromstring(origin.attrib.get("rpy", "0 0 0"), sep=" ")
+        else:
+            xyz, rpy = np.zeros(3), np.zeros(3)
+        return xyz, rpy
+
+    def _process_mesh_to_poly(
+        self,
+        mesh_path: str,
+        xyz: np.ndarray,
+        rpy: np.ndarray,
+    ) -> Polygon:
+        """Load mesh file and convert to 2D footprint polygon.
+
+        Args:
+            mesh_path: Path to the mesh file.
+            xyz: Translation vector.
+            rpy: Rotation in roll-pitch-yaw.
+
+        Returns:
+            Footprint polygon of the mesh.
+
+        """
+        if not os.path.exists(mesh_path):
+            return Polygon()
+
+        mesh = trimesh.load(mesh_path, force="mesh", skip_materials=True)
+
+        matrix = np.eye(4)
+        matrix[:3, :3] = R.from_euler("xyz", rpy).as_matrix()
+        matrix[:3, 3] = xyz
+        mesh.apply_transform(matrix)
+
+        verts = np.asarray(mesh.sample(self.mesh_sample_num))[:, :2]
+        return points_to_polygon(verts)
+
+    def collect(self, urdf_path: str) -> None:
+        """Parse URDF file and collect semantic information.
+
+        Args:
+            urdf_path: Path to the URDF file.
+
+        """
+        logger.info(f"Collecting URDF semantic info from {urdf_path}")
+        self.urdf_path = urdf_path
+        urdf_dir = os.path.dirname(urdf_path)
+
+        self._tree = ET.parse(urdf_path)
+        self._root = self._tree.getroot()
+
+        link_transforms = self._build_link_transforms()
+        self._process_links(urdf_dir, link_transforms)
+        self._update_internal_state()
+
+    def _build_link_transforms(
+        self,
+    ) -> dict[str, tuple[np.ndarray, np.ndarray]]:
+        """Build mapping from link names to their transforms.
+
+        Returns:
+            Dictionary mapping link names to (xyz, rpy) tuples.
+
+        """
+        link_transforms: dict[str, tuple[np.ndarray, np.ndarray]] = {}
+
+        for joint in self._tree.findall("joint"):
+            child = joint.find("child")
+            if child is not None:
+                link_name = child.attrib["link"]
+                link_transforms[link_name] = self._get_transform(joint)
+
+        return link_transforms
+
+    def _process_links(
+        self,
+        urdf_dir: str,
+        link_transforms: dict[str, tuple[np.ndarray, np.ndarray]],
+    ) -> None:
+        """Process all links in the URDF tree.
+
+        Args:
+            urdf_dir: Directory containing the URDF file.
+            link_transforms: Dictionary of link transforms.
+
+        """
+        self.instances = {}
+        self.instance_meta = {}
+        wall_polys: list[Polygon] = []
+
+        for link in self._tree.findall("link"):
+            name = link.attrib.get("name", "").lower()
+            if any(ign in name for ign in self.ignore_items):
+                continue
+
+            visual = link.find("visual")
+            if visual is None:
+                continue
+
+            mesh_node = visual.find("geometry/mesh")
+            if mesh_node is None:
+                continue
+
+            mesh_path = os.path.join(urdf_dir, mesh_node.attrib["filename"])
+            default_transform = (np.zeros(3), np.zeros(3))
+            xyz, rpy = link_transforms.get(
+                link.attrib["name"], default_transform
+            )
+
+            poly = self._process_mesh_to_poly(mesh_path, xyz, rpy)
+            if poly.is_empty:
+                continue
+
+            if "wall" in name:
+                wall_polys.append(poly)
+            else:
+                key = self._process_safe_key_robust(link.attrib["name"])
+                self.instances[key] = poly
+                self.instance_meta[key] = {
+                    "mesh_path": mesh_path,
+                    "xyz": xyz,
+                    "rpy": rpy,
+                }
+
+        self.instances["walls"] = unary_union(wall_polys)
+
+    def _update_internal_state(self) -> None:
+        """Update derived state (rooms, footprints, occupied area)."""
+        self.rooms = {
+            k: v
+            for k, v in self.instances.items()
+            if "_floor" in k.lower() and not v.is_empty
+        }
+
+        self.footprints = {
+            k: v
+            for k, v in self.instances.items()
+            if k != "walls"
+            and "_floor" not in k.lower()
+            and "rug" not in k.lower()
+            and not v.is_empty
+        }
+        self.occ_area = unary_union(list(self.footprints.values()))
+        self.floor_union = unary_union(list(self.rooms.values()))
+
+    def _process_safe_key_robust(self, name: str) -> str:
+        """Convert a link name to a safe, normalized key.
+
+        Args:
+            name: Original link name.
+
+        Returns:
+            Normalized key string.
+
+        """
+        if name.endswith("_floor"):
+            parts = name.split("_")
+            return "_".join(parts[:-2] + ["floor"])
+
+        if "Factory" in name:
+            # Handle infinigen naming convention
+            prefix = name.split("Factory")[0]
+            suffix = f"_{name.split('_')[-1]}"
+        else:
+            prefix, suffix = name, ""
+
+        res = prefix.replace(" ", "_")
+        res = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", res)
+        res = res.lower()
+        res = re.sub(r"_+", "_", res).strip("_ ")
+
+        return f"{res}{suffix}"
+
+    def add_instance(
+        self,
+        asset_path: str,
+        instance_key: str,
+        in_room: str | None = None,
+        on_instance: str | None = None,
+        rotation_rpy: tuple[float, float, float] = DEFAULT_ROTATION_RPY,
+        n_max_attempt: int = DEFAULT_MAX_PLACEMENT_ATTEMPTS,
+        place_strategy: Literal["top", "random"] = "random",
+    ) -> list[float] | None:
+        """Add a new instance to the scene with automatic placement.
+
+        Args:
+            asset_path: Path to the asset mesh file.
+            instance_key: Unique key for the new instance.
+            in_room: Optional room name to constrain placement.
+            on_instance: Optional instance name to place on top of.
+            rotation_rpy: Initial rotation in roll-pitch-yaw.
+            n_max_attempt: Maximum placement attempts.
+            place_strategy: Either "top" or "random".
+
+        Returns:
+            List [x, y, z] of the placed instance center, or None if failed.
+
+        Raises:
+            ValueError: If instance_key already exists or room/instance not found.
+
+        """
+        if instance_key in self.instances:
+            raise ValueError(f"Instance key '{instance_key}' already exists.")
+
+        room_poly = self._resolve_room_polygon(in_room)
+        target_area, obstacles, base_z = self._resolve_placement_target(
+            on_instance, room_poly, place_strategy
+        )
+
+        if target_area.is_empty:
+            logger.error("Target area for placement is empty.")
+            return None
+
+        mesh = trimesh.load(asset_path, force="mesh")
+        mesh.apply_transform(
+            trimesh.transformations.euler_matrix(*rotation_rpy, "sxyz")
+        )
+
+        verts = np.asarray(mesh.sample(self.mesh_sample_num))[:, :2]
+        base_poly = points_to_polygon(verts)
+        centroid = base_poly.centroid
+        base_poly = translate(base_poly, xoff=-centroid.x, yoff=-centroid.y)
+
+        placement = self._try_place_polygon(
+            base_poly, target_area, obstacles, n_max_attempt
+        )
+
+        if placement is None:
+            logger.error(
+                f"Failed to place {asset_path} after {n_max_attempt} attempts."
+            )
+            return None
+
+        x, y, candidate = placement
+        self.instances[instance_key] = candidate
+        final_z = base_z + mesh.extents[2] / 2
+        self._update_internal_state()
+
+        return [round(v, 4) for v in (x, y, final_z)]
+
+    def _resolve_room_polygon(self, in_room: str | None) -> Geometry | None:
+        """Resolve room name to polygon.
+
+        Args:
+            in_room: Room name query string.
+
+        Returns:
+            Room polygon or None if not specified.
+
+        Raises:
+            ValueError: If room not found.
+
+        """
+        if in_room is None:
+            return None
+
+        query_room = in_room.lower()
+        room_matches = [
+            k for k in self.rooms.keys() if query_room in k.lower()
+        ]
+
+        if not room_matches:
+            raise ValueError(f"Room '{in_room}' not found.")
+
+        return unary_union([self.rooms[k] for k in room_matches])
+
+    def _resolve_placement_target(
+        self,
+        on_instance: str | None,
+        room_poly: Geometry | None,
+        place_strategy: Literal["top", "random"],
+    ) -> tuple[Geometry, Geometry, float]:
+        """Resolve the target placement area and obstacles.
+
+        Args:
+            on_instance: Instance name to place on.
+            room_poly: Room polygon constraint.
+            place_strategy: Placement strategy.
+
+        Returns:
+            Tuple of (target_area, obstacles, base_z_height).
+
+        Raises:
+            ValueError: If on_instance not found.
+
+        """
+        if on_instance is None:
+            if room_poly is not None:
+                return room_poly, self.occ_area, 0.0
+            return self.floor_union, self.occ_area, 0.0
+
+        query_obj = on_instance.lower()
+        possible_matches = [
+            k
+            for k in self.instances.keys()
+            if query_obj in k.lower() and k != "walls"
+        ]
+
+        if room_poly is not None:
+            possible_matches = [
+                k
+                for k in possible_matches
+                if self.instances[k].intersects(room_poly)
+            ]
+
+        if not possible_matches:
+            location_msg = f" in room '{on_instance}'" if room_poly else ""
+            raise ValueError(
+                f"No instance matching '{on_instance}' found{location_msg}."
+            )
+
+        if place_strategy == "random":
+            target_parent_key = random.choice(possible_matches)
+        else:
+            target_parent_key = possible_matches[0]
+
+        if len(possible_matches) > 1:
+            logger.warning(
+                f"Multiple matches for '{on_instance}': {possible_matches}. "
+                f"Using '{target_parent_key}'."
+            )
+
+        meta = self.instance_meta[target_parent_key]
+        parent_mesh = trimesh.load(meta["mesh_path"], force="mesh")
+        matrix = np.eye(4)
+        matrix[:3, :3] = R.from_euler("xyz", meta["rpy"]).as_matrix()
+        matrix[:3, 3] = meta["xyz"]
+        parent_mesh.apply_transform(matrix)
+
+        best_z, surface_poly = get_actionable_surface(
+            parent_mesh, place_strategy=place_strategy
+        )
+        obstacles = self.occ_area.difference(self.instances[target_parent_key])
+
+        logger.info(f"Placing on '{target_parent_key}' (Z={best_z:.3f})")
+
+        return surface_poly, obstacles, best_z
+
+    def _try_place_polygon(
+        self,
+        base_poly: Polygon,
+        target_area: Geometry,
+        obstacles: Geometry,
+        n_max_attempt: int,
+    ) -> tuple[float, float, Polygon] | None:
+        """Try to place polygon in target area avoiding obstacles.
+
+        Args:
+            base_poly: Polygon to place (centered at origin).
+            target_area: Area where placement is allowed.
+            obstacles: Areas to avoid.
+            n_max_attempt: Maximum attempts.
+
+        Returns:
+            Tuple of (x, y, placed_polygon) or None if failed.
+
+        """
+        minx, miny, maxx, maxy = target_area.bounds
+
+        for _ in range(n_max_attempt):
+            x = np.random.uniform(minx, maxx)
+            y = np.random.uniform(miny, maxy)
+            candidate = translate(base_poly, xoff=x, yoff=y)
+
+            if target_area.contains(candidate) and not candidate.intersects(
+                obstacles
+            ):
+                return x, y, candidate
+
+        return None
+
+    def update_urdf_info(
+        self,
+        output_path: str,
+        instance_key: str,
+        visual_mesh_path: str,
+        collision_mesh_path: str | None = None,
+        trans_xyz: tuple[float, float, float] = (0, 0, 0),
+        rot_rpy: tuple[float, float, float] = DEFAULT_ROTATION_RPY,
+        joint_type: str = "fixed",
+    ) -> None:
+        """Add a new link to the URDF tree and save.
+
+        Args:
+            output_path: Path to save the updated URDF.
+            instance_key: Name for the new link.
+            visual_mesh_path: Path to the visual mesh file.
+            collision_mesh_path: Optional path to collision mesh.
+            trans_xyz: Translation (x, y, z).
+            rot_rpy: Rotation (roll, pitch, yaw).
+            joint_type: Type of joint (e.g., "fixed").
+
+        """
+        if self._root is None:
+            return
+
+        logger.info(f"Updating URDF for instance '{instance_key}'.")
+        urdf_dir = os.path.dirname(self.urdf_path)
+
+        # Copy mesh files
+        copytree(
+            os.path.dirname(visual_mesh_path),
+            f"{urdf_dir}/{instance_key}",
+            dirs_exist_ok=True,
+        )
+        visual_rel_path = (
+            f"{instance_key}/{os.path.basename(visual_mesh_path)}"
+        )
+
+        collision_rel_path = None
+        if collision_mesh_path is not None:
+            copytree(
+                os.path.dirname(collision_mesh_path),
+                f"{urdf_dir}/{instance_key}",
+                dirs_exist_ok=True,
+            )
+            collision_rel_path = (
+                f"{instance_key}/{os.path.basename(collision_mesh_path)}"
+            )
+
+        # Create link element
+        link = ET.SubElement(self._root, "link", attrib={"name": instance_key})
+
+        visual = ET.SubElement(link, "visual")
+        v_geo = ET.SubElement(visual, "geometry")
+        ET.SubElement(v_geo, "mesh", attrib={"filename": visual_rel_path})
+
+        if collision_rel_path is not None:
+            collision = ET.SubElement(link, "collision")
+            c_geo = ET.SubElement(collision, "geometry")
+            ET.SubElement(
+                c_geo, "mesh", attrib={"filename": collision_rel_path}
+            )
+
+        # Create joint element
+        joint_name = f"joint_{instance_key}"
+        joint = ET.SubElement(
+            self._root,
+            "joint",
+            attrib={"name": joint_name, "type": joint_type},
+        )
+
+        ET.SubElement(joint, "parent", attrib={"link": "base"})
+        ET.SubElement(joint, "child", attrib={"link": instance_key})
+
+        xyz_str = f"{trans_xyz[0]:.4f} {trans_xyz[1]:.4f} {trans_xyz[2]:.4f}"
+        rpy_str = f"{rot_rpy[0]:.4f} {rot_rpy[1]:.4f} {rot_rpy[2]:.4f}"
+        ET.SubElement(joint, "origin", attrib={"xyz": xyz_str, "rpy": rpy_str})
+
+        self.save_urdf(output_path)
+
+    def update_usd_info(
+        self,
+        usd_path: str,
+        output_path: str,
+        instance_key: str,
+        visual_mesh_path: str,
+        trans_xyz: list[float],
+        rot_rpy: tuple[float, float, float] = DEFAULT_ROTATION_RPY,
+    ) -> None:
+        """Add a mesh instance to an existing USD file.
+
+        Args:
+            usd_path: Path to the source USD file.
+            output_path: Path to save the modified USD.
+            instance_key: Prim path name for the new instance.
+            visual_mesh_path: Path to the visual mesh (OBJ format).
+            trans_xyz: Translation [x, y, z].
+            rot_rpy: Rotation (roll, pitch, yaw).
+
+        """
+        import bpy
+        from pxr import Gf, Usd, UsdGeom
+
+        prim_path = f"/{instance_key}"
+        out_dir = os.path.dirname(output_path)
+        target_dir = os.path.join(out_dir, instance_key)
+        os.makedirs(target_dir, exist_ok=True)
+
+        mesh_filename = os.path.basename(visual_mesh_path)
+        usdc_filename = os.path.splitext(mesh_filename)[0] + ".usdc"
+        target_usdc_path = os.path.join(target_dir, usdc_filename)
+
+        logger.info(
+            f"Converting with Blender (bpy): "
+            f"{visual_mesh_path} -> {target_usdc_path}"
+        )
+        bpy.ops.wm.read_factory_settings(use_empty=True)
+        bpy.ops.wm.obj_import(
+            filepath=visual_mesh_path,
+            forward_axis="Y",
+            up_axis="Z",
+        )
+        bpy.ops.wm.usd_export(
+            filepath=target_usdc_path,
+            selected_objects_only=False,
+        )
+
+        # Copy texture files
+        src_dir = os.path.dirname(visual_mesh_path)
+        for f in os.listdir(src_dir):
+            if f.lower().endswith((".png", ".jpg", ".jpeg", ".mtl")):
+                copy2(os.path.join(src_dir, f), target_dir)
+
+        final_rel_path = f"./{instance_key}/{usdc_filename}"
+
+        # Update USD stage
+        stage = Usd.Stage.Open(usd_path)
+        mesh_prim = UsdGeom.Xform.Define(stage, prim_path)
+
+        ref_prim = UsdGeom.Mesh.Define(stage, f"{prim_path}/Mesh")
+        ref_prim.GetPrim().GetReferences().AddReference(final_rel_path)
+
+        # Build transform matrix
+        translation_mat = Gf.Matrix4d().SetTranslate(
+            Gf.Vec3d(trans_xyz[0], trans_xyz[1], trans_xyz[2])
+        )
+        rx = Gf.Matrix4d().SetRotate(
+            Gf.Rotation(Gf.Vec3d(1, 0, 0), np.degrees(rot_rpy[0]))
+        )
+        ry = Gf.Matrix4d().SetRotate(
+            Gf.Rotation(Gf.Vec3d(0, 1, 0), np.degrees(rot_rpy[1]))
+        )
+        rz = Gf.Matrix4d().SetRotate(
+            Gf.Rotation(Gf.Vec3d(0, 0, 1), np.degrees(rot_rpy[2]))
+        )
+        rotation_mat = rx * ry * rz
+        transform = rotation_mat * translation_mat
+        mesh_prim.AddTransformOp().Set(transform)
+
+        stage.GetRootLayer().Export(output_path)
+        logger.info(f"Exported: {output_path}")
+
+    def save_urdf(self, output_path: str) -> None:
+        """Save the current URDF tree to file.
+
+        Args:
+            output_path: Path to save the URDF file.
+
+        """
+        if self._tree is None:
+            return
+
+        if hasattr(ET, "indent"):
+            ET.indent(self._tree, space="  ", level=0)
+
+        self._tree.write(output_path, encoding="utf-8", xml_declaration=True)
+        logger.info(f"Saved updated URDF to {output_path}")
+
+
+def entrypoint(cfg: Scene3DGenConfig) -> None:
+    """Main entry point for floorplan visualization and scene manipulation.
+
+    Args:
+        cfg: Configuration object with all parameters.
+
+    """
+    # Initialize collector and parse URDF
+    collector = UrdfSemanticInfoCollector(
+        mesh_sample_num=cfg.mesh_sample_num,
+        ignore_items=cfg.ignore_items,
+    )
+    collector.collect(cfg.urdf_path)
+
+    # Add asset instance if specified
+    center = None
+    if cfg.asset_path is not None:
+        center = collector.add_instance(
+            asset_path=cfg.asset_path,
+            instance_key=cfg.instance_key,
+            in_room=cfg.in_room,
+            on_instance=cfg.on_instance,
+            rotation_rpy=cfg.rotation_rpy,
+            n_max_attempt=cfg.max_placement_attempts,
+            place_strategy=cfg.place_strategy,
+        )
+
+        if center is not None:
+            logger.info(
+                f"Placed '{cfg.instance_key}' at position: "
+                f"({center[0]:.3f}, {center[1]:.3f}, {center[2]:.3f})"
+            )
+
+            # Update URDF if requested
+            if cfg.update_urdf:
+                urdf_output = cfg.urdf_path.replace(".urdf", "_updated.urdf")
+                collision_path = cfg.asset_path.replace(
+                    ".obj", "_collision.obj"
+                )
+
+                # Use collision mesh only if it exists
+                if not os.path.exists(collision_path):
+                    collision_path = None
+
+                collector.update_urdf_info(
+                    output_path=urdf_output,
+                    instance_key=cfg.instance_key,
+                    visual_mesh_path=cfg.asset_path,
+                    collision_mesh_path=collision_path,
+                    trans_xyz=tuple(center),
+                    rot_rpy=cfg.rotation_rpy,
+                    joint_type="fixed",
+                )
+
+            # Update USD if requested and path is provided
+            if cfg.update_usd and cfg.usd_path is not None:
+                usd_output = cfg.usd_path.replace(".usdc", "_updated.usdc")
+                collector.update_usd_info(
+                    usd_path=cfg.usd_path,
+                    output_path=usd_output,
+                    instance_key=cfg.instance_key,
+                    visual_mesh_path=cfg.asset_path,
+                    trans_xyz=center,
+                    rot_rpy=cfg.rotation_rpy,
+                )
+        else:
+            logger.warning(
+                f"Failed to place '{cfg.instance_key}' in the scene."
+            )
+
+    # Generate floorplan visualization
+    FloorplanVisualizer.plot(
+        collector.rooms,
+        collector.footprints,
+        collector.occ_area,
+        cfg.output_path,
+    )
+
+
+if __name__ == "__main__":
+    config = tyro.cli(Scene3DGenConfig)
+    entrypoint(config)
+
+    """
+    python embodied_gen/scripts/room_gen/visualize_floorplan.py \
+    --urdf_path outputs/rooms/Office_seed68661/urdf/export_scene/scene.urdf \
+    --output_path outputs/rooms/Office_seed68661/floorplan.png \
+    --usd_path outputs/rooms_v2/Kitchen_seed0/usd/export_scene/export_scene.usdc \
+    --asset_path /home/users/xinjie.wang/xinjie/asset3d-gen/outputs/semantics_tasks/task_0059/asset3d/red_apple/result/mesh/red_apple.obj \
+    --instance_key red_apple \
+    --in_room kitchen \
+    --on_instance oven \
+    --place_strategy top
+    """

embodied_gen/trainer/pono2mesh_trainer.py

@@ -15,7 +15,7 @@
 # permissions and limitations under the License.
 
 
-from embodied_gen.utils.monkey_patches import monkey_patch_pano2room
+from embodied_gen.utils.monkey_patch.pano2room import monkey_patch_pano2room
 
 monkey_patch_pano2room()
 

embodied_gen/utils/gpt_clients.py

@@ -42,7 +42,8 @@ __all__ = [
     "GPTclient",
 ]
 
-CONFIG_FILE = "embodied_gen/utils/gpt_config.yaml"
+_CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+CONFIG_FILE = os.path.join(_CURRENT_DIR, "gpt_config.yaml")
 
 
 class GPTclient:

embodied_gen/utils/inference.py

@@ -1,4 +1,21 @@
-from embodied_gen.utils.monkey_patches import monkey_path_trellis
+# 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 embodied_gen.utils.monkey_patch.trellis import monkey_path_trellis
 
 monkey_path_trellis()
 import random
@@ -21,6 +38,7 @@ def image3d_model_infer(
     seed: int = None,
     **kwargs: dict,
 ) -> dict[str, any]:
+    """Execute 3D generation using Trellis or SAM3D pipeline on input image."""
     if isinstance(pipe, TrellisImageTo3DPipeline):
         pipe.cuda()
         seg_image = trellis_preprocess(seg_image)

embodied_gen/utils/monkey_patch/infinigen.py

@@ -0,0 +1,781 @@
+# 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 numpy as np
+
+
+def _infinigen_path():
+    current_file = os.path.abspath(__file__)
+    current_dir = os.path.dirname(current_file)
+    return os.path.abspath(
+        os.path.join(current_dir, "../../..", "thirdparty", "infinigen")
+    )
+
+
+def _ensure_infinigen_on_path():
+    path = _infinigen_path()
+    if path not in sys.path:
+        sys.path.insert(0, path)
+
+
+def patch_material_assignments():
+    """Replace ceramic.tile with ceramic.Tile in utility_floor assignments."""
+    _ensure_infinigen_on_path()
+    from infinigen.assets.composition import material_assignments
+    from infinigen.assets.materials import ceramic
+
+    # utility_floor: ceramic.tile -> ceramic.Tile
+    material_assignments.utility_floor = [
+        (ceramic.Concrete, 1.0),
+        (ceramic.Plaster, 1.0),
+        (ceramic.Tile, 1.0),
+    ]
+
+
+def patch_concrete():
+    """Filter Concrete.generate kwargs to supported keys."""
+    _ensure_infinigen_on_path()
+    from infinigen.assets.materials.ceramic import concrete
+    from infinigen.core import surface
+
+    shader_concrete = concrete.shader_concrete
+
+    def patched_generate(self, **kwargs):
+        # Filter out unsupported keywords and pass remaining arguments
+        # Concrete.shader_concrete accepts: scale, base_color_hsv, seed, roughness, crack_amount, crack_scale, snake_crack
+        supported_kwargs = {
+            'scale',
+            'base_color_hsv',
+            'seed',
+            'roughness',
+            'crack_amount',
+            'crack_scale',
+            'snake_crack',
+        }
+        filtered_kwargs = {
+            k: v for k, v in kwargs.items() if k in supported_kwargs
+        }
+        return surface.shaderfunc_to_material(
+            shader_concrete, **filtered_kwargs
+        )
+
+    concrete.Concrete.generate = patched_generate
+    concrete.Concrete.__call__ = patched_generate
+
+
+def patch_room_constants():
+    """Add Office to RoomConstants.home_room_types."""
+    _ensure_infinigen_on_path()
+    from infinigen.core import tags as t
+    from infinigen.core.constraints.constraint_language.constants import (
+        RoomConstants,
+    )
+
+    _original_home_room_types = RoomConstants.home_room_types.fget
+
+    @property
+    def patched_home_room_types(self):
+        return _original_home_room_types(self) | {t.Semantics.Office}
+
+    RoomConstants.home_room_types = patched_home_room_types
+
+
+def patch_doors_base_simple():
+    """Override BaseDoorFactory init to customize door dimensions and handles."""
+    _ensure_infinigen_on_path()
+    from infinigen.assets import colors
+    from infinigen.assets.composition import material_assignments
+    from infinigen.assets.objects.elements.doors.base import BaseDoorFactory
+    from infinigen.core.constraints.constraint_language.constants import (
+        RoomConstants,
+    )
+    from infinigen.core.placement.factory import AssetFactory
+    from infinigen.core.util.math import FixedSeed
+    from infinigen.core.util.random import weighted_sample
+    from numpy.random import uniform
+
+    _orig_init = BaseDoorFactory.__init__
+
+    def patched_init(self, factory_seed, coarse=False, constants=None):
+        _orig_init(self, factory_seed, coarse=coarse, constants=constants)
+        with FixedSeed(self.factory_seed):
+            if constants is None:
+                constants = RoomConstants()
+            self.width = constants.door_width - 0.02
+            self.door_frame_style = np.random.choice(
+                ["single_column", "full_frame_square", "full_frame_dome"]
+            )
+            self.door_frame_width = 0.02
+            handle_types = ["knob", "lever", "pull", "none"]
+            if self.door_frame_style != "full_frame_dome":
+                handle_types.append("bar")
+            if self.door_frame_style != "single_column":
+                self.width += -0.02
+                self.height += -0.04
+            self.handle_type = np.random.choice(handle_types)
+            if self.handle_type == "bar":
+                self.surface = weighted_sample(material_assignments.metals)()
+            if self.handle_type == "bar":
+                self.handle_info_dict = {
+                    "handle_type": self.handle_type,
+                    "bar_length": uniform(0.7, 0.9) * self.width,
+                    "bar_thickness": uniform(0.025, 0.045) * self.height,
+                    "bar_aspect_ratio": uniform(0.4, 0.6),
+                    "bar_height_ratio": uniform(0.7, 0.9),
+                    "bar_length_ratio": uniform(0.5, 0.8),
+                    "bar_end_length_ratio": uniform(0.1, 0.15),
+                    "bar_end_height_ratio": uniform(1.8, 3.0),
+                    "bar_overall_z_offset": -uniform(0.0, 0.1) * self.height,
+                    "shader": weighted_sample(material_assignments.metals)(),
+                    "color": colors.hsv2rgba(colors.metal_natural_hsv()),
+                }
+            else:
+                self.handle_info_dict = {"handle_type": self.handle_type}
+            if self.handle_type in ["knob", "lever"]:
+                self.handle_joint = "hinge"
+            elif self.handle_type == "bar":
+                self.handle_joint = "slide"
+            elif self.handle_type == "pull":
+                self.handle_joint = "rigid"
+            else:
+                self.handle_joint = "none"
+
+    BaseDoorFactory.__init__ = patched_init
+
+
+def patch_kitchen_cabinet():
+    """Add kitchen_space_bottom support to kitchen cabinet factories."""
+    _ensure_infinigen_on_path()
+    from infinigen.assets.objects.shelves.kitchen_cabinet import (
+        KitchenCabinetBaseFactory,
+        KitchenCabinetFactory,
+    )
+    from numpy.random import uniform
+
+    _orig_base_init = KitchenCabinetBaseFactory.__init__
+
+    def patched_base_init(
+        self,
+        factory_seed,
+        params=None,
+        coarse=False,
+        kitchen_space_bottom=False,
+    ):
+        if params is None:
+            params = {}
+        _orig_base_init(self, factory_seed, params=params, coarse=coarse)
+        self.bottom_mid = kitchen_space_bottom
+
+    KitchenCabinetBaseFactory.__init__ = patched_base_init
+
+    def patched_factory_init(
+        self,
+        factory_seed,
+        params=None,
+        coarse=False,
+        dimensions=None,
+        drawer_only=False,
+        kitchen_space_bottom=False,
+    ):
+        if params is None:
+            params = {}
+        self.dimensions = dimensions
+        KitchenCabinetBaseFactory.__init__(
+            self,
+            factory_seed,
+            params=params,
+            coarse=coarse,
+            kitchen_space_bottom=kitchen_space_bottom,
+        )
+        self.drawer_only = drawer_only
+
+    KitchenCabinetFactory.__init__ = patched_factory_init
+
+    _orig_sample_params = KitchenCabinetFactory.sample_params
+
+    def patched_sample_params(self):
+        params = dict()
+        if self.dimensions is None:
+            dimensions = (
+                uniform(0.25, 0.35),
+                uniform(0.5, 1.0),
+                uniform(0.5, 1.3),
+            )
+            self.dimensions = dimensions
+        else:
+            dimensions = self.dimensions
+        params["Dimensions"] = dimensions
+        # Copy frame_params logic from original
+        params["shelf_depth"] = params["Dimensions"][0] - 0.01
+        num_h = int((params["Dimensions"][2] - 0.06) / 0.3)
+        params["shelf_cell_height"] = [
+            (params["Dimensions"][2] - 0.06) / num_h for _ in range(num_h)
+        ]
+        params["side_board_thickness"] = 0.02
+        params["division_board_thickness"] = 0.02
+        params["bottom_board_height"] = 0.06
+        self.frame_params = params
+        n_cells = max(int(params["Dimensions"][1] / 0.45), 1)
+        intervals = np.random.uniform(0.55, 1.0, size=(n_cells,))
+        intervals = intervals / intervals.sum() * params["Dimensions"][1]
+        self.cabinet_widths = intervals.tolist()
+        if getattr(self, "bottom_mid", False):
+            self.cabinet_widths = [params["Dimensions"][1]]
+
+    KitchenCabinetFactory.sample_params = patched_sample_params
+
+
+def patch_kitchen_space():
+    """Customize kitchen space/island creation with sink and layout tweaks."""
+    _ensure_infinigen_on_path()
+    from infinigen.assets.objects.shelves.kitchen_cabinet import (
+        KitchenCabinetFactory,
+    )
+
+    # Need to import geometry_nodes_add_cabinet_top and nodegroup_tag_cube from same module
+    from infinigen.assets.objects.shelves.kitchen_space import (
+        KitchenIslandFactory,
+        KitchenSpaceFactory,
+        geometry_nodes_add_cabinet_top,
+        nodegroup_tag_cube,
+    )
+    from infinigen.assets.objects.table_decorations import SinkFactory
+    from infinigen.assets.objects.wall_decorations.range_hood import (
+        RangeHoodFactory,
+    )
+    from infinigen.assets.utils.object import new_bbox
+    from infinigen.core import surface, tagging
+    from infinigen.core.util import blender as butil
+    from infinigen.core.util.math import FixedSeed
+    from mathutils import Vector
+    from numpy.random import choice, uniform
+
+    _orig_ks_init = KitchenSpaceFactory.__init__
+
+    def patched_ks_init(
+        self,
+        factory_seed,
+        coarse=False,
+        dimensions=None,
+        island=False,
+        has_sink=False,
+    ):
+        KitchenSpaceFactory.__bases__[0].__init__(
+            self, factory_seed, coarse=coarse
+        )
+        with FixedSeed(factory_seed):
+            if dimensions is None:
+                dimensions = Vector(
+                    (uniform(0.7, 1), uniform(1.7, 5), uniform(2.3, 2.5))
+                )
+            self.island = island
+            if self.island:
+                dimensions.x *= uniform(1.5, 2)
+                dimensions.y = uniform(1, 2)
+            self.dimensions = dimensions
+            self.params = self.sample_parameters(dimensions)
+            self.has_sink = has_sink
+
+    KitchenSpaceFactory.__init__ = patched_ks_init
+
+    _orig_create_asset = KitchenSpaceFactory.create_asset
+
+    def patched_create_asset(self, **params):
+        x, y, z = self.dimensions
+        parts = []
+        cabinet_bottom_height = self.cabinet_bottom_height
+        cabinet_top_height = self.cabinet_top_height
+        mid_width = uniform(1.0, 1.3)
+        other_width = (y - mid_width) / 2.0
+        offset_bm = 0.04
+        offset_tm = 0.08
+        offset = 0.04
+        if other_width >= 0.98:
+            offset = 0.08
+        elif 0.98 > other_width >= 0.9:
+            other_width += -0.04
+            mid_width += 0.08
+        if other_width >= 1.47:
+            offset = 0.12
+        elif 1.47 > other_width >= 1.35:
+            other_width += -0.04
+            mid_width += 0.08
+        if other_width >= 1.96:
+            offset = 0.16
+        elif 1.96 > other_width >= 1.8:
+            other_width += -0.04
+            mid_width += 0.08
+
+        if self.island and other_width <= 0.3:
+            num_cells = False
+            offset = 0.08
+            if getattr(self, "has_sink", False) or y < 1.35:
+                num_cells = True
+                offset = 0.04
+            island_factory = KitchenCabinetFactory(
+                self.factory_seed,
+                dimensions=(x, y - offset, cabinet_bottom_height),
+                drawer_only=True,
+                kitchen_space_bottom=num_cells,
+            )
+            cabinet_bottom = island_factory(i=0)
+        else:
+            cabinet_bottom_factory = KitchenCabinetFactory(
+                self.factory_seed,
+                dimensions=(x, other_width - offset, cabinet_bottom_height),
+                drawer_only=True,
+            )
+            cabinet_bottom_left = cabinet_bottom_factory(i=0)
+            cabinet_bottom_right = cabinet_bottom_factory(i=1)
+            cabinet_bottom_left.location = (0.0, 0.0, 0.0)
+            cabinet_bottom_right.location = (0.0, y - other_width, 0.0)
+            cabinet_bottom_mid_factory = KitchenCabinetFactory(
+                self.factory_seed,
+                dimensions=(x, mid_width - offset_bm, cabinet_bottom_height),
+                drawer_only=True,
+                kitchen_space_bottom=True,
+            )
+            bottom_mid = cabinet_bottom_mid_factory(i=0)
+            bottom_mid.location = (0.0, y - other_width - mid_width, 0.0)
+            cabinet_bottom = butil.join_objects(
+                [cabinet_bottom_left, cabinet_bottom_right, bottom_mid]
+            )
+        parts.append(cabinet_bottom)
+        surface.add_geomod(
+            cabinet_bottom, geometry_nodes_add_cabinet_top, apply=True
+        )
+
+        if getattr(self, "has_sink", False):
+            sink_factory = SinkFactory(
+                factory_seed=self.factory_seed,
+                dimensions=[
+                    mid_width * 0.7,
+                    min(x * 0.7, 0.4),
+                    cabinet_bottom_height * 0.3,
+                ],
+            )
+            sink = sink_factory(i=0)
+            sink.location = (
+                (x / 2.0) - 0.3,
+                y / 2.0,
+                cabinet_bottom_height * 0.7 + 0.12,
+            )
+            sink.parent = cabinet_bottom
+
+        if not self.island:
+            cabinet_top_factory = KitchenCabinetFactory(
+                self.factory_seed,
+                dimensions=(x / 2.0, other_width - offset, cabinet_top_height),
+                drawer_only=False,
+            )
+            cabinet_top_left = cabinet_top_factory(i=0)
+            cabinet_top_right = cabinet_top_factory(i=1)
+            cabinet_top_left.location = (-x / 4.0, 0.0, z - cabinet_top_height)
+            cabinet_top_right.location = (
+                -x / 4.0,
+                y - other_width,
+                z - cabinet_top_height,
+            )
+            mid_style = choice(["cabinet"])
+            if mid_style == "range_hood":
+                range_hood_factory = RangeHoodFactory(
+                    self.factory_seed,
+                    dimensions=(
+                        x * 0.66,
+                        mid_width + 0.15,
+                        cabinet_top_height,
+                    ),
+                )
+                top_mid = range_hood_factory(i=0)
+                top_mid.location = (
+                    -x * 0.5,
+                    y / 2.0,
+                    z - cabinet_top_height + 0.05,
+                )
+            elif mid_style == "cabinet":
+                cabinet_top_mid_factory = KitchenCabinetFactory(
+                    self.factory_seed,
+                    dimensions=(
+                        x / 2.0,
+                        mid_width - offset_tm,
+                        cabinet_top_height,
+                    ),
+                    drawer_only=False,
+                )
+                top_mid = cabinet_top_mid_factory(i=0)
+                top_mid.location = (
+                    -x / 4.0,
+                    (y / 2.0) - (mid_width / 2.0),
+                    z - cabinet_top_height,
+                )
+            else:
+                raise NotImplementedError
+            parts += [cabinet_top_left, cabinet_top_right, top_mid]
+
+        kitchen_space = butil.join_objects(parts)
+        if not self.island:
+            kitchen_space.dimensions = self.dimensions
+        butil.apply_transform(kitchen_space)
+        tagging.tag_system.relabel_obj(kitchen_space)
+        return kitchen_space
+
+    KitchenSpaceFactory.create_asset = patched_create_asset
+
+    def patched_island_init(self, factory_seed):
+        KitchenSpaceFactory.__init__(
+            self, factory_seed=factory_seed, island=True, has_sink=False
+        )
+
+    KitchenIslandFactory.__init__ = patched_island_init
+
+
+def patch_sink():
+    """Simplify SinkFactory.sample_parameters with fixed sampling ranges."""
+    _ensure_infinigen_on_path()
+    from infinigen.assets.objects.table_decorations.sink import SinkFactory
+    from numpy.random import uniform as U
+
+    def patched_sample_parameters(
+        dimensions, upper_height, use_default=False, open=False
+    ):
+        if not dimensions:
+            width = U(0.4, 1.0)
+            depth = U(0.4, 0.5)
+            upper_height = U(0.2, 0.4)
+        else:
+            width, depth, upper_height = dimensions
+        curvature = U(1.0, 1.0)
+        lower_height = U(0.00, 0.01)
+        hole_radius = U(0.02, 0.05)
+        margin = U(0.02, 0.05)
+        watertap_margin = U(0.1, 0.12)
+        params = {
+            "Width": width,
+            "Depth": depth,
+            "Curvature": curvature,
+            "Upper Height": upper_height,
+            "Lower Height": lower_height,
+            "HoleRadius": hole_radius,
+            "Margin": margin,
+            "WaterTapMargin": watertap_margin,
+            "ProtrudeAboveCounter": U(0.01, 0.025),
+        }
+        return params
+
+    SinkFactory.sample_parameters = staticmethod(patched_sample_parameters)
+
+
+def patch_generate_indoors():
+    """Force populate_doors to use all_open=True by default."""
+    _ensure_infinigen_on_path()
+    from infinigen.core.constraints.example_solver.room import (
+        decorate as room_dec,
+    )
+
+    _orig_populate_doors = room_dec.populate_doors
+
+    def patched_populate_doors(
+        placeholders,
+        constants,
+        n_doors=3,
+        door_chance=1,
+        casing_chance=0.0,
+        all_open=False,
+        **kwargs,
+    ):
+        return _orig_populate_doors(
+            placeholders,
+            constants,
+            n_doors=n_doors,
+            door_chance=door_chance,
+            casing_chance=casing_chance,
+            all_open=True,
+            **kwargs,
+        )
+
+    room_dec.populate_doors = patched_populate_doors
+
+
+def patch_room_types():
+    """Include Office in util.room_types."""
+    _ensure_infinigen_on_path()
+    from infinigen.core import tags as t
+    from infinigen_examples.constraints import util as cu
+
+    cu.room_types.add(t.Semantics.Office)
+
+
+def patch_home_constraints():
+    """Add office-only room constraints and desk/chair furniture rules."""
+    _ensure_infinigen_on_path()
+    from collections import OrderedDict
+
+    import gin
+    from infinigen.assets.objects import seating, shelves
+    from infinigen.core.constraints import constraint_language as cl
+    from infinigen.core.constraints.constraint_language.constants import (
+        RoomConstants,
+    )
+    from infinigen.core.tags import Semantics
+    from infinigen_examples.constraints import home as home_module
+    from infinigen_examples.constraints import util as cu
+
+    gin.enter_interactive_mode()
+    _orig_home_room_constraints = home_module.home_room_constraints
+
+    def _office_room_constraints():
+        constraints = OrderedDict()
+        score_terms = OrderedDict()
+        constants = RoomConstants(
+            fixed_contour=False, room_type={Semantics.Office}
+        )
+        rooms = cl.scene()[Semantics.RoomContour]
+        constraints["node_gen"] = rooms[Semantics.Root].all(
+            lambda r: rooms[Semantics.Office]
+            .related_to(r, cl.Traverse())
+            .count()
+            .in_range(1, 1, mean=1)
+        )
+        constraints["node"] = (
+            rooms[Semantics.Office].count().in_range(1, 1, mean=1)
+            * (rooms[Semantics.Entrance].count() >= 0)
+            * (rooms[Semantics.StaircaseRoom].count() == 0)
+        )
+        all_rooms = cl.scene()[Semantics.RoomContour]
+        rooms_filtered = all_rooms[-Semantics.Exterior][-Semantics.Staircase]
+        score_terms["room"] = (
+            rooms_filtered[Semantics.Office]
+            .sum(lambda r: (r.area() / 25).log().hinge(0, 0.4).pow(2))
+            .minimize(weight=500.0)
+        )
+        return cl.Problem(
+            constraints=constraints,
+            score_terms=score_terms,
+            constants=constants,
+        )
+
+    @gin.configurable(
+        "home_room_constraints", module="infinigen_examples.constraints.home"
+    )
+    def patched_home_room_constraints(
+        has_fewer_rooms=False, office_only=False
+    ):
+        if office_only:
+            return _office_room_constraints()
+        return _orig_home_room_constraints(has_fewer_rooms=has_fewer_rooms)
+
+    home_module.home_room_constraints = patched_home_room_constraints
+
+    # --- home_furniture_constraints: Office room (1-2 desks, 1-2 chairs each) ---
+    _orig_home_furniture_constraints = home_module.home_furniture_constraints
+
+    def patched_home_furniture_constraints():
+        problem = _orig_home_furniture_constraints()
+        constraints = OrderedDict(problem.constraints)
+        score_terms = OrderedDict(problem.score_terms)
+        rooms = cl.scene()[{Semantics.Room, -Semantics.Object}]
+        obj = cl.scene()[{Semantics.Object, -Semantics.Room}]
+        furniture = obj[Semantics.Furniture].related_to(rooms, cu.on_floor)
+        wallfurn = furniture.related_to(rooms, cu.against_wall)
+        desks = wallfurn[shelves.SimpleDeskFactory]
+        deskchair = furniture[seating.OfficeChairFactory].related_to(
+            desks, cu.front_to_front
+        )
+        offices = rooms[Semantics.Office]
+        constraints["office_desks"] = offices.all(
+            lambda r: desks.related_to(r).count().in_range(1, 2, mean=1.5)
+        )
+        constraints["office_desk_chairs"] = offices.all(
+            lambda r: desks.related_to(r).all(
+                lambda t: deskchair.related_to(r)
+                .related_to(t)
+                .count()
+                .in_range(1, 2, mean=1.5)
+            )
+        )
+        score_terms["office_desks"] = offices.mean(
+            lambda r: desks.related_to(r).mean(
+                lambda d: (
+                    cl.accessibility_cost(d, furniture.related_to(r)).minimize(
+                        weight=3
+                    )
+                    + cl.accessibility_cost(d, r).minimize(weight=3)
+                    + deskchair.related_to(r)
+                    .distance(rooms, cu.walltags)
+                    .maximize(weight=1)
+                )
+            )
+        )
+        return cl.Problem(constraints=constraints, score_terms=score_terms)
+
+    home_module.home_furniture_constraints = patched_home_furniture_constraints
+
+
+def patch_floor_plan_solver():
+    """Guard swap_room against layouts without swap targets."""
+    _ensure_infinigen_on_path()
+    from infinigen.core.constraints.example_solver.room import (
+        solver as solver_module,
+    )
+
+    _orig_swap_room = solver_module.FloorPlanMoves.swap_room
+
+    def patched_swap_room(self, state, k):
+        candidates = [
+            r.target_name for r in state[k].relations if r.value.length > 0
+        ]
+        if not candidates:
+            raise NotImplementedError(
+                "No valid swap targets (e.g. single-room layout)"
+            )
+        return _orig_swap_room(self, state, k)
+
+    solver_module.FloorPlanMoves.swap_room = patched_swap_room
+
+
+def patch_room_graph_root():
+    """Allow single-room graphs to select a valid root without StaircaseRoom."""
+    _ensure_infinigen_on_path()
+    from infinigen.core.constraints.example_solver.room import (
+        base as base_module,
+    )
+    from infinigen.core.tags import Semantics
+
+    @property
+    def patched_root(self):
+        if self.entrance is None:
+            if self[Semantics.StaircaseRoom]:
+                return self.names[self[Semantics.StaircaseRoom][0]]
+            if self[Semantics.Root]:
+                return self.names[self[Semantics.Root][0]]
+            for i, n in enumerate(self.names):
+                if base_module.room_type(n) != Semantics.Exterior:
+                    return self.names[i]
+            raise IndexError(
+                "Graph has no StaircaseRoom, Root, or interior room for root"
+            )
+        return self.names[self._entrance]
+
+    base_module.RoomGraph.root = patched_root
+
+
+def _make_run_main_impl():
+    def _run_main_impl():
+        import argparse
+        from pathlib import Path
+
+        import infinigen_examples.generate_indoors as gi
+        from infinigen.core import init
+
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--output_folder", type=Path)
+        parser.add_argument("--input_folder", type=Path, default=None)
+        parser.add_argument("-s", "--seed", default=None)
+        parser.add_argument(
+            "-t",
+            "--task",
+            nargs="+",
+            default=["coarse"],
+            choices=[
+                "coarse",
+                "populate",
+                "fine_terrain",
+                "ground_truth",
+                "render",
+                "mesh_save",
+                "export",
+            ],
+        )
+        parser.add_argument("-g", "--configs", nargs="+", default=["base"])
+        parser.add_argument("-p", "--overrides", nargs="+", default=[])
+        parser.add_argument("--task_uniqname", type=str, default=None)
+        parser.add_argument("-d", "--debug", type=str, nargs="*", default=None)
+
+        args = init.parse_args_blender(parser)
+
+        import logging
+
+        logging.getLogger("infinigen").setLevel(logging.INFO)
+        logging.getLogger("infinigen.core.nodes.node_wrangler").setLevel(
+            logging.CRITICAL
+        )
+        if args.debug is not None:
+            for name in logging.root.manager.loggerDict:
+                if not name.startswith("infinigen"):
+                    continue
+                if len(args.debug) == 0 or any(
+                    name.endswith(x) for x in args.debug
+                ):
+                    logging.getLogger(name).setLevel(logging.DEBUG)
+
+        gi.main(args)
+
+    return _run_main_impl
+
+
+def add_run_main_to_module(module):
+    """Inject _run_main into generate_indoors module. Call after 'import infinigen_examples.generate_indoors as gi'."""
+    module._run_main = _make_run_main_impl()
+
+
+def patch_generate_indoors_run_main():
+    """Legacy: add _run_main if module already in sys.modules (e.g. when patch runs from generate_indoors top)."""
+    mod = sys.modules.get("infinigen_examples.generate_indoors")
+    if mod is not None:
+        add_run_main_to_module(mod)
+
+
+def monkey_patch_infinigen(
+    *,
+    material_assignments=True,
+    concrete=True,
+    room_constants=True,
+    room_types=True,
+    home_constraints=True,
+    doors=True,
+    kitchen_cabinet=True,
+    kitchen_space=True,
+    sink=True,
+    generate_indoors=True,
+):
+    """Apply selected monkey patches to Infinigen."""
+    if material_assignments:
+        patch_material_assignments()
+    if concrete:
+        patch_concrete()
+    if room_constants:
+        patch_room_constants()
+    if room_types:
+        patch_room_types()
+    if home_constraints:
+        patch_home_constraints()
+    if doors:
+        patch_doors_base_simple()
+    if kitchen_cabinet:
+        patch_kitchen_cabinet()
+    if kitchen_space:
+        patch_kitchen_space()
+    if sink:
+        patch_sink()
+    if generate_indoors:
+        patch_generate_indoors()
+    patch_floor_plan_solver()
+    patch_room_graph_root()
+    patch_generate_indoors_run_main()

embodied_gen/utils/monkey_patch/maniskill.py

@@ -0,0 +1,88 @@
+# 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 numpy as np
+import torch
+
+
+def monkey_patch_maniskill():
+    """Monkey patches ManiSkillScene to support sensor image retrieval and RGBA rendering."""
+    from mani_skill.envs.scene import ManiSkillScene
+
+    def get_sensor_images(
+        self, obs: dict[str, any]
+    ) -> dict[str, dict[str, torch.Tensor]]:
+        """Retrieve images from all sensors based on observations."""
+        sensor_data = dict()
+        for name, sensor in self.sensors.items():
+            sensor_data[name] = sensor.get_images(obs[name])
+        return sensor_data
+
+    def get_human_render_camera_images(
+        self, camera_name: str = None, return_alpha: bool = False
+    ) -> dict[str, torch.Tensor]:
+        """Render images from human-view cameras, optionally generating alpha channel from segmentation."""
+
+        def get_rgba_tensor(camera, return_alpha):
+            color = camera.get_obs(
+                rgb=True, depth=False, segmentation=False, position=False
+            )["rgb"]
+            if return_alpha:
+                seg_labels = camera.get_obs(
+                    rgb=False, depth=False, segmentation=True, position=False
+                )["segmentation"]
+                masks = np.where((seg_labels.cpu() > 1), 255, 0).astype(
+                    np.uint8
+                )
+                masks = torch.tensor(masks).to(color.device)
+                color = torch.concat([color, masks], dim=-1)
+
+            return color
+
+        image_data = dict()
+        if self.gpu_sim_enabled:
+            if self.parallel_in_single_scene:
+                for name, camera in self.human_render_cameras.items():
+                    camera.camera._render_cameras[0].take_picture()
+                    rgba = get_rgba_tensor(camera, return_alpha)
+                    image_data[name] = rgba
+            else:
+                for name, camera in self.human_render_cameras.items():
+                    if camera_name is not None and name != camera_name:
+                        continue
+                    assert camera.config.shader_config.shader_pack not in [
+                        "rt",
+                        "rt-fast",
+                        "rt-med",
+                    ], "ray tracing shaders do not work with parallel rendering"
+                    camera.capture()
+                    rgba = get_rgba_tensor(camera, return_alpha)
+                    image_data[name] = rgba
+        else:
+            for name, camera in self.human_render_cameras.items():
+                if camera_name is not None and name != camera_name:
+                    continue
+                camera.capture()
+                rgba = get_rgba_tensor(camera, return_alpha)
+                image_data[name] = rgba
+
+        return image_data
+
+    ManiSkillScene.get_sensor_images = get_sensor_images
+    ManiSkillScene.get_human_render_camera_images = (
+        get_human_render_camera_images
+    )

embodied_gen/utils/monkey_patch/pano2room.py

@@ -0,0 +1,159 @@
+# 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 zipfile
+
+import torch
+from huggingface_hub import hf_hub_download
+from omegaconf import OmegaConf
+from PIL import Image
+from torchvision import transforms
+
+
+def monkey_patch_pano2room():
+    """Monkey patches pano2room components with custom initializers and model paths."""
+    current_file_path = os.path.abspath(__file__)
+    current_dir = os.path.dirname(current_file_path)
+    sys.path.append(os.path.join(current_dir, "../../.."))
+    sys.path.append(os.path.join(current_dir, "../../../thirdparty/pano2room"))
+    from thirdparty.pano2room.modules.geo_predictors.omnidata.omnidata_normal_predictor import (
+        OmnidataNormalPredictor,
+    )
+    from thirdparty.pano2room.modules.geo_predictors.omnidata.omnidata_predictor import (
+        OmnidataPredictor,
+    )
+
+    def patched_omni_depth_init(self):
+        """Initialize Omnidata depth predictor with explicit model loading."""
+        self.img_size = 384
+        self.model = torch.hub.load(
+            'alexsax/omnidata_models', 'depth_dpt_hybrid_384'
+        )
+        self.model.eval()
+        self.trans_totensor = transforms.Compose(
+            [
+                transforms.Resize(self.img_size, interpolation=Image.BILINEAR),
+                transforms.CenterCrop(self.img_size),
+                transforms.Normalize(mean=0.5, std=0.5),
+            ]
+        )
+
+    OmnidataPredictor.__init__ = patched_omni_depth_init
+
+    def patched_omni_normal_init(self):
+        """Initialize Omnidata normal predictor with explicit model loading."""
+        self.img_size = 384
+        self.model = torch.hub.load(
+            'alexsax/omnidata_models', 'surface_normal_dpt_hybrid_384'
+        )
+        self.model.eval()
+        self.trans_totensor = transforms.Compose(
+            [
+                transforms.Resize(self.img_size, interpolation=Image.BILINEAR),
+                transforms.CenterCrop(self.img_size),
+                transforms.Normalize(mean=0.5, std=0.5),
+            ]
+        )
+
+    OmnidataNormalPredictor.__init__ = patched_omni_normal_init
+
+    def patched_panojoint_init(self, save_path=None):
+        """Initialize PanoJointPredictor using patched depth/normal predictors."""
+        self.depth_predictor = OmnidataPredictor()
+        self.normal_predictor = OmnidataNormalPredictor()
+        self.save_path = save_path
+
+    from modules.geo_predictors import PanoJointPredictor
+
+    PanoJointPredictor.__init__ = patched_panojoint_init
+
+    # NOTE: We use gsplat instead.
+    # import depth_diff_gaussian_rasterization_min as ddgr
+    # from dataclasses import dataclass
+    # @dataclass
+    # class PatchedGaussianRasterizationSettings:
+    #     image_height: int
+    #     image_width: int
+    #     tanfovx: float
+    #     tanfovy: float
+    #     bg: torch.Tensor
+    #     scale_modifier: float
+    #     viewmatrix: torch.Tensor
+    #     projmatrix: torch.Tensor
+    #     sh_degree: int
+    #     campos: torch.Tensor
+    #     prefiltered: bool
+    #     debug: bool = False
+    # ddgr.GaussianRasterizationSettings = PatchedGaussianRasterizationSettings
+
+    # disable get_has_ddp_rank print in `BaseInpaintingTrainingModule`
+    os.environ["NODE_RANK"] = "0"
+
+    from thirdparty.pano2room.modules.inpainters.lama.saicinpainting.training.trainers import (
+        load_checkpoint,
+    )
+    from thirdparty.pano2room.modules.inpainters.lama_inpainter import (
+        LamaInpainter,
+    )
+
+    def patched_lama_inpaint_init(self):
+        """Initialize LamaInpainter by downloading and setting up Big-Lama model."""
+        zip_path = hf_hub_download(
+            repo_id="smartywu/big-lama",
+            filename="big-lama.zip",
+            repo_type="model",
+        )
+        extract_dir = os.path.splitext(zip_path)[0]
+
+        if not os.path.exists(extract_dir):
+            os.makedirs(extract_dir, exist_ok=True)
+            with zipfile.ZipFile(zip_path, "r") as zip_ref:
+                zip_ref.extractall(extract_dir)
+
+        config_path = os.path.join(extract_dir, 'big-lama', 'config.yaml')
+        checkpoint_path = os.path.join(
+            extract_dir, 'big-lama/models/best.ckpt'
+        )
+        train_config = OmegaConf.load(config_path)
+        train_config.training_model.predict_only = True
+        train_config.visualizer.kind = 'noop'
+
+        self.model = load_checkpoint(
+            train_config, checkpoint_path, strict=False, map_location='cpu'
+        )
+        self.model.freeze()
+
+    LamaInpainter.__init__ = patched_lama_inpaint_init
+
+    from diffusers import StableDiffusionInpaintPipeline
+    from thirdparty.pano2room.modules.inpainters.SDFT_inpainter import (
+        SDFTInpainter,
+    )
+
+    def patched_sd_inpaint_init(self, subset_name=None):
+        """Initialize SDFTInpainter with Stable Diffusion 2 Inpainting pipeline."""
+        super(SDFTInpainter, self).__init__()
+        pipe = StableDiffusionInpaintPipeline.from_pretrained(
+            # "stabilityai/stable-diffusion-2-inpainting",
+            "sd2-community/stable-diffusion-2-inpainting",
+            torch_dtype=torch.float16,
+        ).to("cuda")
+        pipe.enable_model_cpu_offload()
+        self.inpaint_pipe = pipe
+
+    SDFTInpainter.__init__ = patched_sd_inpaint_init

embodied_gen/utils/monkey_patch/sam3d.py

@@ -0,0 +1,385 @@
+# 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
+from copy import deepcopy
+from typing import Optional, Union
+
+import numpy as np
+import torch
+from PIL import Image
+
+
+def monkey_patch_sam3d():
+    """Monkey patches SAM3D inference pipelines with custom initialization and execution logic."""
+    from embodied_gen.data.utils import model_device_ctx
+    from embodied_gen.utils.log import logger
+
+    os.environ["LIDRA_SKIP_INIT"] = "true"
+
+    current_file_path = os.path.abspath(__file__)
+    current_dir = os.path.dirname(current_file_path)
+    sam3d_root = os.path.abspath(
+        os.path.join(current_dir, "../../../thirdparty/sam3d")
+    )
+    if sam3d_root not in sys.path:
+        sys.path.insert(0, sam3d_root)
+
+    def patch_pointmap_infer_pipeline():
+        """Patches InferencePipelinePointMap.run to handle pointmap generation and 3D structure sampling."""
+        try:
+            from sam3d_objects.pipeline.inference_pipeline_pointmap import (
+                InferencePipelinePointMap,
+            )
+        except ImportError:
+            logger.error(
+                "[MonkeyPatch]: Could not import sam3d_objects directly. Check paths."
+            )
+            return
+
+        def patch_run(
+            self,
+            image: Union[None, Image.Image, np.ndarray],
+            mask: Union[None, Image.Image, np.ndarray] = None,
+            seed: Optional[int] = None,
+            stage1_only=False,
+            with_mesh_postprocess=True,
+            with_texture_baking=True,
+            with_layout_postprocess=True,
+            use_vertex_color=False,
+            stage1_inference_steps=None,
+            stage2_inference_steps=None,
+            use_stage1_distillation=False,
+            use_stage2_distillation=False,
+            pointmap=None,
+            decode_formats=None,
+            estimate_plane=False,
+        ) -> dict:
+            """Execute the inference pipeline: process image/mask, generate layouts (SS), and decode 3D shapes (SLAT)."""
+            image = self.merge_image_and_mask(image, mask)
+            with self.device:
+                pointmap_dict = self.compute_pointmap(image, pointmap)
+                pointmap = pointmap_dict["pointmap"]
+                pts = type(self)._down_sample_img(pointmap)
+                pts_colors = type(self)._down_sample_img(
+                    pointmap_dict["pts_color"]
+                )
+
+                if estimate_plane:
+                    return self.estimate_plane(pointmap_dict, image)
+
+                ss_input_dict = self.preprocess_image(
+                    image, self.ss_preprocessor, pointmap=pointmap
+                )
+
+                slat_input_dict = self.preprocess_image(
+                    image, self.slat_preprocessor
+                )
+                if seed is not None:
+                    torch.manual_seed(seed)
+
+                with model_device_ctx(
+                    self.models["ss_generator"],
+                    self.models["ss_decoder"],
+                    self.condition_embedders["ss_condition_embedder"],
+                ):
+                    ss_return_dict = self.sample_sparse_structure(
+                        ss_input_dict,
+                        inference_steps=stage1_inference_steps,
+                        use_distillation=use_stage1_distillation,
+                    )
+
+                # We could probably use the decoder from the models themselves
+                pointmap_scale = ss_input_dict.get("pointmap_scale", None)
+                pointmap_shift = ss_input_dict.get("pointmap_shift", None)
+                ss_return_dict.update(
+                    self.pose_decoder(
+                        ss_return_dict,
+                        scene_scale=pointmap_scale,
+                        scene_shift=pointmap_shift,
+                    )
+                )
+
+                ss_return_dict["scale"] = (
+                    ss_return_dict["scale"]
+                    * ss_return_dict["downsample_factor"]
+                )
+
+                if stage1_only:
+                    logger.info("Finished!")
+                    ss_return_dict["voxel"] = (
+                        ss_return_dict["coords"][:, 1:] / 64 - 0.5
+                    )
+                    return {
+                        **ss_return_dict,
+                        "pointmap": pts.cpu().permute((1, 2, 0)),  # HxWx3
+                        "pointmap_colors": pts_colors.cpu().permute(
+                            (1, 2, 0)
+                        ),  # HxWx3
+                    }
+                    # return ss_return_dict
+
+                coords = ss_return_dict["coords"]
+                with model_device_ctx(
+                    self.models["slat_generator"],
+                    self.condition_embedders["slat_condition_embedder"],
+                ):
+                    slat = self.sample_slat(
+                        slat_input_dict,
+                        coords,
+                        inference_steps=stage2_inference_steps,
+                        use_distillation=use_stage2_distillation,
+                    )
+
+                with model_device_ctx(
+                    self.models["slat_decoder_mesh"],
+                    self.models["slat_decoder_gs"],
+                    self.models["slat_decoder_gs_4"],
+                ):
+                    outputs = self.decode_slat(
+                        slat,
+                        (
+                            self.decode_formats
+                            if decode_formats is None
+                            else decode_formats
+                        ),
+                    )
+
+                outputs = self.postprocess_slat_output(
+                    outputs,
+                    with_mesh_postprocess,
+                    with_texture_baking,
+                    use_vertex_color,
+                )
+                glb = outputs.get("glb", None)
+
+                try:
+                    if (
+                        with_layout_postprocess
+                        and self.layout_post_optimization_method is not None
+                    ):
+                        assert (
+                            glb is not None
+                        ), "require mesh to run postprocessing"
+                        logger.info(
+                            "Running layout post optimization method..."
+                        )
+                        postprocessed_pose = self.run_post_optimization(
+                            deepcopy(glb),
+                            pointmap_dict["intrinsics"],
+                            ss_return_dict,
+                            ss_input_dict,
+                        )
+                        ss_return_dict.update(postprocessed_pose)
+                except Exception as e:
+                    logger.error(
+                        f"Error during layout post optimization: {e}",
+                        exc_info=True,
+                    )
+
+                result = {
+                    **ss_return_dict,
+                    **outputs,
+                    "pointmap": pts.cpu().permute((1, 2, 0)),
+                    "pointmap_colors": pts_colors.cpu().permute((1, 2, 0)),
+                }
+                return result
+
+        InferencePipelinePointMap.run = patch_run
+
+    def patch_infer_init():
+        """Patches InferencePipeline.__init__ to allow CPU offloading during model initialization."""
+        import torch
+
+        try:
+            from sam3d_objects.pipeline import preprocess_utils
+            from sam3d_objects.pipeline.inference_pipeline_pointmap import (
+                InferencePipeline,
+            )
+            from sam3d_objects.pipeline.inference_utils import (
+                SLAT_MEAN,
+                SLAT_STD,
+            )
+        except ImportError:
+            print(
+                "[MonkeyPatch] Error: Could not import sam3d_objects directly for infer pipeline."
+            )
+            return
+
+        def patch_init(
+            self,
+            ss_generator_config_path,
+            ss_generator_ckpt_path,
+            slat_generator_config_path,
+            slat_generator_ckpt_path,
+            ss_decoder_config_path,
+            ss_decoder_ckpt_path,
+            slat_decoder_gs_config_path,
+            slat_decoder_gs_ckpt_path,
+            slat_decoder_mesh_config_path,
+            slat_decoder_mesh_ckpt_path,
+            slat_decoder_gs_4_config_path=None,
+            slat_decoder_gs_4_ckpt_path=None,
+            ss_encoder_config_path=None,
+            ss_encoder_ckpt_path=None,
+            decode_formats=["gaussian", "mesh"],
+            dtype="bfloat16",
+            pad_size=1.0,
+            version="v0",
+            device="cuda",
+            ss_preprocessor=preprocess_utils.get_default_preprocessor(),
+            slat_preprocessor=preprocess_utils.get_default_preprocessor(),
+            ss_condition_input_mapping=["image"],
+            slat_condition_input_mapping=["image"],
+            pose_decoder_name="default",
+            workspace_dir="",
+            downsample_ss_dist=0,  # the distance we use to downsample
+            ss_inference_steps=25,
+            ss_rescale_t=3,
+            ss_cfg_strength=7,
+            ss_cfg_interval=[0, 500],
+            ss_cfg_strength_pm=0.0,
+            slat_inference_steps=25,
+            slat_rescale_t=3,
+            slat_cfg_strength=5,
+            slat_cfg_interval=[0, 500],
+            rendering_engine: str = "nvdiffrast",  # nvdiffrast OR pytorch3d,
+            shape_model_dtype=None,
+            compile_model=False,
+            slat_mean=SLAT_MEAN,
+            slat_std=SLAT_STD,
+        ):
+            """Initialize pipeline components on CPU first to save GPU memory, then move necessary parts later."""
+            self.rendering_engine = rendering_engine
+            self.device = torch.device(device)
+            self.compile_model = compile_model
+            with self.device:
+                self.decode_formats = decode_formats
+                self.pad_size = pad_size
+                self.version = version
+                self.ss_condition_input_mapping = ss_condition_input_mapping
+                self.slat_condition_input_mapping = (
+                    slat_condition_input_mapping
+                )
+                self.workspace_dir = workspace_dir
+                self.downsample_ss_dist = downsample_ss_dist
+                self.ss_inference_steps = ss_inference_steps
+                self.ss_rescale_t = ss_rescale_t
+                self.ss_cfg_strength = ss_cfg_strength
+                self.ss_cfg_interval = ss_cfg_interval
+                self.ss_cfg_strength_pm = ss_cfg_strength_pm
+                self.slat_inference_steps = slat_inference_steps
+                self.slat_rescale_t = slat_rescale_t
+                self.slat_cfg_strength = slat_cfg_strength
+                self.slat_cfg_interval = slat_cfg_interval
+
+                self.dtype = self._get_dtype(dtype)
+                if shape_model_dtype is None:
+                    self.shape_model_dtype = self.dtype
+                else:
+                    self.shape_model_dtype = self._get_dtype(shape_model_dtype)
+
+                # Setup preprocessors
+                self.pose_decoder = self.init_pose_decoder(
+                    ss_generator_config_path, pose_decoder_name
+                )
+                self.ss_preprocessor = self.init_ss_preprocessor(
+                    ss_preprocessor, ss_generator_config_path
+                )
+                self.slat_preprocessor = slat_preprocessor
+
+                raw_device = self.device
+                self.device = torch.device("cpu")
+                ss_generator = self.init_ss_generator(
+                    ss_generator_config_path, ss_generator_ckpt_path
+                )
+                slat_generator = self.init_slat_generator(
+                    slat_generator_config_path, slat_generator_ckpt_path
+                )
+                ss_decoder = self.init_ss_decoder(
+                    ss_decoder_config_path, ss_decoder_ckpt_path
+                )
+                ss_encoder = self.init_ss_encoder(
+                    ss_encoder_config_path, ss_encoder_ckpt_path
+                )
+                slat_decoder_gs = self.init_slat_decoder_gs(
+                    slat_decoder_gs_config_path, slat_decoder_gs_ckpt_path
+                )
+                slat_decoder_gs_4 = self.init_slat_decoder_gs(
+                    slat_decoder_gs_4_config_path, slat_decoder_gs_4_ckpt_path
+                )
+                slat_decoder_mesh = self.init_slat_decoder_mesh(
+                    slat_decoder_mesh_config_path, slat_decoder_mesh_ckpt_path
+                )
+
+                # Load conditioner embedder so that we only load it once
+                ss_condition_embedder = self.init_ss_condition_embedder(
+                    ss_generator_config_path, ss_generator_ckpt_path
+                )
+                slat_condition_embedder = self.init_slat_condition_embedder(
+                    slat_generator_config_path, slat_generator_ckpt_path
+                )
+                self.device = raw_device
+
+                self.condition_embedders = {
+                    "ss_condition_embedder": ss_condition_embedder,
+                    "slat_condition_embedder": slat_condition_embedder,
+                }
+
+                # override generator and condition embedder setting
+                self.override_ss_generator_cfg_config(
+                    ss_generator,
+                    cfg_strength=ss_cfg_strength,
+                    inference_steps=ss_inference_steps,
+                    rescale_t=ss_rescale_t,
+                    cfg_interval=ss_cfg_interval,
+                    cfg_strength_pm=ss_cfg_strength_pm,
+                )
+                self.override_slat_generator_cfg_config(
+                    slat_generator,
+                    cfg_strength=slat_cfg_strength,
+                    inference_steps=slat_inference_steps,
+                    rescale_t=slat_rescale_t,
+                    cfg_interval=slat_cfg_interval,
+                )
+
+                self.models = torch.nn.ModuleDict(
+                    {
+                        "ss_generator": ss_generator,
+                        "slat_generator": slat_generator,
+                        "ss_encoder": ss_encoder,
+                        "ss_decoder": ss_decoder,
+                        "slat_decoder_gs": slat_decoder_gs,
+                        "slat_decoder_gs_4": slat_decoder_gs_4,
+                        "slat_decoder_mesh": slat_decoder_mesh,
+                    }
+                )
+                logger.info("Loading SAM3D model weights completed.")
+
+                if self.compile_model:
+                    logger.info("Compiling model...")
+                    self._compile()
+                    logger.info("Model compilation completed!")
+                self.slat_mean = torch.tensor(slat_mean)
+                self.slat_std = torch.tensor(slat_std)
+
+        InferencePipeline.__init__ = patch_init
+
+    patch_pointmap_infer_pipeline()
+    patch_infer_init()
+
+    return

embodied_gen/utils/monkey_patch/trellis.py

@@ -0,0 +1,83 @@
+# 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 torch
+import torch.nn.functional as F
+
+
+def monkey_path_trellis():
+    """Monkey patches TRELLIS with specific environment settings and Gaussian setup functions."""
+    current_file_path = os.path.abspath(__file__)
+    current_dir = os.path.dirname(current_file_path)
+    sys.path.append(os.path.join(current_dir, "../../.."))
+
+    from thirdparty.TRELLIS.trellis.representations import Gaussian
+    from thirdparty.TRELLIS.trellis.representations.gaussian.general_utils import (
+        build_scaling_rotation,
+        inverse_sigmoid,
+        strip_symmetric,
+    )
+
+    os.environ["TORCH_EXTENSIONS_DIR"] = os.path.expanduser(
+        "~/.cache/torch_extensions"
+    )
+    os.environ["SPCONV_ALGO"] = "auto"  # Can be 'native' or 'auto'
+    os.environ['ATTN_BACKEND'] = (
+        "xformers"  # Can be 'flash-attn' or 'xformers'
+    )
+    from thirdparty.TRELLIS.trellis.modules.sparse import set_attn
+
+    set_attn("xformers")
+
+    def patched_setup_functions(self):
+        """Configure activation functions and biases for Gaussian representation."""
+
+        def inverse_softplus(x):
+            return x + torch.log(-torch.expm1(-x))
+
+        def build_covariance_from_scaling_rotation(
+            scaling, scaling_modifier, rotation
+        ):
+            L = build_scaling_rotation(scaling_modifier * scaling, rotation)
+            actual_covariance = L @ L.transpose(1, 2)
+            symm = strip_symmetric(actual_covariance)
+            return symm
+
+        if self.scaling_activation_type == "exp":
+            self.scaling_activation = torch.exp
+            self.inverse_scaling_activation = torch.log
+        elif self.scaling_activation_type == "softplus":
+            self.scaling_activation = F.softplus
+            self.inverse_scaling_activation = inverse_softplus
+
+        self.covariance_activation = build_covariance_from_scaling_rotation
+        self.opacity_activation = torch.sigmoid
+        self.inverse_opacity_activation = inverse_sigmoid
+        self.rotation_activation = F.normalize
+
+        self.scale_bias = self.inverse_scaling_activation(
+            torch.tensor(self.scaling_bias)
+        ).to(self.device)
+        self.rots_bias = torch.zeros((4)).to(self.device)
+        self.rots_bias[0] = 1
+        self.opacity_bias = self.inverse_opacity_activation(
+            torch.tensor(self.opacity_bias)
+        ).to(self.device)
+
+    Gaussian.setup_functions = patched_setup_functions

embodied_gen/utils/simulation.py

@@ -25,6 +25,7 @@ import numpy as np
 import sapien.core as sapien
 import sapien.physx as physx
 import torch
+import trimesh
 from mani_skill.agents.base_agent import BaseAgent
 from mani_skill.envs.scene import ManiSkillScene
 from mani_skill.examples.motionplanning.panda.utils import (
@@ -57,9 +58,24 @@ __all__ = [
     "load_assets_from_layout_file",
     "load_mani_skill_robot",
     "render_images",
+    "is_urdf_articulated",
 ]
 
 
+def is_urdf_articulated(urdf_path: str) -> bool:
+    try:
+        tree = ET.parse(urdf_path)
+        root = tree.getroot()
+        for joint in root.findall(".//joint"):
+            j_type = joint.get("type")
+            if j_type in ["prismatic", "revolute", "continuous", "planar"]:
+                return True
+        return False
+    except Exception as e:
+        print(f"Error parsing URDF {urdf_path}: {e}.")
+        return False
+
+
 def load_actor_from_urdf(
     scene: sapien.Scene | ManiSkillScene,
     file_path: str,
@@ -203,14 +219,21 @@ def load_assets_from_layout_file(
         # Combine initial quaternion with object quaternion
         x, y, z, qx, qy, qz, qw = position
         qx, qy, qz, qw = quaternion_multiply([qx, qy, qz, qw], init_quat)
-        actor = load_actor_from_urdf(
-            scene,
-            urdf_file,
-            sapien.Pose(p=[x, y, z], q=[qw, qx, qy, qz]),
-            env_idx,
-            use_static=use_static,
-            update_mass=False,
-        )
+        target_pose = sapien.Pose(p=[x, y, z], q=[qw, qx, qy, qz])
+        if is_urdf_articulated(urdf_file):
+            loader = scene.create_urdf_loader()
+            loader.fix_root_link = use_static
+            actor = loader.load(urdf_file)
+            actor.set_root_pose(target_pose)
+        else:
+            actor = load_actor_from_urdf(
+                scene,
+                urdf_file,
+                target_pose,
+                env_idx,
+                use_static=use_static,
+                update_mass=False,
+            )
         actors[node] = actor
 
     return actors
@@ -725,8 +748,23 @@ class FrankaPandaGrasper(object):
         Returns:
             np.ndarray: Array of grasp actions.
         """
-        physx_rigid = actor.components[1]
-        mesh = get_component_mesh(physx_rigid, to_world_frame=True)
+        if isinstance(actor, physx.PhysxArticulation):
+            meshes = []
+            for link in actor.links:
+                link_mesh = get_component_mesh(link, to_world_frame=True)
+                if link_mesh is not None and not link_mesh.is_empty:
+                    meshes.append(link_mesh)
+            if meshes:
+                mesh = trimesh.util.concatenate(meshes)
+            else:
+                logger.warning(
+                    f"Articulation {actor.name} has no valid meshes."
+                )
+                return None
+        else:
+            physx_rigid = actor.components[1]
+            mesh = get_component_mesh(physx_rigid, to_world_frame=True)
+
         obb = mesh.bounding_box_oriented
         approaching = np.array([0, 0, -1])
         tcp_pose = self.agent.tcp.pose[env_idx]

embodied_gen/utils/tags.py

@@ -1 +1 @@
-VERSION = "v0.1.7"
+VERSION = "v0.1.8"

embodied_gen/validators/urdf_convertor.py

@@ -127,7 +127,7 @@ class URDFGenerator(object):
         self.gpt_client = gpt_client
         self.render_view_num = render_view_num
         if render_view_num == 4:
-            view_desc = "This is orthographic projection showing the front, left, right and back views "  # noqa
+            view_desc = "This is an orthographic projection showing the front(1st image), right(2nd), back(3rd), and left(4th) views."  # noqa
         else:
             view_desc = "This is the rendered views "
 
@@ -139,7 +139,7 @@ class URDFGenerator(object):
             You are an expert in 3D object analysis and physical property estimation.
             Give the category of this object asset (within 3 words), (if category is
             already provided, use it directly), accurately describe this 3D object asset (within 15 words),
-            Determine the pose of the object in the first image and estimate the true vertical height
+            Determine the pose of the object in the first image based on all views and estimate the true vertical height
             (vertical projection) range of the object (in meters), i.e., how tall the object appears from top
             to bottom in the first image. also weight range (unit: kilogram), the average
             static friction coefficient of the object relative to rubber and the average dynamic friction
@@ -161,14 +161,16 @@ class URDFGenerator(object):
             use the diameter as the vertical height. If the edge is visible, use the thickness instead.
             - This is not necessarily the full length of the object, but how tall it appears
             in the first image vertically, based on its pose and orientation estimation on all views.
-            - For objects(e.g., spoons, forks, writing instruments etc.) at an angle showing in images,
-                e.g., tilted at 45° will appear shorter vertically than when upright.
+            - Distinguish whether the entire objects such as plates, books, pens, spoons, fork are placed
+                horizontally or vertically based on pictures from left, right views.
+
             Estimate the vertical projection of their real length based on its pose.
             For example:
               - A pen standing upright in the first image (aligned with the image's vertical axis)
-                full body visible in the first image: → vertical height ≈ 0.14-0.20 m
+                full body visible in the first and other image: → vertically → vertical height ≈ 0.14-0.20 m
               - A pen lying flat in the first image or either the tip or the tail is facing the image
-                (showing thickness or as a circle) → vertical height ≈ 0.018-0.025 m
+                (showing thickness or as a circle), left/right view can show the full body
+                → horizontally → vertical height ≈ 0.018-0.025 m
               - Tilted pen in the first image (e.g., ~45° angle): vertical height ≈ 0.07-0.12 m
             - Use the rest views to help determine the object's 3D pose and orientation.
             Assume the object is in real-world scale and estimate the approximate vertical height
@@ -204,8 +206,13 @@ class URDFGenerator(object):
         Returns:
             dict[str, any]: Parsed attributes.
         """
-        lines = response.split("\n")
-        lines = [line.strip() for line in lines if line]
+        raw_lines = response.split("\n")
+        lines = []
+        for line in raw_lines:
+            line = line.strip()
+            if line and not line.startswith("```") and ":" in line:
+                lines.append(line)
+
         category = lines[0].split(": ")[1]
         description = lines[1].split(": ")[1]
         min_height, max_height = map(