Package us.ihmc.euclid.tuple4D.interfaces

Interface QuaternionBasics

All Superinterfaces:

Clearable, Orientation3DBasics, Orientation3DReadOnly, QuaternionReadOnly, Transformable, Tuple4DBasics, Tuple4DReadOnly

All Known Implementing Classes:

Quaternion, Quaternion32

public interface QuaternionBasics
extends QuaternionReadOnly, Orientation3DBasics, Tuple4DBasics

Write and read interface for unit-quaternion used to represent 3D orientations.

When describing a 4D tuple, its 4 components are often gathered in two groups: the scalar part s and the vector part (x, y, z).

Note on the difference between applying a 3D transform on a quaternion and a 4D vector:

• When transformed by a homogeneous transformation matrix, a quaternion is only pre-multiplied by the rotation part of the transform, resulting in concatenating the orientations of the transform and the quaternion.
• When transformed by a homogeneous transformation matrix, a 4D vector scalar part s remains unchanged. The vector part (x, y, z) is scaled and rotated, and translated by s times the translation part of the transform. Note that for s = 0, a 4D vector behaves as a 3D vector, and for s = 1 it behaves as a 3D point.

Author:

Sylvain Bertrand

Field Summary

Fields

Modifier and Type	Field	Description
static double	EPS_POW	Tolerance used in pow(double) to determine if this quaternion is equal to the neurtral quaternion.

Fields inherited from interface us.ihmc.euclid.orientation.interfaces.Orientation3DReadOnly

ORIENTATION_2D_EPSILON

Fields inherited from interface us.ihmc.euclid.tuple4D.interfaces.QuaternionReadOnly

EPS_UNITARY, GEOMETRICALLY_EQUALS_THRESHOLD

Method Summary

Modifier and Type	Method	Description
default void	absolute()	Sets each component of this tuple to its absolute value.
default void	append(Orientation3DReadOnly orientation)	Appends the given orientation to this orientation.
default void	appendInvertOther(Orientation3DReadOnly orientation)	Appends the inverse of the given orientation to this orientation.
default void	appendPitchRotation(double pitch)	Append a rotation about the y-axis to this quaternion.
default void	appendRollRotation(double roll)	Append a rotation about the x-axis to this quaternion.
default void	appendYawRotation(double yaw)	Append a rotation about the z-axis to this quaternion.
default void	applyInverseTransform(Transform transform)	Transforms this quaternion using the inverse of the given transform.
default void	applyTransform(Transform transform)	Transforms this quaternion using the given transform.
default void	conjugate()	Sets this quaternion to its conjugate.
default void	difference(QuaternionReadOnly q1, QuaternionReadOnly q2)	Sets this quaternion to the difference of q1 and q2.
default void	interpolate(QuaternionReadOnly qf, double alpha)	Performs a linear interpolation in SO(3) from this to qf given the percentage alpha.
default void	interpolate(QuaternionReadOnly q0, QuaternionReadOnly qf, double alpha)	Performs a linear interpolation in SO(3) from q0 to qf given the percentage alpha.
default void	inverse()	Sets this quaternion to its inverse.
default void	invert()	Inverses this orientation.
default void	multiply(QuaternionReadOnly other)	Multiplies this quaternion by other.
default void	multiply(QuaternionReadOnly q1, QuaternionReadOnly q2)	Sets this quaternion to the multiplication of q1 and q2.
default void	multiplyConjugateBoth(QuaternionReadOnly other)	Sets this quaternion to the multiplication of the conjugate of this and other.
default void	multiplyConjugateOther(QuaternionReadOnly other)	Multiplies this quaternion by the conjugate of other.
default void	multiplyConjugateThis(QuaternionReadOnly other)	Sets this quaternion to the multiplication of the conjugate of this and other.
default void	negate()	Changes the sign of each component of this tuple.
default void	normalize()	Recomputes this quaternion's components to ensure its norm is equal to 1.
default void	normalizeAndLimitToPi()	Normalizes this quaternion and then limits the angle of the rotation it represents to be ∈ [-pi;pi].
default void	pow(double alpha)	Raises this quaternion to the power alpha.
default void	preMultiply(QuaternionReadOnly other)	Pre-multiplies this quaternion by other.
default void	preMultiplyConjugateBoth(QuaternionReadOnly other)	Sets this quaternion to the multiplication of the conjugate of other and the conjugate of this.
default void	preMultiplyConjugateOther(QuaternionReadOnly other)	Sets this quaternion to the multiplication of the conjugate of other and this.
default void	preMultiplyConjugateThis(QuaternionReadOnly other)	Sets this quaternion to the multiplication of other and the conjugate of this.
default void	prepend(Orientation3DReadOnly orientation)	Prepends the given orientation to this orientation.
default void	prependInvertOther(Orientation3DReadOnly orientation)	Prepends the inverse of the given orientation to this orientation.
default void	prependPitchRotation(double pitch)	Prepend a rotation about the y-axis to this quaternion.
default void	prependRollRotation(double roll)	Prepend a rotation about the x-axis to this quaternion.
default void	prependYawRotation(double yaw)	Prepend a rotation about the z-axis to this quaternion.
default void	set(double x, double y, double z, double s)	Sets this tuple's components to x, y, z, and s.
default void	set(Orientation3DReadOnly orientation3DReadOnly)	Converts, if necessary, and sets this orientation to represents the same orientation as orientation3DReadOnly.
default void	set(QuaternionReadOnly other)	Sets this quaternion to other.
default void	setAndConjugate(QuaternionReadOnly other)	Sets this quaternion to the conjugate of other.
default void	setAndInverse(QuaternionReadOnly other)	Deprecated. Use Orientation3DBasics.setAndInvert(Orientation3DReadOnly) instead
default void	setAndNegate(QuaternionReadOnly other)	Sets this quaternion to other and then calls negate().
default void	setAndNormalize(QuaternionReadOnly other)	Sets this tuple to other and then calls normalize().
default void	setAndNormalize(Tuple4DReadOnly other)	Sets this tuple to other and then calls Tuple4DBasics.normalize().
default void	setAxisAngle(double x, double y, double z, double angle)	Sets this orientation to represents the same orientation as an axis-angle given its 4 components.
default void	setQuaternion(double x, double y, double z, double s)	Sets this orientation to represents the same orientation as a quaternion given its 4 components.
default void	setRotationMatrix(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22)	Sets this orientation to represents the same orientation as a rotation matrix given its 9 components.
default void	setRotationVector(double x, double y, double z)	Sets this orientation to represents the same orientation as a rotation vector given its 3 components.
default void	setToPitchQuaternion(double pitch)	Sets this quaternion to represent a counter clockwise rotation around the y-axis of an angle pitch.
default void	setToRollQuaternion(double roll)	Sets this quaternion to represent a counter clockwise rotation around the x-axis of an angle roll.
default void	setToYawQuaternion(double yaw)	Sets this quaternion to represent a counter clockwise rotation around the z-axis of an angle yaw.
default void	setToZero()	Sets this quaternion to the neutral quaternion representing a 'zero' rotation.
void	setUnsafe(double qx, double qy, double qz, double qs)	Sets the four components of this quaternion without normalizing.
default void	setYawPitchRoll(double yaw, double pitch, double roll)	Sets this orientation to represents the same orientation as a yaw-pitch-roll representation.

Methods inherited from interface us.ihmc.euclid.orientation.interfaces.Orientation3DBasics

appendInvertBoth, appendInvertThis, prependInvertBoth, prependInvertThis, setAndInvert, setAndNormalize, setEuler, setEuler, setRotationVector, setYawPitchRoll

Methods inherited from interface us.ihmc.euclid.orientation.interfaces.Orientation3DReadOnly

addTransform, checkIfOrientation2D, checkIfOrientation2D, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, isOrientation2D, toStringAsYawPitchRoll, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform

Methods inherited from interface us.ihmc.euclid.tuple4D.interfaces.QuaternionReadOnly

addTransform, checkIfIsZOnly, checkIfUnitary, checkIfUnitary, distance, distancePrecise, geometricallyEquals, get, get, get, getAngle, getEuler, getPitch, getRoll, getRotationVector, getYaw, getYawPitchRoll, inverseTransform, inverseTransform, inverseTransform, inverseTransform, isOrientation2D, isUnitary, isZOnly, norm, transform, transform, transform, transform

Methods inherited from interface us.ihmc.euclid.tuple4D.interfaces.Tuple4DBasics

containsNaN, set, set, set, set, set, set, set, set, setAndAbsolute, setAndNegate, setToNaN

Methods inherited from interface us.ihmc.euclid.tuple4D.interfaces.Tuple4DReadOnly

dot, epsilonEquals, equals, get, get, get, get, get, get, get, getElement, getElement32, getS, getS32, getX, getX32, getY, getY32, getZ, getZ32, normSquared

Field Detail

EPS_POW

static final double EPS_POW

Tolerance used in pow(double) to determine if this quaternion is equal to the neurtral quaternion.

See Also:

Constant Field Values

Method Detail

setUnsafe

void setUnsafe(double qx,
               double qy,
               double qz,
               double qs)

Sets the four components of this quaternion without normalizing.

This method is meant for internal usage. Prefer using set(double, double, double, double).

Parameters:

qx - the x-component of this quaternion.

qy - the y-component of this quaternion.

qz - the z-component of this quaternion.

qs - the s-component of this quaternion.

setToZero

default void setToZero()

Sets this quaternion to the neutral quaternion representing a 'zero' rotation.

Specified by:

setToZero in interface Clearable

absolute

default void absolute()

Sets each component of this tuple to its absolute value.

Specified by:

absolute in interface Tuple4DBasics

negate

default void negate()

Changes the sign of each component of this tuple.

Specified by:

negate in interface Tuple4DBasics

conjugate

default void conjugate()

Sets this quaternion to its conjugate.

      / -qx \
 q* = | -qy |
      | -qz |
      \  qs /
 

invert

default void invert()

Inverses this orientation.

If this orientation describes the orientation of a coordinate system A with respect to a coordinate system B, after this method, the orientation will describe the orientation of B with respect to A.

Note that appending or prepending an orientation with its inverse will result into a "zero" orientation.

Specified by:

invert in interface Orientation3DBasics

inverse

default void inverse()

Sets this quaternion to its inverse.

Essentially calling conjugate() and then normalize().

normalize

default void normalize()

Recomputes this quaternion's components to ensure its norm is equal to 1.

Edge cases:

• if this axis-angle contains Double.NaN, this method is ineffective.

Specified by:

normalize in interface Orientation3DBasics

Specified by:

normalize in interface Tuple4DBasics

normalizeAndLimitToPi

default void normalizeAndLimitToPi()

Normalizes this quaternion and then limits the angle of the rotation it represents to be ∈ [-pi;pi].

pow

default void pow(double alpha)

Raises this quaternion to the power alpha.

This is equivalent to converting this quaternion into an axis-angle, scaling the angle by alpha, and finally converting back to a quaternion.

Edge cases:

• If this quaternion contains Double.NaN, this method is ineffective.
• If the length of the vector part is below EPS_POW, the method setToZero() is called.

Parameters:

alpha - the real value of the power.

set

default void set(double x,
                 double y,
                 double z,
                 double s)

Sets this tuple's components to x, y, z, and s.

Specified by:

set in interface Tuple4DBasics

Parameters:

x - the new value for the x-component of this tuple.

y - the new value for the y-component of this tuple.

z - the new value for the z-component of this tuple.

s - the new value for the s-component of this tuple.

set

default void set(Orientation3DReadOnly orientation3DReadOnly)

Converts, if necessary, and sets this orientation to represents the same orientation as orientation3DReadOnly.

Specified by:

set in interface Orientation3DBasics

Parameters:

orientation3DReadOnly - the new orientation. Not modified.

set

default void set(QuaternionReadOnly other)

Sets this quaternion to other.

Parameters:

other - the other quaternion to copy the values from. Not modified.

setAndNormalize

default void setAndNormalize(Tuple4DReadOnly other)

Sets this tuple to other and then calls Tuple4DBasics.normalize().

Specified by:

setAndNormalize in interface Tuple4DBasics

Parameters:

other - the other tuple to copy the values from. Not modified.

setAndNormalize

default void setAndNormalize(QuaternionReadOnly other)

Sets this tuple to other and then calls normalize().

Parameters:

other - the other quaternion to copy the values from. Not modified.

setAndConjugate

default void setAndConjugate(QuaternionReadOnly other)

Sets this quaternion to the conjugate of other.

      / -qx \
 q* = | -qy |
      | -qz |
      \  qs /
 

Parameters:

other - the other quaternion to copy the values from. Not modified.

setAndNegate

default void setAndNegate(QuaternionReadOnly other)

Sets this quaternion to other and then calls negate().

Parameters:

other - the other quaternion to copy the values from. Not modified.

setAndInverse

default void setAndInverse(QuaternionReadOnly other)

Deprecated.

Use Orientation3DBasics.setAndInvert(Orientation3DReadOnly) instead

Sets this quaternion to the inverse of other.

Parameters:

other - the other quaternion to copy the values from. Not modified.

setAxisAngle

default void setAxisAngle(double x,
                          double y,
                          double z,
                          double angle)

Sets this orientation to represents the same orientation as an axis-angle given its 4 components.

Specified by:

setAxisAngle in interface Orientation3DBasics

Parameters:

x - x-component of the axis part of the axis-angle.

y - y-component of the axis part of the axis-angle.

z - z-component of the axis part of the axis-angle.

angle - the angle part of the axis-angle.

setQuaternion

default void setQuaternion(double x,
                           double y,
                           double z,
                           double s)

Sets this orientation to represents the same orientation as a quaternion given its 4 components.

Specified by:

setQuaternion in interface Orientation3DBasics

Parameters:

x - the x-component of the quaternion.

y - the y-component of the quaternion.

z - the z-component of the quaternion.

s - the s-component of the quaternion.

setRotationVector

default void setRotationVector(double x,
                               double y,
                               double z)

Sets this orientation to represents the same orientation as a rotation vector given its 3 components.

WARNING: a rotation vector is different from a yaw-pitch-roll or Euler angles representation. A rotation vector is equivalent to the axis of an axis-angle that is multiplied by the angle of the same axis-angle.

Specified by:

setRotationVector in interface Orientation3DBasics

Parameters:

x - the x-component of the rotation vector.

y - the y-component of the rotation vector.

z - the z-component of the rotation vector.

setYawPitchRoll

default void setYawPitchRoll(double yaw,
                             double pitch,
                             double roll)

Sets this orientation to represents the same orientation as a yaw-pitch-roll representation.

WARNING: the Euler angles or yaw-pitch-roll representation is sensitive to gimbal lock and is sometimes undefined.

The yaw-pitch-roll representation describes a 3D orientation as a succession of three rotations around three axes:

1. yaw: rotation around the z-axis,
2. pitch: rotation around the y-axis,
3. roll: rotation around the x-axis.

As an example, a rotation matrix can be computed from a yaw-pitch-roll representation as follows:

     / cos(yaw) -sin(yaw) 0 \   /  cos(pitch) 0 sin(pitch) \   / 1     0          0     \
 R = | sin(yaw)  cos(yaw) 0 | * |      0      1     0      | * | 0 cos(roll) -sin(roll) |
     \    0         0     1 /   \ -sin(pitch) 0 cos(pitch) /   \ 0 sin(roll)  cos(roll) /
 

Specified by:

setYawPitchRoll in interface Orientation3DBasics

Parameters:

yaw - the angle to rotate about the z-axis.

pitch - the angle to rotate about the y-axis.

roll - the angle to rotate about the x-axis.

setRotationMatrix

default void setRotationMatrix(double m00,
                               double m01,
                               double m02,
                               double m10,
                               double m11,
                               double m12,
                               double m20,
                               double m21,
                               double m22)

Sets this orientation to represents the same orientation as a rotation matrix given its 9 components.

Specified by:

setRotationMatrix in interface Orientation3DBasics

Parameters:

m00 - the new 1st row 1st column coefficient of the rotation matrix.

m01 - the new 1st row 2nd column coefficient of the rotation matrix.

m02 - the new 1st row 3rd column coefficient of the rotation matrix.

m10 - the new 2nd row 1st column coefficient of the rotation matrix.

m11 - the new 2nd row 2nd column coefficient of the rotation matrix.

m12 - the new 2nd row 3rd column coefficient of the rotation matrix.

m20 - the new 3rd row 1st column coefficient of the rotation matrix.

m21 - the new 3rd row 2nd column coefficient of the rotation matrix.

m22 - the new 3rd row 3rd column coefficient of the rotation matrix.

setToYawQuaternion

default void setToYawQuaternion(double yaw)

Sets this quaternion to represent a counter clockwise rotation around the z-axis of an angle yaw.

Parameters:

yaw - the angle to rotate about the z-axis.

setToPitchQuaternion

default void setToPitchQuaternion(double pitch)

Sets this quaternion to represent a counter clockwise rotation around the y-axis of an angle pitch.

Parameters:

pitch - the angle to rotate about the y-axis.

setToRollQuaternion

default void setToRollQuaternion(double roll)

Sets this quaternion to represent a counter clockwise rotation around the x-axis of an angle roll.

Parameters:

roll - the angle to rotate about the x-axis.

difference

default void difference(QuaternionReadOnly q1,
                        QuaternionReadOnly q2)

Sets this quaternion to the difference of q1 and q2.

this = q1^-1 * q2

Parameters:

q1 - the first quaternion in the difference. Not modified.

q2 - the second quaternion in the difference. Not modified.

multiply

default void multiply(QuaternionReadOnly other)

Multiplies this quaternion by other.

this = this * other

Parameters:

other - the other quaternion to multiply this. Not modified.

multiply

default void multiply(QuaternionReadOnly q1,
                      QuaternionReadOnly q2)

Sets this quaternion to the multiplication of q1 and q2.

this = q1 * q2

Parameters:

q1 - the first quaternion in the multiplication. Not modified.

q2 - the second quaternion in the multiplication. Not modified.

append

default void append(Orientation3DReadOnly orientation)

Appends the given orientation to this orientation.

Let's consider the following:

• three coordinate systems A, B, and C.
• this represents the orientation of B relative to A.
• orientation represents the orientation of C relative to B.

The result of calling this method will be that this, represents the orientation of C relative to A.

Appending orientations is in some way similar to summing translations. However, while the addition for translation is commutative, the "append" operation on orientation is NOT commutative. Such that: this.append(orientation) ≠ orientation.append(this).

Specified by:

append in interface Orientation3DBasics

Parameters:

orientation - the orientation to append to this orientation. Not modified.

multiplyConjugateOther

default void multiplyConjugateOther(QuaternionReadOnly other)

Multiplies this quaternion by the conjugate of other.

this = this * other*

Parameters:

other - the other quaternion to multiply this with. Not modified.

appendInvertOther

default void appendInvertOther(Orientation3DReadOnly orientation)

Appends the inverse of the given orientation to this orientation.

Let's consider the following:

• three coordinate systems A, B, and C.
• this represents the orientation of B relative to A.
• orientation represents the orientation of B relative to C.

The result of calling this method will be that this, represents the orientation of C relative to A.

This operation is in some way similar to subtracting translations, as in this operation can be seen as subtracting orientation to this.

Specified by:

appendInvertOther in interface Orientation3DBasics

Parameters:

orientation - the orientation which the inverse is to be appended to this orientation. Not modified.

multiplyConjugateThis

default void multiplyConjugateThis(QuaternionReadOnly other)

Sets this quaternion to the multiplication of the conjugate of this and other.

this = this* * other

Parameters:

other - the other quaternion to multiply this with. Not modified.

multiplyConjugateBoth

default void multiplyConjugateBoth(QuaternionReadOnly other)

Sets this quaternion to the multiplication of the conjugate of this and other.

this = this* * other

Parameters:

other - the other quaternion to multiply this with. Not modified.

appendYawRotation

default void appendYawRotation(double yaw)

Append a rotation about the z-axis to this quaternion.

               / qx =     0      \
 this = this * | qy =     0      |
               | qz = sin(yaw/2) |
               \ qs = cos(yaw/2) /
 

Specified by:

appendYawRotation in interface Orientation3DBasics

Parameters:

yaw - the angle to rotate about the z-axis.

appendPitchRotation

default void appendPitchRotation(double pitch)

Append a rotation about the y-axis to this quaternion.

               / qx =      0       \
 this = this * | qy = sin(pitch/2) |
               | qz =      0       |
               \ qs = cos(pitch/2) /
 

Specified by:

appendPitchRotation in interface Orientation3DBasics

Parameters:

pitch - the angle to rotate about the y-axis.

appendRollRotation

default void appendRollRotation(double roll)

Append a rotation about the x-axis to this quaternion.

               / qx = sin(roll/2) \
 this = this * | qy =      0      |
               | qz =      0      |
               \ qs = cos(roll/2) /
 

Specified by:

appendRollRotation in interface Orientation3DBasics

Parameters:

roll - the angle to rotate about the x-axis.

preMultiply

default void preMultiply(QuaternionReadOnly other)

Pre-multiplies this quaternion by other.

this = other * this

Parameters:

other - the other quaternion to multiply this with. Not modified.

prepend

default void prepend(Orientation3DReadOnly orientation)

Prepends the given orientation to this orientation.

Let's consider the following:

• three coordinate systems A, B, and C.
• this represents the orientation of C relative to B.
• orientation represents the orientation of B relative to A.

The result of calling this method will be that this, represents the orientation of C relative to A.

Prepending orientations is in some way similar to summing translations. However, while the addition for translation is commutative, the "prepend" operation on orientation is NOT commutative. Such that: this.prepend(orientation) ≠ orientation.prepend(this).

Specified by:

prepend in interface Orientation3DBasics

Parameters:

orientation - the orientation to prepend to this orientation. Not modified.

preMultiplyConjugateOther

default void preMultiplyConjugateOther(QuaternionReadOnly other)

Sets this quaternion to the multiplication of the conjugate of other and this.

this = other* * this

Parameters:

other - the other quaternion to multiply this with. Not modified.

prependInvertOther

default void prependInvertOther(Orientation3DReadOnly orientation)

Prepends the inverse of the given orientation to this orientation.

Let's consider the following:

• three coordinate systems A, B, and C.
• this represents the orientation of B relative to C.
• orientation represents the orientation of B relative to A.

The result of calling this method will be that this, represents the orientation of C relative to A.

This operation is in some way similar to subtracting translations, as in this operation can be seen as subtracting orientation to this.

Specified by:

prependInvertOther in interface Orientation3DBasics

Parameters:

orientation - the orientation which the inverse is to be appended to this orientation. Not modified.

preMultiplyConjugateThis

default void preMultiplyConjugateThis(QuaternionReadOnly other)

Sets this quaternion to the multiplication of other and the conjugate of this.

this = other * this*

Parameters:

other - the other quaternion to multiply this with. Not modified.

preMultiplyConjugateBoth

default void preMultiplyConjugateBoth(QuaternionReadOnly other)

Sets this quaternion to the multiplication of the conjugate of other and the conjugate of this.

this = other* * this*

Parameters:

other - the other quaternion to multiply this with. Not modified.

prependYawRotation

default void prependYawRotation(double yaw)

Prepend a rotation about the z-axis to this quaternion.

        / qx =     0      \
 this = | qy =     0      | * this
        | qz = sin(yaw/2) |
        \ qs = cos(yaw/2) /
 

Specified by:

prependYawRotation in interface Orientation3DBasics

Parameters:

yaw - the angle to rotate about the z-axis.

prependPitchRotation

default void prependPitchRotation(double pitch)

Prepend a rotation about the y-axis to this quaternion.

        / qx =      0       \
 this = | qy = sin(pitch/2) | * this
        | qz =      0       |
        \ qs = cos(pitch/2) /
 

Specified by:

prependPitchRotation in interface Orientation3DBasics

Parameters:

pitch - the angle to rotate about the y-axis.

prependRollRotation

default void prependRollRotation(double roll)

Prepend a rotation about the x-axis to this quaternion.

        / qx = sin(roll/2) \
 this = | qy =      0      | * this
        | qz =      0      |
        \ qs = cos(roll/2) /
 

Specified by:

prependRollRotation in interface Orientation3DBasics

Parameters:

roll - the angle to rotate about the x-axis.

interpolate

default void interpolate(QuaternionReadOnly qf,
                         double alpha)

Performs a linear interpolation in SO(3) from this to qf given the percentage alpha.

The interpolation method used here is often called a Spherical Linear Interpolation or SLERP.

Parameters:

qf - the other quaternion used for the interpolation. Not modified.

alpha - the percentage used for the interpolation. A value of 0 will result in not modifying this quaternion, while a value of 1 is equivalent to setting this quaternion to qf.

interpolate

default void interpolate(QuaternionReadOnly q0,
                         QuaternionReadOnly qf,
                         double alpha)

Performs a linear interpolation in SO(3) from q0 to qf given the percentage alpha.

The interpolation method used here is often called a Spherical Linear Interpolation or SLERP.

Parameters:

q0 - the first quaternion used in the interpolation. Not modified.

qf - the second quaternion used in the interpolation. Not modified.

alpha - the percentage to use for the interpolation. A value of 0 will result in setting this quaternion to q0, while a value of 1 is equivalent to setting this quaternion to qf.

applyTransform

default void applyTransform(Transform transform)

Transforms this quaternion using the given transform.

RigidBodyTransform, QuaternionBasedTransform, and AffineTransform prepend their rotation part the given quaternion. No scale or translation is applied to the quaternion such that the output of this method is still a unit-quaternion.

Specified by:

applyTransform in interface Transformable

Parameters:

transform - the geometric transform to apply on this vector. Not modified.

applyInverseTransform

default void applyInverseTransform(Transform transform)

Transforms this quaternion using the inverse of the given transform.

RigidBodyTransform, QuaternionBasedTransform, and AffineTransform prepend their rotation part the given quaternion. No scale or translation is applied to the quaternion such that the output of this method is still a unit-quaternion.

Specified by:

applyInverseTransform in interface Transformable

Parameters:

transform - the geometric transform to apply on this vector. Not modified.