How to Lerp between two quaternions?

Question

I have two quaternions:

SCNVector4(x: -0.554488897, y: -0.602368534, z: 0.57419008, w: 2.0878818) 

SCNVector4(x: 0.55016619, y: 0.604441643, z: -0.576166153, w: 4.18851328)

and if we create two objects the orientation will be quite similar

but if we try to Lerp from first to second then the position changing quite weird (and looking on the values it's expected but not correct)

[Lerp progress demo][1]

I've googled and found many functions to do lerp e.g. simple one:

extension SCNVector4 {

    func lerp(to: SCNVector4, v: Float) -> SCNVector4 {

        let aX = x + (to.x - x) * v
        let aY = y + (to.y - y) * v
        let aZ = z + (to.z - z) * v
        let aW = w + (to.w - w) * v
        
        return SCNVector4Make(aX, aY, aZ, aW)
        
    }
}

But how to avoid such weird flipping?

PS: I've tried different functions from GLKit but the result is the same [1]: https://i.stack.imgur.com/8jEvm.png

- As suggested tried to flip sign but the issue is that I get dot product greater then 0

    extension SCNVector4 {
    
    func glk() -> GLKQuaternion {
        return GLKQuaternion(q: (x, y, z, w))
    }
    
    func lerp(to: SCNVector4, v: Float) -> SCNVector4 {
        
        let a = GLKQuaternionNormalize(glk())
        let b = GLKQuaternionNormalize(to.glk())
        
        let dot =
            a.x * b.x +
            a.y * b.y +
            a.z * b.z +
            a.w * b.w
        
        var target = b
        if dot < 0 {
            target = GLKQuaternionInvert(b)
        }
        
        let norm = GLKQuaternionNormalize(GLKQuaternionSlerp(a, target, v))
        
        return norm.scn()
        
    }
    
}

extension GLKQuaternion {
    
    func scn() -> SCNVector4 {
        return SCNVector4Make(x, y, z, w)
    }
    
}

Answer 1

The quat values you listed seem wrong if you ask me. 'w' values of 2 or 4 don't add up to a normalised quat, so I'm not surprised lerping them give you odd values. When using quats for rotations, they should be unit length (and those two quats are not unit length).

As for lerping, you basically want to be using a normalised-lerp (nlerp), or spherical-lerp (slerp). NLerp leads to a slight acceleration / deceleration as you rotate from one quat to the other. Slerp gives you a constant angular speed (although it uses sine, so it is slower to compute).

float dot(quat a, quat b)
{
  return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w;
}

quat negate(quat a)
{
  return quat(-a.x, -a.y, -a.z, -a.w);
}

quat normalise(quat a)
{
  float l = 1.0f / std::sqrt(dot(a, a));
  return quat(l*a.x, l*a.y, l*a.z, l*a.w);
}

quat lerp(quat a, quat b, float t) 
{
  // negate second quat if dot product is negative
  const float l2 = dot(a, b);
  if(l2 < 0.0f) 
  {
    b = negate(b);
  }
  quat c;
  // c = a + t(b - a)  -->   c = a - t(a - b)
  // the latter is slightly better on x64
  c.x = a.x - t*(a.x - b.x);
  c.y = a.y - t*(a.y - b.y);
  c.z = a.z - t*(a.z - b.z);
  c.w = a.w - t*(a.w - b.w);
  return c;
}

// this is the method you want
quat nlerp(quat a, quat b, float t) 
{
  return normalise(lerp(a, b, t));
}

/Edit

Are you sure they are quat values? Those values look a lot like axis angle values if you ask me. Try running those values through this conversion func and see if that helps:

quat fromAxisAngle(quat q)
{
  float ha = q.w * 0.5f;
  float sha = std::sin(ha);
  float cha = std::cos(ha);
  return quat(sha * q.x, sha * q.y, sha * q.z, cha);
}

I get these two resulting quats from your original values:

(-0.479296037597, -0.520682836178, 0.496325592199, 0.50281768624)

(0.47649598094, 0.523503659143, -0.499014409188, -0.499880083257)

Answer 2

The latest SDKs have <simd/quaternion.h> which exposes the simd_quatf type to represent a quaternion. Also exposed are different utils to deal with quaternions and among them is simd_slerp which does "the right thing" for quaternion interpolation.

In iOS 11 and macOS 10.13 SceneKit exposes new APIs to deal with SIMD types directly. For instance in addition to SCNNode.orientation you now also have access to SCNNode.simdOrientation.

Edit

Most SIMD APIs are inlined and can thus be used on OS versions earlier than the SDK version. If you really wan to stick to GLKit their version of the spherical interpolation is GLKQuaternionSlerp.

Answer 3

1. Do sign flip, if quaternions dot product is negative.
2. Normalize resulting quaternion.

Answer 4

First of all I want to thank robthebloke for the algorithmic solution. This I am posting is just the translation in Swift of the same algorithm. Hopes this helps someone that is trying to smooth the CMQuaternion coming from CMMotionManager.

extension CMQuaternion {
    static func dot(_ a: CMQuaternion, _ b: CMQuaternion) -> Double {
      return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w
    }

    static func negate(_ a: CMQuaternion) -> CMQuaternion {
        return CMQuaternion(x:-a.x, y:-a.y, z:-a.z, w:-a.w)
    }

    static func normalise(_ a: CMQuaternion) -> CMQuaternion {
        let l : Double = 1.0 / sqrt(dot(a, a))
        return CMQuaternion(x: l*a.x, y: l*a.y, z: l*a.z, w: l*a.w)
    }

    static func lerp(_ a: CMQuaternion, _ b: CMQuaternion, _ t: Double) -> CMQuaternion {
      // negate second quat if dot product is negative
      //const float l2 = dot(a, b);
        let l2 = dot(a, b)
        var b = b
        if l2 < 0.0 {
            b = negate(b)
        }
        // c = a + t(b - a)  -->   c = a - t(a - b)
        // the latter is slightly better on x64
        let x = a.x - t*(a.x - b.x)
        let y = a.y - t*(a.y - b.y)
        let z = a.z - t*(a.z - b.z)
        let w = a.w - t*(a.w - b.w)
        return CMQuaternion(x: x, y: y, z: z, w: w)
    }

    // this is the method you want
    static func nlerp(_ a: CMQuaternion, _ b: CMQuaternion, _ t: Double) -> CMQuaternion {
      return normalise(lerp(a, b, t))
    }
}