Oolite JavaScript Reference: Quaternion

Prototype: Object
Subtypes: none

The Quaternion class represents a quaternion, a four-dimensional number, which is used to express rotations. Explaining quaternion mathematics is way beyond the scope of this document, but a quick overview is provided below.

Quaternions for Rotations

This is a very quick, pragmatic discussion of quaternions as they apply to rotating things in Oolite. If you’re interested in the theory, see:

• Wikipedia: Quaternions and spatial rotation
• Wikipedia: Quaternion
• MathWorld: Quaternion

Consider a ship at point h oriented to face a station at point t. This can be expressed as the vector from the ship to the station, v = t − h. However, if the ship rolls, it is still heading along the same vector v, so additional information is required: a twist angle, α. A rotation quaternion is a tuple Q = (w, x, y, z), such that

Q_w = cos α/2

Q_x = v_x sin α/2

Q_y = v_y sin α/2

Q_z = v_z sin α/2

Additionally, a rotation quaternion must be normalized; that is, it must fulfill the normal invariant Q_w² + Q_x² + Q_y² + Q_z² = 1. Unlike with property list scripting and specifications, quaternions will not be automatically normalized for you except where specified, but a normalize() method is provided.

An identity rotation – that is, one which, when applied, has no effect – is represented by the identity quaternion (1, 0, 0, 0).

The Quaternion class provides several methods to make construction of rotations easier: rotate(), rotateX(), rotateY(), rotateZ().

Rotations can be combined by quaternion multiplication (see the multiply() method). Note that quaternion multiplication is not commutative; that is, PQ is not the same as QP. If this seems strange, take a box or book and assign it x, y and z axes. Rotate it about the x axis and then the y axis. Then, rotate it about the y axis followed by the x axis. If the results of the two rotations are the same, you’re doing it wrong.

Quaternion Expressions

All Oolite-provided functions which take a quaternion as an argument may instead be passed an Entity instead, in which case the entity’s orientation is used. In specifications, this is represented by arguments named quaternionOrEntity. (Is this actually useful? It seems less compellingly so than the vector equivalent. -- User:Ahruman)

Additionally, most Quaternion methods may be passed four numbers, or an array of four numbers, instead of a quaternion. In specifications, this is represented by arguments named quaternionExpression.

Properties

w

w : Number (read/write)

The w component of the quaternion.

x

x : Number (read/write)

The x component of the quaternion.

y

y : Number (read/write)

The y component of the quaternion.

z

z : Number (read/write)

The z component of the quaternion.

Methods

Constructor

new Quaternion([value : quaternionExpression])

Create a new quaternion with the specified value. If no value is provided, the vector is initialized to the identity quaternion (1, 0, 0, 0).

dot

function dot(q : quaternionExpression) : Number

Returns the quaternion dot product (inner product) of the target and q. (For two normalized quaternions, this will be 1 if they’re equal, -1 if they’re opposite and 0 if they’re perpendicular.)

multiply

function multiply(q : quaternionExpression) : Quaternion

Returns the standard quaternion product (Grassmann product) of the target and q. This is used to concatenate rotations together.

normalize

function normalize() : Quaternion

Returns the quaternion adjusted to fulfill the normal invariant. Specifically, this divides each component by the square root of (w² + x² + y² + z²).

rotate

function rotate(a : vectorExpression, angle : Number) : Quaternion

Returns a quaternion rotated angle radians about the axis of a. The vector a must be a normalized vector. (FIXME: clockwise or anticlockwise?)

rotateX

function rotateX(angle : Number) : Quaternion

Returns a quaternion rotated angle radians about the x axis. (FIXME: clockwise or anticlockwise?)

q.rotateX(angle) is equivalent to q.rotate([1, 0, 0], angle).

rotateY

function rotateY(angle : Number) : Quaternion

Returns a quaternion rotated angle radians about the y axis. (FIXME: clockwise or anticlockwise?)

q.rotateY(angle) is equivalent to q.rotate([0, 1, 0], angle).

rotateZ

function rotateZ(angle : Number) : Quaternion

Returns a quaternion rotated angle radians about the z axis. (FIXME: clockwise or anticlockwise?)

q.rotateZ(angle) is equivalent to q.rotate([0, 0, 1], angle).

toArray

function toArray() : Array

Returns an array of the quaternion’s components, in the order [w, x, y, z]. q.toArray() is equivalent to [q.w, q.x, q.y, q.z].

vectorForward

function vectorForward() : Vector

Returns the forward vector from the quaternion.

To understand this, consider an entity which is aligned with the world co-ordinate system – that is, its orientation is the identity quaternion (1, 0, 0, 0), and thus its x axis is aligned with the world x axis, its y axis is aligned with the world y axis and its z axis is aligned with the world z axis. If it is rotated by a quaternion Q, Q.vectorForward() is the forward (z) axis after rotation. Similarly, Q.vectorUp() is the up (y) axis after rotation, and Q.vectorRight() is the right (x) axis after rotation.

vectorRight

function vectorRight() : Vector

Returns the right vector from the quaternion. See vectorForward() for a definition.

vectorUp

function vectorUp() : Vector

Returns the up vector from the quaternion. See vectorForward() for a definition.

Static Methods

random

function random() : Quaternion

Returns a random normalized quaternion.