Package us.ihmc.euclid.axisAngle.interfaces

Interface AxisAngleBasics

All Superinterfaces:

AxisAngleReadOnly, Clearable, Orientation3DBasics, Orientation3DReadOnly

All Known Implementing Classes:

AxisAngle, AxisAngle32

public interface AxisAngleBasics
extends AxisAngleReadOnly, Orientation3DBasics, Clearable

Write and read interface for an axis-angle object.

An axis-angle is used to represent a 3D orientation by a unitary axis of components (x, y, z) and an angle of rotation usually expressed in radians.

Author:

Sylvain Bertrand

Field Summary

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

ORIENTATION_2D_EPSILON

Method Summary

Modifier and Type	Method	Description
default void	absolute()	Sets each component of this axis-angle to its absolute value.
default void	append(Orientation3DReadOnly other)	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 axis-angle.
default void	appendRollRotation(double roll)	Append a rotation about the x-axis to this axis-angle.
default void	appendYawRotation(double yaw)	Append a rotation about the z-axis to this axis-angle.
default boolean	containsNaN()	Tests if this axis-angle contains a Double.NaN.
default void	inverse()	Deprecated. Use invert() instead.
default void	invert()	Inverses this orientation.
default void	multiply(AxisAngleReadOnly other)	Multiplies this axis-angle by other.
default void	multiply(AxisAngleReadOnly aa1, AxisAngleReadOnly aa2)	Sets this axis-angle to the multiplication of aa1 and aa2.
default void	multiplyInvertBoth(AxisAngleReadOnly other)	Sets this axis-angle to the multiplication of the inverse of this and the inverse of other.
default void	multiplyInvertOther(AxisAngleReadOnly other)	Multiplies this axis-angle by the inverse of other.
default void	multiplyInvertThis(AxisAngleReadOnly other)	Sets this axis-angle to the multiplication of the inverse of this and other.
default void	negate()	Negates each component of this axis-angle.
default void	normalize()	Normalizes the axis of this axis-angle such that its norm is equal to 1 after calling this method and its direction remains unchanged.
default void	normalizeAxis()	Deprecated. Use normalize() instead
default void	preMultiply(AxisAngleReadOnly other)	Pre-multiplies this axis-angle by other.
default void	preMultiplyInvertBoth(AxisAngleReadOnly other)	Sets this axis-angle to the multiplication of the inverse of other and the inverse of this.
default void	preMultiplyInvertOther(AxisAngleReadOnly other)	Sets this axis-angle to the multiplication of the inverse of other and this.
default void	preMultiplyInvertThis(AxisAngleReadOnly other)	Sets this axis-angle to the multiplication of other and the inverse 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 axis-angle.
default void	prependRollRotation(double roll)	Prepend a rotation about the x-axis to this axis-angle.
default void	prependYawRotation(double yaw)	Prepend a rotation about the z-axis to this axis-angle.
default void	scaleAngle(double scale)	Multiplies the angle of this axis-angle by the given scale.
default void	set(double[] axisAngleArray)	Copies the values in the given array into this axis-angle as follows: this.setX(axisAngleArray[0]); this.setY(axisAngleArray[1]); this.setZ(axisAngleArray[2]); this.setAngle(axisAngleArray[3]);
default void	set(double x, double y, double z, double angle)	Sets this axis-angle to represent a new rotation of axis (x, y, z) and angle of angle.
default void	set(float[] axisAngleArray)	Copies the values in the given array into this axis-angle as follows: this.setX(axisAngleArray[0]); this.setY(axisAngleArray[1]); this.setZ(axisAngleArray[2]); this.setAngle(axisAngleArray[3]);
default void	set(int startIndex, double[] axisAngleArray)	Copies the values in the given array into this axis-angle as follows: this.setX(axisAngleArray[startIndex + 0]); this.setY(axisAngleArray[startIndex + 1]); this.setZ(axisAngleArray[startIndex + 2]); this.setAngle(axisAngleArray[startIndex + 3]);
default void	set(int startIndex, float[] axisAngleArray)	Copies the values in the given array into this axis-angle as follows: this.setX(axisAngleArray[startIndex + 0]); this.setY(axisAngleArray[startIndex + 1]); this.setZ(axisAngleArray[startIndex + 2]); this.setAngle(axisAngleArray[startIndex + 3]);
default void	set(AxisAngleReadOnly other)	Sets this axis-angle to the same value as the given axis-angle other.
default void	set(Orientation3DReadOnly orientation3DReadOnly)	Converts, if necessary, and sets this orientation to represents the same orientation as orientation3DReadOnly.
default void	set(Vector3DReadOnly axis, double angle)	Sets the axis and the angle of this axis-angle.
default void	setAndNegate(AxisAngleReadOnly other)	Sets this axis-angle to other and then calls negate().
void	setAngle(double angle)	Sets a new angle to this axis-angle.
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	setElement(int index, double value)	Selects a component of this axis-angle based on index and sets it to value.
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	setToNaN()	Sets the components of this axis-angle to Double.NaN.
default void	setToZero()	Sets the components of this axis-angle to represent a "zero" rotation.
void	setX(double x)	Sets a new x-component for the axis of this axis-angle.
void	setY(double y)	Sets a new y-component for the axis of this axis-angle.
default void	setYawPitchRoll(double yaw, double pitch, double roll)	Sets this orientation to represents the same orientation as a yaw-pitch-roll representation.
void	setZ(double z)	Sets a new z-component for the axis of this axis-angle.

Methods inherited from interface us.ihmc.euclid.axisAngle.interfaces.AxisAngleReadOnly

addTransform, axisNorm, checkIfIsZOnly, distance, epsilonEquals, equals, geometricallyEquals, get, get, get, get, get, get, get, getAngle, getAngle32, getElement, getElement32, getEuler, getPitch, getRoll, getRotationVector, getX, getX32, getY, getY32, getYaw, getYawPitchRoll, getZ, getZ32, inverseTransform, inverseTransform, inverseTransform, inverseTransform, isAxisUnitary, isOrientation2D, isZOnly, transform, transform, transform, transform

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

Method Detail

setAngle

void setAngle(double angle)

Sets a new angle to this axis-angle.

Parameters:

angle - the new angle.

setX

void setX(double x)

Sets a new x-component for the axis of this axis-angle.

Parameters:

x - the new axis x-component.

setY

void setY(double y)

Sets a new y-component for the axis of this axis-angle.

Parameters:

y - the new axis y-component.

setZ

void setZ(double z)

Sets a new z-component for the axis of this axis-angle.

Parameters:

z - the new axis z-component.

setToZero

default void setToZero()

Sets the components of this axis-angle to represent a "zero" rotation. After calling the axis is equal to (1, 0, 0) and the angle to 0.

Specified by:

setToZero in interface Clearable

setToNaN

default void setToNaN()

Sets the components of this axis-angle to Double.NaN.

Specified by:

setToNaN in interface Clearable

containsNaN

default boolean containsNaN()

Tests if this axis-angle contains a Double.NaN.

Specified by:

containsNaN in interface AxisAngleReadOnly

Specified by:

containsNaN in interface Clearable

Returns:

true if this axis-angle contains a Double.NaN, false otherwise.

absolute

default void absolute()

Sets each component of this axis-angle to its absolute value.

negate

default void negate()

Negates each component of this axis-angle.

inverse

@Deprecated
default void inverse()

Deprecated.

Use invert() instead.

Sets this axis-angle to its inverse.

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

normalizeAxis

@Deprecated
default void normalizeAxis()

Deprecated.

Use normalize() instead

Normalizes the axis of this axis-angle such that its norm is equal to 1 after calling this method and its direction remains unchanged.

Edge cases:

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

normalize

default void normalize()

Normalizes the axis of this axis-angle such that its norm is equal to 1 after calling this method and its direction remains unchanged.

Edge cases:

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

Specified by:

normalize in interface Orientation3DBasics

scaleAngle

default void scaleAngle(double scale)

Multiplies the angle of this axis-angle by the given scale.

Parameters:

scale - the scaling factor to apply to the angle of this axis-angle.

set

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

Sets this axis-angle to represent a new rotation of axis (x, y, z) and angle of angle.

Parameters:

x - x-component of the new axis.

y - y-component of the new axis.

z - z-component of the new axis.

angle - the new angle.

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(Vector3DReadOnly axis,
                 double angle)

Sets the axis and the angle of this axis-angle.

Parameters:

axis - the new axis. Not modified.

angle - the new angle.

set

default void set(AxisAngleReadOnly other)

Sets this axis-angle to the same value as the given axis-angle other.

Parameters:

other - the other axis-angle. Not modified.

setAndNegate

default void setAndNegate(AxisAngleReadOnly other)

Sets this axis-angle to other and then calls negate().

Parameters:

other - the other axis-angle to copy the values from. Not modified.

set

default void set(double[] axisAngleArray)

Copies the values in the given array into this axis-angle as follows:

• this.setX(axisAngleArray[0]);
• this.setY(axisAngleArray[1]);
• this.setZ(axisAngleArray[2]);
• this.setAngle(axisAngleArray[3]);

Parameters:

axisAngleArray - the array containing the new values for this axis-angle. Not modified.

set

default void set(int startIndex,
                 double[] axisAngleArray)

Copies the values in the given array into this axis-angle as follows:

• this.setX(axisAngleArray[startIndex + 0]);
• this.setY(axisAngleArray[startIndex + 1]);
• this.setZ(axisAngleArray[startIndex + 2]);
• this.setAngle(axisAngleArray[startIndex + 3]);

Parameters:

startIndex - the first index to start reading from in the array.

axisAngleArray - the array containing the new values for this axis-angle. Not modified.

set

default void set(float[] axisAngleArray)

Copies the values in the given array into this axis-angle as follows:

• this.setX(axisAngleArray[0]);
• this.setY(axisAngleArray[1]);
• this.setZ(axisAngleArray[2]);
• this.setAngle(axisAngleArray[3]);

Parameters:

axisAngleArray - the array containing the new values for this axis-angle. Not modified.

set

default void set(int startIndex,
                 float[] axisAngleArray)

Copies the values in the given array into this axis-angle as follows:

• this.setX(axisAngleArray[startIndex + 0]);
• this.setY(axisAngleArray[startIndex + 1]);
• this.setZ(axisAngleArray[startIndex + 2]);
• this.setAngle(axisAngleArray[startIndex + 3]);

Parameters:

startIndex - the first index to start reading from in the array.

axisAngleArray - the array containing the new values for this axis-angle. 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.

setElement

default void setElement(int index,
                        double value)

Selects a component of this axis-angle based on index and sets it to value.

For index values of 0, 1, and 2, the corresponding components are x, y, and z, respectively, while 3 corresponds to the angle.

Parameters:

index - the index of the component to set.

value - the new value of the selected component.

Throws:

java.lang.IndexOutOfBoundsException - if index ∉ [0, 3].

multiply

default void multiply(AxisAngleReadOnly other)

Multiplies this axis-angle by other.

this = this * other

Parameters:

other - the other axis-angle to multiply this. Not modified.

append

default void append(Orientation3DReadOnly other)

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:

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

multiply

default void multiply(AxisAngleReadOnly aa1,
                      AxisAngleReadOnly aa2)

Sets this axis-angle to the multiplication of aa1 and aa2.

this = aa1 * aa2

Parameters:

aa1 - the first axis-angle in the multiplication. Not modified.

aa2 - the second axis-angle in the multiplication. Not modified.

multiplyInvertOther

default void multiplyInvertOther(AxisAngleReadOnly other)

Multiplies this axis-angle by the inverse of other.

this = this * other^-1

Parameters:

other - the other axis-angle to multiply this. 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.

multiplyInvertThis

default void multiplyInvertThis(AxisAngleReadOnly other)

Sets this axis-angle to the multiplication of the inverse of this and other.

this = this^-1 * other

Parameters:

other - the other axis-angle to multiply this. Not modified.

multiplyInvertBoth

default void multiplyInvertBoth(AxisAngleReadOnly other)

Sets this axis-angle to the multiplication of the inverse of this and the inverse of other.

this = this^-1 * other^-1

Parameters:

other - the other axis-angle to multiply this. Not modified.

appendYawRotation

default void appendYawRotation(double yaw)

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

               / ux    =  0  \
 this = this * | uy    =  0  |
               | uz    =  1  |
               \ angle = yaw /
 

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 axis-angle.

               / ux    =  0    \
 this = this * | uy    =  1    |
               | uz    =  0    |
               \ angle = pitch /
 

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 axis-angle.

               / ux    =  1   \
 this = this * | uy    =  0   |
               | uz    =  0   |
               \ angle = roll /
 

Specified by:

appendRollRotation in interface Orientation3DBasics

Parameters:

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

preMultiply

default void preMultiply(AxisAngleReadOnly other)

Pre-multiplies this axis-angle by other.

this = other * other

Parameters:

other - the other axis-angle to multiply this. 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.

preMultiplyInvertOther

default void preMultiplyInvertOther(AxisAngleReadOnly other)

Sets this axis-angle to the multiplication of the inverse of other and this.

this = other^-1 * this

Parameters:

other - the other axis-angle to multiply this. 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.

preMultiplyInvertThis

default void preMultiplyInvertThis(AxisAngleReadOnly other)

Sets this axis-angle to the multiplication of other and the inverse of this.

this = other * this^-1

Parameters:

other - the other axis-angle to multiply this. Not modified.

preMultiplyInvertBoth

default void preMultiplyInvertBoth(AxisAngleReadOnly other)

Sets this axis-angle to the multiplication of the inverse of other and the inverse of this.

this = other^-1 * this^-1

Parameters:

other - the other axis-angle to multiply this. Not modified.

prependYawRotation

default void prependYawRotation(double yaw)

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

        / ux    =  0  \
 this = | uy    =  0  | * this
        | uz    =  1  |
        \ angle = yaw /
 

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 axis-angle.

        / ux    =  0    \
 this = | uy    =  1    | * this
        | uz    =  0    |
        \ angle = pitch /
 

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 axis-angle.

        / ux    =  1   \
 this = | uy    =  0   | * this
        | uz    =  0   |
        \ angle = roll /
 

Specified by:

prependRollRotation in interface Orientation3DBasics

Parameters:

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