Fixes caching of the terrain using the terrain generator (#757)

# Description

The caching of terrains with the terrain generator did not work as
expected even when the curriculum was enabled (which should have yielded the
same terrain every time). On deeper investigation, it appears that the
terrain generator samples a range when using the curriculum to avoid having
the same sub-terrain in columns of the same terrain type. Thus, the
terrain `difficulty` was stochastic between runs, which affected the
caching of the terrain.

This MR fixes the following:

- Adds documentation of the above behavior
- Modifies the generator to use `np.random.Generator` (RNG) instead of
setting the seed globally
- Adds a warning if the user wants to cache the terrain and the seed is
not set
- Adds tests to check caching works for the terrain generator with and
without curriculum

Note: Right now, complete determinism (i.e., the same terrain is generated)
is only possible when seed is set and caching is enabled. If caching is
disabled, it is possible that the terrain may have small differences. To
fix this, the RNG needs to be propagated to all the generation functions
as well. I leave that as a future TODO.

## Type of change

- Bug fix (non-breaking change which fixes an issue)
- This change requires a documentation update

## Checklist

- [x] I have run the [`pre-commit` checks](https://pre-commit.com/) with
`./isaaclab.sh --format`
- [x] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] I have updated the changelog and the corresponding version in the
extension's `config/extension.toml` file
- [x] I have added my name to the `CONTRIBUTORS.md` or my name already
exists there

source/extensions/omni.isaac.lab/config/extension.toml

 [package]
 
 # Note: Semantic Versioning is used: https://semver.org/
-version = "0.20.3"
+version = "0.20.4"
 
 # Description
 title = "Isaac Lab framework for Robot Learning"

source/extensions/omni.isaac.lab/docs/CHANGELOG.rst

 Changelog
 ---------
 
+0.20.4 (2024-08-02)
+~~~~~~~~~~~~~~~~~~~
+
+Fixed
+^^^^^
+
+* Fixed the caching of terrains when using the :class:`omni.isaac.lab.terrains.TerrainGenerator` class.
+  Earlier, the random sampling of the difficulty levels led to different hash values for the same terrain
+  configuration. This caused the terrains to be re-generated even when the same configuration was used.
+  Now, the numpy random generator is seeded with the same seed to ensure that the difficulty levels are
+  sampled in the same order between different runs.
+
+
 0.20.3 (2024-08-02)
 ~~~~~~~~~~~~~~~~~~~
 

source/extensions/omni.isaac.lab/omni/isaac/lab/terrains/config/__init__.py

+# Copyright (c) 2022-2024, The Isaac Lab Project Developers.
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Pre-defined terrain configurations for the terrain generator."""
+
+from .rough import *  # noqa: F401

source/extensions/omni.isaac.lab/omni/isaac/lab/terrains/terrain_generator.py

@@ -22,7 +22,7 @@ from .utils import color_meshes_by_height, find_flat_patches
 
 
 class TerrainGenerator:
-    """Terrain generator to handle different terrain generation functions.
+    r"""Terrain generator to handle different terrain generation functions.
 
     The terrains are represented as meshes. These are obtained either from height fields or by using the
     `trimesh <https://trimsh.org/trimesh.html>`__ library. The height field representation is more
@@ -39,18 +39,41 @@ class TerrainGenerator:
     which contains the common parameters for all terrains.
 
     If a curriculum is used, the terrains are generated based on their difficulty parameter.
-    The difficulty is varied linearly over the number of rows (i.e. along x). If a curriculum
-    is not used, the terrains are generated randomly.
+    The difficulty is varied linearly over the number of rows (i.e. along x) with a small random value
+    added to the difficulty to ensure that the columns with the same sub-terrain type are not exactly
+    the same. The difficulty parameter for a sub-terrain at a given row is calculated as:
 
-    If the :obj:`cfg.flat_patch_sampling` is specified for a sub-terrain, flat patches are sampled
+    .. math::
+
+        \text{difficulty} = \frac{\text{row_id} + \eta}{\text{num_rows}} \times (\text{upper} - \text{lower}) + \text{lower}
+
+    where :math:`\eta\sim\mathcal{U}(0, 1)` is a random perturbation to the difficulty, and
+    :math:`(\text{lower}, \text{upper})` is the range of the difficulty parameter, specified using the
+    :attr:`~TerrainGeneratorCfg.difficulty_range` parameter.
+
+    If a curriculum is not used, the terrains are generated randomly. In this case, the difficulty parameter
+    is randomly sampled from the specified range, given by the :attr:`~TerrainGeneratorCfg.difficulty_range` parameter:
+
+    .. math::
+
+        \text{difficulty} \sim \mathcal{U}(\text{lower}, \text{upper})
+
+    If the :attr:`~TerrainGeneratorCfg.flat_patch_sampling` is specified for a sub-terrain, flat patches are sampled
     on the terrain. These can be used for spawning robots, targets, etc. The sampled patches are stored
     in the :obj:`flat_patches` dictionary. The key specifies the intention of the flat patches and the
     value is a tensor containing the flat patches for each sub-terrain.
 
-    If the flag :obj:`cfg.use_cache` is set to True, the terrains are cached based on their
+    If the flag :attr:`~TerrainGeneratorCfg.use_cache` is set to True, the terrains are cached based on their
     sub-terrain configurations. This means that if the same sub-terrain configuration is used
     multiple times, the terrain is only generated once and then reused. This is useful when
     generating complex sub-terrains that take a long time to generate.
+
+    .. attention::
+
+        The terrain generation has its own seed parameter. This is set using the :attr:`TerrainGeneratorCfg.seed`
+        parameter. If the seed is not set and the caching is disabled, the terrain generation will not be
+        reproducible.
+
     """
 
     terrain_mesh: trimesh.Trimesh
@@ -83,8 +106,7 @@ class TerrainGenerator:
         # store inputs
         self.cfg = cfg
         self.device = device
-        # -- valid patches
-        self.flat_patches = {}
+
         # set common values to all sub-terrains config
         for sub_cfg in self.cfg.sub_terrains.values():
             # size of all terrains
@@ -95,10 +117,20 @@ class TerrainGenerator:
                 sub_cfg.vertical_scale = self.cfg.vertical_scale
                 sub_cfg.slope_threshold = self.cfg.slope_threshold
 
+        # throw a warning if the cache is enabled but the seed is not set
+        if self.cfg.use_cache and self.cfg.seed is None:
+            carb.log_warn(
+                "Cache is enabled but the seed is not set. The terrain generation will not be reproducible."
+                " Please set the seed in the terrain generator configuration to make the generation reproducible."
+            )
+
         # set the seed for reproducibility
-        if self.cfg.seed is not None:
-            torch.manual_seed(self.cfg.seed)
-            np.random.seed(self.cfg.seed)
+        # note: we create a new random number generator to avoid affecting the global state
+        #  in the other places where random numbers are used.
+        self.np_rng = np.random.default_rng(self.cfg.seed)
+
+        # buffer for storing valid patches
+        self.flat_patches = {}
         # create a list of all sub-terrains
         self.terrain_meshes = list()
         self.terrain_origins = np.zeros((self.cfg.num_rows, self.cfg.num_cols, 3))
@@ -120,7 +152,7 @@ class TerrainGenerator:
         if self.cfg.color_scheme == "height":
             self.terrain_mesh = color_meshes_by_height(self.terrain_mesh)
         elif self.cfg.color_scheme == "random":
-            self.terrain_mesh.visual.vertex_colors = np.random.choice(
+            self.terrain_mesh.visual.vertex_colors = self.np_rng.choice(
                 range(256), size=(len(self.terrain_mesh.vertices), 4)
             )
         elif self.cfg.color_scheme == "none":
@@ -140,6 +172,23 @@ class TerrainGenerator:
         for name, value in self.flat_patches.items():
             self.flat_patches[name] = value + terrain_origins_torch
 
+    def __str__(self):
+        """Return a string representation of the terrain generator."""
+        msg = "Terrain Generator:"
+        msg += f"\n\tSeed: {self.cfg.seed}"
+        msg += f"\n\tNumber of rows: {self.cfg.num_rows}"
+        msg += f"\n\tNumber of columns: {self.cfg.num_cols}"
+        msg += f"\n\tSub-terrain size: {self.cfg.size}"
+        msg += f"\n\tSub-terrain types: {list(self.cfg.sub_terrains.keys())}"
+        msg += f"\n\tCurriculum: {self.cfg.curriculum}"
+        msg += f"\n\tDifficulty range: {self.cfg.difficulty_range}"
+        msg += f"\n\tColor scheme: {self.cfg.color_scheme}"
+        msg += f"\n\tUse cache: {self.cfg.use_cache}"
+        if self.cfg.use_cache:
+            msg += f"\n\tCache directory: {self.cfg.cache_dir}"
+
+        return msg
+
     """
     Terrain generator functions.
     """
@@ -157,9 +206,9 @@ class TerrainGenerator:
             # coordinate index of the sub-terrain
             (sub_row, sub_col) = np.unravel_index(index, (self.cfg.num_rows, self.cfg.num_cols))
             # randomly sample terrain index
-            sub_index = np.random.choice(len(proportions), p=proportions)
+            sub_index = self.np_rng.choice(len(proportions), p=proportions)
             # randomly sample difficulty parameter
-            difficulty = np.random.uniform(*self.cfg.difficulty_range)
+            difficulty = self.np_rng.uniform(*self.cfg.difficulty_range)
             # generate terrain
             mesh, origin = self._get_terrain_mesh(difficulty, sub_terrains_cfgs[sub_index])
             # add to sub-terrains
@@ -185,8 +234,13 @@ class TerrainGenerator:
         for sub_col in range(self.cfg.num_cols):
             for sub_row in range(self.cfg.num_rows):
                 # vary the difficulty parameter linearly over the number of rows
+                # note: based on the proportion, multiple columns can have the same sub-terrain type.
+                #  Thus to increase the diversity along the rows, we add a small random value to the difficulty.
+                #  This ensures that the terrains are not exactly the same. For example, if the
+                #  the row index is 2 and the number of rows is 10, the nominal difficulty is 0.2.
+                #  We add a small random value to the difficulty to make it between 0.2 and 0.3.
                 lower, upper = self.cfg.difficulty_range
-                difficulty = (sub_row + np.random.uniform()) / self.cfg.num_rows
+                difficulty = (sub_row + self.np_rng.uniform()) / self.cfg.num_rows
                 difficulty = lower + (upper - lower) * difficulty
                 # generate terrain
                 mesh, origin = self._get_terrain_mesh(difficulty, sub_terrains_cfgs[sub_indices[sub_col]])
@@ -280,6 +334,8 @@ class TerrainGenerator:
         Returns:
             The sub-terrain mesh and origin.
         """
+        # copy the configuration
+        cfg = cfg.copy()
         # add other parameters to the sub-terrain configuration
         cfg.difficulty = float(difficulty)
         cfg.seed = self.cfg.seed
@@ -287,14 +343,14 @@ class TerrainGenerator:
         sub_terrain_hash = dict_to_md5_hash(cfg.to_dict())
         # generate the file name
         sub_terrain_cache_dir = os.path.join(self.cfg.cache_dir, sub_terrain_hash)
-        sub_terrain_stl_filename = os.path.join(sub_terrain_cache_dir, "mesh.stl")
+        sub_terrain_obj_filename = os.path.join(sub_terrain_cache_dir, "mesh.obj")
         sub_terrain_csv_filename = os.path.join(sub_terrain_cache_dir, "origin.csv")
         sub_terrain_meta_filename = os.path.join(sub_terrain_cache_dir, "cfg.yaml")
 
         # check if hash exists - if true, load the mesh and origin and return
-        if self.cfg.use_cache and os.path.exists(sub_terrain_stl_filename):
+        if self.cfg.use_cache and os.path.exists(sub_terrain_obj_filename):
             # load existing mesh
-            mesh = trimesh.load_mesh(sub_terrain_stl_filename)
+            mesh = trimesh.load_mesh(sub_terrain_obj_filename, process=False)
             origin = np.loadtxt(sub_terrain_csv_filename, delimiter=",")
             # return the generated mesh
             return mesh, origin
@@ -314,7 +370,7 @@ class TerrainGenerator:
             # create the cache directory
             os.makedirs(sub_terrain_cache_dir, exist_ok=True)
             # save the data
-            mesh.export(sub_terrain_stl_filename)
+            mesh.export(sub_terrain_obj_filename)
             np.savetxt(sub_terrain_csv_filename, origin, delimiter=",", header="x,y,z")
             dump_yaml(sub_terrain_meta_filename, cfg)
         # return the generated mesh

source/extensions/omni.isaac.lab/omni/isaac/lab/terrains/terrain_generator_cfg.py

@@ -176,7 +176,12 @@ class TerrainGeneratorCfg:
     """
 
     use_cache: bool = False
-    """Whether to load the terrain from cache if it exists. Defaults to True."""
+    """Whether to load the sub-terrain from cache if it exists. Defaults to True.
+
+    If enabled, the generated terrains are stored in the cache directory. When generating terrains, the cache
+    is checked to see if the terrain already exists. If it does, the terrain is loaded from the cache. Otherwise,
+    the terrain is generated and stored in the cache. Caching can be used to speed up terrain generation.
+    """
 
     cache_dir: str = "/tmp/isaaclab/terrains"
     """The directory where the terrain cache is stored. Defaults to "/tmp/isaaclab/terrains"."""

source/extensions/omni.isaac.lab/omni/isaac/lab/terrains/utils.py

@@ -27,6 +27,7 @@ def color_meshes_by_height(meshes: list[trimesh.Trimesh], **kwargs) -> trimesh.T
     Keyword Args:
         color: A list of 3 integers in the range [0,255] representing the RGB
             color of the mesh. Used when the z-coordinates of all vertices are the same.
+            Defaults to [172, 216, 230].
         color_map: The name of the color map to be used. Defaults to "turbo".
 
     Returns:
@@ -39,7 +40,7 @@ def color_meshes_by_height(meshes: list[trimesh.Trimesh], **kwargs) -> trimesh.T
     # Check if the z-coordinates are all the same
     if np.max(heights) == np.min(heights):
         # Obtain a single color: light blue
-        color = kwargs.pop("color", [172, 216, 230, 255])
+        color = kwargs.pop("color", (172, 216, 230))
         color = np.asarray(color, dtype=np.uint8)
         # Set the color for all vertices
         mesh.visual.vertex_colors = color
@@ -140,7 +141,7 @@ def find_flat_patches(
     y_range: tuple[float, float],
     z_range: tuple[float, float],
     max_height_diff: float,
-):
+) -> torch.Tensor:
     """Finds flat patches of given radius in the input mesh.
 
     The function finds flat patches of given radius based on the search space defined by the input ranges.

source/extensions/omni.isaac.lab/omni/isaac/lab/utils/string.py

@@ -96,7 +96,11 @@ def callable_to_string(value: Callable) -> str:
         raise ValueError(f"The input argument is not callable: {value}.")
     # check if lambda function
     if value.__name__ == "<lambda>":
-        return f"lambda {inspect.getsourcelines(value)[0][0].strip().split('lambda')[1].strip().split(',')[0]}"
+        # we resolve the lambda expression by checking the source code and extracting the line with lambda expression
+        # we also remove any comments from the line
+        lambda_line = inspect.getsourcelines(value)[0][0].strip().split("lambda")[1].strip().split(",")[0]
+        lambda_line = re.sub(r"#.*$", "", lambda_line).rstrip()
+        return f"lambda {lambda_line}"
     else:
         # get the module and function name
         module_name = value.__module__

source/extensions/omni.isaac.lab/test/terrains/check_terrain_generator.py

-# Copyright (c) 2022-2024, The Isaac Lab Project Developers.
-# All rights reserved.
-#
-# SPDX-License-Identifier: BSD-3-Clause
-
-"""Launch Isaac Sim Simulator first."""
-
-from omni.isaac.lab.app import AppLauncher
-
-# launch omniverse app
-# note: we only need to do this because of `TerrainImporter` which uses Omniverse functions
-app_launcher = AppLauncher(headless=True)
-simulation_app = app_launcher.app
-
-"""Rest everything follows."""
-
-import os
-import shutil
-
-from omni.isaac.lab.terrains.config.rough import ROUGH_TERRAINS_CFG
-from omni.isaac.lab.terrains.terrain_generator import TerrainGenerator
-
-
-def main():
-    # Create directory to dump results
-    test_dir = os.path.dirname(os.path.abspath(__file__))
-    output_dir = os.path.join(test_dir, "output", "generator")
-    # remove directory
-    if os.path.exists(output_dir):
-        shutil.rmtree(output_dir)
-    # create directory
-    os.makedirs(output_dir, exist_ok=True)
-    # modify the config to cache
-    ROUGH_TERRAINS_CFG.use_cache = True
-    ROUGH_TERRAINS_CFG.cache_dir = output_dir
-    ROUGH_TERRAINS_CFG.curriculum = False
-    # generate terrains
-    terrain_generator = TerrainGenerator(cfg=ROUGH_TERRAINS_CFG)  # noqa: F841
-
-
-if __name__ == "__main__":
-    # run the main function
-    main()
-    # close sim app
-    simulation_app.close()

source/extensions/omni.isaac.lab/test/terrains/test_terrain_generator.py

+# Copyright (c) 2022-2024, The Isaac Lab Project Developers.
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Launch Isaac Sim Simulator first."""
+
+from omni.isaac.lab.app import AppLauncher, run_tests
+
+# launch omniverse app
+simulation_app = AppLauncher(headless=True).app
+
+"""Rest everything follows."""
+
+import numpy as np
+import os
+import shutil
+import torch
+import unittest
+
+from omni.isaac.lab.terrains import FlatPatchSamplingCfg, TerrainGenerator, TerrainGeneratorCfg
+from omni.isaac.lab.terrains.config.rough import ROUGH_TERRAINS_CFG
+
+
+class TestTerrainGenerator(unittest.TestCase):
+    """Test the procedural terrain generator."""
+
+    def setUp(self):
+        # Create directory to dump results
+        test_dir = os.path.dirname(os.path.abspath(__file__))
+        self.output_dir = os.path.join(test_dir, "output", "generator")
+
+    def test_generation(self):
+        """Generates assorted terrains and tests that the resulting mesh has the expected size."""
+        # create terrain generator
+        cfg = ROUGH_TERRAINS_CFG.copy()
+        terrain_generator = TerrainGenerator(cfg=cfg)
+
+        # print terrain generator info
+        print(terrain_generator)
+
+        # get size from mesh bounds
+        bounds = terrain_generator.terrain_mesh.bounds
+        actualSize = abs(bounds[1] - bounds[0])
+        # compute the expected size
+        expectedSizeX = cfg.size[0] * cfg.num_rows + 2 * cfg.border_width
+        expectedSizeY = cfg.size[1] * cfg.num_cols + 2 * cfg.border_width
+
+        # check if the size is as expected
+        self.assertAlmostEqual(actualSize[0], expectedSizeX)
+        self.assertAlmostEqual(actualSize[1], expectedSizeY)
+
+    def test_generation_cache(self):
+        """Generate the terrain and check that caching works.
+
+        When caching is enabled, the terrain should be generated only once and the same terrain should be returned
+        when the terrain generator is created again.
+        """
+        # try out with and without curriculum
+        for curriculum in [True, False]:
+            with self.subTest(curriculum=curriculum):
+                # clear output directory
+                if os.path.exists(self.output_dir):
+                    shutil.rmtree(self.output_dir)
+                # create terrain generator with cache enabled
+                cfg: TerrainGeneratorCfg = ROUGH_TERRAINS_CFG.copy()
+                cfg.use_cache = True
+                cfg.seed = 0
+                cfg.cache_dir = self.output_dir
+                cfg.curriculum = curriculum
+                terrain_generator = TerrainGenerator(cfg=cfg)
+                # keep a copy of the generated terrain mesh
+                terrain_mesh_1 = terrain_generator.terrain_mesh.copy()
+
+                # check cache exists and is equal to the number of terrains
+                # with curriculum, all sub-terrains are uniquely generated
+                hash_ids_1 = set(os.listdir(cfg.cache_dir))
+                self.assertTrue(os.listdir(cfg.cache_dir))
+
+                # set a random seed to disturb the process
+                # this is to ensure that the seed inside the terrain generator makes deterministic results
+                np.random.seed(12456)
+                torch.manual_seed(12456)
+                torch.cuda.manual_seed_all(12456)
+
+                # create terrain generator with cache enabled
+                terrain_generator = TerrainGenerator(cfg=cfg)
+                # keep a copy of the generated terrain mesh
+                terrain_mesh_2 = terrain_generator.terrain_mesh.copy()
+
+                # check no new terrain is generated
+                hash_ids_2 = set(os.listdir(cfg.cache_dir))
+                self.assertEqual(len(hash_ids_1), len(hash_ids_2))
+                self.assertSetEqual(hash_ids_1, hash_ids_2)
+
+                # check if the mesh is the same
+                # check they don't point to the same object
+                self.assertIsNot(terrain_mesh_1, terrain_mesh_2)
+
+                # check if the meshes are equal
+                np.testing.assert_allclose(
+                    terrain_mesh_1.vertices, terrain_mesh_2.vertices, atol=1e-5, err_msg="Vertices are not equal"
+                )
+                np.testing.assert_allclose(
+                    terrain_mesh_1.faces, terrain_mesh_2.faces, atol=1e-5, err_msg="Faces are not equal"
+                )
+
+    def test_terrain_flat_patches(self):
+        """Test the flat patches generation."""
+        # create terrain generator
+        cfg = ROUGH_TERRAINS_CFG.copy()
+        # add flat patch configuration
+        for _, sub_terrain_cfg in cfg.sub_terrains.items():
+            sub_terrain_cfg.flat_patch_sampling = {
+                "root_spawn": FlatPatchSamplingCfg(num_patches=8, patch_radius=0.5, max_height_diff=0.05),
+                "target_spawn": FlatPatchSamplingCfg(num_patches=5, patch_radius=0.35, max_height_diff=0.05),
+            }
+        # generate terrain
+        terrain_generator = TerrainGenerator(cfg=cfg)
+
+        # check if flat patches are generated
+        self.assertTrue(terrain_generator.flat_patches)
+        # check the size of the flat patches
+        self.assertTupleEqual(terrain_generator.flat_patches["root_spawn"].shape, (cfg.num_rows, cfg.num_cols, 8, 3))
+        self.assertTupleEqual(terrain_generator.flat_patches["target_spawn"].shape, (cfg.num_rows, cfg.num_cols, 5, 3))
+        # check that no flat patches are zero
+        for _, flat_patches in terrain_generator.flat_patches.items():
+            self.assertFalse(torch.allclose(flat_patches, torch.zeros_like(flat_patches)))
+
+
+if __name__ == "__main__":
+    run_tests()

source/extensions/omni.isaac.lab/test/terrains/test_terrain_importer.py

@@ -152,17 +152,25 @@ class TestTerrainImporter(unittest.TestCase):
                 self.assertAlmostEqual(actualSize[1], expectedSizeY)
 
     def test_ball_drop(self) -> None:
-        """Generates assorted terrains and spheres. Tests that spheres fall onto terrain and do not pass through it"""
+        """Generates assorted terrains and spheres created as meshes.
+
+        Tests that spheres fall onto terrain and do not pass through it. This ensures that the triangle mesh
+        collision works as expected.
+        """
         for device in ("cuda:0", "cpu"):
             with build_simulation_context(device=device, auto_add_lighting=True) as sim:
+                # Create a scene with rough terrain and balls
                 self._populate_scene(geom_sphere=False, sim=sim)
+
+                # Create a view over all the balls
                 ball_view = RigidPrimView("/World/envs/env_.*/ball", reset_xform_properties=False)
-                sim.reset()
 
+                # Play simulator
+                sim.reset()
                 # Initialize the ball views for physics simulation
                 ball_view.initialize()
 
-                # Play simulator
+                # Run simulator
                 for _ in range(500):
                     sim.step(render=False)
 
@@ -172,17 +180,28 @@ class TestTerrainImporter(unittest.TestCase):
                 self.assertLessEqual(max_velocity_z.item(), 0.5)
 
     def test_ball_drop_geom_sphere(self) -> None:
-        """Generates assorted terrains and geom sepheres. Tests that spheres fall onto terrain and do not pass through it"""
+        """Generates assorted terrains and geom spheres.
+
+        Tests that spheres fall onto terrain and do not pass through it. This ensures that the sphere collision
+        works as expected.
+        """
         for device in ("cuda:0", "cpu"):
             with build_simulation_context(device=device, auto_add_lighting=True) as sim:
+                # Create a scene with rough terrain and balls
+                # TODO: Currently the test fails with geom spheres, need to investigate with the PhysX team.
+                #   Setting the geom_sphere as False to pass the test. This test should be enabled once
+                #   the issue is fixed.
                 self._populate_scene(geom_sphere=False, sim=sim)
+
+                # Create a view over all the balls
                 ball_view = RigidPrimView("/World/envs/env_.*/ball", reset_xform_properties=False)
-                sim.reset()
 
+                # Play simulator
+                sim.reset()
                 # Initialize the ball views for physics simulation
                 ball_view.initialize()
 
-                # Play simulator
+                # Run simulator
                 for _ in range(500):
                     sim.step(render=False)
 

source/extensions/omni.isaac.lab/test/utils/test_configclass.py

@@ -24,7 +24,7 @@ from functools import wraps
 from typing import ClassVar
 
 from omni.isaac.lab.utils.configclass import configclass
-from omni.isaac.lab.utils.dict import class_to_dict, update_class_from_dict
+from omni.isaac.lab.utils.dict import class_to_dict, dict_to_md5_hash, update_class_from_dict
 from omni.isaac.lab.utils.io import dump_yaml, load_yaml
 
 """
@@ -750,6 +750,18 @@ class TestConfigClass(unittest.TestCase):
         self.assertNotEqual(list(cfg.to_dict().keys()), list(cfg_loaded.keys()))
         self.assertDictEqual(cfg.to_dict(), cfg_loaded)
 
+    def test_config_md5_hash(self):
+        """Check that config md5 hash generation works properly."""
+
+        # create config
+        cfg = ChildADemoCfg(a=20, d=3, e=ViewerCfg(), j=["c", "d"])
+
+        # generate md5 hash
+        md5_hash_1 = dict_to_md5_hash(cfg.to_dict())
+        md5_hash_2 = dict_to_md5_hash(cfg.to_dict())
+
+        self.assertEqual(md5_hash_1, md5_hash_2)
+
 
 if __name__ == "__main__":
     run_tests()

source/extensions/omni.isaac.lab/test/utils/test_dict.py

@@ -15,6 +15,7 @@ simulation_app = app_launcher.app
 
 """Rest everything follows."""
 
+import random
 import unittest
 
 import omni.isaac.lab.utils.dict as dict_utils
@@ -77,8 +78,27 @@ class TestDictUtilities(unittest.TestCase):
         # convert string to function
         func_2 = dict_utils.string_to_callable(test_string)
         # check that functions are the same
+        self.assertEqual(test_string, "lambda x: x**2")
         self.assertEqual(func(2), func_2(2))
 
+    def test_dict_to_md5(self):
+        """Test MD5 hash generation for dictionary."""
+        # create a complex nested dictionary
+        test_dict = {
+            "a": 1,
+            "b": 2,
+            "c": {"d": 3, "e": 4, "f": {"g": 5, "h": 6}},
+            "i": random.random(),
+            "k": dict_utils.callable_to_string(dict_utils.class_to_dict),
+        }
+        # generate the MD5 hash
+        md5_hash_1 = dict_utils.dict_to_md5_hash(test_dict)
+
+        # check that the hash is correct even after multiple calls
+        for _ in range(200):
+            md5_hash_2 = dict_utils.dict_to_md5_hash(test_dict)
+            self.assertEqual(md5_hash_1, md5_hash_2)
+
 
 if __name__ == "__main__":
     run_tests()