Quaternion mix is buggy - math

Question

I'm doing Quaternion mixing via SLERP, but my implementation does something very buggy. You can see it on this video: video
Here is the code:
cosTheta = quatDot(a, b);
if (cosTheta > 0.9){
var quat = new Vec4(
a.x + (b.x - a.x)*t,
a.y + (b.y - a.y)*t,
a.z + (b.z - a.z)*t,
a.w + (b.w - a.w)*t
);
normalizeQuat(quat);
return quat;
}
cosTheta = Math.min(Math.max(cosTheta, -1), 1); //clamp
var theta = Math.acos(cosTheta) * t;
var v2 = quatMinus(b, quatExtend(a, cosTheta));
normalizeQuat(v2);
return quatSum(quatExtend(a, cosTheta), quatExtend(v2, Math.sin(theta)));
Here I have my help functions:
function quatDot(a,b){
return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w;
return a.x*b.x + a.y*b.y + a.z*b.z + a.w*b.w;
}
function quatMultiply(q,p){
return new Vec4(
q.w * p.x + q.x * p.w + q.y * p.z - q.z * p.y,
q.w * p.y + q.y * p.w + q.z * p.x - q.x * p.z,
q.w * p.z + q.z * p.w + q.x * p.y - q.y * p.x,
q.w * p.w - q.x * p.x - q.y * p.y - q.z * p.z);
}
function quatExtend(q, t){
return new Vec4(
q.x * t, q.y * t, q.z * t, q.w * t);
}
function quatMinus(q, p){
return new Vec4(
q.x - p.x,
q.y - p.y,
q.z - p.z,
q.w - p.w
);
}
function quatSum(q, p){
return new Vec4(
q.x + p.x,
q.y + p.y,
q.z + p.z,
q.w + p.w
);
}
I tried many implementations from websites but there is always buggy movement. When I tried simple linear interpolation, then animation is smooth, but weird accelerating.

Answer 1

Here's a easy bug: if cosTheta < 0.9 and t= 0, then theta = 0, which means Math.sin(theta) = 0, which means quatExtend(v2, Math.sin(theta)) is the zero quaternion, and you end up returning quatExtend(a, cosTheta), which is not a unit quaternion.
I would expect a correct implementation to take the inverse (or conjugate) of one of the quaternions at least once, and never to call normalizeQuat. But that's just intuition. To get past intuition, try writing a unit test!
By the way, if we're doing a code review, it's confusing that cosTheta is not the cosine of theta. Also, the if (cosTheta > 0.9) block smells like premature optimization; you can probably get rid of it. :)