2. SO(3): 3D Rotations#

The group of all rotations in the 3D Cartesian space is called $S O (3)$ (SO: special orthogonal group). It is typically represented by 3D rotation matrices [7]. The minimum number of components that are required to describe any rotation from $S O (3)$ is 3. However, there is no representation that is non-redundant, continuous, and free of singularities.

Not all representations support all operations directly without conversion to another representation. The following table is an overview. If the operation is not implemented in pytransform3d then it is shown in brackets.

Representation	Inverse	Rotation of vector	Concatenation	Interpolation	Renormalization
Rotation matrix $R R$	Transpose	Yes	Yes	SLERP	Required
Axis-angle $(\hat{ω ω}, θ)$	Negative axis	No	No	SLERP	Not necessary
Rotation vector $ω ω$	Negative	No	No	SLERP / (2) / (3)	Not required
Logarithm of rotation $[ω ω]$	Negative	No	No	SLERP / (2) / (3)	Not required
Quaternion $q q$	Conjugate	Yes	Yes	SLERP	Required
Rotor $R$	Reverse	Yes	Yes	SLERP	Required
Euler angles $(α, β, γ)$	(1)	No	No	No	Not necessary
Modified Rodrigues parameters $ψ ψ$	Negative	No	Yes	No	Not required

Footnotes:

SLERP means Spherical Linear intERPolation. This can either be implemented directly for two instances of the representation or sometimes involves a conversion to a rotation vector that represents the difference of the two orientations.

(1) Inversion of Euler angles in convention ABC (e.g., xyz) requires using another convention CBA (e.g., zyx), reversing the order of angles, and taking the negative of these.

(2) Linear interpolation is approximately correct for small differences.

(3) Fractions of this representation represent partial rotations, but a conversion to another representation is required to interpolate between orientations.

2.1. Rotation Matrix#

One of the most practical representations of orientation is a rotation matrix

\begin{array}{r} R = (\begin{array}{ccc} r_{11} & r_{12} & r_{13} \\ r_{21} & r_{22} & r_{23} \\ r_{31} & r_{32} & r_{33} \end{array}) \in S O (3) . \end{array}

Note that this is a non-minimal representation for orientations because we have 9 values but only 3 degrees of freedom. This is because $R$ is orthonormal, which results in 6 constraints (enforced with norm_matrix() and checked with matrix_requires_renormalization() or check_matrix()):

column vectors must have unit norm (3 constraints)
and must be orthogonal to each other (3 constraints)

A more compact representation of these constraints is $R^{T} R = I \Leftrightarrow R^{T} = R^{- 1}$ .

In addition, $det (R) = 1$ because we use right-handed coordinate system ( $det (R) = - 1$ for left-handed coordinate systems).

Hence, the group $S O (3)$ is defined as

S O (3) = {R \in R^{3 \times 3} | R R^{T} = I, det (R) = 1} .

pytransform3d uses a numpy array of shape (3, 3) to represent rotation matrices and typically we use the variable name R for a rotation matrix.

Warning

There are two conventions on how to interpret rotations: active or passive rotation. The standard in pytransform3d is an active rotation.

We can use a rotation matrix $R_{B A}$ to transform a point $_{A} p$ from frame $A$ to frame $B$ .

Warning

There are two different conventions on how to use rotation matrices to apply a rotation to a vector. We can either (pre-)multiply the rotation matrix to a column vector from the left side or we can (post-)multiply it to a row vector from the right side. We will use the pre-multiplication convention.

This means that we rotate a point $_{A} p$ by

_{B} p = R_{B A A} p

This is called linear map.

Note that with our index notation (as explained in Frame Notation) and these conventions, the second index of the rotation matrix and the left index of the point have to be the same ( $A$ in this example). The rotation is applied incorrectly if this is not the case.

Each column of a rotation matrix $R_{B A}$ is a basis vector of frame $A$ with respect to frame $B$ . We can plot the basis vectors of an orientation to visualize it. Here, we can see orientation represented by the rotation matrix

\begin{array}{r} R = (\begin{array}{ccc} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{array}) . \end{array}

from pytransform3d.rotations import plot_basis
plot_basis()

Note

When plotting basis vectors, it is a convention to use red for the x-axis, green for the y-axis and blue for the z-axis (RGB for xyz).

We can easily chain multiple rotations: we can apply the rotation defined by $R_{C B}$ after the rotation $R_{B A}$ by applying the rotation

R_{C A} = R_{C B} R_{B A} .

Note that the indices have to align again. Otherwise rotations are not applied in the correct order.

Warning

There are two different conventions on how to concatenate rotation matrices. Suppose we have a rotation matrix $R_{1}$ and another matrix $R_{2}$ and we want to first rotate by $R_{1}$ and then by $R_{2}$ . If we want to apply both rotations in global coordinates, we have to concatenate them with $R_{2} \cdot R_{1}$ . We can also express the second rotation in terms of a local, body-fixed coordinates by $R_{1} \cdot R_{2}$ , which means $R_{1}$ defines new coordinates in which $R_{2}$ is applied. Note that this applies to both passive and active rotation matrices.

The easiest way to construct rotation matrices is through rotations about the basis vectors with active_matrix_from_angle(). Multiple rotation matrices that were constructed like this can be concatenated. This will be done, for instance, to obtain rotation matrices from Euler angles (see Euler Angles).

Pros

Supported operations: all except interpolation.
Interpretation: each column is a basis vector.
Singularities: none.
Ambiguities: none that are specific for rotation matrices.

Cons

Representation: 9 values for 3 degrees of freedom.
Renormalization: expensive in comparison to quaternions.

2.2. Axis-Angle#

../_images/sphx_glr_plot_axis_angle_001.png

Each rotation can be represented by a single rotation about one axis. The axis can be represented as a three-dimensional unit vector and the angle by a scalar:

\begin{array}{r} (\hat{ω}, θ) = ((\begin{array}{c} ω_{x} \\ ω_{y} \\ ω_{z} \end{array}), θ) \end{array}

pytransform3d uses a numpy array of shape (4,) for the axis-angle representation of a rotation, where the first 3 entries correspond to the unit axis of rotation and the fourth entry to the rotation angle in radians, and typically we use the variable name a.

Note that the axis-angle representation has a singularity at $θ = 0$ as there is an infinite number of rotation axes that represent the identity rotation in this case. However, we can modify the representation to avoid this singularity.

2.3. Rotation Vector#

Since $| | \hat{ω} | | = 1$ , it is possible to write this in a more compact way as a rotation vector [2]

ω = \hat{ω} θ \in R^{3} .

In code, we call this the compact axis-angle representation. pytransform3d uses a numpy array of shape (3,) for the compact axis-angle representation of a rotation and typically it uses the variable name a.

We can also refer to this representation as exponential coordinates of rotation [5]. We can represent angular velocity as $\hat{ω} \dot{θ}$ and angular acceleration as $\hat{ω} \ddot{θ}$ so that we can easily do component-wise integration and differentiation with this representation.

Pros

Representation: minimal.
Supported operations: interpolation; can also represent angular velocity and acceleration.

Cons

Ambiguities: an angle of 0 and any multiple of $2 π$ represent the same orientation (can be avoided with norm_compact_axis_angle(), which introduces discontinuities); when $θ = π$ , the axes $\hat{ω}$ and $- \hat{ω}$ represent the same rotation.
Supported operations: concatenation and transformation of vectors requires conversion to another representation.

2.4. Logarithm of Rotation#

In addition, we can represent $\hat{ω} θ$ by the cross-product matrix (cross_product_matrix())

\begin{array}{r} [\hat{ω}] θ = (\begin{array}{c} 0 & - ω_{3} & ω_{2} \\ ω_{3} & 0 & - ω_{1} \\ - ω_{2} & ω_{1} & 0 \end{array}) θ \in s o (3) \subset R^{3 \times 3}, \end{array}

where $[\hat{ω}] θ$ is the matrix logarithm of a rotation matrix and $s o (3)$ is the Lie algebra of the Lie group $S O (3)$ .

2.5. Quaternions#

Quaternions are represented by a scalar / real part $w$ and an vector / imaginary part $x i + y j + z k$ .

q = w + x i + y j + z k \in H

Warning

There are two different quaternion conventions: Hamilton’s convention defines $i j k = - 1$ and the Shuster or JPL convention (from NASA’s Jet Propulsion Laboratory, JPL) defines $i j k = 1$ [1]. These two conventions result in different multiplication operations and conversions to other representations. We use Hamilton’s convention.

Read this paper for details about the two conventions and why Hamilton’s convention should be used. Section VI A gives further useful hints to identify which convention is used.

The unit quaternion space $S^{3}$ can be used to represent orientations with an encoding based on the rotation axis and angle. A rotation quaternion is a four-dimensional unit vector (versor) $\hat{q}$ . The following equation describes its relation to axis-angle notation.

\begin{array}{r} \hat{q} = (\begin{array}{c} w \\ x \\ y \\ z \end{array}) = (\begin{array}{c} \cos \frac{θ}{2} \\ ω_{x} \sin \frac{θ}{2} \\ ω_{y} \sin \frac{θ}{2} \\ ω_{z} \sin \frac{θ}{2} \end{array}) = (\begin{array}{c} \cos \frac{θ}{2} \\ \hat{ω} \sin \frac{θ}{2} \end{array}) \end{array}

pytransform3d uses a numpy array of shape (4,) for quaternions and typically we use the variable name q.

Warning

The scalar component $w$ of a quaternion is sometimes the first element and sometimes the last element of the versor. We will use the first element to store the scalar component.

Since the other convention is also used often, pytransform3d provides the functions quaternion_wxyz_from_xyzw() and quaternion_xyzw_from_wxyz() for conversion.

Warning

The antipodal unit quaternions $\hat{q}$ and $- \hat{q}$ (quaternion_double()) represent the same rotation (double cover). This must be considered during operations like interpolation, distance calculation, or (approximate) equality checks.

The quaternion product (concatenate_quaternions()) can be used to concatenate rotations like the matrix product can be used to concatenate rotations represented by rotation matrices.

The inverse of the rotation represented by the unit quaternion $q$ is represented by the conjugate $q^{*}$ (q_conj()).

We can rotate a vector by representing it as a pure quaternion (i.e., with a scalar part of 0) and then left-multiplying the quaternion and right-multiplying its conjugate $q v q^{*}$ with the quaternion product (q_prod_vector()).

Pros

Representation: compact.
Renormalization: checked with quaternion_requires_renormalization(); cheap in comparison to rotation matrices (); less susceptible to round-off errors than matrix representation.
Discontinuities: none.
Computational efficiency: the quaternion product is cheaper than the matrix product.
Singularities: none.

Cons

Interpretation: not straightforward.
Ambiguities: double cover.

2.6. Euler Angles#

A complete rotation can be split into three rotations around basis vectors. pytransform3d uses a numpy array of shape (3,) for Euler angles, where each entry corresponds to a rotation angle in radians around one basis vector. The basis vector that will be used and the order of rotation is defined by the convention that we use. See Euler Angles for more information.

Warning

There are 24 different conventions for defining euler angles. There are 12 different valid ways to sequence rotation axes that can be interpreted as extrinsic or intrinsic rotations: XZX, XYX, YXY, YZY, ZYZ, ZXZ, XZY, XYZ, YXZ, YZX, ZYX, and ZXY.

Pros

Representation: minimal.
Interpretation: easy to interpret for users (when the convention is clearly defined) in comparison to axis-angle or quaternions.

Cons

Ambiguities: 24 different conventions, infinitely many Euler angles represent the same rotation without proper limits for the angles.
Singularity: gimbal lock.
Supported operations: all operations require conversion to another representation.

2.7. Rotors#

../_images/sphx_glr_plot_bivector_001.png

Rotors and quaternions are very similar concepts in 3D. However, rotors are more general as they can be extended to more dimensions [3] [4].

The concept of a quaternion builds on the axis-angle representation, in which we rotate by an angle about a rotation axis (see black arrow in the illustration above). The axis can be computed from the cross product of two vectors (gray arrows). A rotor builds on a plane-angle representation, in which we rotate with a given direction by an angle in a plane (indicated by gray area). The plane can be computed from the wedge product $a \land b$ (see wedge()) of two vectors $a$ and $b$ , which is a so-called bivector. Although both approaches might seem different, in 3D they operate with exactly the same numbers in exactly the same way.

Warning

The rotors $R$ and $- R$ represent exactly the same rotation.

A rotor is a unit multivector

R = (a, b_{y z}, b_{z x}, b_{x y})

that consists of a scalar $a$ and a bivector $(b_{y z}, b_{z x}, b_{x y})$ . The components of a bivector constructed by the wedge product of two vectors can be interpreted as the area of the parallelogram formed by the two vectors projected on the three basis planes yz, zx, and xy (see illustration above). These values also correspond to the x-, y-, and z-components of the cross product of the two vectors, which allows two different interpretations of the same numbers from which we can then derive quaternions on the one hand and rotors on the other hand.

Warning

In pytransform3d our convention is that we organize the components of a rotor in exactly the same way as we organize the components of the equivalent quaternion. There are other conventions. It is not just possible to change the order of the scalar and the bivector (similar to a quaterion), but also to change the order of bivector components.

Pros and cons for rotors are the same as for quaternions as they have the same representation in 3D.

2.8. Modified Rodrigues Parameters#

Another minimal representation of rotation are modified Rodrigues parameters (MRP) [6] [8]

ψ = \tan (\frac{θ}{4}) \hat{ω}

This representation is similar to the compact axis-angle representation. However, the angle of rotation is converted to $\tan (\frac{θ}{4})$ . Hence, there is an easy conversion from unit quaternions to MRP (mrp_from_quaternion()):

\begin{array}{r} ψ = \frac{(\begin{array}{c} x \\ y \\ z \end{array})}{1 + w} \end{array}

given some quaternion with a scalar $w$ and a vector ${(x, y, z)}^{T}$ .

pytransform3d uses a numpy array of shape (3,) for modified Rodrigues parameters.

Warning

MRPs have a singuarity at $2 π$ (see mrp_near_singularity()) which we can avoid by ensuring the angle of rotation does not exceed $π$ (with norm_mrp()).

Warning

MRPs have two representations for the same rotation: $ψ$ and $- \frac{1}{| | ψ | |^{2}} ψ$ (mrp_double()) represent the same rotation and correspond to two antipodal unit quaternions [8].

Pros

Representation: minimal.

Cons

Interpretation: not straightforward.
Singularity: at $θ = 2 π$ .
Ambiguity: double cover.
Supported operations: transformation of vectors requires conversion to another representation.

2. SO(3): 3D Rotations#

2.1. Rotation Matrix#

2.2. Axis-Angle#

2.3. Rotation Vector#

2.4. Logarithm of Rotation#

2.5. Quaternions#

2.6. Euler Angles#

2.7. Rotors#

2.8. Modified Rodrigues Parameters#

2.9. References#