code/task_e_collection/task_e/collector.py

"""Single-episode demo collection and success checking for Task E."""

import numpy as np
import torch
from isaaclab.envs import ManagerBasedRLEnv
from atec_rl_lab.utils import CartesianController
from atec_rl_lab.tasks.task_e.env_cfg import (
    TABLE_CENTER_X, TABLE_CENTER_Y, TABLE_TOP_Z,
    BASKET_CENTER_X, BASKET_CENTER_Y,
)

from .config import (
    ACTION_SCALE,
    EE_BODY_NAME,
    GRIPPER_OPEN_POS, GRIPPER_CLOSE_POS,
    OBJ_GRIPPER_CLOSE_POS,
    RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z,
    DEFAULT_PLACE_QUAT_W,
    BASKET_IN_X, BASKET_IN_Y,
    OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX, OBJ_SPAWN_Z, OBJ_SPAWN_Y_BANDS,
    OBJ_HALF_EXTENTS, OBJ_BBOX_MARGIN, OBJ_GRASP_CENTER_OFFSETS,
    OBJ_FINGER_CENTER_SERVO_STATES, OBJ_FINGER_CENTER_SERVO_GAIN,
    OBJ_FINGER_CENTER_SERVO_MAX_XY, OBJ_FINGER_CENTER_SERVO_TARGET_Z,
    OBJ_FINGER_CENTER_SERVO_MAX_Z,
    WARMUP_STEPS, SETTLE_STEPS,
)
from .state_machine import PickPlaceStateMachine


def _rerandomize_objects(env: ManagerBasedRLEnv, rng: np.random.Generator) -> None:
    """Place each object randomly with AABB-based overlap rejection."""
    placed: dict[int, tuple[float, float]] = {}  # obj_idx -> (x, y)

    for obj_idx in [1, 2, 3]:
        obj = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"]
        y_min, y_max = OBJ_SPAWN_Y_BANDS[obj_idx]
        hx, hy = OBJ_HALF_EXTENTS[obj_idx]

        x = y = None
        for _ in range(200):
            cx = float(rng.uniform(OBJ_SPAWN_X_MIN, OBJ_SPAWN_X_MAX))
            cy = float(rng.uniform(y_min, y_max))
            # AABB overlap check against all already-placed objects
            ok = all(
                abs(cx - px) >= hx + OBJ_HALF_EXTENTS[pi][0] + OBJ_BBOX_MARGIN or
                abs(cy - py) >= hy + OBJ_HALF_EXTENTS[pi][1] + OBJ_BBOX_MARGIN
                for pi, (px, py) in placed.items()
            )
            if ok:
                x, y = cx, cy
                break

        if x is None:  # fallback: band centre
            x = (OBJ_SPAWN_X_MIN + OBJ_SPAWN_X_MAX) / 2.0
            y = (y_min + y_max) / 2.0

        placed[obj_idx] = (x, y)
        state = obj.data.default_root_state[0:1].clone()
        state[0, 0] = x
        state[0, 1] = y
        state[0, 2] = OBJ_SPAWN_Z
        state[0, 7:] = 0.0   # zero velocities
        obj.write_root_state_to_sim(state)

    env.unwrapped.scene.write_data_to_sim()
    env.unwrapped.sim.forward()


_BASKET_MAX_Z = TABLE_TOP_Z + 0.15  # keep aligned with Task-E reward/termination bounds

def check_objects_in_basket(env: ManagerBasedRLEnv, pick_objects: list[int]) -> bool:
    """Return True only if every picked object is inside the basket region and settled."""
    for obj_idx in pick_objects:
        pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0]
        if (abs(pos[0].item() - BASKET_CENTER_X) > BASKET_IN_X or
                abs(pos[1].item() - BASKET_CENTER_Y) > BASKET_IN_Y or
                pos[2].item() > _BASKET_MAX_Z):
            return False
    return True


def basket_status_lines(env: ManagerBasedRLEnv, pick_objects: list[int]) -> list[str]:
    """Return compact debug lines for picked objects against basket bounds."""
    lines = []
    for obj_idx in pick_objects:
        pos = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"].data.root_pos_w[0]
        dx = pos[0].item() - BASKET_CENTER_X
        dy = pos[1].item() - BASKET_CENTER_Y
        z = pos[2].item()
        inside = abs(dx) <= BASKET_IN_X and abs(dy) <= BASKET_IN_Y and TABLE_TOP_Z <= z <= _BASKET_MAX_Z
        lines.append(
            f"object_{obj_idx}: pos=({pos[0].item():.3f},{pos[1].item():.3f},{z:.3f}) "
            f"d=({dx:+.3f},{dy:+.3f}) inside={inside}"
        )
    return lines


def collect_one_demo(
    env:         ManagerBasedRLEnv,
    robot,
    ik_ctrl:     CartesianController,
    arm_ids:     list[int],
    gripper_ids: list[int],
    pick_objects: list[int],
    device:      str,
    default_jpos: torch.Tensor,
    rng:         np.random.Generator,
    camera=None,
    trace: bool = False,
    abort_failed_lift: bool = False,
) -> dict | None:
    """Run one full episode and return recorded data, or None on early termination.

    Returns a dict with keys:
      qpos    (T, 8)        absolute joint positions
      qvel    (T, 8)        joint velocities
      ee_pos  (T, 3)        end-effector position (world frame)
      ee_quat (T, 4)        end-effector quaternion (w,x,y,z)
      action  (T, 8)        env action = (joint_target - default_jpos) / ACTION_SCALE
      frames  (T, H, W, 3)  RGB uint8 — only present when camera is given
    """
    env.reset()
    robot.write_joint_state_to_sim(
        robot.data.default_joint_pos,
        torch.zeros_like(robot.data.default_joint_vel),
    )

    _rerandomize_objects(env, rng)      # write new object positions to sim + sim.forward()
    default_jpos = robot.data.default_joint_pos.clone()

    ee_home = torch.tensor([[RETRACT_POS_X, RETRACT_POS_Y, CARRY_Z]],
                            dtype=torch.float32, device=device)
    eq_home = torch.tensor([DEFAULT_PLACE_QUAT_W], dtype=torch.float32, device=device)
    g_open  = torch.tensor([GRIPPER_OPEN_POS], dtype=torch.float32, device=device)

    robot.update(dt=env.unwrapped.physics_dt)
    ik_ctrl.reset()

    # Warm-up: drive arm to HOME position (not recorded)
    for _ in range(WARMUP_STEPS):
        _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids,
                 ee_home, eq_home, g_open, default_jpos)

    # Pre-compute grasp quaternions from actual object orientations after reset
    sm = PickPlaceStateMachine(pick_objects, device)
    for obj_idx in pick_objects:
        obj_quat = env.unwrapped.scene.rigid_objects[f"object_{obj_idx}"] \
                       .data.root_state_w[0, 3:7]
        sm.set_grasp_quat(obj_idx, obj_quat)

    # Settle
    for _ in range(SETTLE_STEPS):
        _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids,
                 ee_home, eq_home, g_open, default_jpos)

    ik_ctrl.reset()

    # ---- Recording loop ---- #
    qpos_buf, qvel_buf, ee_pos_buf, ee_quat_buf, action_buf = [], [], [], [], []
    frames_buf = [] if camera is not None else None
    trace_stats: dict[str, dict] | None = {} if trace else None
    ee_body_idx = None
    finger_body_indices: tuple[int, int] | None = None
    ee_body_ids, _ = robot.find_bodies(EE_BODY_NAME)
    if len(ee_body_ids) > 0:
        ee_body_idx = int(ee_body_ids[0])
    link7_ids, _ = robot.find_bodies("link7")
    link8_ids, _ = robot.find_bodies("link8")
    if len(link7_ids) > 0 and len(link8_ids) > 0:
        finger_body_indices = (int(link7_ids[0]), int(link8_ids[0]))

    def _finger_center() -> torch.Tensor | None:
        if finger_body_indices is None:
            return None
        f0 = robot.data.body_pos_w[0, finger_body_indices[0], :3].detach()
        f1 = robot.data.body_pos_w[0, finger_body_indices[1], :3].detach()
        return 0.5 * (f0 + f1)

    def _servo_target_to_fingers(
        state_name: str,
        obj_key: str,
        obj_pos: torch.Tensor,
        ee_pos_des: torch.Tensor,
    ) -> torch.Tensor:
        obj_idx = int(obj_key.rsplit("_", 1)[1])
        if state_name not in OBJ_FINGER_CENTER_SERVO_STATES.get(obj_idx, ()):
            return ee_pos_des
        finger_center = _finger_center()
        if finger_center is None:
            return ee_pos_des
        grasp_offset = torch.tensor(
            OBJ_GRASP_CENTER_OFFSETS.get(obj_idx, (0.0, 0.0, 0.0)),
            dtype=torch.float32,
            device=device,
        )
        grasp_center = obj_pos + grasp_offset if obj_idx == 1 else obj_pos
        xy_error = finger_center[:2] - grasp_center[:2]
        err_norm = torch.linalg.norm(xy_error)
        if err_norm.item() > 0.18:
            return ee_pos_des
        gain = OBJ_FINGER_CENTER_SERVO_GAIN.get(obj_idx, 0.85)
        correction = -xy_error * gain
        max_xy = OBJ_FINGER_CENTER_SERVO_MAX_XY.get(obj_idx, 0.08)
        corr_norm = torch.linalg.norm(correction).clamp(min=1e-6)
        if corr_norm.item() > max_xy:
            correction = correction / corr_norm * max_xy
        ee_pos_des = ee_pos_des.clone()
        ee_pos_des[:2] = ee_pos_des[:2] + correction
        if state_name in ("REACH", "CLOSE") and obj_idx in OBJ_FINGER_CENTER_SERVO_TARGET_Z:
            target_rel_z = OBJ_FINGER_CENTER_SERVO_TARGET_Z[obj_idx]
            z_error = target_rel_z - float((finger_center[2] - obj_pos[2]).item())
            max_z = OBJ_FINGER_CENTER_SERVO_MAX_Z.get(obj_idx, 0.02)
            z_correction = min(0.0, max(-max_z, z_error * gain))
            ee_pos_des[2] = ee_pos_des[2] + z_correction
        return ee_pos_des

    def _update_trace(state_name: str, obj_key: str, obj_pos: torch.Tensor) -> None:
        if trace_stats is None:
            return
        obj_idx = int(obj_key.rsplit("_", 1)[1])
        grasp_offset = torch.tensor(
            OBJ_GRASP_CENTER_OFFSETS.get(obj_idx, (0.0, 0.0, 0.0)),
            dtype=torch.float32,
            device=device,
        )
        grasp_center = obj_pos + grasp_offset if obj_idx == 1 else obj_pos
        if ee_body_idx is not None:
            ee_pos = robot.data.body_pos_w[0, ee_body_idx, :3].detach()
        else:
            ee_pos = ik_ctrl.ee_pos_w[0].detach()
        finger_center_dist = None
        finger_body_gap = None
        if finger_body_indices is not None:
            f0 = robot.data.body_pos_w[0, finger_body_indices[0], :3].detach()
            f1 = robot.data.body_pos_w[0, finger_body_indices[1], :3].detach()
            finger_center = 0.5 * (f0 + f1)
            finger_center_dist = float(torch.linalg.norm(grasp_center - finger_center).item())
            finger_body_gap = float(torch.linalg.norm(f0 - f1).item())
            finger_center_vec = [float(v) for v in (finger_center - grasp_center).detach().cpu().tolist()]
        else:
            finger_center_vec = None
        gripper_jpos = robot.data.joint_pos[0, gripper_ids].detach()
        gripper_gap = abs(float(gripper_jpos[0].item() - gripper_jpos[1].item()))
        ee_dist = float(torch.linalg.norm(obj_pos - ee_pos).item())
        ee_vec = [float(v) for v in (ee_pos - obj_pos).detach().cpu().tolist()]
        obj_pos_cpu = [float(v) for v in obj_pos.detach().cpu().tolist()]
        obj_stats = trace_stats.setdefault(
            obj_key,
            {
                "initial_pos": obj_pos_cpu,
                "final_pos": obj_pos_cpu,
                "max_z": obj_pos_cpu[2],
                "min_ee_dist": ee_dist,
                "min_ee_vec": ee_vec,
                "min_gripper_gap": gripper_gap,
                "min_finger_center_dist": finger_center_dist if finger_center_dist is not None else 999.0,
                "min_finger_center_vec": finger_center_vec if finger_center_vec is not None else None,
                "min_finger_body_gap": finger_body_gap if finger_body_gap is not None else 999.0,
                "states": {},
            },
        )
        obj_stats["final_pos"] = obj_pos_cpu
        obj_stats["max_z"] = max(float(obj_stats["max_z"]), obj_pos_cpu[2])
        if ee_dist < float(obj_stats["min_ee_dist"]):
            obj_stats["min_ee_dist"] = ee_dist
            obj_stats["min_ee_vec"] = ee_vec
        obj_stats["min_gripper_gap"] = min(float(obj_stats["min_gripper_gap"]), gripper_gap)
        if finger_center_dist is not None:
            if finger_center_dist < float(obj_stats["min_finger_center_dist"]):
                obj_stats["min_finger_center_dist"] = finger_center_dist
                obj_stats["min_finger_center_vec"] = finger_center_vec
        if finger_body_gap is not None:
            obj_stats["min_finger_body_gap"] = min(float(obj_stats["min_finger_body_gap"]), finger_body_gap)
        st = obj_stats["states"].setdefault(
            state_name,
            {
                "steps": 0,
                "start_pos": obj_pos_cpu,
                "end_pos": obj_pos_cpu,
                "max_z": obj_pos_cpu[2],
                "min_ee_dist": ee_dist,
                "min_ee_vec": ee_vec,
                "min_gripper_gap": gripper_gap,
                "min_finger_center_dist": finger_center_dist if finger_center_dist is not None else 999.0,
                "min_finger_center_vec": finger_center_vec if finger_center_vec is not None else None,
                "min_finger_body_gap": finger_body_gap if finger_body_gap is not None else 999.0,
            },
        )
        st["steps"] += 1
        st["end_pos"] = obj_pos_cpu
        st["max_z"] = max(float(st["max_z"]), obj_pos_cpu[2])
        if ee_dist < float(st["min_ee_dist"]):
            st["min_ee_dist"] = ee_dist
            st["min_ee_vec"] = ee_vec
        st["min_gripper_gap"] = min(float(st["min_gripper_gap"]), gripper_gap)
        if finger_center_dist is not None:
            if finger_center_dist < float(st["min_finger_center_dist"]):
                st["min_finger_center_dist"] = finger_center_dist
                st["min_finger_center_vec"] = finger_center_vec
        if finger_body_gap is not None:
            st["min_finger_body_gap"] = min(float(st["min_finger_body_gap"]), finger_body_gap)

    def _gripper_target_values(obj_key: str, gripper_cmd: str) -> list[float]:
        if gripper_cmd == "open":
            return GRIPPER_OPEN_POS
        obj_idx = int(obj_key.rsplit("_", 1)[1])
        return OBJ_GRIPPER_CLOSE_POS.get(obj_idx, GRIPPER_CLOSE_POS)

    while not sm.done:
        state_name = sm.state
        obj_key = sm.current_object_key
        obj_pos_w = env.unwrapped.scene.rigid_objects[sm.current_object_key] \
                        .data.root_pos_w[0].clone()
        ee_pos_des, ee_quat_des, gripper_cmd = sm.tick(obj_pos_w)
        ee_pos_des = _servo_target_to_fingers(state_name, obj_key, obj_pos_w, ee_pos_des)

        arm_jpos_des   = ik_ctrl.compute(ee_pos_des.unsqueeze(0), ee_quat_des.unsqueeze(0))
        gripper_vals   = _gripper_target_values(obj_key, gripper_cmd)
        gripper_target = torch.tensor([gripper_vals], dtype=torch.float32, device=device)

        full_target = robot.data.joint_pos.clone()
        full_target[:, arm_ids]     = arm_jpos_des
        full_target[:, gripper_ids] = gripper_target
        env_action = (full_target - default_jpos) / ACTION_SCALE

        # Record BEFORE stepping (obs at time t, action at time t)
        qpos_buf.append(robot.data.joint_pos[0].cpu().numpy())
        qvel_buf.append(robot.data.joint_vel[0].cpu().numpy())
        ee_pos_buf.append(ik_ctrl.ee_pos_w[0].cpu().numpy())
        ee_quat_buf.append(ik_ctrl.ee_quat_w[0].cpu().numpy())
        action_buf.append(env_action[0].cpu().numpy())
        if frames_buf is not None:
            rgba = camera.data.output["rgb"][0].cpu().numpy()
            frames_buf.append(rgba[:, :, :3])

        _update_trace(state_name, obj_key, obj_pos_w)
        _, _, terminated, truncated, _ = env.step(env_action)

        if abort_failed_lift and state_name == "LIFT" and sm.state != "LIFT":
            final_obj_pos = env.unwrapped.scene.rigid_objects[obj_key].data.root_pos_w[0]
            lift_gain = float((final_obj_pos[2] - obj_pos_w[2]).item())
            trace_gain = None
            if trace_stats is not None and obj_key in trace_stats:
                obj_stats = trace_stats[obj_key]
                trace_gain = float(obj_stats["max_z"] - obj_stats["initial_pos"][2])
            effective_gain = max(lift_gain, trace_gain if trace_gain is not None else lift_gain)
            if effective_gain < 0.035:
                print(
                    f"[WARN] {obj_key} failed lift gate "
                    f"(z_gain={effective_gain:.3f}) - aborting attempt."
                )
                return None

        if terminated.any() or truncated.any():
            if check_objects_in_basket(env, pick_objects):
                print("[INFO] Episode ended after basket success; keeping demo.")
                break
            print("[WARN] Episode ended early — skipping demo.")
            return None

    result = {
        "qpos":    np.stack(qpos_buf),
        "qvel":    np.stack(qvel_buf),
        "ee_pos":  np.stack(ee_pos_buf),
        "ee_quat": np.stack(ee_quat_buf),
        "action":  np.stack(action_buf),
    }
    if frames_buf is not None:
        result["frames"] = np.stack(frames_buf)
    if trace_stats is not None:
        for obj_idx in pick_objects:
            obj_key = f"object_{obj_idx}"
            if obj_key not in trace_stats:
                continue
            final_pos = env.unwrapped.scene.rigid_objects[obj_key].data.root_pos_w[0]
            final_pos_cpu = [float(v) for v in final_pos.detach().cpu().tolist()]
            obj_stats = trace_stats[obj_key]
            obj_stats["final_pos"] = final_pos_cpu
            obj_stats["z_gain"] = float(obj_stats["max_z"] - obj_stats["initial_pos"][2])
            obj_stats["lifted"] = bool(obj_stats["z_gain"] >= 0.035)
            obj_stats["reward_lifted"] = bool(obj_stats["max_z"] >= TABLE_TOP_Z + 0.15)
            obj_stats["basket_inside"] = check_objects_in_basket(env, [obj_idx])
        result["trace"] = trace_stats
    return result


# ------------------------------------------------------------------ #
# Internal helper
# ------------------------------------------------------------------ #

def _step_to(env, robot, ik_ctrl, arm_ids, gripper_ids,
             ee_pos, ee_quat, gripper_target, default_jpos):
    """Single IK step toward a target pose (utility used during warm-up/settle)."""
    arm_des = ik_ctrl.compute(ee_pos, ee_quat)
    tgt = robot.data.joint_pos.clone()
    tgt[:, arm_ids]     = arm_des
    tgt[:, gripper_ids] = gripper_target
    env.step((tgt - default_jpos) / ACTION_SCALE)
    robot.update(dt=env.unwrapped.physics_dt)