code/task_e_collection/task_e/config.py

"""Task E demo-collection constants.
"""

from atec_rl_lab.tasks.task_e.env_cfg import (
    BASKET_CENTER_X, BASKET_CENTER_Y,
    TABLE_CENTER_X, TABLE_CENTER_Y, TABLE_TOP_Z, TABLE_HALF_X,
    BASKET_EXCL_HALF_X, BASKET_EXCL_HALF_Y,
)

__all__ = [
    "BASKET_CENTER_X", "BASKET_CENTER_Y",
    "TABLE_CENTER_X", "TABLE_CENTER_Y", "TABLE_TOP_Z", "TABLE_HALF_X",
    "BASKET_EXCL_HALF_X", "BASKET_EXCL_HALF_Y",
    # robot
    "EE_BODY_NAME", "ARM_JOINT_NAMES", "GRIPPER_JOINT_NAMES",
    "GRIPPER_OPEN_POS", "GRIPPER_CLOSE_POS", "OBJ_GRIPPER_CLOSE_POS",
    "ACTION_SCALE",
    # state machine
    "STEPS", "STATE_ORDER", "OBJ_STATE_STEP_OVERRIDES",
    # geometry
    "PRE_GRASP_CLEARANCE", "GRASP_Z_OFFSET", "OBJ_GRASP_Z_OFFSETS",
    "OBJ_CLOSE_Z_OFFSETS",
    "OBJ_GRASP_YAW_OFFSETS", "OBJ_CARRY_Z", "OBJ_PLACE_HEIGHTS",
    "OBJ_PLACE_XY_OFFSETS", "OBJ_TRANSPORT_GRIPPER_CMDS",
    "OBJ_KEEP_GRASP_QUAT_STATES", "OBJ_TRANSPORT_PUSH_BIASES",
    "OBJ_MANIPULATION_MODES", "OBJ_PUSH_GRIPPER_CMDS",
    "OBJ_PUSH_APPROACH_CLEARANCE",
    "OBJ_PUSH_X_GAINS", "OBJ_PUSH_MAX_X_CORRECTIONS",
    "OBJ_PUSH_Y_GAINS", "OBJ_PUSH_MAX_Y_CORRECTIONS",
    "OBJ_PUSH_MIN_BEHIND",
    "OBJ_SERVO_TO_BASKET_STATES", "OBJ_SERVO_XY_GAINS", "OBJ_SERVO_MAX_XY",
    "OBJ_SERVO_HOLD_STATES", "OBJ_SERVO_EXTRA_STEPS",
    "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",
    "CARRY_Z", "PLACE_HEIGHT",
    "RETRACT_POS_X", "RETRACT_POS_Y",
    "DEFAULT_PLACE_QUAT_W",
    # success check
    "BASKET_IN_X", "BASKET_IN_Y",
    # spawn regions
    "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",
    # camera
    "CAM_POS", "CAM_ROT", "CAM_H", "CAM_W",
    # actuator
    "ACT_STIFFNESS", "ACT_DAMPING", "ACT_EFFORT_LIMIT", "ACT_VEL_LIMIT",
    # warm-up
    "WARMUP_STEPS", "SETTLE_STEPS",
]

# ------------------------------------------------------------------ #
# Robot
# ------------------------------------------------------------------ #
EE_BODY_NAME        = "gripper_base"
ARM_JOINT_NAMES     = ["joint1", "joint2", "joint3", "joint4", "joint5", "joint6"]
GRIPPER_JOINT_NAMES = ["joint7", "joint8"]
GRIPPER_OPEN_POS    = [0.035, -0.035]   # joint7, joint8
GRIPPER_CLOSE_POS   = [0.0, 0.0]        # joint limits: joint7 >= 0, joint8 <= 0
OBJ_GRIPPER_CLOSE_POS: dict[int, list[float]] = {}

# Must match ActionsCfg: scale=0.5, use_default_offset=True
#   env_action = (joint_target - default_joint_pos) / ACTION_SCALE
ACTION_SCALE = 0.5

# ------------------------------------------------------------------ #
# State-machine
# ------------------------------------------------------------------ #
STEPS: dict[str, int] = {
    "INIT":         100,
    "PRE_GRASP":    220,
    "REACH":        150,
    "CLOSE":         80,
    "LIFT":         170,
    "TRANSPORT":    240,
    "PLACE":         90,
    "OPEN":          70,
    "LIFT_RETRACT":  80,
    "RETRACT":       80,
}
STATE_ORDER = ["INIT", "PRE_GRASP", "REACH", "CLOSE", "LIFT",
               "TRANSPORT", "PLACE", "OPEN", "LIFT_RETRACT", "RETRACT"]
OBJ_STATE_STEP_OVERRIDES: dict[int, dict[str, int]] = {
    1: {
        "TRANSPORT": 2200,
        "PLACE": 300,
    },
    2: {
        "TRANSPORT": 2200,
        "PLACE": 300,
    },
}

# ------------------------------------------------------------------ #
# Geometry
# ------------------------------------------------------------------ #
PRE_GRASP_CLEARANCE = 0.12   # metres above object before descent
GRASP_Z_OFFSET      = 0.09   # metres: gripper approach height above object centre

CARRY_Z      = TABLE_TOP_Z + 0.40   # safe carry height
PLACE_HEIGHT = TABLE_TOP_Z + 0.15   # height at which to release into basket

RETRACT_POS_X = TABLE_CENTER_X + TABLE_HALF_X - 0.05
RETRACT_POS_Y = TABLE_CENTER_Y
DEFAULT_PLACE_QUAT_W = [0.0, 1.0, 0.0, 0.0]   # top-down orientation (w,x,y,z)

# ------------------------------------------------------------------ #
# Object spawn regions
#
#   object_1  Y ∈ [0.25, 0.29]   (top band)
#   object_2  Y ∈ [0.14, 0.20]   (middle band)
#   object_3  Y ∈ [0.03, 0.09]   (bottom band, closest to basket)
# ------------------------------------------------------------------ #
OBJ_SPAWN_X_MIN = TABLE_CENTER_X - 0.10
OBJ_SPAWN_X_MAX = TABLE_CENTER_X + 0.10
OBJ_SPAWN_Z     = TABLE_TOP_Z + 0.05

# Per-object Y-bands: {object_idx: (y_min, y_max)}
OBJ_SPAWN_Y_BANDS = {
    1: (TABLE_CENTER_Y + 0.25, TABLE_CENTER_Y + 0.29),
    2: (TABLE_CENTER_Y + 0.14, TABLE_CENTER_Y + 0.20),
    3: (TABLE_CENTER_Y + 0.03, TABLE_CENTER_Y + 0.09),
}

# Per-object 2-D bounding-box half-extents (metres, world XY plane, scale=1).
# Used for AABB overlap rejection during randomisation.
OBJ_HALF_EXTENTS: dict[int, tuple[float, float]] = {
    1: (0.050, 0.044),   # Sugar box   (half_x, half_y)
    2: (0.050, 0.030),   # Mustard bottle
    3: (0.100, 0.040),   # Banana
}
OBJ_BBOX_MARGIN = 0.015  # extra clearance between object bounding boxes

# The object USD roots are centered on the visible geometry.  Keep the XY target
# on the root/contact point; compensate the Piper TCP primarily in Z through
# OBJ_GRASP_Z_OFFSETS.
OBJ_GRASP_CENTER_OFFSETS: dict[int, tuple[float, float, float]] = {
    1: (0.025, 0.0, 0.0),  # Sugar box: compensate Piper fingertip centre offset
    2: (0.060, 0.0, 0.0),  # Mustard bottle: grasp a narrower side section
    3: (0.0, 0.0, 0.0),  # Banana already works from its root pose
}
OBJ_GRASP_Z_OFFSETS: dict[int, float] = {
    1: 0.072,
    2: 0.135,
    3: GRASP_Z_OFFSET,
}
OBJ_CLOSE_Z_OFFSETS: dict[int, float] = {
    1: 0.020,
}
OBJ_GRASP_YAW_OFFSETS: dict[int, float] = {
    1: 0.0,
    2: 0.0,
    3: 0.0,
}
OBJ_CARRY_Z: dict[int, float] = {
    1: CARRY_Z,
    2: CARRY_Z,
    3: CARRY_Z,
}
OBJ_PLACE_HEIGHTS: dict[int, float] = {
    1: PLACE_HEIGHT,
    2: PLACE_HEIGHT,
    3: PLACE_HEIGHT,
}
OBJ_PLACE_XY_OFFSETS: dict[int, tuple[float, float]] = {
    1: (0.0, 0.0),
    2: (0.0, 0.0),
    3: (0.040, 0.050),
}
OBJ_TRANSPORT_GRIPPER_CMDS: dict[int, str] = {
    1: "close",
    2: "close",
    3: "close",
}
OBJ_KEEP_GRASP_QUAT_STATES: dict[int, tuple[str, ...]] = {
    1: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE", "OPEN"),
    2: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE", "OPEN"),
    3: ("REACH", "CLOSE", "LIFT"),
}
OBJ_TRANSPORT_PUSH_BIASES: dict[int, tuple[float, float, float] | None] = {
    1: None,
    2: None,
    3: None,
}

# Optional manipulation mode used by the candidate search.  "pick" keeps the
# normal top-down grasp.  "push" turns the same state machine into a low,
# table-contact pusher that drives the object centre to the basket.
OBJ_MANIPULATION_MODES: dict[int, str] = {
    1: "pick",
    2: "pick",
    3: "pick",
}
OBJ_PUSH_GRIPPER_CMDS: dict[int, str] = {
    1: "close",
    2: "close",
}
OBJ_PUSH_APPROACH_CLEARANCE: dict[int, float] = {
    1: 0.14,
    2: 0.14,
}
OBJ_PUSH_X_GAINS: dict[int, float] = {
    1: 0.55,
    2: 0.55,
}
OBJ_PUSH_MAX_X_CORRECTIONS: dict[int, float] = {
    1: 0.08,
    2: 0.08,
}
OBJ_PUSH_Y_GAINS: dict[int, float] = {
    1: 0.85,
    2: 0.85,
}
OBJ_PUSH_MAX_Y_CORRECTIONS: dict[int, float] = {
    1: 0.22,
    2: 0.22,
}
OBJ_PUSH_MIN_BEHIND: dict[int, float] = {
    1: 0.035,
    2: 0.030,
}

# For the hard objects, keep the arm target coupled to the measured object
# position during carry/release.  This compensates for Piper gripper_base/TCP
# offsets and small slips: the EE target is nudged in the direction that would
# move the object centre into the basket.
OBJ_SERVO_TO_BASKET_STATES: dict[int, tuple[str, ...]] = {
    1: ("TRANSPORT", "PLACE", "OPEN"),
    2: (),
}
OBJ_SERVO_XY_GAINS: dict[int, float] = {
    1: 0.85,
    2: 0.85,
}
OBJ_SERVO_MAX_XY: dict[int, float] = {
    1: 0.28,
    2: 0.24,
}
OBJ_SERVO_HOLD_STATES: dict[int, tuple[str, ...]] = {
    1: ("PLACE",),
    2: ("PLACE",),
}
OBJ_SERVO_EXTRA_STEPS: dict[int, int] = {
    1: 500,
    2: 500,
}

# Closed-loop correction used during scripted data generation.  The target pose
# is nudged so the measured finger centre stays on the selected object centre,
# which absorbs IK/tracking variation across random object positions.
OBJ_FINGER_CENTER_SERVO_STATES: dict[int, tuple[str, ...]] = {
    1: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE"),
    2: ("REACH", "CLOSE", "LIFT", "TRANSPORT", "PLACE"),
}
OBJ_FINGER_CENTER_SERVO_GAIN: dict[int, float] = {
    1: 1.0,
    2: 1.0,
}
OBJ_FINGER_CENTER_SERVO_MAX_XY: dict[int, float] = {
    1: 0.12,
    2: 0.12,
}
OBJ_FINGER_CENTER_SERVO_TARGET_Z: dict[int, float] = {
    1: -0.025,
}
OBJ_FINGER_CENTER_SERVO_MAX_Z: dict[int, float] = {
    1: 0.050,
}

# ------------------------------------------------------------------ #
# Success / basket bounds
# ------------------------------------------------------------------ #
BASKET_IN_X = 0.20   # ± metres in X around BASKET_CENTER_X
BASKET_IN_Y = 0.11   # ± metres in Y around BASKET_CENTER_Y

# ------------------------------------------------------------------ #
# Camera (for --save_video / --save_images)
# ------------------------------------------------------------------ #
CAM_H, CAM_W = 480, 640
CAM_POS = (TABLE_CENTER_X - 1.2, TABLE_CENTER_Y, TABLE_TOP_Z + 0.8)
CAM_ROT = (0.957, 0.0, 0.290, 0.0)   # ~34° around +Y → looks forward-down

# ------------------------------------------------------------------ #
# Actuator overrides for data collection (high stiffness for fast tracking)
# ------------------------------------------------------------------ #
ACT_STIFFNESS    = 800.0
ACT_DAMPING      = 80.0
ACT_EFFORT_LIMIT = 100.0
ACT_VEL_LIMIT    = 100.0

# ------------------------------------------------------------------ #
# Warm-up / settle steps before recording starts
# ------------------------------------------------------------------ #
WARMUP_STEPS = 150
SETTLE_STEPS = 30