Euler angles, roll-pitch-yaw, axis-angle and quaternions

A rotation matrix uses nine numbers to describe three degrees of freedom. That is perfect for arithmetic but awkward everywhere else: it wastes bandwidth in messages, it is hard for people to read and type, and it gives no intuitive handle for interpolating smoothly from one orientation to another. Robotics therefore uses several compact representations alongside the matrix. Euler angles and their aerospace cousins roll, pitch and yaw are intuitive but suffer from a singularity called gimbal lock. Axis-angle and its exponential-coordinate form connect rotations to angular velocity. Unit quaternions, four numbers with no singularities, are the standard in ROS, game engines and spacecraft. This lesson explains each, how to convert between them, and when to use which.

Euler angles

Leonhard Euler showed that any orientation can be reached by three successive rotations about coordinate axes, provided no two consecutive axes are the same. There are twelve possible axis sequences: six proper Euler sequences that repeat the first axis, such as Z-Y-Z or Z-X-Z, and six Tait–Bryan sequences that use all three axes, such as Z-Y-X or X-Y-Z. Each sequence can be applied about moving axes (intrinsic) or fixed axes (extrinsic), and an intrinsic sequence equals the extrinsic sequence with the axes in reverse order. With twenty-four conventions in use, the first rule of Euler angles is to never accept three angles without knowing exactly which convention produced them.

The Z-Y-Z convention is common for describing the wrists of industrial arms, because many spherical wrists literally rotate about z, then y, then z. With angles \( (\alpha, \beta, \gamma) \) about moving axes:

Roll, pitch and yaw

The most widely used Tait–Bryan convention in mobile robotics and aviation is roll-pitch-yaw. Roll \( \phi \) is rotation about the forward x-axis, pitch \( \theta \) about the sideways y-axis and yaw \( \psi \) about the vertical z-axis. ROS (REP 103) defines them as rotations about fixed axes applied in the order roll, then pitch, then yaw, which is the same as intrinsic rotations in the order yaw, pitch, roll. Either way the matrix is:

Multiplying out gives a matrix in which the pitch angle appears alone in the bottom-left corner, \( r_{31} = -\sin\theta \), which makes extracting the angles from a matrix straightforward:

The two-argument arctangent atan2(y, x) returns an angle in the correct quadrant over the full range \( (-\pi, \pi] \), unlike the ordinary arctangent of a ratio, which cannot tell (1, 1) from (−1, −1). Always use atan2 when recovering angles in kinematics.

Gimbal lock

Every three-number representation of orientation has at least one singularity, a set of orientations where the parameters stop behaving well. For roll-pitch-yaw it occurs at pitch = ±90°. There \( \cos\theta = 0 \), so \( r_{11} \), \( r_{21} \), \( r_{32} \) and \( r_{33} \) all vanish, and the formulas for roll and yaw become atan2(0, 0), which is undefined. Physically, when the nose points straight up, the roll and yaw axes line up, and only their sum or difference affects the orientation. One degree of freedom is lost, and there are infinitely many angle combinations for the same attitude.

The name comes from mechanical gimbals, nested rings that hold a gyroscope or camera. When the middle ring turns 90°, the inner and outer rings align and the mount can no longer rotate in one direction. The Apollo spacecraft's inertial platform used a three-gimbal design and had to avoid a gimbal-lock zone; the guidance computer warned the crew as it approached. For software, gimbal lock causes sudden jumps in roll and yaw near the singularity and makes rates blow up, since small attitude changes require huge angle changes. For a Z-Y-Z wrist the singularity is at \( \beta = 0 \), where the first and third rotation axes coincide; this is one of the wrist singularities of lesson 11.

Axis-angle and Euler's rotation theorem

Euler also proved that any rotation, however it was produced, is equivalent to a single rotation by some angle \( \theta \) about some fixed unit axis \( \hat{\boldsymbol{\omega}} \). This axis-angle representation is the most physical description of a rotation: it is what you would see if you watched the turn happen at constant speed. Rodrigues' formula converts axis-angle to a rotation matrix:

The matrix \( [\hat{\boldsymbol{\omega}}] \) is the skew-symmetric matrix of the axis, defined so that \( [\mathbf{a}]\mathbf{b} = \mathbf{a} \times \mathbf{b} \). It turns cross products into matrix products, and it reappears in the screw theory of lesson 7 and the Jacobians of lesson 10. Going the other way, the angle comes from the trace of the matrix and the axis from its antisymmetric part:

The axis is undefined at \( \theta = 0 \), where there is no rotation at all, and needs special handling near \( \theta = 180^\circ \), where \( \sin\theta \) vanishes and the axis must be recovered from the diagonal instead. Multiplying the unit axis by the angle gives a single 3-vector, \( \boldsymbol{\omega}\theta \), called the rotation vector or exponential coordinates. Its direction is the axis and its length the angle. It is the representation used by OpenCV for camera poses (rvec) and it connects directly to angular velocity: rotating at constant angular velocity \( \boldsymbol{\omega} \) for one second produces the rotation with exponential coordinates \( \boldsymbol{\omega} \).

Unit quaternions

A quaternion is a four-component number \( q = w + x\,\mathbf{i} + y\,\mathbf{j} + z\,\mathbf{k} \), invented by William Rowan Hamilton in 1843, with multiplication rules \( \mathbf{i}^2 = \mathbf{j}^2 = \mathbf{k}^2 = \mathbf{ijk} = -1 \). Quaternions of length one, unit quaternions, represent rotations neatly. The rotation by angle \( \theta \) about unit axis \( \hat{\boldsymbol{\omega}} \) corresponds to:

Composing two rotations is quaternion multiplication, and rotating a vector \( \mathbf{v} \) is \( q\,\mathbf{v}\,q^{*} \), where \( q^{*} = (w, -x, -y, -z) \) is the conjugate and \( \mathbf{v} \) is treated as a quaternion with zero scalar part. In practice software converts to a matrix for rotating many vectors. Quaternions have big advantages: four numbers instead of nine, no singularities anywhere, cheap composition, easy renormalization (divide by the length) and smooth interpolation by spherical linear interpolation (slerp), which moves at constant angular speed along the shortest arc between two orientations.

They have two quirks. First, \( q \) and \( -q \) represent the same rotation, because rotating by \( \theta \) about \( \hat{\boldsymbol{\omega}} \) is the same as rotating by \( 360^\circ - \theta \) about \( -\hat{\boldsymbol{\omega}} \). This double cover means two quaternions can be numerically far apart while describing nearly the same orientation, so before interpolating or averaging, flip one if their dot product is negative. Second, component order differs between libraries: ROS messages and Eigen's storage use (x, y, z, w), while many textbooks, SciPy's scalar_first option and some engines use (w, x, y, z). Mixing them produces wrong orientations that are hard to spot, because the result is still a valid unit quaternion.

Choosing a representation

In ROS 2, orientation fields in messages such as geometry_msgs/Pose are quaternions; tf2 and the tf_transformations or scipy.spatial.transform libraries convert to and from matrices and Euler angles. Configuration files and user interfaces often expose roll-pitch-yaw because people can visualize it. A good pattern is to accept Euler angles at the human boundary, convert once to a quaternion or matrix, and never convert back unless you need to display a value.

import numpy as np
from math import atan2, asin, degrees, radians, cos, sin
def Rx(t): c, s = cos(t), sin(t); return np.array([[1,0,0],[0,c,-s],[0,s,c]])
def Ry(t): c, s = cos(t), sin(t); return np.array([[c,0,s],[0,1,0],[-s,0,c]])
def Rz(t): c, s = cos(t), sin(t); return np.array([[c,-s,0],[s,c,0],[0,0,1]])
def rpy(R): return [degrees(a) for a in (atan2(R[2,1], R[2,2]), -asin(R[2,0]), atan2(R[1,0], R[0,0]))]
def quat_from_R(R):                    # returns (x, y, z, w), ROS order; assumes w is not tiny
    w = 0.5*np.sqrt(1 + np.trace(R))
    return np.array([(R[2,1]-R[1,2])/(4*w), (R[0,2]-R[2,0])/(4*w), (R[1,0]-R[0,1])/(4*w), w])
R = Rz(radians(30)) @ Ry(radians(20)) @ Rx(radians(10))
print("roll, pitch, yaw =", [round(a, 2) for a in rpy(R)])
print("quaternion xyzw  =", np.round(quat_from_R(R), 4))
# near gimbal lock: two different angle sets, (almost) the same attitude
A = Rz(radians(40)) @ Ry(radians(89.999)) @ Rx(radians(10))
B = Rz(radians(70)) @ Ry(radians(89.999)) @ Rx(radians(40))
print("difference near pitch 90:", f"{np.abs(A - B).max():.1e}")

roll, pitch, yaw = [10.0, 20.0, 30.0]
quaternion xyzw  = [0.0381 0.1893 0.2393 0.9515]
difference near pitch 90: 8.2e-06

The last line shows gimbal lock numerically: yaw 40° with roll 10° and yaw 70° with roll 40° differ by 30° in both angles, yet near pitch 90° they produce matrices that differ only in the fifth decimal place. Only the difference between yaw and roll matters there.

Interpolating orientations

Robots constantly move from one orientation to another: a tool reorienting between waypoints, a camera panning, a drone turning. Interpolating Euler angles component by component produces curved, uneven motion and can swing the long way round. Slerp between quaternions produces the natural motion, a constant-speed rotation about a single fixed axis:

For very small angles, where \( \sin\Omega \) approaches zero, implementations fall back to normalized linear interpolation. Trajectory generators for arms, covered in ROB-350, use slerp or its smooth spline extensions for the orientation part of Cartesian paths.