fix the source of inconsistent scene traversal in newton

Author: huidongc

source/isaaclab/isaaclab/cloner/cloner_utils.py

@@ -47,12 +47,15 @@ def clone_from_template(stage: Usd.Stage, num_clones: int, template_clone_cfg: T
         predicate=lambda prim: str(prim.GetPath()).split("/")[-1].startswith(prototype_id),
     )
     if len(prototypes) > 0:
-        prototype_root_set = {"/".join(str(prototype.GetPath()).split("/")[:-1]) for prototype in prototypes}
+        # Sort the prototype roots to ensure consistent order from run to run.
+        prototype_roots = sorted(
+            {"/".join(str(prototype.GetPath()).split("/")[:-1]) for prototype in prototypes}
+        )
         # discover prototypes per root then make a clone plan
         src: list[list[str]] = []
         dest: list[str] = []
 
-        for prototype_root in prototype_root_set:
+        for prototype_root in prototype_roots:
             protos = sim_utils.find_matching_prim_paths(f"{prototype_root}/.*")
             protos = [proto for proto in protos if proto.split("/")[-1].startswith(prototype_id)]
             src.append(protos)

source/isaaclab_newton/isaaclab_newton/renderers/newton_warp_renderer.py

@@ -221,6 +221,7 @@ def render(self, render_data: RenderData):
             depth_image=render_data.outputs.depth_image,
             normal_image=render_data.outputs.normals_image,
             shape_index_image=render_data.outputs.instance_segmentation_image,
+            clear_data=newton.sensors.SensorTiledCamera.ClearData(clear_color=0xFFEEEEEE),
         )
 
     def write_output(self, render_data: RenderData, output_name: str, output_data: torch.Tensor):

source/isaaclab_tasks/test/golden_images/dexsuite_kuka/newton-newton_renderer-rgb.png

@@ -521,15 +521,16 @@ def _validate_camera_outputs(
     golden_image_dir = os.path.join(_GOLDEN_IMAGES_DIRECTORY, test_name)
     os.makedirs(golden_image_dir, exist_ok=True)
 
+    failed_data_types = {}
+
     for data_type, tensor in camera_outputs.items():
         # Replace inf/nan with zero so they do not break comparison; ensure the tensor has at least one non-zero value.
         condition = torch.logical_or(torch.isinf(tensor), torch.isnan(tensor))
         corrected = torch.where(condition, torch.zeros_like(tensor), tensor)
         max_val = corrected.max()
-        assert max_val > 0, (
-            f"[{test_name}] Camera output '{data_type}' has no non-zero pixels. "
-            f"Shape: {corrected.shape}, dtype: {corrected.dtype}."
-        )
+        if max_val <= 0:
+            failed_data_types[data_type] = f"Camera output '{data_type}' has no non-zero pixels."
+            continue
 
         # convert tensors to a tiled image.
         normalized = _normalize_tensor(corrected, data_type)
@@ -543,16 +544,15 @@ def _validate_camera_outputs(
         # first run creates baseline and fails; second run validates.
         golden_path = os.path.join(golden_image_dir, f"{physics_backend}-{renderer}-{data_type}.png")
         if not os.path.exists(golden_path):
+            failed_data_types[data_type] = f"Golden image not found at {golden_path}."
             result_image.save(golden_path)
-            pytest.fail(
-                f"[{test_name}] Golden image not found at {golden_path}. Saved result image to {golden_path}. "
-                "Please run the test again to validate the consistency of rendering outputs."
-            )
+            continue
 
         try:
             golden_image = Image.open(golden_path)
         except Exception as e:
-            pytest.fail(f"Error opening golden image: {e}")
+            failed_data_types[data_type] = f"Error opening golden image: {e}"
+            continue
 
         # validate the consistency of rendering outputs.
         succeeded, error_message, diff_pct, ssim_score = _compare_images(
@@ -579,12 +579,16 @@ def _validate_camera_outputs(
 
         _COMPARISON_SCORES.append(entry)
 
-        assert succeeded, (
-            f"[{test_name}] Camera output does not match the golden image "
-            f"(physics={physics_backend}, renderer={renderer}, data_type={data_type}).\n"
-            f"Mismatch details: {error_message}\n"
-            f"Images were written to {_COMPARISON_IMAGES_DIR}."
-        )
+        if not succeeded:
+            failed_data_types[data_type] = error_message
+
+    if failed_data_types:
+        reason = f"{test_name} (physics={physics_backend}, renderer={renderer}) failed for the following data types:\n"
+        for data_type, error_message in failed_data_types.items():
+            reason += f"- {data_type}: {error_message}\n"
+        reason += f"Comparison images were written to {_COMPARISON_IMAGES_DIR}."
+
+        pytest.fail(reason)
 
 
 def _collect_camera_outputs(env: object) -> dict[str, dict[str, torch.Tensor]]:
@@ -725,10 +729,6 @@ def dexsuite_kuka_allegro_lift_env(request):
 
     physics_backend, renderer, data_type = request.param
 
-    if renderer == "newton_renderer" and data_type == "rgb":
-        # TODO: re-enable the test case once the issue is resolved.
-        pytest.skip("Newton Warp produces inconsistent RGB colors run-to-run; skipping test.")
-
     # Dexsuite data type has explicit resolution suffix (64, 128, 256). We only test 64x64.
     override_args = [f"presets={physics_backend},{renderer},{data_type}64,single_camera,cube"]