Merge branch 'main' of https://github.com/Genesis-Embodied-AI/Genesis into dev_material

Author: ACMLCZH

genesis/engine/mesh.py

@@ -62,9 +62,12 @@ def __init__(
         self._metadata: dict[str, Any] = metadata or {}
         self._color = np.array([1.0, 1.0, 1.0, 1.0], dtype=gs.np_float)
 
-        # By default, all meshes are considered zup, unless the "FileMorph.file_meshes_are_zup" option was set to False.
+        # By default, all meshes are considered zup, unless the "FileMorph.file_meshes_are_zup" option was set to False
         self._metadata.setdefault("imported_as_zup", True)
 
+        # By default, all meshes are considered having their original visual
+        self._metadata.setdefault("is_visual_overwritten", False)
+
         if not is_mesh_zup:
             if self._metadata["imported_as_zup"]:
                 self._mesh.apply_transform(mu.Y_UP_TRANSFORM.T)
@@ -245,6 +248,7 @@ def from_trimesh(
             # Visual may not have uv, e.g. ColorVisuals
             uvs = None
 
+        metadata = metadata or {}
         must_update_surface = True
         roughness_factor = None
         color_image = None
@@ -287,14 +291,14 @@ def from_trimesh(
             else:
                 # TODO: support vertex/face colors in luisa
                 color_factor = tuple(np.array(visual.main_color, dtype=np.float32) / 255.0)
+        elif surface.color is not None:
+            color_factor = surface.color
+            metadata["is_visual_overwritten"] = True
         elif (isinstance(visual, trimesh.visual.color.ColorVisuals) and visual.defined) or (
             isinstance(visual, trimesh.visual.color.VertexColor) and visual.vertex_colors.size > 0
         ):
-            # Color is already vertex-based. No need to create a new texture to keep the original one, unless a color
-            # overwrite has been specified as surface-level.
-            must_update_surface = surface.color is not None
-        elif surface.color is not None:
-            color_factor = surface.color
+            # Color is already vertex-based. It is not only necessary to create a new visual.
+            must_update_surface = False
         else:
             # use white color as default
             color_factor = (1.0, 1.0, 1.0, 1.0)
@@ -336,14 +340,20 @@ def from_attrs(
         if surface is None:
             surface = gs.surfaces.Default()
 
+        metadata = metadata or {}
+        metadata["is_visual_overwritten"] = metadata.get("is_visual_overwritten", False) or (surface.color is not None)
+        visual = mu.surface_uvs_to_trimesh_visual(surface, uvs, len(verts))
+
+        tmesh = trimesh.Trimesh(
+            vertices=verts,
+            faces=faces,
+            vertex_normals=normals,
+            visual=visual,
+            process=False,
+        )
+
         return cls(
-            mesh=trimesh.Trimesh(
-                vertices=verts,
-                faces=faces,
-                vertex_normals=normals,
-                visual=mu.surface_uvs_to_trimesh_visual(surface, uvs, len(verts)),
-                process=False,
-            ),
+            mesh=tmesh,
             surface=surface,
             uvs=uvs,
             scale=scale,
@@ -402,6 +412,7 @@ def update_trimesh_visual(self):
         Update the trimesh obj's visual attributes using its surface and uvs.
         """
         self._mesh.visual = mu.surface_uvs_to_trimesh_visual(self.surface, self.uvs, len(self.verts))
+        self._metadata["is_visual_overwritten"] = True
 
     def apply_transform(self, T):
         """

genesis/options/morphs.py

@@ -6,7 +6,7 @@
 """
 
 import os
-from typing import Any, List, Optional, Sequence, Tuple, Union, Literal
+from typing import Any, List, Optional, Sequence, Tuple, Literal
 from pathlib import Path
 
 import numpy as np
@@ -747,13 +747,17 @@ def __init__(self, **kwargs):
                     "Specifying 'file_meshes_are_zup' for GLTF/GLB files is not supported. A rotation will be applied "
                     "explicitly on the morph instead. Please consider fixing your asset to use Y-UP convention."
                 )
-                quat = (0.707, -0.707, 0.0, 0.0)
+                y_up_quat = (1.0, -1.0, 0.0, 0.0)
                 if self.quat is None:
-                    self.quat = quat
+                    self.quat = y_up_quat
                 else:
                     self.quat = gu.transform_quat_by_quat(
-                        np.array(quat, dtype=gs.np_float), np.array(self.quat, dtype=gs.np_float)
+                        np.array(y_up_quat, dtype=gs.np_float), np.array(self.quat, dtype=gs.np_float)
                     )
+                if self.scale is not None:
+                    scale = np.atleast_1d(np.array(self.scale))
+                    if scale.size == 3:
+                        self.scale = (scale[0], scale[2], scale[1])
             self.file_meshes_are_zup = False
         elif self.file_meshes_are_zup is None:
             self.file_meshes_are_zup = True

genesis/utils/urdf.py

@@ -117,6 +117,7 @@ def parse_urdf(morph, surface):
                     scale *= geometry.scale
 
                 # Overwrite surface color by original color specified in URDF file only if necessary
+                is_urdf_material = False
                 if geom_is_col:
                     geom_surface = gs.surfaces.Collision()
                 elif (
@@ -125,6 +126,7 @@ def parse_urdf(morph, surface):
                     and geom_prop.material.color is not None
                     and (morph.prioritize_urdf_material or surface.color is None)
                 ):
+                    is_urdf_material = True
                     geom_surface = surface.copy()
                     geom_surface.color = geom_prop.material.color
                 else:
@@ -145,6 +147,9 @@ def parse_urdf(morph, surface):
                         is_mesh_zup=morph.file_meshes_are_zup,
                         metadata={"mesh_path": mesh_path},
                     )
+                    if is_urdf_material:
+                        # Material color defined in URDF are not considered as visual overwrite
+                        mesh.metadata["is_visual_overwritten"] = False
 
                     g_info = {"mesh" if geom_is_col else "vmesh": mesh}
                     link_g_infos_.append(g_info)

genesis/vis/rasterizer_context.py

@@ -832,7 +832,7 @@ def draw_debug_frame(self, T, axis_length=1.0, origin_size=0.015, axis_radius=0.
 
     def draw_debug_frames(self, poses, axis_length=1.0, origin_size=0.015, axis_radius=0.01):
         mesh = trimesh.creation.axis(origin_size=origin_size, axis_radius=axis_radius, axis_length=axis_length)
-        node = pyrender.Mesh.from_trimesh(mesh, name=f"debug_frame_{gs.UID()}", is_marker=True)
+        node = pyrender.Mesh.from_trimesh(mesh, name=f"debug_frame_{gs.UID()}", poses=poses, is_marker=True)
         self.add_external_node(node)
         return node
 

tests/test_mesh.py

@@ -153,16 +153,13 @@ def check_gs_surfaces(gs_surface1, gs_surface2, material_name):
     check_gs_textures(gs_surface1.emissive_texture, gs_surface2.emissive_texture, 0.0, material_name, "emissive")
 
 
-# ==================== Scaling Tests ====================
+# ==================== Scale Tests ====================
 
 
 @pytest.mark.required
-@pytest.mark.parametrize("scale", [(2.0, 3.0, 5.0), (2.0, 2.0, 2.0)])
-@pytest.mark.parametrize(
-    "mesh_file, file_meshes_are_zup",
-    [("meshes/camera/camera.glb", False), ("meshes/axis.obj", True)],
-)
-def test_morph_scaling(scale, mesh_file, file_meshes_are_zup, show_viewer, tmp_path):
+@pytest.mark.parametrize("scale", [(0.5, 2.0, 8.0), (2.0, 2.0, 2.0)])
+@pytest.mark.parametrize("mesh_file", ["meshes/camera/camera.glb", "meshes/axis.obj"])
+def test_morph_scale(scale, mesh_file, show_viewer, tmp_path):
     urdf_path = tmp_path / "model.urdf"
     urdf_path.write_text(
         f"""<robot name="cannon">
@@ -179,48 +176,72 @@ def test_morph_scaling(scale, mesh_file, file_meshes_are_zup, show_viewer, tmp_p
     obj_orig = scene.add_entity(
         morph=gs.morphs.Mesh(
             file=mesh_file,
+            file_meshes_are_zup=False,
             pos=(0, 0, 1.0),
-            scale=(1.0, 1.0, 1.0),
+            scale=1.0,
             convexify=False,
             fixed=True,
         ),
+        surface=gs.surfaces.Default(
+            color=(1.0, 0.0, 0.0, 1.0),
+        ),
     )
-    mesh_orig = obj_orig.vgeoms[0].vmesh.trimesh
+    for vgeom in obj_orig.vgeoms:
+        mesh_orig = vgeom.vmesh.trimesh
+        mesh_orig.apply_transform(mu.Y_UP_TRANSFORM)
+        mesh_orig.apply_scale(scale)
+
     obj_scaled = scene.add_entity(
         morph=gs.morphs.Mesh(
             file=mesh_file,
+            file_meshes_are_zup=True,
             pos=(0, 0, 1.0),
             scale=scale,
             convexify=False,
             fixed=True,
         ),
+        surface=gs.surfaces.Default(
+            color=(0.0, 1.0, 0.0, 1.0),
+        ),
     )
-    mesh_scaled = obj_scaled.vgeoms[0].vmesh.trimesh
+    assert obj_orig.n_vgeoms == obj_scaled.n_vgeoms
 
     is_isotropic = np.unique(scale).size == 1
     with nullcontext() if is_isotropic else pytest.raises(gs.GenesisException):
         robot_scaled = scene.add_entity(
             gs.morphs.URDF(
                 file=urdf_path,
+                file_meshes_are_zup=True,
+                pos=(0, 0, 1.0),
+                scale=scale,
                 convexify=False,
                 fixed=True,
-                scale=scale,
-                file_meshes_are_zup=file_meshes_are_zup,
+            ),
+            surface=gs.surfaces.Default(
+                color=(0.0, 0.0, 1.0, 1.0),
             ),
         )
-        mesh_robot_scaled = robot_scaled.vgeoms[0].vmesh.trimesh
+        assert robot_scaled.n_vgeoms == obj_scaled.n_vgeoms
 
-    if show_viewer:
-        scene.build()
 
-    assert_allclose(mesh_orig.vertices * scale, mesh_scaled.vertices, tol=gs.EPS)
-    if is_isotropic:
-        assert_allclose(mesh_robot_scaled.vertices, mesh_scaled.vertices, tol=gs.EPS)
+    for i_vg in range(obj_orig.n_vgeoms):
+        mesh_orig = obj_orig.vgeoms[i_vg].vmesh.trimesh.copy()
+        mesh_orig.apply_transform(gu.trans_quat_to_T(obj_orig.base_link.pos, obj_orig.base_link.quat))
+        mesh_scaled = obj_scaled.vgeoms[i_vg].vmesh.trimesh.copy()
+        mesh_scaled.apply_transform(gu.trans_quat_to_T(obj_scaled.base_link.pos, obj_scaled.base_link.quat))
+        assert_allclose(mesh_orig.vertices, mesh_scaled.vertices, tol=gs.EPS)
+
+        if is_isotropic:
+            mesh_robot_scaled = robot_scaled.vgeoms[i_vg].vmesh.trimesh.copy()
+            mesh_robot_scaled.apply_transform(
+                gu.trans_quat_to_T(robot_scaled.base_link.pos, robot_scaled.base_link.quat)
+            )
+            assert_allclose(mesh_robot_scaled.vertices, mesh_scaled.vertices, tol=gs.EPS)
 
 
 @pytest.mark.required
 @pytest.mark.parametrize("mesh_file", ["glb/combined_transform.glb", "yup_zup_coverage/cannon_y_-z.stl"])
-def test_urdf_scaling(mesh_file, tmp_path, show_viewer):
+def test_urdf_scale(mesh_file, tmp_path, show_viewer):
     SCALE_FACTOR = 2.0
 
     asset_path = get_hf_dataset(pattern=mesh_file)
@@ -262,7 +283,7 @@ def test_urdf_scaling(mesh_file, tmp_path, show_viewer):
     assert_allclose(SCALE_FACTOR * mesh_1.extents, mesh_2.extents, tol=gs.EPS)
 
 
-# ==================== Coordinate System Tests ====================
+# ==================== Y-Up Coordinate Tests ====================
 
 
 @pytest.mark.required
@@ -647,19 +668,6 @@ def test_2_channels_luminance_alpha_textures(show_viewer):
     )
 
 
-@pytest.mark.required
-def test_plane_texture_path_preservation(show_viewer):
-    """Test that plane primitives preserve texture paths in metadata."""
-    scene = gs.Scene(show_viewer=show_viewer, show_FPS=False)
-    plane = scene.add_entity(gs.morphs.Plane())
-
-    # The texture path should be stored in metadata
-    assert plane.vgeoms[0].vmesh.metadata["texture_path"] == "textures/checker.png"
-
-
-# ==================== Special Texture Format Tests ====================
-
-
 @pytest.mark.required
 @pytest.mark.parametrize(
     "n_channels, float_type",

tests/test_rigid_physics.py

@@ -2711,11 +2711,12 @@ def test_urdf_capsule(tmp_path, show_viewer, tol):
 @pytest.mark.required
 @pytest.mark.required
 @pytest.mark.parametrize("overwrite", [False, True])
-def test_urdf_color_overwrite(overwrite):
-    scene = gs.Scene()
+def test_urdf_color_overwrite(overwrite, show_viewer):
+    scene = gs.Scene(show_viewer=show_viewer)
     box = scene.add_entity(
         gs.morphs.URDF(
             file="genesis/assets/urdf/blue_box/model.urdf",
+            convexify=False,
         ),
         surface=gs.surfaces.Default(
             color=(1.0, 0.0, 0.0, 1.0) if overwrite else None,
@@ -2724,26 +2725,49 @@ def test_urdf_color_overwrite(overwrite):
     axis = scene.add_entity(
         gs.morphs.Mesh(
             file="meshes/axis.obj",
+            convexify=False,
         ),
         surface=gs.surfaces.Default(
             color=(1.0, 0.0, 0.0, 1.0) if overwrite else None,
         ),
     )
+    asset_path = get_hf_dataset(pattern="work_table.glb")
+    table = scene.add_entity(
+        gs.morphs.Mesh(
+            file=f"{asset_path}/work_table.glb",
+            convexify=False,
+        ),
+        surface=gs.surfaces.Default(
+            color=(1.0, 0.0, 0.0, 1.0) if overwrite else None,
+        ),
+    )
+    if show_viewer:
+        scene.build()
     for vgeom in box.vgeoms:
+        assert vgeom.vmesh.metadata["is_visual_overwritten"] == overwrite
         visual = vgeom.vmesh.trimesh.visual
         assert visual.defined
         color = np.unique(visual.vertex_colors, axis=0)
         assert_array_equal(color, (255, 0, 0, 255) if overwrite else (0, 0, 255, 255))
     for vgeom in axis.vgeoms:
+        assert vgeom.vmesh.metadata["is_visual_overwritten"] == overwrite
         visual = vgeom.vmesh.trimesh.visual
         assert visual.defined
         color = np.unique(visual.vertex_colors, axis=0)
         if overwrite:
             assert_array_equal(color, (255, 0, 0, 255))
         else:
             assert_array_equal(color, [[0, 0, 178, 255], [0, 178, 0, 255], [178, 0, 0, 255], [255, 255, 255, 255]])
+    for vgeom in table.vgeoms:
+        assert vgeom.vmesh.metadata["is_visual_overwritten"] == overwrite
+        visual = vgeom.vmesh.trimesh.visual
+        assert visual.defined
+        if overwrite:
+            color = np.unique(visual.vertex_colors, axis=0)
+            assert_array_equal(color, (255, 0, 0, 255))
     for entity in scene.entities:
         for geom in entity.geoms:
+            assert geom.mesh.metadata["is_visual_overwritten"]
             visual = geom.mesh.trimesh.visual
             assert visual.defined
             color = np.unique(visual.vertex_colors, axis=0)