views:

85

answers:

3

I have two vectors describing rotations; a start rotation A and a target rotation B. How would I best go about interpolating A by a factor F to approach B?

Using a simple lerp on the vectors fails to work when more than one dimension needs to be interpolated (i.e. produces undesirable rotations). Maybe building quaternions from the rotation vectors and using slerp is the way to go. But how, then, could I extract a vector describing the new rotation from the resulting quaternion?

Thanks in advance.

+2  A: 

Well, your slerp approach would work and is probably computationally most efficient (even though it's a bit tough to understand). To get back from the quaternions to the vector, you'll need to use a set of formulas you can find here.

There's also a bit of relevant code here, although I don't know if it corresponds to the way you have your data represented.

Andrew McGregor
Thank you.I managed to get the vector back from the Quaternion. The setup using SLERP works fine if I only interpolate on one axis. However, quite curiously for me, SLERP produces about the same behaviour as the simple vector LERP when using more than one axis, that is, the rotation jumps around wildly at times. Any ideas?
uhuu
Sounds like you're getting gimbal lock; representing rotation as a vector only works if you represent it in the right coordinates: http://en.wikipedia.org/wiki/Gimbal_lock
Andrew McGregor
Uhuu, could you clarify what you mean by "rotating around multiple axes"? When you perform slerp between quaternions a and b, you rotate around one axis; the axis of the quaternion c, where c = b * a^-1
SuperElectric
A: 

If you have decided to go with Quaternions (which will slerp very nicely), see my answer here on resources for implementing Quaternions: http://stackoverflow.com/questions/2758501/rotating-in-opengl-relative-to-the-viewport/2758673#2758673

You should find plenty of examples in the links in that post.

Xavier Ho
A: 

Since I don't seem to understand your question, here is a little SLERP implementation in python using numpy. I plotted the results using matplotlib (v.99 for Axes3D). I don't know if you can use python, but does look like your SLERP implementation? It seems to me to give fine results ...

from numpy import *
from numpy.linalg import norm

def slerp(p0, p1, t):
        omega = arccos(dot(p0/norm(p0), p1/norm(p1)))
        so = sin(omega)
        return sin((1.0-t)*omega) / so * p0 + sin(t*omega)/so * p1


# test code
if __name__ == '__main__':
    pA = array([-2.0, 0.0, 2.0])
    pB = array([0.0, 2.0, -2.0])

    ps = array([slerp(pA, pB, t) for t in arange(0.0, 1.0, 0.01)])

    from pylab import *
    from mpl_toolkits.mplot3d import Axes3D
    f = figure()
    ax = Axes3D(f)
    ax.plot3D(ps[:,0], ps[:,1], ps[:,2], '.')
    show()
catchmeifyoutry