Data.Vect.Float.Util.Quaternion

The unit sphere in the space of quaternions has the group structure SU(2) coming from the quaternion multiplication, which is the double cover of the group SO(3) of rotations in R^3. Thus, unit quaternions can be used to encode rotations in 3D, which is a more compact encoding (4 floats) than a 3x3 matrix; however, there are two quaternions corresponding to each rotation.

See http://en.wikipedia.org/wiki/Quaternion and http://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation for more information.

types

newtype Quaternion

The type for quaternions.

Constructors

Q Vec4

Instances

Read Quaternion

Show Quaternion

Storable Quaternion

Random Quaternion

DotProd Quaternion

Vector Quaternion

MultSemiGroup Quaternion

AbelianGroup Quaternion

Interpolate Quaternion

UnitVector Quaternion UnitQuaternion

newtype UnitQuaternion

The type for unit quaternions.

Constructors

U Vec4

Instances

Read UnitQuaternion

Show UnitQuaternion

Storable UnitQuaternion

Random UnitQuaternion

DotProd UnitQuaternion

MultSemiGroup UnitQuaternion

UnitVector Quaternion UnitQuaternion

LeftModule UnitQuaternion Vec3

type Q = Quaternion

An abbreviated type synonym for quaternions

type U = UnitQuaternion

An abbreviated type synonym for unit quaternions

general quaternions

unitQ :: Q

zeroQ :: Q

multQ :: Q -> Q -> Q

negQ :: Q -> Q

normalizeQ :: Q -> Q

invQ :: Q -> Q

The inverse quaternion

fromQ :: Q -> Vec4

toQ :: Vec4 -> Q

unit quaternions

unitU :: U

multU :: U -> U -> U

negU :: U -> U

The opposite quaternion (which encodes the same rotation)

normalizeU :: U -> U

This is no-op, up to numerical imprecision. However, if you multiply together a large number of unit quaternions, it may be a good idea to normalize the end result.

invU :: U -> U

The inverse of a unit quaternion

fromU :: U -> Vec4

fromU' :: U -> Normal4

mkU :: Vec4 -> U

toU :: Normal4 -> U

unsafeToU :: Vec4 -> U

unit quaternions as rotations

actU :: U -> Vec3 -> Vec3

The left action of unit quaternions on 3D vectors. That is,

 actU q1 $ actU q2 v  ==  actU (q1 `multU` q2) v 

rotU :: Vec3 -> Float -> U

The quaternion to encode rotation around an axis. Please note that quaternions act on the left, that is

 rotU axis1 angl1 *. rotU axis2 angl2 *. v  ==  (rotU axis1 angl1 .*. rotU axis2 angl2) *. v 

rotU' :: Normal3 -> Float -> U

longSlerpU :: Float -> U -> U -> U

Interpolation of unit quaternions. Note that when applied to rotations, this may be not what you want, since it is possible that the shortest path in the space of unit quaternions is not the shortest path in the space of rotations; see slerpU!

slerpU :: Float -> U -> U -> U

This is shortest path interpolation in the space of rotations; however this is achieved by possibly flipping the first endpoint in the space of quaternions. Thus slerpU 0.001 q1 q2 may be very far from q1 (and very close to negU q1) in the space of quaternions (but they are very close in the space of rotations).

rightOrthoU :: U -> Ortho3

Makes a rotation matrix (to be multiplied with on the right) out of a unit quaternion:

 v .* rightOrthoU (rotU axis angl)  ==  v .* rotMatrix3 axis angl

Please note that while these matrices act on the right, quaternions act on the left; thus

 rightOrthoU q1 .*. rightOrthoU q2  ==  rightOrthoU (q2 .*. q1)

leftOrthoU :: U -> Ortho3

Makes a rotation matrix (to be multiplied with on the left) out of a unit quaternion.

 leftOrthoU (rotU axis angl) *. v  ==  v .* rotMatrix3 axis angl