How to Properly Calculate an Intermediate Quaternion Between Two Quaternions

The correct way to calculate an intermediate quaternion between two quaternions for rotation interpolation is to use Spherical Linear Interpolation (SLERP), not simple linear interpolation. SLERP ensures the interpolated quaternion remains on the unit sphere and represents a valid rotation throughout the interpolation process.

Contents

• What Are Quaternions and Why They’re Used for Rotations
• Why Linear Interpolation Fails for Quaternions
• Proper SLERP Implementation
• Handling Edge Cases in Quaternion Interpolation
• SLERP vs. Other Interpolation Methods
• Optimized SLERP Implementation
• Practical Considerations

What Are Quaternions and Why They’re Used for Rotations

Quaternions are a mathematical extension of complex numbers, consisting of one real component and three imaginary components: $q = w + xi + yj + zk$. When representing rotations, we typically use unit quaternions where $w^2 + x^2 + y^2 + z^2 = 1$.

Quaternions offer several advantages over other rotation representations:

• They avoid gimbal lock
• They provide smooth interpolation
• They’re computationally efficient for composition
• They don’t suffer from singularities

A quaternion represents a rotation of $2\theta$ degrees around an axis $\mathbf{v} = (x, y, z)$ where:

• $\theta = \arccos(w)$
• The axis is normalized to $\mathbf{v} = (x, y, z) / \sqrt{1-w^2}$

Why Linear Interpolation Fails for Quaternions

Your first approach using naive linear interpolation doesn’t work because quaternions lie on a 4D unit sphere. Linear interpolation in Euclidean space doesn’t preserve this constraint:

// This produces invalid rotation quaternions
q3 = {
    q1[0] + (q2[0] - q1[0])*ratio,
    q1[1] + (q2[1] - q1[1])*ratio,
    q1[2] + (q2[2] - q1[2])*ratio,
    q1[3] + (q2[3] - q1[3])*ratio,
};

The resulting quaternion won’t be normalized, leading to distorted rotations. Furthermore, the path taken by linear interpolation doesn’t follow the great circle (shortest path) on the quaternion sphere.

Proper SLERP Implementation

SLERP (Spherical Linear Interpolation) is the standard method for interpolating between quaternions. It follows the great circle arc between two points on a 4D sphere, ensuring constant angular velocity.

Here’s a corrected SLERP implementation:

vec4 quaternionSlerp(vec4 q1, vec4 q2, float t)
{
    // Ensure unit quaternions
    q1 = normalize(q1);
    q2 = normalize(q2);
    
    // Compute cosine of angle between quaternions
    float cosHalfTheta = dot(q1, q2);
    
    // If quaternions are very close, use linear interpolation to avoid division by zero
    if (fabs(cosHalfTheta) >= 1.0f - 1e-6f) {
        return normalize(mix(q1, q2, t));
    }
    
    // Ensure we take the shortest path
    if (cosHalfTheta < 0.0f) {
        q2 = -q2;
        cosHalfTheta = -cosHalfTheta;
    }
    
    // Compute interpolation parameters
    float halfTheta = acos(cosHalfTheta);
    float sinHalfTheta = sqrt(1.0f - cosHalfTheta * cosHalfTheta);
    float ratioA = sin((1.0f - t) * halfTheta) / sinHalfTheta;
    float ratioB = sin(t * halfTheta) / sinHalfTheta;
    
    // Perform interpolation
    return {
        q1[0] * ratioA + q2[0] * ratioB,
        q1[1] * ratioA + q2[1] * ratioB,
        q1[2] * ratioA + q2[2] * ratioB,
        q1[3] * ratioA + q2[3] * ratioB
    };
}

Handling Edge Cases in Quaternion Interpolation

Several edge cases need special attention when implementing SLERP:

1. Identical Quaternions: When q1 and q2 represent the same rotation (or opposite rotations)
2. Perpendicular Quaternions: When the angle between quaternions is 90°
3. Very Close Quaternions: When numerically unstable calculations might occur

A robust implementation should handle these cases as shown in the code above. The key improvements over your original implementation are:

• Normalizing input quaternions
• Handling the double-cover property (q and -q represent the same rotation)
• Using linear interpolation when quaternions are very close

SLERP vs. Other Interpolation Methods

While SLERP is the gold standard for quaternion interpolation, other methods exist for different use cases:

For most applications, SLERP is the preferred method when quality is important.

Optimized SLERP Implementation

For performance-critical applications, here’s an optimized SLERP implementation:

vec4 fastSlerp(vec4 q1, vec4 q2, float t)
{
    // Ensure unit quaternions
    q1 = normalize(q1);
    q2 = normalize(q2);
    
    float cosTheta = dot(q1, q2);
    
    // Handle identical quaternions
    if (cosTheta > 0.9995f) {
        return normalize(mix(q1, q2, t));
    }
    
    // Ensure shortest path
    if (cosTheta < 0.0f) {
        q2 = -q2;
        cosTheta = -cosTheta;
    }
    
    // Use approximation for small angles
    if (cosTheta > 0.995f) {
        float theta = acos(cosTheta);
        float sinTheta = sqrt(1.0f - cosTheta * cosTheta);
        float theta_t = t * theta;
        float sin_theta_t = sin(theta_t);
        
        float scale0 = sin(theta - theta_t) / sinTheta;
        float scale1 = sin_theta_t / sinTheta;
        
        return scale0 * q1 + scale1 * q2;
    }
    
    // Standard SLERP for most cases
    float theta = acos(cosTheta);
    float sinTheta = sqrt(1.0f - cosTheta * cosTheta);
    float theta_t = t * theta;
    float sin_theta_t = sin(theta_t);
    
    float scale0 = sin(theta - theta_t) / sinTheta;
    float scale1 = sin_theta_t / sinTheta;
    
    return scale0 * q1 + scale1 * q2;
}

Practical Considerations

When implementing quaternion interpolation in your project, consider these best practices:

1. Always normalize quaternions before interpolation: This ensures valid rotations
2. Handle the double-cover property: Check if q2 should be negated for shortest path
3. Consider performance: Use approximations when appropriate for your use case
4. Test edge cases: Verify interpolation works for identical, opposite, and perpendicular quaternions
5. Visual debugging: When possible, visualize interpolation to verify correctness

Your third approach using quaternion multiplication and conjugate doesn’t work because it’s attempting to apply linear interpolation in a non-linear space. Quaternion multiplication represents composition of rotations, not linear interpolation between them.

Conclusion

To properly calculate an intermediate quaternion between two quaternions:

1. Use SLERP (Spherical Linear Interpolation) for accurate rotation interpolation
2. Normalize your quaternions before interpolation
3. Handle the double-cover property by checking if quaternions should be negated
4. Consider edge cases like identical quaternions or very close ones
5. Use approximations in performance-critical applications where appropriate

SLERP ensures your interpolated rotations follow the shortest path on the quaternion sphere with constant angular velocity, which is essential for smooth animation and camera movements in 3D applications.