Skip to main content
Public pose types and convenience constructors.

​
Position Objects

@dataclass
class Position()
3-D position (translation).

​
CompositePose Objects

@dataclass
class CompositePose()
Rotation + position pair.

​
AffinePose Objects

@dataclass
class AffinePose()
4x4 affine transform matrix (16 floats, column-major). The 16 values are stored column-by-column:: Given the matrix: | r00 r01 r02 tx | | r10 r11 r12 ty | | r20 r21 r22 tz | | 0 0 0 1 | Flat order: [r00, r10, r20, 0, r01, r11, r21, 0, r02, r12, r22, 0, tx, ty, tz, 1] The upper-left 3x3 must be a proper rotation matrix (orthogonal, det = 1). The fourth column is translation and the fourth row must be [0, 0, 0, 1]. These constraints are enforced server-side.

​
quaternion_pose

def quaternion_pose(qx: float, qy: float, qz: float, qw: float, x: float,
                    y: float, z: float) -> CompositePose
Create a pose from a unit quaternion rotation and a position. The quaternion must have unit magnitude (server-side validated). See QuaternionRotation for constraints. Arguments:
  • qx - Quaternion x component (in [-1, 1]).
  • qy - Quaternion y component (in [-1, 1]).
  • qz - Quaternion z component (in [-1, 1]).
  • qw - Quaternion w (scalar) component (in [-1, 1]).
  • x - Translation along the world x-axis.
  • y - Translation along the world y-axis.
  • z - Translation along the world z-axis.

​
euler_pose

def euler_pose(rx: float, ry: float, rz: float, x: float, y: float,
               z: float) -> CompositePose
Create a pose from Euler angles (radians) and a position. Rotation order is extrinsic X-Y-Z. See EulerRotation for constraints. Arguments:
  • rx - Rotation around the x-axis in radians.
  • ry - Rotation around the y-axis in radians.
  • rz - Rotation around the z-axis in radians.
  • x - Translation along the world x-axis.
  • y - Translation along the world y-axis.
  • z - Translation along the world z-axis.

​
matrix_pose

def matrix_pose(rotation: Sequence[float], x: float, y: float,
                z: float) -> CompositePose
Create a pose from a 3x3 rotation matrix and a position. See MatrixRotation for constraints (orthogonal, det = 1). Arguments:
  • rotation - Nine floats in column-major order representing a 3x3 rotation matrix.
  • x - Translation along the world x-axis.
  • y - Translation along the world y-axis.
  • z - Translation along the world z-axis.

​
affine_transform

def affine_transform(matrix: Sequence[float]) -> AffinePose
Create a pose from a 4x4 affine transform matrix. See AffinePose for constraints (rotation submatrix must be proper, bottom row [0, 0, 0, 1]). Arguments:
  • matrix - Sixteen floats in column-major order. The fourth row must be [0, 0, 0, 1].

​
identity_pose

def identity_pose() -> CompositePose
Return the identity pose (no rotation, no translation).

​
translation_only

def translation_only(x: float, y: float, z: float) -> CompositePose
Create a pose with translation but no rotation. Arguments:
  • x - Translation along the world x-axis.
  • y - Translation along the world y-axis.
  • z - Translation along the world z-axis.

​
rotation_only

def rotation_only(rotation: Rotation) -> CompositePose
Create a pose with rotation but no translation. Arguments:
  • rotation - Any supported rotation type (quaternion, Euler, or matrix).