Collision Constraints for Objects (#460)

## Summary
Add NoCollision relation and loss strategy 

## Detailed description
Add NoCollision relation 
Add NoCollisionLossStrategy
Add Isaac Sim NoCollision example
Add GR1 table multi-object NoCollision environment

Author: zhx06

isaaclab_arena/environments/arena_env_builder.py

@@ -26,6 +26,7 @@
 )
 from isaaclab_arena.metrics.recorder_manager_utils import metrics_to_recorder_manager_cfg
 from isaaclab_arena.relations.object_placer import ObjectPlacer
+from isaaclab_arena.relations.relations import IsAnchor, NoCollision
 from isaaclab_arena.tasks.no_task import NoTask
 from isaaclab_arena.utils.configclass import combine_configclass_instances
 from isaaclab_arena.utils.multiprocess import get_local_rank
@@ -67,12 +68,23 @@ def _get_objects_with_relations(self) -> list[Object | ObjectReference]:
                 objects_with_relations.append(asset)
         return objects_with_relations
 
+    def _add_pairwise_no_collision(self, objects_with_relations: list[Object | ObjectReference]) -> None:
+        """Add NoCollision between every pair of non-anchor objects (if not already present)."""
+        non_anchors = [
+            obj for obj in objects_with_relations if not any(isinstance(r, IsAnchor) for r in obj.get_relations())
+        ]
+        for i, obj_a in enumerate(non_anchors):
+            for obj_b in non_anchors[i + 1 :]:
+                has_no_collision = any(isinstance(r, NoCollision) and r.parent is obj_b for r in obj_a.get_relations())
+                if not has_no_collision:
+                    obj_a.add_relation(NoCollision(obj_b))
+
     def _solve_relations(self) -> None:
         """Solve spatial relations for objects in the scene.
 
         This method:
         1. Collects all objects from the scene that have relations
-        2. Finds the anchor object (marked with IsAnchor)
+        2. Adds NoCollision between every pair of non-anchor objects (if not already present)
         3. Runs the ObjectPlacer to solve spatial constraints
         4. Applies solved positions to objects
         """
@@ -83,7 +95,9 @@ def _solve_relations(self) -> None:
             print("No objects with relations found in scene. Skipping relation solving.")
             return
 
-        # Run the ObjectPlacer
+        self._add_pairwise_no_collision(objects_with_relations)
+
+        # Run the ObjectPlacer (default on_relation_z_tolerance_m accommodates solver residual).
         placer = ObjectPlacer()
         result = placer.place(objects=objects_with_relations)
 

isaaclab_arena/evaluation/policy_runner.py

@@ -111,8 +111,8 @@ def rollout_policy(
         raise RuntimeError(f"Error rolling out policy: {e}")
 
     else:
-        # only compute metrics if env has metrics registered
-        if hasattr(env.cfg, "metrics"):
+        # Only compute metrics if env has a non-None metrics list (e.g. NoTask leaves metrics as None).
+        if hasattr(env.cfg, "metrics") and env.cfg.metrics is not None:
             # NOTE(xinjieyao, 2025-10-07): lazy import to prevent app stalling caused by omni.kit
             from isaaclab_arena.metrics.metrics import compute_metrics
 

isaaclab_arena/relations/loss_primitives.py

@@ -122,3 +122,41 @@ def single_point_linear_loss(
         target = torch.tensor(target, dtype=value.dtype, device=value.device)
 
     return slope * torch.abs(value - target)
+
+
+def interval_overlap_axis_loss(
+    child_min: torch.Tensor,
+    child_max: torch.Tensor,
+    parent_min: torch.Tensor | float,
+    parent_max: torch.Tensor | float,
+    slope: float = 1.0,
+) -> torch.Tensor:
+    """ReLU-style interval overlap: zero when separated, slope * overlap length otherwise.
+
+    Used by NoCollisionLossStrategy for per-axis overlap. Intervals [child_min, child_max]
+    and [parent_min, parent_max]; loss is zero when they do not overlap, else
+    slope * overlap_length.
+
+    Args:
+        child_min: Child interval min (tensor for gradient flow).
+        child_max: Child interval max (tensor).
+        parent_min: Parent interval min (tensor or float).
+        parent_max: Parent interval max (tensor or float).
+        slope: Gradient magnitude (default: 1.0).
+
+    Returns:
+        Zero when intervals are separated; otherwise slope * overlap length.
+    """
+    assert isinstance(child_min, torch.Tensor), f"child_min must be a torch.Tensor, got {type(child_min)}"
+    assert isinstance(child_max, torch.Tensor), f"child_max must be a torch.Tensor, got {type(child_max)}"
+    assert torch.all(child_min <= child_max), "child_min must be <= child_max for valid interval [child_min, child_max]"
+    if not isinstance(parent_min, torch.Tensor):
+        parent_min = torch.tensor(parent_min, dtype=child_min.dtype, device=child_min.device)
+    if not isinstance(parent_max, torch.Tensor):
+        parent_max = torch.tensor(parent_max, dtype=child_max.dtype, device=child_max.device)
+    assert torch.all(
+        parent_min <= parent_max
+    ), "parent_min must be <= parent_max for valid interval [parent_min, parent_max]"
+    overlap_high = torch.minimum(child_max, parent_max)
+    overlap_low = torch.maximum(child_min, parent_min)
+    return single_boundary_linear_loss(overlap_high, overlap_low, slope=slope, penalty_side="greater")

isaaclab_arena/relations/object_placer.py

@@ -11,7 +11,7 @@
 from isaaclab_arena.relations.object_placer_params import ObjectPlacerParams
 from isaaclab_arena.relations.placement_result import PlacementResult
 from isaaclab_arena.relations.relation_solver import RelationSolver
-from isaaclab_arena.relations.relations import RandomAroundSolution, RotateAroundSolution, get_anchor_objects
+from isaaclab_arena.relations.relations import On, RandomAroundSolution, RotateAroundSolution, get_anchor_objects
 from isaaclab_arena.utils.bounding_box import AxisAlignedBoundingBox, get_random_pose_within_bounding_box
 from isaaclab_arena.utils.pose import Pose
 
@@ -185,20 +185,51 @@ def _generate_initial_positions(
                 positions[obj] = random_pose.position_xyz
         return positions
 
-    def _validate_placement(
+    def _validate_on_relations(
         self,
         positions: dict[Object | ObjectReference, tuple[float, float, float]],
     ) -> bool:
-        """Validate that no two objects overlap in 3D.
-
-        Checks all object pairs for axis-aligned bounding box overlap.
+        """Validate each On relation; logic matches OnLossStrategy (relation_loss_strategies.py).
 
-        Args:
-            positions: Dictionary mapping objects to their solved (x, y, z) positions.
-
-        Returns:
-            True if no overlaps exist, False otherwise.
+        1. X: child's footprint entirely within parent's X extent.
+        2. Y: child's footprint entirely within parent's Y extent.
+        3. Z: child_bottom in (parent_top, parent_top+clearance_m], within on_relation_z_tolerance_m.
         """
+        for obj in positions:
+            for rel in obj.get_relations():
+                if not isinstance(rel, On):
+                    continue
+                parent = rel.parent
+                if parent not in positions:
+                    continue
+                child_world = obj.get_bounding_box().translated(positions[obj])
+                parent_world = parent.get_bounding_box().translated(positions[parent])
+                # 1 & 2: Same as OnLossStrategy X/Y band (child's footprint within parent).
+                if (
+                    child_world.min_point[0] < parent_world.min_point[0]
+                    or child_world.max_point[0] > parent_world.max_point[0]
+                    or child_world.min_point[1] < parent_world.min_point[1]
+                    or child_world.max_point[1] > parent_world.max_point[1]
+                ):
+                    if self.params.verbose:
+                        print(f"  On relation: '{obj.name}' XY outside parent (retrying)")
+                    return False
+                # 3. Z: same as OnLossStrategy; child_bottom in (parent_top, parent_top+clearance_m], within on_relation_z_tolerance_m.
+                parent_top_z = parent_world.max_point[2]
+                clearance_m = rel.clearance_m
+                child_bottom_z = child_world.min_point[2]
+                eps_z = self.params.on_relation_z_tolerance_m
+                if child_bottom_z <= parent_top_z - eps_z or child_bottom_z > parent_top_z + clearance_m + eps_z:
+                    if self.params.verbose:
+                        print(f"  On relation: '{obj.name}' Z outside band (retrying)")
+                    return False
+        return True
+
+    def _validate_no_overlap(
+        self,
+        positions: dict[Object | ObjectReference, tuple[float, float, float]],
+    ) -> bool:
+        """Check that no two objects overlap in 3D (axis-aligned bbox with margin)."""
         objects = list(positions.keys())
         for i in range(len(objects)):
             for j in range(i + 1, len(objects)):
@@ -211,9 +242,22 @@ def _validate_placement(
                     if self.params.verbose:
                         print(f"  Overlap between '{a.name}' and '{b.name}'")
                     return False
-
         return True
 
+    def _validate_placement(
+        self,
+        positions: dict[Object | ObjectReference, tuple[float, float, float]],
+    ) -> bool:
+        """Validate that no two objects overlap in 3D and On relations are satisfied.
+
+        Args:
+            positions: Dictionary mapping objects to their solved (x, y, z) positions.
+
+        Returns:
+            True if no overlaps exist and On relations hold, False otherwise.
+        """
+        return self._validate_no_overlap(positions) and self._validate_on_relations(positions)
+
     def _apply_positions(
         self,
         positions: dict[Object | ObjectReference, tuple[float, float, float]],

isaaclab_arena/relations/object_placer_params.py

@@ -38,3 +38,7 @@ class ObjectPlacerParams:
     """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."""
+
+    on_relation_z_tolerance_m: float = 5e-3
+    """Tolerance (meters) for On-relation Z validation. Valid Z band is extended to
+    (parent_top - tolerance, parent_top + clearance_m + tolerance]. Default 5e-3 accommodates solver residual."""

isaaclab_arena/relations/relation_loss_strategies.py

@@ -10,14 +10,15 @@
 from typing import TYPE_CHECKING
 
 from isaaclab_arena.relations.loss_primitives import (
+    interval_overlap_axis_loss,
     linear_band_loss,
     single_boundary_linear_loss,
     single_point_linear_loss,
 )
 from isaaclab_arena.utils.bounding_box import AxisAlignedBoundingBox
 
 if TYPE_CHECKING:
-    from isaaclab_arena.relations.relations import AtPosition, NextTo, On, Relation
+    from isaaclab_arena.relations.relations import AtPosition, NextTo, On, Relation, NoCollision
 
 from isaaclab_arena.relations.relations import Side
 
@@ -305,6 +306,84 @@ def compute_loss(
         return relation.relation_loss_weight * total_loss
 
 
+class NoCollisionLossStrategy(RelationLossStrategy):
+    """Loss strategy for NoCollision relations.
+
+    Computes loss based on:
+    1. X overlap: zero when child and parent are separated along X; else overlap length
+    2. Y overlap: zero when separated along Y; else overlap length
+    3. Z overlap: zero when separated along Z; else overlap length
+    4. Volume loss: slope * (overlap_x * overlap_y * overlap_z)
+    """
+
+    def __init__(self, slope: float = 10.0, debug: bool = False):
+        """
+        Args:
+            slope: Gradient magnitude for overlap volume loss (default: 10.0).
+                   Loss scales with slope times overlap volume.
+            debug: If True, print detailed loss component breakdown.
+        """
+        self.slope = slope
+        self.debug = debug
+
+    def compute_loss(
+        self,
+        relation: "NoCollision",
+        child_pos: torch.Tensor,
+        child_bbox: AxisAlignedBoundingBox,
+        parent_world_bbox: AxisAlignedBoundingBox,
+    ) -> torch.Tensor:
+        """Compute loss for NoCollision relation.
+
+        Args:
+            relation: NoCollision relation with relation_loss_weight.
+            child_pos: Child object position tensor (x, y, z) in world coords.
+            child_bbox: Child object local bounding box.
+            parent_world_bbox: Parent bounding box in world coordinates.
+
+        Returns:
+            Weighted loss tensor.
+        """
+        # Parent world extents from the world bounding box, expanded by clearance_m
+        c = relation.clearance_m
+        parent_x_min = parent_world_bbox.min_point[0] - c
+        parent_x_max = parent_world_bbox.max_point[0] + c
+        parent_y_min = parent_world_bbox.min_point[1] - c
+        parent_y_max = parent_world_bbox.max_point[1] + c
+        parent_z_min = parent_world_bbox.min_point[2] - c
+        parent_z_max = parent_world_bbox.max_point[2] + c
+
+        # Child world extents
+        child_world_min = child_pos + torch.tensor(child_bbox.min_point, dtype=child_pos.dtype, device=child_pos.device)
+        child_world_max = child_pos + torch.tensor(child_bbox.max_point, dtype=child_pos.dtype, device=child_pos.device)
+
+        # 1. Per-axis overlap: zero when separated; else overlap length (default slope 1.0 gives length in m)
+        overlap_x = interval_overlap_axis_loss(child_world_min[0], child_world_max[0], parent_x_min, parent_x_max)
+        overlap_y = interval_overlap_axis_loss(child_world_min[1], child_world_max[1], parent_y_min, parent_y_max)
+        overlap_z = interval_overlap_axis_loss(child_world_min[2], child_world_max[2], parent_z_min, parent_z_max)
+
+        # 2. Volume loss: slope * product of per-axis overlap lengths (overlap volume when slope 1.0)
+        overlap_volume = overlap_x * overlap_y * overlap_z
+        total_loss = self.slope * overlap_volume
+
+        if self.debug:
+            print(
+                f"    [NoCollision] X: overlap={overlap_x.item():.6f} (child_x=[{child_world_min[0].item():.4f},"
+                f" {child_world_max[0].item():.4f}], parent_x=[{parent_x_min:.4f}, {parent_x_max:.4f}])"
+            )
+            print(
+                f"    [NoCollision] Y: overlap={overlap_y.item():.6f} (child_y=[{child_world_min[1].item():.4f},"
+                f" {child_world_max[1].item():.4f}], parent_y=[{parent_y_min:.4f}, {parent_y_max:.4f}])"
+            )
+            print(
+                f"    [NoCollision] Z: overlap={overlap_z.item():.6f} (child_z=[{child_world_min[2].item():.4f},"
+                f" {child_world_max[2].item():.4f}], parent_z=[{parent_z_min:.4f}, {parent_z_max:.4f}])"
+            )
+            print(f"    [NoCollision] volume={overlap_volume.item():.6f}, loss={total_loss.item():.6f}")
+
+        return relation.relation_loss_weight * total_loss
+
+
 class AtPositionLossStrategy(UnaryRelationLossStrategy):
     """Loss strategy for AtPosition relations.
 

isaaclab_arena/relations/relation_solver_params.py

@@ -8,18 +8,20 @@
 from isaaclab_arena.relations.relation_loss_strategies import (
     AtPositionLossStrategy,
     NextToLossStrategy,
+    NoCollisionLossStrategy,
     OnLossStrategy,
     RelationLossStrategy,
     UnaryRelationLossStrategy,
 )
-from isaaclab_arena.relations.relations import AtPosition, NextTo, On, RelationBase
+from isaaclab_arena.relations.relations import AtPosition, NextTo, NoCollision, On, RelationBase
 
 
 def _default_strategies() -> dict[type[RelationBase], RelationLossStrategy | UnaryRelationLossStrategy]:
     """Factory for default loss strategies."""
     return {
         NextTo: NextToLossStrategy(slope=10.0),
         On: OnLossStrategy(slope=100.0),
+        NoCollision: NoCollisionLossStrategy(slope=100.0),
         AtPosition: AtPositionLossStrategy(slope=100.0),
     }
 

isaaclab_arena/relations/relations.py

@@ -117,6 +117,33 @@ def __init__(
         self.clearance_m = clearance_m
 
 
+class NoCollision(Relation):
+    """Represents a 'no collision' relationship between two objects.
+
+    This relation specifies that the child and parent bounding boxes must not
+    overlap. Adding NoCollision on one side is enough; the solver counts each
+    unordered pair once.
+
+    Note: Loss computation is handled by NoCollisionLossStrategy in relation_loss_strategies.py.
+    """
+
+    def __init__(
+        self,
+        parent: Object | ObjectReference,
+        relation_loss_weight: float = 1.0,
+        clearance_m: float = 0.01,
+    ):
+        """
+        Args:
+            parent: The other object that this object must not collide with.
+            relation_loss_weight: Weight for the relationship loss function.
+            clearance_m: Minimum clearance between bounding boxes in meters (default: 1cm).
+        """
+        super().__init__(parent, relation_loss_weight)
+        assert clearance_m >= 0.0, f"clearance_m must be non-negative, got {clearance_m}"
+        self.clearance_m = clearance_m
+
+
 class IsAnchor(RelationBase):
     """Marker indicating this object is an anchor for relation solving.