# Task Conditionals ## Run a demo To run the conditionals test suite: ```bash python examples/test_conditionals.py --headless ``` The test will use the following test scene: Conditionals scene ## Conditionals: See [`robolab/robolab/core/task/conditionals.py`](../robolab/core/task/conditionals.py) for implementation details. ## Frames in spatial conditions Spatial conditions (`object_right_of`, `object_left_of`, `object_in_front_of`, `object_behind`) support different frame of reference modes: - **`frame_of_reference="robot"`** (default): Uses the robot's egocentric perspective - X-axis: robot's forward direction - Y-axis: robot's left direction - **`frame_of_reference="world"`**: Uses global world coordinates The **`mirrored=False`** (default) uses the robot's natural perspective. Set **`mirrored=True`** for a flipped XY perspective, as if viewing the scene from across the robot. Frame of Reference Overlay ## Geometric Containment ### `object_in_container` / `object_inside` / `object_outside_of` / `object_enclosed` — Centroid-in-Convex-Hull Check Containment is checked by transforming the **centroid of the inside-object's convex-hull vertices** into the **container's local frame** and testing it against the container's **convex-hull face planes**. The predicate is fully orientation-invariant — a flipped, tipped, or rotated container is handled correctly because the test happens entirely in the container's own coordinate system. The container's convex hull is built once at scene-load from the prim's mesh points (via `scipy.spatial.ConvexHull`), cached on the `WorldState`, and reused on every per-step evaluation. For "open-top" semantics, the hull's top-facing faces (those with outward normal projecting ≥ 0.7 onto the container's local +z) are dropped, so the polytope is unbounded along the opening direction — an object lifted above the rim still reads as inside. #### Mathematical formulation Let $\mathbf{p}_c, \mathbf{q}_c$ be the container's world position and quaternion, $\mathbf{p}_o, \mathbf{q}_o$ the inside-object's world position and quaternion, $\bar{\mathbf{v}}$ the centroid of the object's hull vertices in the **object's own local frame**, and $\{(\mathbf{n}_i, d_i)\}_{i=1}^F$ the container's hull face planes (outward normal + offset) in the **container's local frame**. The centroid is transformed object-local → world → container-local: ```math \mathbf{x}_w = \mathbf{q}_o \cdot \bar{\mathbf{v}} + \mathbf{p}_o ``` ```math \mathbf{x}_c = \mathbf{q}_c^{-1} \cdot (\mathbf{x}_w - \mathbf{p}_c) ``` The predicate then evaluates a single boolean: ```math \text{inside} \;=\; \max_i \big( \mathbf{n}_i \cdot \mathbf{x}_c + d_i \big) \;\le\; 0 ``` i.e., the centroid satisfies every face's half-space constraint simultaneously. | variant | face set used | semantics | | -------- | -------------- | ----------- | | `object_in_container` / `object_inside` | open-top (top faces dropped, $n_z \ge 0.7$ filter) | true iff the centroid is in the cavity, including the air column above the rim | | `object_outside_of` | open-top (negation of in_opentop_container) | true iff the centroid is outside the cavity / column | | `object_enclosed` | full closed hull | true iff the centroid is fully bounded (all faces, no open top) | #### USD scale handling Mesh points are extracted via the prim's full local-to-world transform (which absorbs any nested `xformOp:scale` and USD `metersPerUnit` conversions), then re-expressed in the prim's rotated frame **without undoing the scale** (`Gf.Matrix4d.RemoveScaleShear()` keeps only translation+rotation when inverting). This keeps the hull dimensions in world meters regardless of how the source USD was authored — a container in cm with `xformOp:scale = 0.01` produces the same hull as one authored directly in meters at scale 1. #### Why centroid (not corners or fraction-of-vertices) A single point at the object's hull centroid is the closest match to human intuition for "in" / "out" and gives clean boolean semantics with no thresholds. Two earlier attempts failed: - **OBB corners:** elongated objects (e.g. a banana whose tips poke over the rim) have all 8 corners *outside* the cavity even when the body is clearly inside. - **Fraction-of-hull-vertices** (e.g. ≥ 50% inside): introduces an asymmetry pathology — a banana with one tip dangling into the bin column lands in a marginal frac ≈ 0.3-0.6 range and fails both "mostly out" and strict "all out" thresholds. The centroid-in-hull test is also ~30× cheaper per step than the per-vertex frac aggregation it replaced (one rotation + one matmul instead of $V$). #### Performance The hull data (vertices, full plane set, open-top plane set, hull centroid) is precomputed once per body in `LocalHull` (see `robolab/core/task/hull_check.py`) and cached on the `WorldState`. Per-step cost on the hot path: one `quat_apply`, one `quat_apply_inverse`, one $(F, 3) \cdot (3,) + (F,)$ matmul-and-max — fully vectorizable across envs. ## Contact Force Cone Detection ### `object_on_top` — Stable Support Detection The `object_on_top` conditional uses physics-based contact force analysis to determine if an object is stably supported on a surface. #### Mathematical Formulation Let $\mathbf{f} = [f_x, f_y, f_z]^\top$ be the contact force from surface $B$ acting on object $A$, expressed in the **world frame** (Z-up). For $A$ to be stably supported on $B$, the force must lie within an **upward cone**: - **Cone axis**: $\hat{n} = [0, 0, 1]^\top$ (upward direction) - **Cone half-angle**: $\theta_{\max}$ (default 45°) **Conditions for stable support:** ```math \begin{aligned} \text{1. Meaningful contact:} \quad & \|\mathbf{f}\| > f_{\min} \\ \text{2. Upward force:} \quad & f_z > 0 \\ \text{3. Within cone:} \quad & f_z \geq \|\mathbf{f}\| \cdot \cos(\theta_{\max}) \end{aligned} ``` The cone constraint (3) can be derived from the dot product: ```math \cos(\theta) = \frac{\mathbf{f} \cdot \hat{n}}{\|\mathbf{f}\|} = \frac{f_z}{\|\mathbf{f}\|} \geq \cos(\theta_{\max}) ``` #### Comparison with Geometric Detection | Function | Method | Use Case | |----------|--------|----------| | `object_on_top` | Contact force cone | Stable resting detection (terminations) | | `object_above` | Bounding box geometry | Position-based checks (lifted above surface) | | `object_in_container` / `object_inside` / `object_outside_of` / `object_enclosed` | Centroid of object's hull verts vs container's convex-hull face planes (orientation-invariant; open-top variant drops top faces so the air column above the rim counts as "in") | Containment detection (terminations, subtasks) | #### Usage ```python # Check if orange is stably resting on plate object_on_top(env, object="orange", reference_object="plate", require_gripper_detached=True) # Geometric check (e.g., for lifted detection) object_above(env, object="orange", reference_object="table", z_margin=0.05) ``` --- ## Details ### Logicals For functions that support logicals, the available logicals are: - `any`: if at least 1 object satisfies the condition - `all`: All objects need to satisfy the condition - `choose`: Given the set of `objects` with size `N`, exactly `K` objects must satisfy the condition. ### Function decorators #### Atomic Functions Base functions; can be used for task `Terminations` as well as `subtasks`. #### Composite Functions These expand into multiple atomic subtasks. These cannot be used for `Terminations`. - `pick_and_place(object, container, logical)`: Picks up objects and places them in a container - Automatically creates the sequence: grab → move above → drop → verify in container - Supports multiple objects with "all" or "any" completion logic