Robot Orientation and Quaternions

Why Does This Exist?

A wrist needs to turn from a heading of 170 degrees to -170 degrees. Averaging those numbers gives zero: a tool pointing the opposite way from the intended midpoint. The numbers wrap; the physical orientation does not jump.

Orientation describes which way a rigid body's axes point. It has no translation. Coordinate frames already explain rotation matrices and frame composition. Here the missing operation is representing and interpolating orientation without treating angle coordinates as ordinary positions. A quaternion is a compact representation of that same rotation, not an extra physical degree of freedom.

Think of It Like This

How It Actually Works

What do the four components mean?

Use active rotations of vectors in a fixed right-handed frame and scalar-first Hamilton quaternions $q=(w,\mathbf v)=(w,x,y,z)$. For a unit rotation axis $\mathbf n$ and angle $\theta$ in radians,

The axis sets the turn's direction; the angle sets its size. Four constrained numbers represent three rotational degrees of freedom. SciPy's quaternion API documents both component orders; its default is scalar-last, unlike this page. Label the convention at every interface.

For unit $q$, the inverse is $q^{-1}=(w,-\mathbf v)$. A vector $\mathbf p$ rotates by taking the vector part of $q(0,\mathbf p)q^{-1}$. Both $q$ and $-q$ produce the same answer because the two minus signs cancel. This double cover explains why raw quaternion-component differences are poor orientation errors.

For $q_a=(a,\mathbf u)$ and $q_b=(b,\mathbf v)$, Hamilton multiplication is

The dot product is a scalar; the cross product is the perpendicular vector. Under our active convention, $q_aq_b$ applies $q_b$ first. Rotations about different axes generally do not commute. Multiplication order must also agree with the source and destination frame convention.

Which interpolated orientation is halfway?

Normalize both endpoints $q_0,q_1$. If their dot product is negative, replace $q_1$ with $-q_1$. With $\Omega=\arccos(q_0\cdot q_1)$ and fraction $s$ between zero and one, spherical interpolation is

$\Omega$ is the angle between quaternion vectors, half the physical shortest rotation angle. For nearly coincident endpoints, normalized linear interpolation avoids division by a tiny sine. SciPy's SLERP documentation specifies a fixed-axis, constant-angular-speed shortest rotation between each pair of keyframes.

For our yaw-only fixture,

Their dot product is $\cos170^\circ=-0.984808$. Flip $q_1$; the dot becomes $0.984808$ and $\Omega=10^\circ$. At $s=1/2$, the scalar parts cancel and the normalized result is $(0,0,0,1)$: a 180-degree yaw. The physical total turn is $2\Omega=20^\circ$. In the drawing, the short solid arc crosses the left-pointing midpoint. The dashed long arc passes the right-pointing zero heading and represents the unwanted 340-degree route.

What should a controller measure?

For current orientation $q_c$ and desired orientation $q_d$ in our fixed-frame convention, use $q_e=q_dq_c^{-1}$. Align its sign so $w_e$ is nonnegative. Its angle is $2\operatorname{atan2}(\lVert\mathbf v_e\rVert,w_e)$, with axis $\mathbf v_e/\lVert\mathbf v_e\rVert$ away from zero. The angle times that axis is a local three-component error, expressed in the fixed frame for this product order. A body-frame error uses the opposite order.

Quaternions avoid Euler-angle chart singularities but require normalization and sign management. Matrices are often clearer for transforming many vectors. SLERP also supplies no collision check, joint solution or smooth angular acceleration across multiple keyframes; use trajectory generation for timing and derivative constraints. At an exact 180-degree relative rotation, the shortest direction is ambiguous and needs a consistent tie rule.

Code

This dependency-free Python example handles sign equivalence and the near-coincident case. It checks that changing an endpoint's sign doesn't change the physical midpoint.

1from math import acos, atan2, cos, degrees, isclose, radians, sin, sqrt2
3Quat = tuple[float, float, float, float]4
5def unit(q: Quat) -> Quat:6    norm = sqrt(sum(x*x for x in q))7    if norm == 0:8        raise ValueError("zero quaternion")9    return tuple(x / norm for x in q)10
11def slerp(a: Quat, b: Quat, s: float) -> Quat:12    a, b = unit(a), unit(b)13    dot = sum(x*y for x, y in zip(a, b))14    if dot < 0:15        b, dot = tuple(-x for x in b), -dot16    dot = min(1.0, max(-1.0, dot))17    if dot > 0.9995:18        return unit(tuple((1-s)*x + s*y for x, y in zip(a, b)))19    angle = acos(dot)20    return unit(tuple((sin((1-s)*angle)*x + sin(s*angle)*y) / sin(angle)21                      for x, y in zip(a, b)))22
23def yaw(deg: float) -> Quat:24    half = radians(deg) / 225    return cos(half), 0.0, 0.0, sin(half)26
27a, b = yaw(170), yaw(-170)28mid = slerp(a, b, 0.5)29same = slerp(a, tuple(-x for x in b), 0.5)30assert isclose(abs(sum(x*y for x, y in zip(mid, same))), 1.0)31assert isclose(sum(x*x for x in mid), 1.0)32assert isclose(abs(slerp(a, a, 0.5)[0]), abs(a[0]))33print(f"midpoint yaw: {degrees(2*atan2(mid[3], mid[0])):.1f} deg")

Output: midpoint yaw: 180.0 deg. The yaw extraction here is only for this pure-z rotation, not a general Euler-angle conversion.

Watch Out For

The Quick Version

• Unit quaternions represent rotations with four constrained components; opposite signs describe the same orientation.
• Sign-aligned SLERP takes the 20-degree route from 170 to -170 degrees through 180 degrees.
• Relative quaternion products give orientation error only after frame and multiplication conventions are fixed.
• Interpolating orientation does not prove joint reachability, collision clearance or feasible angular acceleration.

What to Read Next

• Coordinate Frames and Transformations
• Robot Trajectory Generation and Time Scaling
• Robot Inertial Navigation