vllm_omni.diffusion.models.gr00t.dataio.state_action.pose ¶

Bases: Pose

Represents a single end-effector pose with translation and rotation components.

This class handles Cartesian space representations of robot end-effector poses, supporting multiple rotation representations (quaternions, Euler angles, rotation vectors, rotation matrices, etc.).

Examples:

Create with quaternion (wxyz order)¶

pose = EndEffectorPose( translation=[1.0, 2.0, 3.0], rotation=[1.0, 0.0, 0.0, 0.0], rotation_type="quat", rotation_order="wxyz" )

Create with Euler angles (degrees by default)¶

pose = EndEffectorPose( translation=[1, 2, 3], rotation=[0, 0, 90], rotation_type="euler", rotation_order="xyz" )

Create with Euler angles in radians¶

pose = EndEffectorPose( translation=[1, 2, 3], rotation=[0, 0, np.pi/2], rotation_type="euler", rotation_order="xyz", degrees=False )

Create from homogeneous matrix¶

H = np.eye(4) H[:3, 3] = [1, 2, 3] pose = EndEffectorPose(homogeneous=H)

Convert between representations¶

quat_wxyz = pose.to_rotation("quat", "wxyz") euler_zyx = pose.to_rotation("euler", "zyx") rot6d = pose.to_rotation("rot6d")

Compute relative transformation¶

pose1 = EndEffectorPose(translation=[1, 0, 0], rotation=[1,0,0,0], rotation_type="quat", rotation_order="wxyz") pose2 = EndEffectorPose(translation=[2, 0, 0], rotation=[1,0,0,0], rotation_type="quat", rotation_order="wxyz") relative = pose2 - pose1 # Transformation from pose1's frame to pose2's frame

euler_xyz: ndarray

homogeneous: ndarray

pose_type = 'end_effector'

quat_wxyz: ndarray

quat_xyzw: ndarray

rot6d: ndarray

rotation_matrix: ndarray

rotvec: ndarray

translation: ndarray

xyz_rot6d: ndarray

xyz_rotvec: ndarray

copy() -> EndEffectorPose

from_action_format(
    data: ndarray, action_format: ActionFormat
) -> EndEffectorPose

set_rotation(
    rotation: list | ndarray,
    rotation_type: str,
    rotation_order: str | None = None,
    degrees: bool = True,
)

to_homogeneous() -> ndarray

to_rotation(
    rotation_type: str,
    rotation_order: str | None = None,
    degrees: bool = True,
) -> ndarray

Bases: Enum

Common Euler angle conventions

XYZ = 'xyz'

XZY = 'xzy'

YXZ = 'yxz'

YZX = 'yzx'

ZXY = 'zxy'

ZYX = 'zyx'

Bases: Pose

Represents a robot configuration in joint space.

This class stores joint angles/positions for a robot manipulator. Unlike end-effector poses, joint poses represent the configuration of all joints in the kinematic chain.

Examples:

Create a 6-DOF joint configuration¶

joint_pose = JointPose( joints=[0.0, -np.pi/4, np.pi/2, 0.0, np.pi/4, 0.0], joint_names=["shoulder_pan", "shoulder_lift", "elbow", "wrist_1", "wrist_2", "wrist_3"] )

Create with default joint names¶

joint_pose = JointPose(joints=[0.0, 0.5, 1.0])

Get as dictionary¶

joint_dict = joint_pose.to_dict() # {"joint_0": 0.0, ...}

Access individual joints¶

first_joint = joint_pose.joints[0] num_joints = joint_pose.num_joints

Compute relative joint displacement¶

joint1 = JointPose([0.0, 0.5, 1.0]) joint2 = JointPose([0.1, 0.6, 1.2]) relative = joint2 - joint1 # [0.1, 0.1, 0.2]

joint_names = [
    f"joint_{i}" for i in (range(len(self.joints)))
]

joints = np.array(joints, dtype=np.float64)

num_joints: int

pose_type = 'joint'

copy() -> JointPose

to_dict() -> dict

Abstract base class for robot poses.

This class provides common functionality for different pose representations including relative pose computation via the subtraction operator.

pose_type: str

copy() -> PoseT

Bases: Enum

Quaternion ordering conventions

WXYZ = 'wxyz'

XYZW = 'xyzw'

Bases: Enum

Supported rotation representation types

EULER = 'euler'

MATRIX = 'matrix'

QUAT = 'quat'

ROT6D = 'rot6d'

ROTVEC = 'rotvec'