update change logs

Author: ooctipus

scripts/demos/multi.py

@@ -228,7 +228,9 @@ def run_simulator(sim: SimulationContext, scene: InteractiveScene):
     # Extract scene entities
     # note: we only do this here for readability.
     rigid_object: RigidObject | None = scene["object"] if "object" in scene.keys() else None
-    rigid_object_collection: RigidObjectCollection | None = scene["object_collection"] if "object_collection" in scene.keys() else None
+    rigid_object_collection: RigidObjectCollection | None = (
+        scene["object_collection"] if "object_collection" in scene.keys() else None
+    )
     robot: Articulation | None = scene["robot"] if "robot" in scene.keys() else None
     # Define simulation stepping
     sim_dt = sim.get_physics_dt()

source/isaaclab/config/extension.toml

@@ -1,7 +1,7 @@
 [package]
 
 # Note: Semantic Versioning is used: https://semver.org/
-version = "0.47.7"
+version = "0.48.0"
 
 # Description
 title = "Isaac Lab framework for Robot Learning"

source/isaaclab/docs/CHANGELOG.rst

@@ -1,6 +1,41 @@
 Changelog
 ---------
 
+0.48.0 (2025-11-04)
+~~~~~~~~~~~~~~~~~~~
+
+Changed
+^^^^^^^
+
+* Removed hard dependency on the Isaac Sim Cloner for scene replication. Replication now uses internal utilities
+  :func:`~isaaclab.scene.cloner.usd_replicate` and :func:`~isaaclab.scene.cloner.physx_replicate`, reducing coupling
+  to Isaac Sim. Public APIs in :class:`~isaaclab.scene.interactive_scene.InteractiveScene` remain unchanged; code
+  directly importing the external Cloner should migrate to these utilities.
+
+
+Added
+^^^^^
+
+* Added optional random prototype selection during environment cloning in
+  :class:`~isaaclab.scene.interactive_scene.InteractiveScene` via
+  :attr:`~isaaclab.scene.interactive_scene_cfg.InteractiveSceneCfg.random_heterogenous_cloning`.
+  Defaults to ``True``; round-robin (modulo) mapping remains available by setting it to ``False``.
+
+* Added flexible per-object cloning path in
+  :class:`~isaaclab.scene.interactive_scene.InteractiveScene`: when environments are heterogeneous
+  (different prototypes across envs), replication switches to per-object instead of whole-env cloning.
+  This reduces PhysX cloning time in heterogeneous scenes.  
+
+
+Deprecated
+^^^^^^^^^^
+
+* Deprecated :attr:`~isaaclab.sim.spawners.wrappers.MultiAssetSpawnerCfg.random_choice` and
+  :attr:`~isaaclab.sim.spawners.wrappers.MultiUsdFileCfg.random_choice`. Use
+  :attr:`~isaaclab.scene.interactive_scene_cfg.InteractiveSceneCfg.random_heterogenous_cloning` to control whether
+  assets are selected randomly (``True``) or via round-robin (``False``) across environments.
+
+
 0.47.7 (2025-10-31)
 ~~~~~~~~~~~~~~~~~~~
 

source/isaaclab/isaaclab/scene/cloner.py

@@ -1,7 +1,13 @@
-from pxr import Usd, UsdUtils, Sdf, UsdGeom, PhysxSchema, Gf, Vt
-from omni.physx import get_physx_replicator_interface
-import torch
+# Copyright (c) 2022-2025, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
 import math
+import torch
+
+from omni.physx import get_physx_replicator_interface
+from pxr import Gf, PhysxSchema, Sdf, Usd, UsdGeom, UsdUtils, Vt
 
 
 def usd_replicate(
@@ -86,10 +92,10 @@ def dp_depth(template: str) -> int:
 
 def physx_replicate(
     stage: Usd.Stage,
-    sources: list[str],            # e.g. ["/World/Template/A", "/World/Template/B"]
-    destinations: list[str],       # e.g. ["/World/envs/env_{}/Robot", "/World/envs/env_{}/Object"]
-    env_ids: torch.Tensor,         # env_ids
-    mapping: torch.Tensor,         # (num_sources, num_envs) bool; True -> place sources[i] into world=j
+    sources: list[str],  # e.g. ["/World/Template/A", "/World/Template/B"]
+    destinations: list[str],  # e.g. ["/World/envs/env_{}/Robot", "/World/envs/env_{}/Object"]
+    env_ids: torch.Tensor,  # env_ids
+    mapping: torch.Tensor,  # (num_sources, num_envs) bool; True -> place sources[i] into world=j
     use_fabric: bool = False,
 ) -> None:
     """Replicate prims via PhysX replicator with per-row mapping.
@@ -127,7 +133,13 @@ def attach_end_fn(_stage_id: int):
         for i, src in enumerate(sources):
             current_worlds[:] = env_ids[mapping[i]].tolist()
             current_template = destinations[i]
-            rep.replicate(_stage_id, src, len(current_worlds), useEnvIds=len(current_worlds) == num_envs, useFabricForReplication=use_fabric)
+            rep.replicate(
+                _stage_id,
+                src,
+                len(current_worlds),
+                useEnvIds=len(current_worlds) == num_envs,
+                useFabricForReplication=use_fabric,
+            )
         # unregister only AFTER all replicate() calls completed
         rep.unregister_replicator(_stage_id)
 
@@ -139,7 +151,7 @@ def filter_collisions(
     physicsscene_path: str,
     collision_root_path: str,
     prim_paths: list[str],
-    global_paths: list[str] = []
+    global_paths: list[str] = [],
 ) -> None:
     """Create inverted collision groups for clones.
 
@@ -165,7 +177,7 @@ def filter_collisions(
 
     # Make sure we create the collision_scope in the RootLayer since the edit target may be a live layer in the case of Live Sync.
     with Usd.EditContext(stage, Usd.EditTarget(stage.GetRootLayer())):
-        collision_scope = UsdGeom.Scope.Define(stage, collision_root_path)
+        UsdGeom.Scope.Define(stage, collision_root_path)
 
     with Sdf.ChangeBlock():
         if len(global_paths) > 0:
@@ -178,9 +190,7 @@ def filter_collisions(
                 "PhysicsCollisionGroup",
             )
             # prepend collision API schema
-            global_collision_group.SetInfo(
-                Usd.Tokens.apiSchemas, Sdf.TokenListOp.Create({"CollectionAPI:colliders"})
-            )
+            global_collision_group.SetInfo(Usd.Tokens.apiSchemas, Sdf.TokenListOp.Create({"CollectionAPI:colliders"}))
 
             # expansion rule
             expansion_rule = Sdf.AttributeSpec(

source/isaaclab/isaaclab/scene/interactive_scene.py

@@ -10,7 +10,7 @@
 import omni.log
 from isaacsim.core.prims import XFormPrim
 from isaacsim.core.utils.stage import get_current_stage
-from pxr import Sdf, PhysxSchema
+from pxr import PhysxSchema, Sdf
 
 import isaaclab.sim as sim_utils
 from isaaclab.assets import (
@@ -31,7 +31,7 @@
 from isaaclab.sim.utils import get_current_stage_id
 from isaaclab.terrains import TerrainImporter, TerrainImporterCfg
 
-from .cloner import physx_replicate, filter_collisions, usd_replicate, grid_transforms
+from .cloner import filter_collisions, grid_transforms, physx_replicate, usd_replicate
 from .interactive_scene_cfg import InteractiveSceneCfg
 
 
@@ -145,16 +145,18 @@ def __init__(self, cfg: InteractiveSceneCfg):
             prim.CreateAttribute("physxScene:envIdInBoundsBitCount", Sdf.ValueTypeNames.Int).Set(4)
         self._default_env_origins, _ = grid_transforms(self.cfg.num_envs, self.cfg.env_spacing, device=self.device)
         # copy empty prim of env_0 to env_1, env_2, ..., env_{num_envs-1} with correct location.
-        usd_replicate(self.stage, [self.env_fmt.format(0)], [self.env_fmt], self._ALL_INDICES, positions=self._default_env_origins)
+        usd_replicate(
+            self.stage, [self.env_fmt.format(0)], [self.env_fmt], self._ALL_INDICES, positions=self._default_env_origins
+        )
 
         self._global_prim_paths = list()
         if self._is_scene_setup_from_cfg():
             clone_plan = {"src": [], "dest": [], "mapping": torch.empty((0,), dtype=torch.bool).to(self.device)}
             self._global_template_prim_paths = list()  # store paths that are in global collision filter from templates
             self._add_entities_from_cfg()
             for prim_path in self._global_template_prim_paths:
-                i = clone_plan['src'].index(prim_path)
-                self._global_prim_paths.extend(sim_utils.find_matching_prim_paths(clone_plan['dest'][i].format(".*")))
+                i = clone_plan["src"].index(prim_path)
+                self._global_prim_paths.extend(sim_utils.find_matching_prim_paths(clone_plan["dest"][i].format(".*")))
 
             self.clone_environments()
 
@@ -173,9 +175,9 @@ def clone_environments(self, copy_from_source: bool = False):
             clone_plan = {"src": [], "dest": [], "mapping": torch.empty((0,), dtype=torch.bool).to(self.device)}
             prototypes = sim_utils.get_all_matching_child_prims(
                 self.template_path,
-                predicate=lambda prim: str(prim.GetPath()).split("/")[-1].startswith(self.prototype_name)
+                predicate=lambda prim: str(prim.GetPath()).split("/")[-1].startswith(self.prototype_name),
             )
-            prototype_root_set = set(["/".join(str(prototype.GetPath()).split("/")[:-1]) for prototype in prototypes])
+            prototype_root_set = {"/".join(str(prototype.GetPath()).split("/")[:-1]) for prototype in prototypes}
             for prototype_root in prototype_root_set:
                 protos = sim_utils.find_matching_prim_paths(f"{prototype_root}/.*")
                 protos = [proto for proto in protos if proto.split("/")[-1].startswith(self.prototype_name)]
@@ -187,22 +189,22 @@ def clone_environments(self, copy_from_source: bool = False):
                 else:
                     m[self._ALL_INDICES % len(protos), self._ALL_INDICES] = True
 
-                clone_plan['src'].extend(protos)
-                clone_plan['dest'].extend([prototype_root.replace(self.template_path, self.env_fmt)] * len(protos))
-                clone_plan['mapping'] = torch.cat((clone_plan['mapping'].reshape(-1, m.size(1)), m), dim=0)
+                clone_plan["src"].extend(protos)
+                clone_plan["dest"].extend([prototype_root.replace(self.template_path, self.env_fmt)] * len(protos))
+                clone_plan["mapping"] = torch.cat((clone_plan["mapping"].reshape(-1, m.size(1)), m), dim=0)
 
-            proto_idx = clone_plan['mapping'].to(torch.int32).argmax(dim=1)
-            proto_mask = torch.zeros_like(clone_plan['mapping'])
-            proto_mask.scatter_(1, proto_idx.view(-1, 1).to(torch.long), clone_plan['mapping'].any(dim=1, keepdim=True))
-            usd_replicate(self.stage, clone_plan['src'], clone_plan['dest'], self._ALL_INDICES, proto_mask)
+            proto_idx = clone_plan["mapping"].to(torch.int32).argmax(dim=1)
+            proto_mask = torch.zeros_like(clone_plan["mapping"])
+            proto_mask.scatter_(1, proto_idx.view(-1, 1).to(torch.long), clone_plan["mapping"].any(dim=1, keepdim=True))
+            usd_replicate(self.stage, clone_plan["src"], clone_plan["dest"], self._ALL_INDICES, proto_mask)
             self.stage.GetPrimAtPath(self.template_path).SetActive(False)
 
             # If all prototypes map to env_0, clone whole env_0 to all envs; else clone per-object
             if torch.all(proto_idx == 0):
-                replicate_args = [self.env_fmt.format(0)], [self.env_fmt], self._ALL_INDICES, clone_plan['mapping']
+                replicate_args = [self.env_fmt.format(0)], [self.env_fmt], self._ALL_INDICES, clone_plan["mapping"]
             else:
-                src = [tpl.format(int(idx)) for tpl, idx in zip(clone_plan['dest'], proto_idx.tolist())]
-                replicate_args = src, clone_plan['dest'], self._ALL_INDICES, clone_plan['mapping']
+                src = [tpl.format(int(idx)) for tpl, idx in zip(clone_plan["dest"], proto_idx.tolist())]
+                replicate_args = src, clone_plan["dest"], self._ALL_INDICES, clone_plan["mapping"]
         else:
             mapping = torch.ones((1, self.num_envs), device=self.device, dtype=torch.bool)
             replicate_args = [self.env_fmt.format(0)], [self.env_fmt], self._ALL_INDICES, mapping
@@ -677,7 +679,7 @@ def _add_entities_from_cfg(self):
                 # prepared /World/template path, once all template is ready, cloner can determine what rules to follow
                 # to combine, and distribute the templates to cloned environments.
                 destinations_regex_ns = asset_cfg.prim_path.format(ENV_REGEX_NS=self.env_regex_ns)
-                if (self.env_regex_ns[:-2] in destinations_regex_ns):
+                if self.env_regex_ns[:-2] in destinations_regex_ns:
                     require_clone = True
                     prototype_root = asset_cfg.prim_path.format(ENV_REGEX_NS=self.template_path)
                     asset_cfg.prim_path = f"{prototype_root}/{self.prototype_name}_.*"

source/isaaclab/isaaclab/sensors/camera/camera.py

@@ -7,7 +7,6 @@
 
 import json
 import numpy as np
-import re
 import torch
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, Any, Literal

source/isaaclab/isaaclab/sim/spawners/wrappers/wrappers.py

@@ -5,13 +5,9 @@
 
 from __future__ import annotations
 
-import re
-import torch
 from typing import TYPE_CHECKING
 
 import isaacsim.core.utils.prims as prim_utils
-import isaacsim.core.utils.stage as stage_utils
-from isaacsim.core.utils.stage import get_current_stage
 from pxr import Usd
 
 from isaaclab.sim.spawners.from_files import UsdFileCfg

source/isaaclab/isaaclab/sim/spawners/wrappers/wrappers_cfg.py

@@ -39,6 +39,11 @@ class MultiAssetSpawnerCfg(RigidObjectSpawnerCfg, DeformableObjectSpawnerCfg):
 
     If False, the asset configurations are spawned in the order they are provided in the list.
     If True, a random asset configuration is selected for each spawn.
+
+    .. warning::
+
+        This attribute is deprecated. Use
+        :attr:`~isaaclab.scene.interactive_scene_cfg.InteractiveSceneCfg.random_heterogenous_cloning` instead.
     """
 
 
@@ -64,8 +69,9 @@ class MultiUsdFileCfg(UsdFileCfg):
 
     If False, the asset configurations are spawned in the order they are provided in the list.
     If True, a random asset configuration is selected for each spawn.
+
     .. warning::
 
-        This attribute is deprecated. Use :attr:`~isaaclab.scene.InteractiveSceneCfg.random_heterogenous_spawning`
-        instead.
+        This attribute is deprecated. Use
+        :attr:`~isaaclab.scene.interactive_scene_cfg.InteractiveSceneCfg.random_heterogenous_cloning` instead.
     """

source/isaaclab/isaaclab/sim/utils.py

@@ -11,7 +11,6 @@
 import functools
 import inspect
 import re
-import torch
 from collections.abc import Callable, Generator
 from typing import TYPE_CHECKING, Any