iicm.utils3d
Class Quaternion

java.lang.Object
  |
  +--iicm.utils3d.Quaternion

public class Quaternion
extends java.lang.Object


Constructor Summary
Quaternion()
          default: "identity" quaternion (angle 0, any axis)
Quaternion(float[] axis, float angle)
          create a quaternion with a normalized axis and angle
Quaternion(int offset, float[] arr)
          create a quaternion. take normalized axis and angle out of an array, starting at offset position.
Quaternion(Quaternion q)
          copy constructor
 
Method Summary
 float[] getAxisAngle()
          convert quaternion to normalized axis and angle
 void levelize()
          make the quaternion represent a rotation around (0, +/-1, 0); i.e. on the same "level"
 void multiply(Quaternion q1)
          multiply this quaternion (q0) with another (q1) from the right side. q0 = q0 * q1 (multiplication non commutative), having the effect of preconcatening the rotation q1 to this one
 void multiplyLeft(Quaternion q1)
          multiply this quaternion (q0) with another (q1) from the left side. q0 = q1 * q0 (multiplication non commutative), having the effect of postconcatening the rotation q1 to this one
static Quaternion product(Quaternion q0, Quaternion q1)
          calculate the product of two quaternions (both q0, q1 unchanged). when q0 and q1 represent rotations, the result is q0 done after q1.
 void renormalize()
          ensure the quaternion stays normalized.
 void reset()
          back to the "identity" quaternion
 float[] rotatePointCenter(float[] v, float[] c)
          rotate a point p about an arbitrary center c by the quaternion, i.e. add (the rotated vector from c to p) to c.
 float[] rotateVector(float[] v)
          rotate a vector by the quaternion; the result will be normalized if the input vector was; the input vector will not be changed
static float[] rotationAxisToVector(int num, float[] v)
          get the rotation (normalized axis and angle) that rotates a coordinate axis (given by number) to another (normalized) vector. e.g. rotationAxisToVector (2, negativenormalizedlookatvector) gives you the orientation axis/angle values of a VRML viewpoint.
static float[] rotationBetweenVectors(float[] a, float[] b)
          get the rotation (normalized axis and angle) that rotates vector a to vector b. a and b should be normalized
static Quaternion slerp(Quaternion q1, Quaternion q2, float t)
          spherical linear interpolation. return a quaternion that lies "at t between q1 and q2", i.e. q1 for t == 0, q2 for t == 1 and an interpolation of q1 and q2 for values between 0 and 1. remind that q and -q describe the same rotation, thus interpolate to -q2 if path to it is shorter than to q2.
 float[] transformAxis(int num)
          transform (rotate) an axis by the quaternion
 void untilt()
          make the quaternion represent tilt-free rotation (no z part)
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

Quaternion

public Quaternion()
default: "identity" quaternion (angle 0, any axis)

Quaternion

public Quaternion(float[] axis,
                  float angle)
create a quaternion with a normalized axis and angle

Quaternion

public Quaternion(int offset,
                  float[] arr)
create a quaternion. take normalized axis and angle out of an array, starting at offset position.

Quaternion

public Quaternion(Quaternion q)
copy constructor
Method Detail

rotationBetweenVectors

public static float[] rotationBetweenVectors(float[] a,
                                             float[] b)
get the rotation (normalized axis and angle) that rotates vector a to vector b. a and b should be normalized
See Also:
rotationAxisToVector(int, float[])

rotationAxisToVector

public static float[] rotationAxisToVector(int num,
                                           float[] v)
get the rotation (normalized axis and angle) that rotates a coordinate axis (given by number) to another (normalized) vector. e.g. rotationAxisToVector (2, negativenormalizedlookatvector) gives you the orientation axis/angle values of a VRML viewpoint.
See Also:
rotationBetweenVectors(float[], float[])

reset

public final void reset()
back to the "identity" quaternion

levelize

public void levelize()
make the quaternion represent a rotation around (0, +/-1, 0); i.e. on the same "level"

untilt

public void untilt()
make the quaternion represent tilt-free rotation (no z part)

renormalize

public final void renormalize()
ensure the quaternion stays normalized. Useful e.g. after several mulitplications

getAxisAngle

public final float[] getAxisAngle()
convert quaternion to normalized axis and angle

product

public static final Quaternion product(Quaternion q0,
                                       Quaternion q1)
calculate the product of two quaternions (both q0, q1 unchanged). when q0 and q1 represent rotations, the result is q0 done after q1.
Returns:
q0 * q1 (multiplication non commutative)

multiply

public final void multiply(Quaternion q1)
multiply this quaternion (q0) with another (q1) from the right side. q0 = q0 * q1 (multiplication non commutative), having the effect of preconcatening the rotation q1 to this one

multiplyLeft

public final void multiplyLeft(Quaternion q1)
multiply this quaternion (q0) with another (q1) from the left side. q0 = q1 * q0 (multiplication non commutative), having the effect of postconcatening the rotation q1 to this one

slerp

public static Quaternion slerp(Quaternion q1,
                               Quaternion q2,
                               float t)
spherical linear interpolation. return a quaternion that lies "at t between q1 and q2", i.e. q1 for t == 0, q2 for t == 1 and an interpolation of q1 and q2 for values between 0 and 1. remind that q and -q describe the same rotation, thus interpolate to -q2 if path to it is shorter than to q2.

transformAxis

public float[] transformAxis(int num)
transform (rotate) an axis by the quaternion
Parameters:
i - no. of the axis (0 for x, 1 for y, 2 for z)
Returns:
the transformed axis (unit length)

rotateVector

public float[] rotateVector(float[] v)
rotate a vector by the quaternion; the result will be normalized if the input vector was; the input vector will not be changed

rotatePointCenter

public float[] rotatePointCenter(float[] v,
                                 float[] c)
rotate a point p about an arbitrary center c by the quaternion, i.e. add (the rotated vector from c to p) to c.
See Also:
rotateVector(float[])