Class iicm.utils3d.Quaternion
All Packages  Class Hierarchy  This Package  Previous  Next  Index

Class iicm.utils3d.Quaternion

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

public class Quaternion
extends Object
Quaternion - quaternion used to describe rotations/orientations Copyright (c) 1996,97 IICM

Constructor Index

 o Quaternion()
default: "identity" quaternion (angle 0, any axis)
 o Quaternion(float[], float)
create a quaternion with a normalized axis and angle
 o Quaternion(int, float[])
create a quaternion.
 o Quaternion(Quaternion)
copy constructor

Method Index

 o getAxisAngle()
convert quaternion to normalized axis and angle
 o levelize()
make the quaternion represent a rotation around (0, +/-1, 0); i.e.
 o multiply(Quaternion)
multiply this quaternion (q0) with another (q1) from the right side.
 o multiplyLeft(Quaternion)
multiply this quaternion (q0) with another (q1) from the left side.
 o product(Quaternion, Quaternion)
calculate the product of two quaternions (both q0, q1 unchanged).
 o renormalize()
ensure the quaternion stays normalized.
 o reset()
back to the "identity" quaternion
 o rotatePointCenter(float[], float[])
rotate a point p about an arbitrary center c by the quaternion, i.e.
 o rotateVector(float[])
rotate a vector by the quaternion; the result will be normalized if the input vector was; the input vector will not be changed
 o rotationAxisToVector(int, float[])
get the rotation (normalized axis and angle) that rotates a coordinate axis (given by number) to another (normalized) vector.
 o rotationBetweenVectors(float[], float[])
get the rotation (normalized axis and angle) that rotates vector a to vector b.
 o slerp(Quaternion, Quaternion, float)
spherical linear interpolation.
 o transformAxis(int)
transform (rotate) an axis by the quaternion
 o untilt()
make the quaternion represent tilt-free rotation (no z part)

Constructors

 o Quaternion
  public Quaternion()
default: "identity" quaternion (angle 0, any axis)
 o Quaternion
  public Quaternion(float axis[],
                    float angle)
create a quaternion with a normalized axis and angle
 o Quaternion
  public Quaternion(int offset,
                    float arr[])
create a quaternion. take normalized axis and angle out of an array, starting at offset position.
 o Quaternion
  public Quaternion(Quaternion q)
copy constructor

Methods

 o 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
 o 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
 o reset
  public final void reset()
back to the "identity" quaternion
 o levelize
  public void levelize()
make the quaternion represent a rotation around (0, +/-1, 0); i.e. on the same "level"
 o untilt
  public void untilt()
make the quaternion represent tilt-free rotation (no z part)
 o renormalize
  public final void renormalize()
ensure the quaternion stays normalized. Useful e.g. after several mulitplications
 o getAxisAngle
  public final float[] getAxisAngle()
convert quaternion to normalized axis and angle
 o product
  public final 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.
Returns:
q0 * q1 (multiplication non commutative)
 o 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
 o 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
 o 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.
 o 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)
 o 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
 o 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

All Packages  Class Hierarchy  This Package  Previous  Next  Index