Quaternions Without the Fear

Let's get this out of the way: quaternions are weird. They're 4D numbers that somehow represent 3D rotations. They obey strange multiplication rules. And they're everywhere in robotics.

But here's the good news: you don't need to understand the deep math to use them effectively. You just need to know what they solve, how to use them, and when they matter.

The Problem: Gimbal Lock

We've been representing rotations with three angles: roll, pitch, yaw (also called Euler angles). This seems intuitive — "rotate 30° left, tilt 20° down."

But there's a fatal flaw. Consider a camera:

1. Start pointing forward
2. Tilt 90° up (now pointing at the sky)
3. Try to "turn left"

What happens? Nothing. You've lost a degree of freedom. Roll and yaw become the same rotation. This is called gimbal lock — two rotation axes collapse into one.

Here's the intuition: Euler angles apply rotations in a specific order (e.g., yaw → pitch → roll). Each rotation changes the meaning of the next axis. At certain angles (like 90° pitch), two axes align and you lose control.

The Solution: Quaternions

Quaternions represent rotations in a way that:

• Never has gimbal lock — all orientations are equally valid
• Interpolates smoothly — blending between rotations is natural
• Composes efficiently — multiplying quaternions is faster than matrix multiplication
• Uses less memory — 4 numbers instead of 9 (for a 3×3 rotation matrix)

The trade-off: they're less intuitive. You can't look at a quaternion and instantly visualize the rotation.

What Is a Quaternion?

A quaternion has four components: (w, x, y, z)

• w is the "scalar part" (cosine of half the rotation angle)
• x, y, z form the "vector part" (axis of rotation, scaled by sine of half the angle)

The formula:

q = (cos(θ/2), sin(θ/2) * axis)

Where θ is the rotation angle and axis is a unit vector (e.g., [0, 0, 1] for Z-axis).

Example: 90° rotation around Z-axis

θ = 90° = π/2 radians
axis = [0, 0, 1]

w = cos(π/4) = 0.707
x = sin(π/4) * 0 = 0
y = sin(π/4) * 0 = 0
z = sin(π/4) * 1 = 0.707

q = (0.707, 0, 0, 0.707)

Using Quaternions Practically

You almost never construct quaternions by hand. Instead:

1. Convert from Euler angles or axis-angle

2. Multiply to compose rotations

3. Interpolate smoothly (SLERP)

This is where quaternions shine. To smoothly rotate from orientation A to orientation B, you use SLERP (Spherical Linear Interpolation).

Why is SLERP better than linearly interpolating Euler angles? Because it takes the shortest path on the rotation sphere and maintains constant angular velocity. Interpolating Euler angles can cause weird intermediate rotations.

Quaternion Properties

A few things to know:

1. Unit quaternions represent rotations

Only quaternions where w² + x² + y² + z² = 1 represent valid rotations. Always normalize after math operations.

2. Opposite quaternions are the same rotation

(w, x, y, z) and (-w, -x, -y, -z) represent the same rotation. This is normal — just pick one.

3. Identity rotation

The "no rotation" quaternion is (1, 0, 0, 0) or (0, 0, 0, 1) depending on convention.

4. Inverse rotation

To reverse a rotation, conjugate the quaternion: q_inverse = (w, -x, -y, -z)

When Quaternions Matter

You'll encounter quaternions in:

What's Next?

You've learned how to represent and transform between coordinate frames. But robots don't stand still — transforms change as the robot moves. In the next lesson, we'll cover time-varying transforms and how to handle measurements from different moments in time.