ObjectPlacer: reject overlapping placements (#439)

## Summary

`_validate_placement` was a stub that always returned True, so the
solver could converge to solutions where objects overlap

- Implement `_validate_placement` in ObjectPlacer to detect bounding-box
overlaps between placed objects, causing the placer to retry again.

Author: cvolkcvolk

isaaclab_arena/relations/object_placer.py

@@ -103,18 +103,20 @@ def place(
             if self.params.verbose:
                 print(f"Attempt {attempt + 1}/{self.params.max_placement_attempts}: loss = {loss:.6f}")
 
-            # Track best result
-            if loss < best_loss:
-                best_loss = loss
-                best_positions = positions
-
             # Check if placement is valid
             if self._validate_placement(positions):
+                best_loss = loss
+                best_positions = positions
                 success = True
                 if self.params.verbose:
                     print(f"Success on attempt {attempt + 1}")
                 break
 
+            # Track best invalid result as fallback
+            if loss < best_loss:
+                best_loss = loss
+                best_positions = positions
+
         # Apply solved positions to objects
         if self.params.apply_positions_to_objects:
             self._apply_positions(best_positions, anchor_objects_set)
@@ -187,18 +189,29 @@ def _validate_placement(
         self,
         positions: dict[Object | ObjectReference, tuple[float, float, float]],
     ) -> bool:
-        """Validate that the placement is geometrically valid.
+        """Validate that no two objects overlap in 3D.
+
+        Checks all object pairs for axis-aligned bounding box overlap.
 
         Args:
-            positions: Dictionary mapping objects to their positions.
+            positions: Dictionary mapping objects to their solved (x, y, z) positions.
 
         Returns:
-            True if placement is valid, False otherwise.
+            True if no overlaps exist, False otherwise.
         """
-        # TODO(cvolk): Implement geometric checks like:
-        # - Collision detection between objects
-        # - Boundary checks (objects within workspace)
-        print("WARNING: Placement validation not yet implemented. Skipping geometric checks (collision, boundary).")
+        objects = list(positions.keys())
+        for i in range(len(objects)):
+            for j in range(i + 1, len(objects)):
+                a, b = objects[i], objects[j]
+
+                a_world = a.get_bounding_box().translated(positions[a])
+                b_world = b.get_bounding_box().translated(positions[b])
+
+                if a_world.overlaps(b_world, margin=self.params.min_separation_m):
+                    if self.params.verbose:
+                        print(f"  Overlap between '{a.name}' and '{b.name}'")
+                    return False
+
         return True
 
     def _apply_positions(

isaaclab_arena/relations/object_placer_params.py

@@ -33,3 +33,8 @@ class ObjectPlacerParams:
 
     placement_seed: int | None = None
     """Random seed for reproducible placement. If None, uses current RNG state."""
+
+    min_separation_m: float = 0.0
+    """Minimum separation (meters) required between object bounding boxes.
+    Set to 0.0 to only reject actual overlaps. A small positive value (e.g. 0.005)
+    adds a safety margin between objects."""

isaaclab_arena/tests/test_validate_placement.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2025-2026, The Isaac Lab Arena Project Developers (https://github.com/isaac-sim/IsaacLab-Arena/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for ObjectPlacer._validate_placement 3D overlap detection."""
+
+from isaaclab_arena.assets.dummy_object import DummyObject
+from isaaclab_arena.relations.object_placer import ObjectPlacer
+from isaaclab_arena.relations.object_placer_params import ObjectPlacerParams
+from isaaclab_arena.utils.bounding_box import AxisAlignedBoundingBox
+
+
+def _make_box(name: str, size: float = 0.2) -> DummyObject:
+    half = size / 2
+    return DummyObject(
+        name=name,
+        bounding_box=AxisAlignedBoundingBox(min_point=(-half, -half, -half), max_point=(half, half, half)),
+    )
+
+
+def _make_desk() -> DummyObject:
+    return DummyObject(
+        name="desk",
+        bounding_box=AxisAlignedBoundingBox(min_point=(-0.5, -0.5, 0.0), max_point=(0.5, 0.5, 0.05)),
+    )
+
+
+def test_no_overlap_returns_true():
+    """Two boxes far apart should pass validation."""
+    placer = ObjectPlacer(params=ObjectPlacerParams())
+    a = _make_box("a")
+    b = _make_box("b")
+    positions = {a: (0.0, 0.0, 0.0), b: (1.0, 0.0, 0.0)}
+    assert placer._validate_placement(positions) is True
+
+
+def test_overlapping_returns_false():
+    """Two boxes at the same position should fail validation."""
+    placer = ObjectPlacer(params=ObjectPlacerParams())
+    a = _make_box("a")
+    b = _make_box("b")
+    positions = {a: (0.0, 0.0, 0.0), b: (0.0, 0.0, 0.0)}
+    assert placer._validate_placement(positions) is False
+
+
+def test_partial_overlap_returns_false():
+    """Two boxes with partial 3D overlap should fail."""
+    placer = ObjectPlacer(params=ObjectPlacerParams())
+    a = _make_box("a", size=0.2)
+    b = _make_box("b", size=0.2)
+    positions = {a: (0.0, 0.0, 0.0), b: (0.1, 0.1, 0.0)}
+    assert placer._validate_placement(positions) is False
+
+
+def test_separated_in_z_passes():
+    """Two boxes sharing XY footprint but separated in Z should pass."""
+    placer = ObjectPlacer(params=ObjectPlacerParams())
+    a = _make_box("a")
+    b = _make_box("b")
+    positions = {a: (0.0, 0.0, 0.0), b: (0.0, 0.0, 5.0)}
+    assert placer._validate_placement(positions) is True
+
+
+def test_object_on_surface_no_overlap():
+    """A box placed above a desk surface (no 3D overlap) should pass."""
+    placer = ObjectPlacer(params=ObjectPlacerParams())
+    desk = _make_desk()
+    box = _make_box("box", size=0.2)
+    # Desk top at z=0.05; box at z=0.16 → box occupies z=[0.06, 0.26], clear of desk
+    positions = {desk: (0.0, 0.0, 0.0), box: (0.0, 0.0, 0.16)}
+    assert placer._validate_placement(positions) is True
+
+
+def test_colocated_siblings_overlap_rejected():
+    """Two objects at the same position should fail."""
+    placer = ObjectPlacer(params=ObjectPlacerParams())
+    desk = _make_desk()
+    a = _make_box("a", size=0.2)
+    b = _make_box("b", size=0.2)
+    positions = {desk: (0.0, 0.0, 0.0), a: (0.0, 0.0, 0.15), b: (0.0, 0.0, 0.15)}
+    assert placer._validate_placement(positions) is False

isaaclab_arena/utils/bounding_box.py

@@ -154,6 +154,26 @@ def centered(self) -> "AxisAlignedBoundingBox":
             ),
         )
 
+    def overlaps(self, other: "AxisAlignedBoundingBox", margin: float = 0.0) -> bool:
+        """Check if two AABBs overlap in 3D.
+
+        Args:
+            other: The other bounding box to test against.
+            margin: Minimum required separation in meters. A positive value
+                rejects placements where the gap is smaller than margin.
+
+        Returns:
+            True if the volumes overlap (or are closer than margin).
+        """
+        return (
+            self.max_point[0] + margin > other.min_point[0]
+            and other.max_point[0] + margin > self.min_point[0]
+            and self.max_point[1] + margin > other.min_point[1]
+            and other.max_point[1] + margin > self.min_point[1]
+            and self.max_point[2] + margin > other.min_point[2]
+            and other.max_point[2] + margin > self.min_point[2]
+        )
+
     def rotated_90_around_z(self, quarters: int) -> "AxisAlignedBoundingBox":
         """Rotate AABB by quarters * 90° around Z axis.