Quick guide to Quaternions

Introduction

Quaternions are an alternative way of specifying rotations. They do not store redundant information like Euler Angles do, and they require less multiplication operations to combine rotations than rotation matrices. It is also extremely easy to interpolate between two quaternions. Information on quaternions is widely available on the net in different shapes and forms. During my assignment I spent a lot of time researching quaternions and found useful bits and pieces scattered across the web. This guide is an attempt to compile all the material I use now for future reference. Maybe someone will find this useful aswell? Who knows? :)

Conventions

All angles are in radians.
All source code is MATLAB. Remember in MATLAB indices start at 1, not 0.

Definition

Rotation $\theta$ about vector $\v{v}$ in quaternion form is expressed as:

$q=cos(\frac{\theta}{2})+\v{v}\cdot(sin(\frac{\theta}{2}))$

It can be thought of as a complex number with 3 complex parts:

$q=cos(\frac{\theta}{2})+sin(\frac{\theta}{2})i+sin(\frac{\theta}{2})j+sin(\frac{\theta}{2})k$

Multiplying Quaternions

Quaternions are cool because they can represent any rotation in a compact way. Rotations can also be combined using quaternions by multiplying them. Here is how you multiply quaternions. Suppose we call our 4 coefficients $\{q_w, q_x, q_y, q_z\}$ .

Then multiplication is as follows:

$q_r=q_1\times{q_2}$

$q_{r[w]} = q_{1[w]}q_{2[w]} - q_{1[x]}q_{2[x]} - q_{1[y]}q_{2[y]} - q_{2[z]}q_{2[z]}$

$q_{r[x]} = q_{1[w]}q_{2[x]} + q_{1[x]}q_{2[w]} + q_{1[y]}q_{2[z]} - q_{2[z]}q_{2[y]}$

$q_{r[y]} = q_{1[w]}q_{2[y]} - q_{1[x]}q_{2[x]} + q_{1[y]}q_{2[w]} + q_{2[z]}q_{2[x]}$

$q_{r[z]} = q_{1[w]}q_{2[z]} + q_{1[x]}q_{2[y]} - q_{1[y]}q_{2[x]} + q_{2[z]}q_{2[w]}$

Combining quaternions

Successive rotations can then be expressed as follows. Say, we have 3 rotations expressed as quaternions: $q_1$ , $q_2$ , $q_3$ . We can then combine these into a single rotation (rotate by $q_1$ , then by $q_2$ and finally by $q_3$ ) by doing:

$q_3\times{{q_2\times{q_1}}$

More quaternion operations

Some more common quaternion operations.

Conjugate

$q^{-1} = q_w - q_x - q_y - q_z$

Magnitude

$|q| = \sqrt{ q_w^2 + q_x^2 + q_y^2 + q_z^2}$

Normalisation

$q_{normalised} = \frac{q}{|q|}$

Transforming quaternions into other representations

Quaternion to 3x3 Rotation Matrix

$R = \left( \begin{array}{ccc}1 - 2( q_y^2 + q_z^2) & 2( q_{x}q_y - q_{w}q_z ) & 2( q_{w}q_y + q_{x}q_z ) \\2( q_{x}q_y + q_{w}q_z ) & 1 - 2( q_x^2 + q_z^2) & 2( q_{y}q_z - q_{w}q_x ) \\2( q_{x}q_z - q_{w}q_y ) & 2( q_{w}q_x + q_{y}q_z ) & 1 - 2( q_x^2 + q_y^2) \end{array} \right)$

Quaternion to Axis Angle

$\theta = 2acos(q_w)$
$\v{v} =\frac{( q_x,q_y,q_z )}{\sqrt{1-q_w^2}}$

Quaternion to Euler Angles

This transformation depends on your multiplication order. Have a look at my other post for a general implementation. It's based on this paper.

Spherical Interpolation - SLERP

See code

% Interpolate between Q0 and Q1
% Return intermediate quaternion at time t ( parametric value [0,1] )
% R - Intermediate quaternion
function R = slerp( Q0, Q1, t )
 
% cos of half the angle between Q0 and Q1
cosHalfTheta = Q0(1) * Q1(1) + Q0(2) * Q1(2) + Q0(3) * Q1(3) + Q0(4) * Q1(4);
 
if abs( cosHalfTheta ) >= 1
    R = Q0;
    return;
end
 
halfTheta = acos( cosHalfTheta );
 
sinHalfTheta = sqrt( 1 - cosHalfTheta ^ 2 );
 
R = zeros( 1, 4 );
 
% if theta = 180 degrees then result is not fully defined
% we could rotate around any axis normal to qa or qb
if abs( sinHalfTheta ) == 0
    R(1) = Q0(1) * 0.5 + Q1(1) * 0.5;
    R(2) = Q0(2) * 0.5 + Q1(2) * 0.5;
    R(3) = Q0(3) * 0.5 + Q1(3) * 0.5;
    R(4) = Q0(4) * 0.5 + Q1(4) * 0.5;
    return;
end
 
ratioA = sin( (1.0 - t) * halfTheta ) / sinHalfTheta;
ratioB = sin( t * halfTheta ) / sinHalfTheta; 
 
R(1) = Q0(1) * ratioA + Q1(1) * ratioB;
R(2) = Q0(2) * ratioA + Q1(2) * ratioB;
R(3) = Q0(3) * ratioA + Q1(3) * ratioB;
R(4) = Q0(4) * ratioA + Q1(4) * ratioB;
 
end

Approximating SLERP with LERP (Linear Interpolation)

Have a look at "Understanding SLERP and approximating it". It's a very good article, it explains advantages and disadvantages of this method and also shows some ways in which you can improve the method.

See code

function R = approximate_slerp( Q0, Q1, t )
 
% linearly interpolate between Q0 and Q1
 
R = zeros(1, 4);
 
R(1) = Q0(1) + t * ( Q1(1) - Q0(1) );
R(2) = Q0(2) + t * ( Q1(2) - Q0(2) );
R(3) = Q0(3) + t * ( Q1(3) - Q0(3) );
R(4) = Q0(4) + t * ( Q1(4) - Q0(4) );
 
% normalize R
 
m = R .^ 2;
m = sqrt( sum( m ) );
 
R = R ./ m;
 
end

Useful links and additional reading

Wikipedia - Quaternions and spatial rotation
EucledianSpace - Quaternions
Understanding SLERP and approximating it

For those of you who have access to eJournals, here is an interesting paper:
Fast Quaternion SLERP

Снег. Keeps the dream alive.