RigidBodyTransform

java.lang.Object
- us.ihmc.euclid.transform.RigidBodyTransform

All Implemented Interfaces:

Clearable, EpsilonComparable<RigidBodyTransform>, GeometricallyComparable<RigidBodyTransform>, Settable<RigidBodyTransform>, Transform
```
public class RigidBodyTransform
extends java.lang.Object
implements Transform, EpsilonComparable<RigidBodyTransform>, GeometricallyComparable<RigidBodyTransform>, Settable<RigidBodyTransform>, Clearable
```
A RigidBodyTransform represents a 4-by-4 transformation matrix that can rotate and translate.
For efficiency and readability, the transform is never stored in a 4-by-4 matrix.

The RigidBodyTransform is composed of RotationMatrix to rotate, and a Vector3D to translate.

A few special cases to keep in mind:
- when transforming a QuaternionBasics, the rotation part of this transform is prepend to the quaternion, such that the output remains a proper unit-quaternion that still only describes a rotation.
- when transforming a RotationMatrix, the rotation part of this transform is prepend to the rotation matrix, such that the output remains a proper rotation matrix.
- when applying this transform on a Point3DBasics or Point2DBasics, this object is, in order, rotated and then translated.
- when applying this transform on a Vector3DBasics or Vector2DBasics, this object is only rotated. It is NOT translated.
Author:

Sylvain Bertrand

Constructor Summary

Constructors
Constructor	Description
`RigidBodyTransform()`	Creates a new rigid-body transform set to identity.
`RigidBodyTransform(double[] transformArray)`	Sets the raw components of this rigid-body transform from the given `transformArray`.
`RigidBodyTransform(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23)`	Creates a new rigid-body transform and sets it from the given 12 coefficients.
`RigidBodyTransform(org.ejml.data.DenseMatrix64F matrix)`	Creates a new rigid-body transform and sets its raw components from the given `matrix`.
`RigidBodyTransform(Orientation3DReadOnly orientation, Tuple3DReadOnly translation)`	Creates a new rigid-body transform and sets it to the given `orientation` and `translation`.
`RigidBodyTransform(QuaternionBasedTransform quaternionBasedTransform)`	Creates a new rigid-body transform and sets it to `quaternionBasedTransform`.
`RigidBodyTransform(RigidBodyTransform other)`	Creates a new rigid-body transform and sets it to `other`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`appendPitchRotation(double pitch)`	Append a rotation about the y-axis to the rotation part of this transform.
`void`	`appendRollRotation(double roll)`	Append a rotation about the x-axis to the rotation part of this transform.
`void`	`appendTranslation(double x, double y, double z)`	Append a translation transform to this transform.
`void`	`appendTranslation(Tuple3DReadOnly translation)`	Append a translation transform to this transform.
`void`	`appendYawRotation(double yaw)`	Append a rotation about the z-axis to the rotation part of this transform.
`void`	`checkIfRotation2D()`	Asserts that the rotation part of this transform describes a transformation in the XY plane.
`boolean`	`containsNaN()`	Tests if at least one element of this transform is equal to Double.NaN.
`double`	`determinantRotationPart()`	Computes the determinant of the rotation part of this transform.
`boolean`	`epsilonEquals(RigidBodyTransform other, double epsilon)`	Tests separately and on a per component basis if the rotation part and the translation part of this transform and `other` are equal to an `epsilon`.
`boolean`	`equals(java.lang.Object object)`	Tests if the given `object`'s class is the same as this, in which case the method returns `equals(RigidBodyTransform)`, it returns `false` otherwise or if the `object` is `null`.
`boolean`	`equals(RigidBodyTransform other)`	Tests separately and on a per component basis if the rotation part and the translation part of this transform and `other` are exactly equal.
`boolean`	`geometricallyEquals(RigidBodyTransform other, double epsilon)`	Two rigid body transforms are considered geometrically equal if both the rotation matrices and translation vectors are equal.
`void`	`get(double[] transformArrayToPack)`	Packs this transform as a 4-by-4 matrix into a 1D row-major array.
`void`	`get(float[] transformArrayToPack)`	Packs this transform as a 4-by-4 matrix into a 1D row-major array.
`void`	`get(int startRow, int startColumn, org.ejml.data.DenseMatrix64F matrixToPack)`	Packs this transform as a 4-by-4 matrix.
`void`	`get(org.ejml.data.DenseMatrix64F matrixToPack)`	Packs this transform as a 4-by-4 matrix.
`void`	`get(Matrix3DBasics rotationMarixToPack, Tuple3DBasics translationToPack)`	Packs the rotation matrix and translation vector of this rigid-body transform.
`void`	`get(RotationMatrix rotationMarixToPack, Tuple3DBasics translationToPack)`	Packs the rotation matrix and translation vector of this rigid-body transform.
`void`	`get(RotationScaleMatrix rotationMarixToPack, Tuple3DBasics translationToPack)`	Packs the rotation matrix and translation vector of this rigid-body transform.
`void`	`get(Orientation3DBasics orientationToPack, Tuple3DBasics translationToPack)`	Packs the rotation matrix and translation vector of this rigid-body transform.
`void`	`get(Vector3DBasics rotationVectorToPack, Tuple3DBasics translationToPack)`	Packs the rotation matrix and translation vector of this rigid-body transform.
`double`	`getElement(int row, int column)`	Retrieves and returns a coefficient of this transform given its row and column indices.
`double`	`getM00()`	Gets the 1st row 1st column coefficient of this transform.
`double`	`getM01()`	Gets the 1st row 2nd column coefficient of this transform.
`double`	`getM02()`	Gets the 1st row 3rd column coefficient of this transform.
`double`	`getM03()`	Gets the 1st row 4th column coefficient of this transform.
`double`	`getM10()`	Gets the 2nd row 1st column coefficient of this transform.
`double`	`getM11()`	Gets the 2nd row 2nd column coefficient of this transform.
`double`	`getM12()`	Gets the 2nd row 3rd column coefficient of this transform.
`double`	`getM13()`	Gets the 2nd row 4th column coefficient of this transform.
`double`	`getM20()`	Gets the 3rd row 1st column coefficient of this transform.
`double`	`getM21()`	Gets the 3rd row 2nd column coefficient of this transform.
`double`	`getM22()`	Gets the 3rd row 3rd column coefficient of this transform.
`double`	`getM23()`	Gets the 3rd row 4th column coefficient of this transform.
`double`	`getM30()`	Gets the 4th row 1st column coefficient of this transform.
`double`	`getM31()`	Gets the 4th row 2nd column coefficient of this transform.
`double`	`getM32()`	Gets the 4th row 3rd column coefficient of this transform.
`double`	`getM33()`	Gets the 4th row 4th column coefficient of this transform.
`void`	`getRotation(double[] rotationMatrixArrayToPack)`	Packs the rotation part of this rigid-body transform in 1D row-major array.
`void`	`getRotation(org.ejml.data.DenseMatrix64F rotationMatrixToPack)`	Packs the rotation part of this rigid-body transform.
`void`	`getRotation(Matrix3DBasics rotationMatrixToPack)`	Packs the rotation part of this rigid-body transform.
`void`	`getRotation(RotationMatrix rotationMatrixToPack)`	Packs the rotation part of this rigid-body transform.
`void`	`getRotation(RotationScaleMatrix rotationMatrixToPack)`	Packs the rotation part of this rigid-body transform.
`void`	`getRotation(Orientation3DBasics orientationToPack)`	Packs the rotation part of this rigid-body transform as a quaternion.
`void`	`getRotation(Vector3DBasics rotationVectorToPack)`	Packs the rotation part of this rigid-body transform as a rotation vector.
`void`	`getRotationEuler(Vector3DBasics eulerAnglesToPack)`	Computes and packs the orientation described by the rotation part of this transform as the Euler angles.
`RotationMatrixReadOnly`	`getRotationMatrix()`	Gets the read-only reference to the rotation part of this transform.
`void`	`getRotationYawPitchRoll(double[] yawPitchRollToPack)`	Computes and packs the orientation described by the rotation part of this transform as the yaw-pitch-roll angles.
`void`	`getTranslation(Tuple3DBasics translationToPack)`	Packs the translation part of this rigid-body transform.
`Vector3DReadOnly`	`getTranslationVector()`	Gets the read-only reference of the translation part of this rigid-body transform.
`double`	`getTranslationX()`	Gets the x-component of the translation part of this transform.
`double`	`getTranslationY()`	Gets the y-component of the translation part of this transform.
`double`	`getTranslationZ()`	Gets the z-component of the translation part of this transform.
`int`	`hashCode()`
`void`	`inverseTransform(Matrix3DReadOnly matrixOriginal, Matrix3D matrixTransformed)`	Performs the inverse of the transform on the given matrix `matrixOriginal` and stores the result in `matrixTransformed`.
`void`	`inverseTransform(RotationMatrixReadOnly matrixOriginal, RotationMatrix matrixTransformed)`	Performs the inverse of the transform on the given matrix `matrixOriginal` and stores the result in `matrixTransformed`.
`void`	`inverseTransform(AffineTransform original, AffineTransform transformed)`	Performs the inverse of the transform on the given `original` and stores the result in `transformed`.
`void`	`inverseTransform(QuaternionBasedTransform original, QuaternionBasedTransform transformed)`	Performs the inverse of the transform on the given `original` stores the result in `transformed`.
`void`	`inverseTransform(RigidBodyTransform original, RigidBodyTransform transformed)`	Performs the inverse of the transform on the given `original` and stores the result in `transformed`.
`void`	`inverseTransform(Point2DReadOnly pointOriginal, Point2DBasics pointTransformed, boolean checkIfTransformInXYPlane)`	Performs the inverse of the transform on the given point `pointOriginal` and stores the result in `pointTransformed`.
`void`	`inverseTransform(Vector2DReadOnly vectorOriginal, Vector2DBasics vectorTransformed, boolean checkIfTransformInXYPlane)`	Performs the inverse of the transform on the given vector `vectorOriginal` and stores the result in `vectorTransformed`.
`void`	`inverseTransform(Point3DReadOnly pointOriginal, Point3DBasics pointTransformed)`	Performs the inverse of the transform on the given point `pointOriginal` and stores the result in `pointTransformed`.
`void`	`inverseTransform(Vector3DReadOnly vectorOriginal, Vector3DBasics vectorTransformed)`	Performs the inverse of the transform on the given vector `vectorOriginal` and stores the result in `vectorTransformed`.
`void`	`inverseTransform(QuaternionReadOnly quaternionOriginal, QuaternionBasics quaternionTransformed)`	Performs the inverse of the transform on the given quaternion `quaternionOriginal` and stores the result in `quaternionTransformed`.
`void`	`inverseTransform(Vector4DReadOnly vectorOriginal, Vector4DBasics vectorTransformed)`	Performs the inverse of the transform on the given vector `vectorOriginal` and stores the result in `vectorTransformed`.
`void`	`invert()`	Inverts this rigid-body transform.
`void`	`invertRotation()`	Inverts only the rotation part of this transform, the translation remains unchanged.
`boolean`	`isRotation2D()`	Tests if the rotation part of this transform describes a transformation in the XY plane.
`void`	`multiply(AffineTransform affineTransform)`	Performs the multiplication of this transform with `affineTransform`.
`void`	`multiply(QuaternionBasedTransform quaternionBasedTransform)`	Performs the multiplication of this transform with `quaternionBasedTransform`.
`void`	`multiply(RigidBodyTransform other)`	Performs the multiplication of this transform with `other`.
`void`	`multiplyInvertOther(AffineTransform affineTransform)`	Performs the multiplication of this transform with the inverse of `affineTransform`.
`void`	`multiplyInvertOther(QuaternionBasedTransform quaternionBasedTransform)`	Performs the multiplication of this transform with the inverse of `quaternionBasedTransform`.
`void`	`multiplyInvertOther(RigidBodyTransform other)`	Performs the multiplication of this transform with the inverse of `other`.
`void`	`multiplyInvertThis(AffineTransform affineTransform)`	Performs the multiplication of the inverse of this transform with `affineTransform`.
`void`	`multiplyInvertThis(QuaternionBasedTransform quaternionBasedTransform)`	Performs the multiplication of the inverse of this transform with `quaternionBasedTransform`.
`void`	`multiplyInvertThis(RigidBodyTransform other)`	Performs the multiplication of the inverse of this transform with `other`.
`void`	`normalizeRotationPart()`	Normalize the rotation part of this transform.
`void`	`preMultiply(AffineTransform affineTransform)`	Performs the multiplication of `affineTransform` with this transform.
`void`	`preMultiply(QuaternionBasedTransform quaternionBasedTransform)`	Performs the multiplication of `quaternionBasedTransform` with this transform.
`void`	`preMultiply(RigidBodyTransform other)`	Performs the multiplication of `other` with this transform.
`void`	`preMultiplyInvertOther(AffineTransform affineTransform)`	Performs the multiplication of the inverse of `affineTransform` with this transform.
`void`	`preMultiplyInvertOther(QuaternionBasedTransform quaternionBasedTransform)`	Performs the multiplication of the inverse of `quaternionBasedTransform` with this transform.
`void`	`preMultiplyInvertOther(RigidBodyTransform other)`	Performs the multiplication of the inverse of `other` with this transform.
`void`	`preMultiplyInvertThis(AffineTransform affineTransform)`	Performs the multiplication of `affineTransform` with the inverse of this transform.
`void`	`preMultiplyInvertThis(QuaternionBasedTransform quaternionBasedTransform)`	Performs the multiplication of `quaternionBasedTransform` with the inverse of this transform.
`void`	`preMultiplyInvertThis(RigidBodyTransform other)`	Performs the multiplication of `other` with the inverse of this transform.
`void`	`prependPitchRotation(double pitch)`	Prepend a rotation about the y-axis to this transform.
`void`	`prependRollRotation(double roll)`	Prepend a rotation about the x-axis to this transform.
`void`	`prependTranslation(double x, double y, double z)`	Prepend a translation transform to this transform.
`void`	`prependTranslation(Tuple3DReadOnly translation)`	Prepend a translation transform to this transform.
`void`	`prependYawRotation(double yaw)`	Prepend a rotation about the z-axis to this transform.
`void`	`set(double[] transformArray)`	Sets the raw components of this rigid-body transform from the given `transformArray`.
`void`	`set(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23)`	Sets this rigid-body transform from the given 12 coefficients.
`void`	`set(float[] transformArray)`	Sets the raw components of this rigid-body transform from the given `transformArray`.
`void`	`set(org.ejml.data.DenseMatrix64F matrix)`	Sets the raw components of this rigid-body transform from the given `matrix`.
`void`	`set(org.ejml.data.DenseMatrix64F matrix, int startRow, int startColumn)`	Sets the raw components of this rigid-body transform from the given `matrix`.
`void`	`set(Matrix3DReadOnly rotationMatrix, Tuple3DReadOnly translation)`	Sets the rotation and translation parts of this transform separately.
`void`	`set(RotationMatrixReadOnly rotationMatrix, Tuple3DReadOnly translation)`	Sets the rotation and translation parts of this transform separately.
`void`	`set(RotationScaleMatrixReadOnly rotationScaleMatrix, Tuple3DReadOnly translation)`	Sets the rotation and translation parts of this transform separately.
`void`	`set(Orientation3DReadOnly orientation, Tuple3DReadOnly translation)`	Sets the rotation and translation parts of this transform separately.
`void`	`set(QuaternionBasedTransform quaternionBasedTransform)`	Sets this rigid-body transform to the given `quaternionBasedTransform`.
`void`	`set(RigidBodyTransform other)`	Sets this rigid-body transform to `other`.
`void`	`setAndInvert(RigidBodyTransform other)`	Sets this rigid-body transform to `other` and then inverts it.
`void`	`setAsTranspose(double[] transformArray)`	Sets the raw components of this rigid-body transform from the given `transformArray`.
`void`	`setAsTranspose(float[] transformArray)`	Sets the raw components of this rigid-body transform from the given `transformArray`.
`void`	`setIdentity()`	Resets this rigid-body transform to identity.
`void`	`setRotation(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22)`	Sets the rotation part of this transform from the given 9 coefficients.
`void`	`setRotation(org.ejml.data.DenseMatrix64F rotationMatrix)`	Sets the rotation part of this transform to the given matrix.
`void`	`setRotation(Matrix3DReadOnly rotationMatrix)`	Sets the rotation part of this transform to the given matrix.
`void`	`setRotation(RotationMatrixReadOnly rotationMatrix)`	Sets the rotation part of this transform to the given matrix.
`void`	`setRotation(Orientation3DReadOnly orientation)`	Sets the rotation part of this transform to the given axis-angle.
`void`	`setRotation(Vector3DReadOnly rotationVector)`	Sets the rotation part of this transform to the given rotation vector.
`void`	`setRotationAndZeroTranslation(org.ejml.data.DenseMatrix64F rotationMatrix)`	Sets the rotation part of this transform to the given matrix and sets the translation part to zero.
`void`	`setRotationAndZeroTranslation(Matrix3DReadOnly rotationMatrix)`	Sets the rotation part of this transform to the given matrix and sets the translation part to zero.
`void`	`setRotationAndZeroTranslation(RotationMatrixReadOnly rotationMatrix)`	Sets the rotation part of this transform to the given orientation and sets the translation part to zero.
`void`	`setRotationAndZeroTranslation(Orientation3DReadOnly orientation)`	Sets the rotation part of this transform to the given orientation and sets the translation part to zero.
`void`	`setRotationAndZeroTranslation(Vector3DReadOnly rotationVector)`	Sets the rotation part of this transform to the given rotation vector and sets the translation part to zero.
`void`	`setRotationEuler(double rotX, double rotY, double rotZ)`	Sets the rotation part of this transform to represent the same orientation as the given Euler angles `rotX`, `rotY`, and `rotZ`.
`void`	`setRotationEuler(Vector3DReadOnly eulerAngles)`	Sets the rotation part of this transform to represent the same orientation as the given Euler angles `eulerAngles`.
`void`	`setRotationEulerAndZeroTranslation(double rotX, double rotY, double rotZ)`	Sets the rotation part of this transform to represent the same orientation as the given Euler angles `rotX`, `rotY`, and `rotZ` and sets the translation part to zero.
`void`	`setRotationEulerAndZeroTranslation(Vector3DReadOnly eulerAngles)`	Sets the rotation part of this transform to represent the same orientation as the given Euler angles `eulerAngles` and sets the translation part to zero.
`void`	`setRotationPitch(double pitch)`	Sets the rotation part of this transform to represent a counter clockwise rotation around the y-axis of an angle `pitch`.
`void`	`setRotationPitchAndZeroTranslation(double pitch)`	Sets the rotation part of this transform to represent a counter clockwise rotation around the y-axis of an angle `pitch` and sets the translation part to zero.
`void`	`setRotationRoll(double roll)`	Sets the rotation part of this transform to represent a counter clockwise rotation around the x-axis of an angle `roll`.
`void`	`setRotationRollAndZeroTranslation(double roll)`	Sets the rotation part of this transform to represent a counter clockwise rotation around the x-axis of an angle `roll` and sets the translation part to zero.
`void`	`setRotationToNaN()`	Sets all the components of the rotation matrix to `Double.NaN`.
`void`	`setRotationToZero()`	Sets the rotation part to represent a 'zero' rotation.
`void`	`setRotationUnsafe(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22)`	Sets the rotation part of this transform from the given 9 coefficients.
`void`	`setRotationYaw(double yaw)`	Sets the rotation part of this transform to represent a counter clockwise rotation around the z-axis of an angle `yaw`.
`void`	`setRotationYawAndZeroTranslation(double yaw)`	Sets the rotation part of this transform to represent a counter clockwise rotation around the z-axis of an angle `yaw` and sets the translation part to zero.
`void`	`setRotationYawPitchRoll(double[] yawPitchRoll)`	Sets the rotation part of this transform to represent the same orientation as the given yaw-pitch-roll angles `yaw`, `pitch`, and `roll`.
`void`	`setRotationYawPitchRoll(double yaw, double pitch, double roll)`	Sets the rotation part of this transform to represent the same orientation as the given yaw-pitch-roll angles `yaw`, `pitch`, and `roll`.
`void`	`setRotationYawPitchRollAndZeroTranslation(double[] yawPitchRoll)`	Sets the rotation part of this transform to represent the same orientation as the given yaw-pitch-roll angles `yaw`, `pitch`, and `roll` and sets the translation part to zero.
`void`	`setRotationYawPitchRollAndZeroTranslation(double yaw, double pitch, double roll)`	Sets the rotation part of this transform to represent the same orientation as the given yaw-pitch-roll angles `yaw`, `pitch`, and `roll` and sets the translation part to zero.
`void`	`setToNaN()`	Sets all the components of this affine transform making it invalid.
`void`	`setToZero()`	Resets this rigid-body transform to identity.
`void`	`setTranslation(double x, double y, double z)`	Sets the translation part of this transform.
`void`	`setTranslation(Tuple3DReadOnly translation)`	Sets the translation part of this transform.
`void`	`setTranslationAndIdentityRotation(double x, double y, double z)`	Sets the translation part of this transform and sets the rotation part to identity.
`void`	`setTranslationAndIdentityRotation(Tuple3DReadOnly translation)`	Sets the translation part of this transform and sets the rotation part to identity.
`void`	`setTranslationToNaN()`	Sets all the components of the translation vector to `Double.NaN`.
`void`	`setTranslationToZero()`	Sets the translation part to zero.
`void`	`setTranslationX(double x)`	Sets the x-component of the translation part of this transform.
`void`	`setTranslationY(double y)`	Sets the y-component of the translation part of this transform.
`void`	`setTranslationZ(double z)`	Sets the z-component of the translation part of this transform.
`void`	`setUnsafe(double m00, double m01, double m02, double m03, double m10, double m11, double m12, double m13, double m20, double m21, double m22, double m23)`	Sets this rigid-body transform from the given 12 coefficients.
`java.lang.String`	`toString()`	Provides a `String` representation of this transform as follows: m00, m01, m02 \| m03 m10, m11, m12 \| m13 m20, m21, m22 \| m23
`void`	`transform(Matrix3DReadOnly matrixOriginal, Matrix3D matrixTransformed)`	Transforms the given `matrixOriginal` by this transform and stores the result in `matrixTransformed`.
`void`	`transform(RotationMatrixReadOnly matrixOriginal, RotationMatrix matrixTransformed)`	Transforms the given `matrixOriginal` by this transform and stores the result in `matrixTransformed`.
`void`	`transform(AffineTransform original, AffineTransform transformed)`	Transforms the given `original` by this transform and stores the result in `transformed`.
`void`	`transform(QuaternionBasedTransform original, QuaternionBasedTransform transformed)`	Transforms the given `original` by this transform and stores the result in `transformed`.
`void`	`transform(RigidBodyTransform original, RigidBodyTransform transformed)`	Transforms the given `original` by this transform and stores the result in `transformed`.
`void`	`transform(Point2DReadOnly point2DOriginal, Point2DBasics point2DTransformed, boolean checkIfTransformInXYPlane)`	Transforms the given `point2DOriginal` by this transform and stores the result in `point2DTransformed`.
`void`	`transform(Vector2DReadOnly vector2DOriginal, Vector2DBasics vector2DTransformed, boolean checkIfTransformInXYPlane)`	Transforms the given `vector2DOriginal` by this transform and stores the result in `vector2DTransformed`.
`void`	`transform(Point3DReadOnly pointOriginal, Point3DBasics pointTransformed)`	Transforms the given `pointOriginal` by this transform and stores the result in `pointTransformed`.
`void`	`transform(Vector3DReadOnly vectorOriginal, Vector3DBasics vectorTransformed)`	Transforms the given `vectorOriginal` by this transform and stores the result in `vectorTransformed`.
`void`	`transform(QuaternionReadOnly quaternionOriginal, QuaternionBasics quaternionTransformed)`	Transforms the given `quaternionOriginal` by this transform and stores the result in `quaternionTransformed`.
`void`	`transform(Vector4DReadOnly vectorOriginal, Vector4DBasics vectorTransformed)`	Transforms the vector part (x, y, z) of the given `vector4DOriginal` as a 3D vector and translates it by `s` times the translation part of the transform.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface us.ihmc.euclid.transform.interfaces.Transform
inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform

- Constructor Detail
  - RigidBodyTransform
```
public RigidBodyTransform()
```
    Creates a new rigid-body transform set to identity.
    When set to identity, this transform has no effect when transforming a geometry object.
  - RigidBodyTransform
```
public RigidBodyTransform(RigidBodyTransform other)
```
    Creates a new rigid-body transform and sets it to other.
    
    Parameters:
    
    other - the other rigid-body transform to copy. Not modified.
  - RigidBodyTransform
```
public RigidBodyTransform(QuaternionBasedTransform quaternionBasedTransform)
```
    Creates a new rigid-body transform and sets it to quaternionBasedTransform.
    
    Parameters:
    
    quaternionBasedTransform - the QuaternionBasedTransform to initialize to.
  - RigidBodyTransform
```
public RigidBodyTransform(org.ejml.data.DenseMatrix64F matrix)
```
    Creates a new rigid-body transform and sets its raw components from the given matrix.
    The rotation part R is set as follows:
```
     / matrix.get(0, 0) matrix.get(0, 1) matrix.get(0, 2) \
 R = | matrix.get(1, 0) matrix.get(1, 1) matrix.get(1, 2) |
     \ matrix.get(2, 0) matrix.get(2, 1) matrix.get(2, 2) /
 
```
    The translation part T is set as follows:
```
     / matrix.get(0, 3) \
 T = | matrix.get(1, 3) |
     \ matrix.get(2, 3) /
 
```
    Parameters:
    
    matrix - the matrix to get this transform's components from. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the resulting matrix for the rotation part of this transform is not a rotation matrix.
  - RigidBodyTransform
```
public RigidBodyTransform(double[] transformArray)
```
    Sets the raw components of this rigid-body transform from the given transformArray.
    The rotation part R is set as follows:
```
     / transformArray[0] transformArray[1] transformArray[ 2] \
 R = | transformArray[4] transformArray[5] transformArray[ 6] |
     \ transformArray[8] transformArray[9] transformArray[10] /
 
```
    The translation part T is set as follows:
```
     / transformArray[ 3] \
 T = | transformArray[ 7] |
     \ transformArray[11] /
 
```
    Parameters:
    
    transformArray - the 1D row-major array to get this transform's components from. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the resulting matrix for the rotation part of this transform is not a rotation matrix.
  - RigidBodyTransform
```
public RigidBodyTransform(Orientation3DReadOnly orientation,
                          Tuple3DReadOnly translation)
```
    Creates a new rigid-body transform and sets it to the given orientation and translation.
    
    Parameters:
    
    orientation - the orientation used to set this transform's rotation part. Not modified.
    
    translation - the tuple used to set this transform's translation part. Not modified.
  - RigidBodyTransform
```
public RigidBodyTransform(double m00,
                          double m01,
                          double m02,
                          double m03,
                          double m10,
                          double m11,
                          double m12,
                          double m13,
                          double m20,
                          double m21,
                          double m22,
                          double m23)
```
    Creates a new rigid-body transform and sets it from the given 12 coefficients.
    
    Parameters:
    
    m00 - the 1st row 1st column component of the rotation part of this transform.
    
    m01 - the 1st row 2nd column component of the rotation part of this transform.
    
    m02 - the 1st row 3rd column component of the rotation part of this transform.
    
    m03 - the x-component of the translation part of this transform.
    
    m10 - the 2nd row 1st column component of the rotation part of this transform.
    
    m11 - the 2nd row 2nd column component of the rotation part of this transform.
    
    m12 - the 2nd row 3rd column component of the rotation part of this transform.
    
    m13 - the y-component of the translation part of this transform.
    
    m20 - the 3rd row 1st column component of the rotation part of this transform.
    
    m21 - the 3rd row 2nd column component of the rotation part of this transform.
    
    m22 - the 3rd row 3rd column component of the rotation part of this transform.
    
    m23 - the z-component of the translation part of this transform.
    
    Throws:
    
    NotARotationMatrixException - if the components for the rotation part do not represent a rotation matrix.
- Method Detail
  - setIdentity
```
public void setIdentity()
```
    Resets this rigid-body transform to identity.
    When set to identity, this transform has no effect when transforming a geometry object.
  - setToZero
```
public void setToZero()
```
    Resets this rigid-body transform to identity.
    When set to identity, this transform has no effect when transforming a geometry object.
    
    Specified by:
    
    setToZero in interface Clearable
  - setRotationToZero
```
public void setRotationToZero()
```
    Sets the rotation part to represent a 'zero' rotation.
  - setTranslationToZero
```
public void setTranslationToZero()
```
    Sets the translation part to zero.
  - setToNaN
```
public void setToNaN()
```
    Sets all the components of this affine transform making it invalid.
    
    Specified by:
    
    setToNaN in interface Clearable
  - setRotationToNaN
```
public void setRotationToNaN()
```
    Sets all the components of the rotation matrix to Double.NaN.
    See RotationScaleMatrix.setToNaN().
  - setTranslationToNaN
```
public void setTranslationToNaN()
```
    Sets all the components of the translation vector to Double.NaN.
    See Tuple3DBasics.setToNaN().
  - containsNaN
```
public boolean containsNaN()
```
    Tests if at least one element of this transform is equal to Double.NaN.
    
    Specified by:
    
    containsNaN in interface Clearable
    
    Returns:
    
    true if at least one element of this transform is equal to Double.NaN, false otherwise.
  - isRotation2D
```
public boolean isRotation2D()
```
    Tests if the rotation part of this transform describes a transformation in the XY plane.
    The rotation part is considered to be a 2D transformation in the XY plane if:
    - the last diagonal coefficient m22 is equal to 1.0 +/- Matrix3DFeatures.EPS_CHECK_2D,
    - the coefficients m20, m02, m21, and m12 are equal to 0.0 +/- Matrix3DFeatures.EPS_CHECK_2D.
    Returns:
    
    true if the rotation part describes a 2D transformation in the XY plane, false otherwise.
  - checkIfRotation2D
```
public void checkIfRotation2D()
```
    Asserts that the rotation part of this transform describes a transformation in the XY plane.
    The rotation part is considered to be a 2D transformation in the XY plane if:
    - the last diagonal coefficient m22 is equal to 1.0 +/- Matrix3DFeatures.EPS_CHECK_2D,
    - the coefficients m20, m02, m21, and m12 are equal to 0.0 +/- Matrix3DFeatures.EPS_CHECK_2D.
    Throws:
    
    NotAMatrix2DException - if the rotation part represents a 3D transformation.
  - normalizeRotationPart
```
public void normalizeRotationPart()
```
    Normalize the rotation part of this transform.
  - determinantRotationPart
```
public double determinantRotationPart()
```
    Computes the determinant of the rotation part of this transform.
    
    Returns:
    
    the determinant's value.
  - set
```
public void set(double m00,
                double m01,
                double m02,
                double m03,
                double m10,
                double m11,
                double m12,
                double m13,
                double m20,
                double m21,
                double m22,
                double m23)
```
    Sets this rigid-body transform from the given 12 coefficients.
    
    Parameters:
    
    m00 - the 1st row 1st column component of the rotation part of this transform.
    
    m01 - the 1st row 2nd column component of the rotation part of this transform.
    
    m02 - the 1st row 3rd column component of the rotation part of this transform.
    
    m03 - the x-component of the translation part of this transform.
    
    m10 - the 2nd row 1st column component of the rotation part of this transform.
    
    m11 - the 2nd row 2nd column component of the rotation part of this transform.
    
    m12 - the 2nd row 3rd column component of the rotation part of this transform.
    
    m13 - the y-component of the translation part of this transform.
    
    m20 - the 3rd row 1st column component of the rotation part of this transform.
    
    m21 - the 3rd row 2nd column component of the rotation part of this transform.
    
    m22 - the 3rd row 3rd column component of the rotation part of this transform.
    
    m23 - the z-component of the translation part of this transform.
    
    Throws:
    
    NotARotationMatrixException - if the components for the rotation part do not represent a rotation matrix.
  - setUnsafe
```
public void setUnsafe(double m00,
                      double m01,
                      double m02,
                      double m03,
                      double m10,
                      double m11,
                      double m12,
                      double m13,
                      double m20,
                      double m21,
                      double m22,
                      double m23)
```
    Sets this rigid-body transform from the given 12 coefficients.
    Prefer using the method set(double, double, double, double, double, double, double, double, double, double, double, double) as it asserts that the coefficients for the rotation part represent a rotation matrix.
    
    Parameters:
    
    m00 - the 1st row 1st column component of the rotation part of this transform.
    
    m01 - the 1st row 2nd column component of the rotation part of this transform.
    
    m02 - the 1st row 3rd column component of the rotation part of this transform.
    
    m03 - the x-component of the translation part of this transform.
    
    m10 - the 2nd row 1st column component of the rotation part of this transform.
    
    m11 - the 2nd row 2nd column component of the rotation part of this transform.
    
    m12 - the 2nd row 3rd column component of the rotation part of this transform.
    
    m13 - the y-component of the translation part of this transform.
    
    m20 - the 3rd row 1st column component of the rotation part of this transform.
    
    m21 - the 3rd row 2nd column component of the rotation part of this transform.
    
    m22 - the 3rd row 3rd column component of the rotation part of this transform.
    
    m23 - the z-component of the translation part of this transform.
  - set
```
public void set(RigidBodyTransform other)
```
    Sets this rigid-body transform to other.
    
    Specified by:
    
    set in interface Settable<RigidBodyTransform>
    
    Parameters:
    
    other - the other rigid-body transform to copy the values from. Not modified.
  - setAndInvert
```
public void setAndInvert(RigidBodyTransform other)
```
    Sets this rigid-body transform to other and then inverts it.
    
    Parameters:
    
    other - the other rigid-body transform to copy the values from. Not modified.
  - set
```
public void set(QuaternionBasedTransform quaternionBasedTransform)
```
    Sets this rigid-body transform to the given quaternionBasedTransform.
    
    Parameters:
    
    quaternionBasedTransform - the quaternion-based transform to copy the values from. Not modified.
  - set
```
public void set(org.ejml.data.DenseMatrix64F matrix)
```
    Sets the raw components of this rigid-body transform from the given matrix.
    The rotation-scale part R is set as follows:
```
     / matrix.get(0, 0) matrix.get(0, 1) matrix.get(0, 2) \
 R = | matrix.get(1, 0) matrix.get(1, 1) matrix.get(1, 2) |
     \ matrix.get(2, 0) matrix.get(2, 1) matrix.get(2, 2) /
 
```
    The translation part T is set as follows:
```
     / matrix.get(0, 3) \
 T = | matrix.get(1, 3) |
     \ matrix.get(2, 3) /
 
```
    Parameters:
    
    matrix - the matrix to get this transform's components from. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the resulting matrix for the rotation part of this transform is not a rotation matrix.
  - set
```
public void set(org.ejml.data.DenseMatrix64F matrix,
                int startRow,
                int startColumn)
```
    Sets the raw components of this rigid-body transform from the given matrix.
    The rotation part R is set as follows:
```
     / matrix.get(startRow + 0, startColumn + 0) matrix.get(startRow + 0, startColumn + 1) matrix.get(startRow + 0, startColumn + 2) \
 R = | matrix.get(startRow + 1, startColumn + 0) matrix.get(startRow + 1, startColumn + 1) matrix.get(startRow + 1, startColumn + 2) |
     \ matrix.get(startRow + 2, startColumn + 0) matrix.get(startRow + 2, startColumn + 1) matrix.get(startRow + 2, startColumn + 2) /
 
```
    The translation part T is set as follows:
```
     / matrix.get(startRow + 0, startColumn + 3) \
 T = | matrix.get(startRow + 1, startColumn + 3) |
     \ matrix.get(startRow + 2, startColumn + 3) /
 
```
    Parameters:
    
    matrix - the matrix to get this transform's components from. Not modified.
    
    startRow - the row index of the first component to read.
    
    startColumn - the column index of the first component to read.
    
    Throws:
    
    NotARotationMatrixException - if the resulting matrix for the rotation part of this transform is not a rotation matrix.
  - set
```
public void set(double[] transformArray)
```
    Sets the raw components of this rigid-body transform from the given transformArray.
    The rotation-scale part R is set as follows:
```
     / transformArray[0] transformArray[1] transformArray[ 2] \
 R = | transformArray[4] transformArray[5] transformArray[ 6] |
     \ transformArray[8] transformArray[9] transformArray[10] /
 
```
    The translation part T is set as follows:
```
     / transformArray[ 3] \
 T = | transformArray[ 7] |
     \ transformArray[11] /
 
```
    Parameters:
    
    transformArray - the 1D row-major array to get this transform's components from. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the resulting matrix for the rotation part of this transform is not a rotation matrix.
  - setAsTranspose
```
public void setAsTranspose(double[] transformArray)
```
    Sets the raw components of this rigid-body transform from the given transformArray.
    The rotation-scale part R is set as follows:
```
     / transformArray[0] transformArray[4] transformArray[ 8] \
 R = | transformArray[1] transformArray[5] transformArray[ 9] |
     \ transformArray[2] transformArray[6] transformArray[10] /
 
```
    The translation part T is set as follows:
```
     / transformArray[12] \
 T = | transformArray[13] |
     \ transformArray[14] /
 
```
    Parameters:
    
    transformArray - the 1D column-major array to get this transform's components from. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the resulting matrix for the rotation part of this transform is not a rotation matrix.
  - set
```
public void set(float[] transformArray)
```
    Sets the raw components of this rigid-body transform from the given transformArray.
    The rotation-scale part R is set as follows:
```
     / transformArray[0] transformArray[1] transformArray[ 2] \
 R = | transformArray[4] transformArray[5] transformArray[ 6] |
     \ transformArray[8] transformArray[9] transformArray[10] /
 
```
    The translation part T is set as follows:
```
     / transformArray[ 3] \
 T = | transformArray[ 7] |
     \ transformArray[11] /
 
```
    Parameters:
    
    transformArray - the 1D row-major array to get this transform's components from. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the resulting matrix for the rotation part of this transform is not a rotation matrix.
  - setAsTranspose
```
public void setAsTranspose(float[] transformArray)
```
    Sets the raw components of this rigid-body transform from the given transformArray.
    The rotation-scale part R is set as follows:
```
     / transformArray[0] transformArray[4] transformArray[ 8] \
 R = | transformArray[1] transformArray[5] transformArray[ 9] |
     \ transformArray[2] transformArray[6] transformArray[10] /
 
```
    The translation part T is set as follows:
```
     / transformArray[12] \
 T = | transformArray[13] |
     \ transformArray[14] /
 
```
    Parameters:
    
    transformArray - the 1D column-major array to get this transform's components from. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the resulting matrix for the rotation part of this transform is not a rotation matrix.
  - set
```
public void set(Matrix3DReadOnly rotationMatrix,
                Tuple3DReadOnly translation)
```
    Sets the rotation and translation parts of this transform separately.
    
    Parameters:
    
    rotationMatrix - the matrix used to set the rotation part of this transform. Not modified.
    
    translation - the tuple used to set the translation part of this transform. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the given rotationMatrix is not a rotation matrix.
  - set
```
public void set(RotationMatrixReadOnly rotationMatrix,
                Tuple3DReadOnly translation)
```
    Sets the rotation and translation parts of this transform separately.
    
    Parameters:
    
    rotationMatrix - the matrix used to set the rotation part of this transform. Not modified.
    
    translation - the tuple used to set the translation part of this transform. Not modified.
  - set
```
public void set(RotationScaleMatrixReadOnly rotationScaleMatrix,
                Tuple3DReadOnly translation)
```
    Sets the rotation and translation parts of this transform separately.
    Only the rotation matrix from rotationScaleMatrix is used to set the rotation part of this transform.
    
    Parameters:
    
    rotationScaleMatrix - the matrix used to set the rotation part of this transform. Not modified.
    
    translation - the tuple used to set the translation part of this transform. Not modified.
  - set
```
public void set(Orientation3DReadOnly orientation,
                Tuple3DReadOnly translation)
```
    Sets the rotation and translation parts of this transform separately.
    
    Parameters:
    
    orientation - the orientation used to set the rotation part of this transform. Not modified.
    
    translation - the tuple used to set the translation part of this transform. Not modified.
  - setRotation
```
public void setRotation(double m00,
                        double m01,
                        double m02,
                        double m10,
                        double m11,
                        double m12,
                        double m20,
                        double m21,
                        double m22)
```
    Sets the rotation part of this transform from the given 9 coefficients.
    
    Parameters:
    
    m00 - the 1st row 1st column component of the rotation part of this transform.
    
    m01 - the 1st row 2nd column component of the rotation part of this transform.
    
    m02 - the 1st row 3rd column component of the rotation part of this transform.
    
    m10 - the 2nd row 1st column component of the rotation part of this transform.
    
    m11 - the 2nd row 2nd column component of the rotation part of this transform.
    
    m12 - the 2nd row 3rd column component of the rotation part of this transform.
    
    m20 - the 3rd row 1st column component of the rotation part of this transform.
    
    m21 - the 3rd row 2nd column component of the rotation part of this transform.
    
    m22 - the 3rd row 3rd column component of the rotation part of this transform.
    
    Throws:
    
    NotARotationMatrixException - if the resulting matrix does not represent a rotation matrix.
  - setRotationUnsafe
```
public void setRotationUnsafe(double m00,
                              double m01,
                              double m02,
                              double m10,
                              double m11,
                              double m12,
                              double m20,
                              double m21,
                              double m22)
```
    Sets the rotation part of this transform from the given 9 coefficients.
    Prefer using the method setRotation(double, double, double, double, double, double, double, double, double) as it asserts that the coefficients 0represent a rotation matrix.
    
    Parameters:
    
    m00 - the 1st row 1st column component of the rotation part of this transform.
    
    m01 - the 1st row 2nd column component of the rotation part of this transform.
    
    m02 - the 1st row 3rd column component of the rotation part of this transform.
    
    m10 - the 2nd row 1st column component of the rotation part of this transform.
    
    m11 - the 2nd row 2nd column component of the rotation part of this transform.
    
    m12 - the 2nd row 3rd column component of the rotation part of this transform.
    
    m20 - the 3rd row 1st column component of the rotation part of this transform.
    
    m21 - the 3rd row 2nd column component of the rotation part of this transform.
    
    m22 - the 3rd row 3rd column component of the rotation part of this transform.
  - setRotation
```
public void setRotation(Orientation3DReadOnly orientation)
```
    Sets the rotation part of this transform to the given axis-angle.
    This method does not affect the translation part of this transform.
    
    Parameters:
    
    orientation - the orientation used to set the rotation part of this transform. Not modified.
  - setRotation
```
public void setRotation(Vector3DReadOnly rotationVector)
```
    Sets the rotation part of this transform to the given rotation vector.
    This method does not affect the translation part of this transform.
    
    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.
    
    Parameters:
    
    rotationVector - the rotation vector used to set the rotation part of this transform. Not modified.
  - setRotation
```
public void setRotation(org.ejml.data.DenseMatrix64F rotationMatrix)
```
    Sets the rotation part of this transform to the given matrix.
    This method does not affect the translation part of this transform.
    
    Parameters:
    
    rotationMatrix - the matrix used to set the rotation part of this transform. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the given rotationMatrix is not a rotation matrix.
  - setRotation
```
public void setRotation(Matrix3DReadOnly rotationMatrix)
```
    Sets the rotation part of this transform to the given matrix.
    This method does not affect the translation part of this transform.
    
    Parameters:
    
    rotationMatrix - the matrix used to set the rotation part of this transform. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the given rotationMatrix is not a rotation matrix.
  - setRotation
```
public void setRotation(RotationMatrixReadOnly rotationMatrix)
```
    Sets the rotation part of this transform to the given matrix.
    This method does not affect the translation part of this transform.
    
    Parameters:
    
    rotationMatrix - the matrix used to set the rotation part of this transform. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the given rotationMatrix is not a rotation matrix.
  - setRotationYaw
```
public void setRotationYaw(double yaw)
```
    Sets the rotation part of this transform to represent a counter clockwise rotation around the z-axis of an angle yaw.
```
     / cos(yaw) -sin(yaw) 0 \
 R = | sin(yaw)  cos(yaw) 0 |
     \    0         0     1 /
 
```
    This method does not affect the translation part of this transform.
    Parameters:
    
    yaw - the angle to rotate about the z-axis.
  - setRotationPitch
```
public void setRotationPitch(double pitch)
```
    Sets the rotation part of this transform to represent a counter clockwise rotation around the y-axis of an angle pitch.
```
     /  cos(pitch) 0 sin(pitch) \
 R = |      0      1     0      |
     \ -sin(pitch) 0 cos(pitch) /
 
```
    This method does not affect the translation part of this transform.
    Parameters:
    
    pitch - the angle to rotate about the y-axis.
  - setRotationRoll
```
public void setRotationRoll(double roll)
```
    Sets the rotation part of this transform to represent a counter clockwise rotation around the x-axis of an angle roll.
```
     / 1     0          0     \
 R = | 0 cos(roll) -sin(roll) |
     \ 0 sin(roll)  cos(roll) /
 
```
    This method does not affect the translation part of this transform.
    Parameters:
    
    roll - the angle to rotate about the x-axis.
  - setRotationYawPitchRoll
```
public void setRotationYawPitchRoll(double[] yawPitchRoll)
```
    Sets the rotation part of this transform to represent the same orientation as the given yaw-pitch-roll angles yaw, pitch, and roll.
```
     / 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) /
 
```
    This method does not affect the translation part of this transform.
    Parameters:
    
    yawPitchRoll - array containing the yaw-pitch-roll angles. Not modified.
  - setRotationYawPitchRoll
```
public void setRotationYawPitchRoll(double yaw,
                                    double pitch,
                                    double roll)
```
    Sets the rotation part of this transform to represent the same orientation as the given yaw-pitch-roll angles yaw, pitch, and roll.
```
     / 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) /
 
```
    This method does not affect the translation part of this transform.
    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.
  - setRotationEuler
```
public void setRotationEuler(Vector3DReadOnly eulerAngles)
```
    Sets the rotation part of this transform to represent the same orientation as the given Euler angles eulerAngles.
```
     / cos(eulerAngles.z) -sin(eulerAngles.z) 0 \   /  cos(eulerAngles.y) 0 sin(eulerAngles.y) \   / 1         0                   0          \
 R = | sin(eulerAngles.z)  cos(eulerAngles.z) 0 | * |          0          1         0          | * | 0 cos(eulerAngles.x) -sin(eulerAngles.x) |
     \         0                   0          1 /   \ -sin(eulerAngles.y) 0 cos(eulerAngles.y) /   \ 0 sin(eulerAngles.x)  cos(eulerAngles.x) /
 
```
    This method does not affect the translation part of this transform.
    
    This is equivalent to this.setRotationYawPitchRoll(eulerAngles.getZ(), eulerAngles.getY(), eulerAngles.getX()).
    Parameters:
    
    eulerAngles - the Euler angles to copy the orientation from. Not modified.
  - setRotationEuler
```
public void setRotationEuler(double rotX,
                             double rotY,
                             double rotZ)
```
    Sets the rotation part of this transform to represent the same orientation as the given Euler angles rotX, rotY, and rotZ.
```
     / cos(rotZ) -sin(rotZ) 0 \   /  cos(rotY) 0 sin(rotY) \   / 1     0          0     \
 R = | sin(rotZ)  cos(rotZ) 0 | * |      0     1     0     | * | 0 cos(rotX) -sin(rotX) |
     \     0          0     1 /   \ -sin(rotY) 0 cos(rotY) /   \ 0 sin(rotX)  cos(rotX) /
 
```
    This method does not affect the translation part of this transform.
    
    This is equivalent to this.setRotationYawPitchRoll(rotZ, rotY, rotX).
    Parameters:
    
    rotX - the angle to rotate about the x-axis.
    
    rotY - the angle to rotate about the y-axis.
    
    rotZ - the angle to rotate about the z-axis.
  - setRotationAndZeroTranslation
```
public void setRotationAndZeroTranslation(Orientation3DReadOnly orientation)
```
    Sets the rotation part of this transform to the given orientation and sets the translation part to zero.
    
    Parameters:
    
    orientation - the orientation used to set the rotation part of this transform. Not modified.
  - setRotationAndZeroTranslation
```
public void setRotationAndZeroTranslation(RotationMatrixReadOnly rotationMatrix)
```
    Sets the rotation part of this transform to the given orientation and sets the translation part to zero.
    
    Parameters:
    
    rotationMatrix - the rotation matrix used to set the rotation part of this transform. Not modified.
  - setRotationAndZeroTranslation
```
public void setRotationAndZeroTranslation(Vector3DReadOnly rotationVector)
```
    Sets the rotation part of this transform to the given rotation vector and sets the translation part to zero.
    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.
    
    Parameters:
    
    rotationVector - the rotation vector used to set the rotation part of this transform. Not modified.
  - setRotationAndZeroTranslation
```
public void setRotationAndZeroTranslation(org.ejml.data.DenseMatrix64F rotationMatrix)
```
    Sets the rotation part of this transform to the given matrix and sets the translation part to zero.
    
    Parameters:
    
    rotationMatrix - the matrix used to set the rotation part of this transform. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the given rotationMatrix is not a rotation matrix.
  - setRotationAndZeroTranslation
```
public void setRotationAndZeroTranslation(Matrix3DReadOnly rotationMatrix)
```
    Sets the rotation part of this transform to the given matrix and sets the translation part to zero.
    
    Parameters:
    
    rotationMatrix - the matrix used to set the rotation part of this transform. Not modified.
    
    Throws:
    
    NotARotationMatrixException - if the given rotationMatrix is not a rotation matrix.
  - setRotationYawAndZeroTranslation
```
public void setRotationYawAndZeroTranslation(double yaw)
```
    Sets the rotation part of this transform to represent a counter clockwise rotation around the z-axis of an angle yaw and sets the translation part to zero.
```
     / cos(yaw) -sin(yaw) 0 \
 R = | sin(yaw)  cos(yaw) 0 |
     \    0         0     1 /
 
```
    Parameters:
    
    yaw - the angle to rotate about the z-axis.
  - setRotationPitchAndZeroTranslation
```
public void setRotationPitchAndZeroTranslation(double pitch)
```
    Sets the rotation part of this transform to represent a counter clockwise rotation around the y-axis of an angle pitch and sets the translation part to zero.
```
        /  cos(pitch) 0 sin(pitch) \
 this = |      0      1     0      |
        \ -sin(pitch) 0 cos(pitch) /
 
```
    Parameters:
    
    pitch - the angle to rotate about the y-axis.
  - setRotationRollAndZeroTranslation
```
public void setRotationRollAndZeroTranslation(double roll)
```
    Sets the rotation part of this transform to represent a counter clockwise rotation around the x-axis of an angle roll and sets the translation part to zero.
```
        / 1     0          0     \
 this = | 0 cos(roll) -sin(roll) |
        \ 0 sin(roll)  cos(roll) /
 
```
    Parameters:
    
    roll - the angle to rotate about the x-axis.
  - setRotationYawPitchRollAndZeroTranslation
```
public void setRotationYawPitchRollAndZeroTranslation(double[] yawPitchRoll)
```
    Sets the rotation part of this transform to represent the same orientation as the given yaw-pitch-roll angles yaw, pitch, and roll and sets the translation part to zero.
```
     / 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) /
 
```
    Parameters:
    
    yawPitchRoll - array containing the yaw-pitch-roll angles. Not modified.
  - setRotationYawPitchRollAndZeroTranslation
```
public void setRotationYawPitchRollAndZeroTranslation(double yaw,
                                                      double pitch,
                                                      double roll)
```
    Sets the rotation part of this transform to represent the same orientation as the given yaw-pitch-roll angles yaw, pitch, and roll and sets the translation part to zero.
```
     / 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) /
 
```
    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.
  - setRotationEulerAndZeroTranslation
```
public void setRotationEulerAndZeroTranslation(Vector3DReadOnly eulerAngles)
```
    Sets the rotation part of this transform to represent the same orientation as the given Euler angles eulerAngles and sets the translation part to zero.
```
     / cos(eulerAngles.z) -sin(eulerAngles.z) 0 \   /  cos(eulerAngles.y) 0 sin(eulerAngles.y) \   / 1         0                   0          \
 R = | sin(eulerAngles.z)  cos(eulerAngles.z) 0 | * |          0          1         0          | * | 0 cos(eulerAngles.x) -sin(eulerAngles.x) |
     \         0                   0          1 /   \ -sin(eulerAngles.y) 0 cos(eulerAngles.y) /   \ 0 sin(eulerAngles.x)  cos(eulerAngles.x) /
 
```
    This is equivalent to this.setRotationYawPitchRollAndZeroTranslation(eulerAngles.getZ(), eulerAngles.getY(), eulerAngles.getX()).
    Parameters:
    
    eulerAngles - the Euler angles to copy the orientation from. Not modified.
  - setRotationEulerAndZeroTranslation
```
public void setRotationEulerAndZeroTranslation(double rotX,
                                               double rotY,
                                               double rotZ)
```
    Sets the rotation part of this transform to represent the same orientation as the given Euler angles rotX, rotY, and rotZ and sets the translation part to zero.
```
     / cos(rotZ) -sin(rotZ) 0 \   /  cos(rotY) 0 sin(rotY) \   / 1     0          0     \
 R = | sin(rotZ)  cos(rotZ) 0 | * |      0     1     0     | * | 0 cos(rotX) -sin(rotX) |
     \     0          0     1 /   \ -sin(rotY) 0 cos(rotY) /   \ 0 sin(rotX)  cos(rotX) /
 
```
    This is equivalent to this.setRotationYawPitchRollAndZeroTranslation(rotZ, rotY, rotX).
    Parameters:
    
    rotX - the angle to rotate about the x-axis.
    
    rotY - the angle to rotate about the y-axis.
    
    rotZ - the angle to rotate about the z-axis.
  - setTranslationX
```
public void setTranslationX(double x)
```
    Sets the x-component of the translation part of this transform.
    This method does not affect the rotation part of this transform.
    
    Parameters:
    
    x - the x-component of the translation part.
  - setTranslationY
```
public void setTranslationY(double y)
```
    Sets the y-component of the translation part of this transform.
    This method does not affect the rotation part of this transform.
    
    Parameters:
    
    y - the y-component of the translation part.
  - setTranslationZ
```
public void setTranslationZ(double z)
```
    Sets the z-component of the translation part of this transform.
    This method does not affect the rotation part of this transform.
    
    Parameters:
    
    z - the z-component of the translation part.
  - setTranslation
```
public void setTranslation(double x,
                           double y,
                           double z)
```
    Sets the translation part of this transform.
    This method does not affect the rotation part of this transform.
    
    Parameters:
    
    x - the x-component of the translation part.
    
    y - the y-component of the translation part.
    
    z - the z-component of the translation part.
  - setTranslation
```
public void setTranslation(Tuple3DReadOnly translation)
```
    Sets the translation part of this transform.
    This method does not affect the rotation part of this transform.
    
    Parameters:
    
    translation - tuple used to set the translation part of this transform. Not modified.
  - setTranslationAndIdentityRotation
```
public void setTranslationAndIdentityRotation(double x,
                                              double y,
                                              double z)
```
    Sets the translation part of this transform and sets the rotation part to identity.
    
    Parameters:
    
    x - the x-component of the translation part.
    
    y - the y-component of the translation part.
    
    z - the z-component of the translation part.
  - setTranslationAndIdentityRotation
```
public void setTranslationAndIdentityRotation(Tuple3DReadOnly translation)
```
    Sets the translation part of this transform and sets the rotation part to identity.
    
    Parameters:
    
    translation - tuple used to set the translation part of this transform. Not modified.
  - invert
```
public void invert()
```
    Inverts this rigid-body transform.
  - invertRotation
```
public void invertRotation()
```
    Inverts only the rotation part of this transform, the translation remains unchanged.
  - multiply
```
public void multiply(RigidBodyTransform other)
```
    Performs the multiplication of this transform with other.
    this = this * other
    
    Parameters:
    
    other - the other transform to multiply this with. Not modified.
  - multiply
```
public void multiply(QuaternionBasedTransform quaternionBasedTransform)
```
    Performs the multiplication of this transform with quaternionBasedTransform.
    this = this * H(quaternionBasedTransform)
    where H(q) is the function converting a quaternion-based transform into a 4-by-4 transformation matrix.
    
    Parameters:
    
    quaternionBasedTransform - the quaternion-based transform to multiply this with. Not modified.
  - multiply
```
public void multiply(AffineTransform affineTransform)
```
    Performs the multiplication of this transform with affineTransform.
    Note: the scale part of the given affine transform is not used when performing the multiplication to conserve a proper rigid-body transform describing only a rotation and a translation.
    
    this = this * S(affineTransform)
    where S(affineTransform) is the function selecting only the rotation and translation parts of the affine transform.
    
    Parameters:
    
    affineTransform - the affine transform to multiply this with. Not modified.
  - multiplyInvertThis
```
public void multiplyInvertThis(RigidBodyTransform other)
```
    Performs the multiplication of the inverse of this transform with other.
    this = this^-1 * other
    
    Parameters:
    
    other - the other transform to multiply this with. Not modified.
  - multiplyInvertOther
```
public void multiplyInvertOther(RigidBodyTransform other)
```
    Performs the multiplication of this transform with the inverse of other.
    this = this * other^-1
    
    Parameters:
    
    other - the other transform to multiply this with. Not modified.
  - multiplyInvertThis
```
public void multiplyInvertThis(QuaternionBasedTransform quaternionBasedTransform)
```
    Performs the multiplication of the inverse of this transform with quaternionBasedTransform.
    this = this^-1 * H(quaternionBasedTransform)
    where H(q) is the function converting a quaternion-based transform into a 4-by-4 transformation matrix.
    
    Parameters:
    
    quaternionBasedTransform - the quaternion-based transform to multiply this with. Not modified.
  - multiplyInvertOther
```
public void multiplyInvertOther(QuaternionBasedTransform quaternionBasedTransform)
```
    Performs the multiplication of this transform with the inverse of quaternionBasedTransform.
    this = this * H(quaternionBasedTransform)^-1
    where H(q) is the function converting a quaternion-based transform into a 4-by-4 transformation matrix.
    
    Parameters:
    
    quaternionBasedTransform - the quaternion-based transform to multiply this with. Not modified.
  - multiplyInvertThis
```
public void multiplyInvertThis(AffineTransform affineTransform)
```
    Performs the multiplication of the inverse of this transform with affineTransform.
    Note: the scale part of the given affine transform is not used when performing the multiplication to conserve a proper rigid-body transform describing only a rotation and a translation.
    
    this = this^-1 * S(affineTransform)
    where S(affineTransform) is the function selecting only the rotation and translation parts of the affine transform.
    
    Parameters:
    
    affineTransform - the affine transform to multiply this with. Not modified.
  - multiplyInvertOther
```
public void multiplyInvertOther(AffineTransform affineTransform)
```
    Performs the multiplication of this transform with the inverse of affineTransform.
    Note: the scale part of the given affine transform is not used when performing the multiplication to conserve a proper rigid-body transform describing only a rotation and a translation.
    
    this = this * S(affineTransform)^-1
    where S(affineTransform) is the function selecting only the rotation and translation parts of the affine transform.
    
    Parameters:
    
    affineTransform - the affine transform to multiply this with. Not modified.
  - appendTranslation
```
public void appendTranslation(Tuple3DReadOnly translation)
```
    Append a translation transform to this transform.
```
               / 1 0 0 translation.x \
 this = this * | 0 1 0 translation.y |
               | 0 0 1 translation.z |
               \ 0 0 0      1        /
 
```
    This method does not affect the rotation part of this transform.
    Parameters:
    
    translation - the translation to append to this transform. Not modified.
  - appendTranslation
```
public void appendTranslation(double x,
                              double y,
                              double z)
```
    Append a translation transform to this transform.
```
               / 1 0 0 x \
 this = this * | 0 1 0 y |
               | 0 0 1 z |
               \ 0 0 0 1 /
 
```
    This method does not affect the rotation part of this transform.
    Parameters:
    
    x - the translation along the x-axis to apply.
    
    y - the translation along the y-axis to apply.
    
    z - the translation along the z-axis to apply.
  - appendYawRotation
```
public void appendYawRotation(double yaw)
```
    Append a rotation about the z-axis to the rotation part of this transform.
```
         / cos(yaw) -sin(yaw) 0 \
 R = R * | sin(yaw)  cos(yaw) 0 |
         \    0         0     1 /
 
```
    This method does not affect the translation part of this transform.
    Parameters:
    
    yaw - the angle to rotate about the z-axis.
  - appendPitchRotation
```
public void appendPitchRotation(double pitch)
```
    Append a rotation about the y-axis to the rotation part of this transform.
```
         /  cos(pitch) 0 sin(pitch) \
 R = R * |      0      1     0      |
         \ -sin(pitch) 0 cos(pitch) /
 
```
    This method does not affect the translation part of this transform.
    Parameters:
    
    pitch - the angle to rotate about the y-axis.
  - appendRollRotation
```
public void appendRollRotation(double roll)
```
    Append a rotation about the x-axis to the rotation part of this transform.
```
         / 1     0          0     \
 R = R * | 0 cos(roll) -sin(roll) |
         \ 0 sin(roll)  cos(roll) /
 
```
    This method does not affect the translation part of this transform.
    Parameters:
    
    roll - the angle to rotate about the x-axis.
  - preMultiply
```
public void preMultiply(RigidBodyTransform other)
```
    Performs the multiplication of other with this transform.
    this = other * this
    
    Parameters:
    
    other - the other transform to multiply this with. Not modified.
  - preMultiply
```
public void preMultiply(QuaternionBasedTransform quaternionBasedTransform)
```
    Performs the multiplication of quaternionBasedTransform with this transform.
    this = H(quaternionBasedTransform) * this
    where H(q) is the function converting a quaternion-based transform into a 4-by-4 transformation matrix.
    
    Parameters:
    
    quaternionBasedTransform - the quaternion-based transform to multiply this with. Not modified.
  - preMultiply
```
public void preMultiply(AffineTransform affineTransform)
```
    Performs the multiplication of affineTransform with this transform.
    Note: the scale part of the given affine transform is not used when performing the multiplication to conserve a proper rigid-body transform describing only a rotation and a translation.
    
    this = S(affineTransform) * this
    where S(affineTransform) is the function selecting only the rotation and translation parts of the affine transform.
    
    Parameters:
    
    affineTransform - the affine transform to multiply this with. Not modified.
  - preMultiplyInvertThis
```
public void preMultiplyInvertThis(RigidBodyTransform other)
```
    Performs the multiplication of other with the inverse of this transform.
    this = other * this^-1
    
    Parameters:
    
    other - the other transform to multiply this with. Not modified.
  - preMultiplyInvertOther
```
public void preMultiplyInvertOther(RigidBodyTransform other)
```
    Performs the multiplication of the inverse of other with this transform.
    this = other^-1 * this
    
    Parameters:
    
    other - the other transform to multiply this with. Not modified.
  - preMultiplyInvertThis
```
public void preMultiplyInvertThis(QuaternionBasedTransform quaternionBasedTransform)
```
    Performs the multiplication of quaternionBasedTransform with the inverse of this transform.
    this = H(quaternionBasedTransform) * this^-1
    where H(q) is the function converting a quaternion-based transform into a 4-by-4 transformation matrix.
    
    Parameters:
    
    quaternionBasedTransform - the quaternion-based transform to multiply this with. Not modified.
  - preMultiplyInvertOther
```
public void preMultiplyInvertOther(QuaternionBasedTransform quaternionBasedTransform)
```
    Performs the multiplication of the inverse of quaternionBasedTransform with this transform.
    this = H(quaternionBasedTransform)^-1 * this
    where H(q) is the function converting a quaternion-based transform into a 4-by-4 transformation matrix.
    
    Parameters:
    
    quaternionBasedTransform - the quaternion-based transform to multiply this with. Not modified.
  - preMultiplyInvertThis
```
public void preMultiplyInvertThis(AffineTransform affineTransform)
```
    Performs the multiplication of affineTransform with the inverse of this transform.
    Note: the scale part of the given affine transform is not used when performing the multiplication to conserve a proper rigid-body transform describing only a rotation and a translation.
    
    this = S(affineTransform) * this^-1
    where S(affineTransform) is the function selecting only the rotation and translation parts of the affine transform.
    
    Parameters:
    
    affineTransform - the affine transform to multiply this with. Not modified.
  - preMultiplyInvertOther
```
public void preMultiplyInvertOther(AffineTransform affineTransform)
```
    Performs the multiplication of the inverse of affineTransform with this transform.
    Note: the scale part of the given affine transform is not used when performing the multiplication to conserve a proper rigid-body transform describing only a rotation and a translation.
    
    this = S(affineTransform)^-1 * this
    where S(affineTransform) is the function selecting only the rotation and translation parts of the affine transform.
    
    Parameters:
    
    affineTransform - the affine transform to multiply this with. Not modified.
  - prependTranslation
```
public void prependTranslation(Tuple3DReadOnly translation)
```
    Prepend a translation transform to this transform.
```
        / 1 0 0 translation.x \
 this = | 0 1 0 translation.y | * this
        | 0 0 1 translation.z |
        \ 0 0 0      1        /
 
```
    This method does not affect the rotation part of this transform.
    Parameters:
    
    translation - the translation to prepend to this transform. Not modified.
  - prependTranslation
```
public void prependTranslation(double x,
                               double y,
                               double z)
```
    Prepend a translation transform to this transform.
```
        / 1 0 0 x \
 this = | 0 1 0 y | * this
        | 0 0 1 z |
        \ 0 0 0 1 /
 
```
    This method does not affect the rotation part of this transform.
    Parameters:
    
    x - the translation along the x-axis to apply.
    
    y - the translation along the y-axis to apply.
    
    z - the translation along the z-axis to apply.
  - prependYawRotation
```
public void prependYawRotation(double yaw)
```
    Prepend a rotation about the z-axis to this transform.
    This method first rotates the translation part and then prepend the yaw-rotation to the rotation part of this transform.
```
        / cos(yaw) -sin(yaw)  0   0 \
 this = | sin(yaw)  cos(yaw)  0   0 | * this
        |    0         0      1   0 |
        \    0         0      0   1 /
 
```
    Parameters:
    
    yaw - the angle to rotate about the z-axis.
  - prependPitchRotation
```
public void prependPitchRotation(double pitch)
```
    Prepend a rotation about the y-axis to this transform.
    This method first rotates the translation part and then prepend the pitch-rotation to the rotation part of this transform.
```
        /  cos(pitch) 0 sin(pitch)  0 \
 this = |      0      1     0       0 | * this
        | -sin(pitch) 0 cos(pitch)  0 |
        \      0      0     0       1 /
 
```
    Parameters:
    
    pitch - the angle to rotate about the y-axis.
  - prependRollRotation
```
public void prependRollRotation(double roll)
```
    Prepend a rotation about the x-axis to this transform.
    This method first rotates the translation part and then prepend the roll-rotation to the rotation part of this transform.
```
        / 1     0          0     0 \
 this = | 0 cos(roll) -sin(roll) 0 | * this
        | 0 sin(roll)  cos(roll) 0 |
        \ 0     0          0     1 /
 
```
    Parameters:
    
    roll - the angle to rotate about the x-axis.
  - transform
```
public void transform(Point3DReadOnly pointOriginal,
                      Point3DBasics pointTransformed)
```
    Transforms the given pointOriginal by this transform and stores the result in pointTransformed.
    Note: transforming a point differs from transforming a vector in the way that the point can be translated, whereas the vector can be only rotated and scaled.
    
    The transformation depends on the implementation of the transform, here are a few examples:
    - RigidBodyTransform rotates then translates a point.
    - QuaternionBasedTransform rotates then translates a point.
    - AffineTransform scales, rotates, then translates a point.
    Specified by:
    
    transform in interface Transform
    
    Parameters:
    
    pointOriginal - the point to transform. Not modified.
    
    pointTransformed - the point in which the result is stored. Modified.
  - transform
```
public void transform(Vector3DReadOnly vectorOriginal,
                      Vector3DBasics vectorTransformed)
```
    Transforms the given vectorOriginal by this transform and stores the result in vectorTransformed.
    Note: transforming a point differs from transforming a vector in the way that the point can be translated, whereas the vector only rotated and scaled.
    
    The transformation depends on the implementation of the transform, here are a few examples:
    - RigidBodyTransform rotates a vector.
    - QuaternionBasedTransform rotates a vector.
    - AffineTransform scales then rotates a vector.
    Specified by:
    
    transform in interface Transform
    
    Parameters:
    
    vectorOriginal - the vector to transform. Not modified.
    
    vectorTransformed - the vector in which the result is stored. Modified.
  - transform
```
public void transform(QuaternionReadOnly quaternionOriginal,
                      QuaternionBasics quaternionTransformed)
```
    Transforms the given quaternionOriginal by this transform and stores the result in quaternionTransformed.
    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:
    
    transform in interface Transform
    
    Parameters:
    
    quaternionOriginal - the quaternion to transform. Not modified.
    
    quaternionTransformed - the quaternion in which the result is stored. Modified.
  - transform
```
public void transform(Vector4DReadOnly vectorOriginal,
                      Vector4DBasics vectorTransformed)
```
    Transforms the vector part (x, y, z) of the given vector4DOriginal as a 3D vector and translates it by s times the translation part of the transform. The scalar part (s) remains unchanged.
    Note that for s = 0, a 4D vector behaves as a 3D vector, and for s = 1 it behaves as a 3D point.
  - RigidBodyTransform rotates then translates a vector.
  - QuaternionBasedTransform rotates then translates a vector.
  - AffineTransform scales, rotates, then translates a vector.

Specified by:: transform in interface Transform
Parameters:: vectorOriginal - the 4D vector to transform. Not modified.; vectorTransformed - the 4D vector in which the result is stored. Modified.

transform
```
public void transform(Point2DReadOnly point2DOriginal,
                      Point2DBasics point2DTransformed,
                      boolean checkIfTransformInXYPlane)
```
Transforms the given point2DOriginal by this transform and stores the result in point2DTransformed.
Note: transforming a point differs from transforming a vector in the way that the point can be translated, whereas the vector can be only rotated and scaled.

The transformation depends on the implementation of the transform, here are a few examples:
- RigidBodyTransform rotates then translates a point.
- QuaternionBasedTransform rotates then translates a point.
- AffineTransform scales, rotates, then translates a point.
Specified by:

transform in interface Transform

Parameters:

point2DOriginal - the point to transform. Not modified.

point2DTransformed - the point in which the result is stored. Modified.

checkIfTransformInXYPlane - whether this method should assert that the rotation part of this transform represents a transformation in the XY plane.

transform
```
public void transform(Vector2DReadOnly vector2DOriginal,
                      Vector2DBasics vector2DTransformed,
                      boolean checkIfTransformInXYPlane)
```
Transforms the given vector2DOriginal by this transform and stores the result in vector2DTransformed.
Note: transforming a point differs from transforming a vector in the way that the point can be translated, whereas the vector can be only rotated and scaled.

The transformation depends on the implementation of the transform, here are a few examples:
- RigidBodyTransform rotates then translates a point.
- QuaternionBasedTransform rotates then translates a point.
- AffineTransform scales, rotates, then translates a point.
Specified by:

transform in interface Transform

Parameters:

vector2DOriginal - the vector to transform. Not modified.

vector2DTransformed - the vector in which the result is stored. Modified.

checkIfTransformInXYPlane - whether this method should assert that the rotation part of this transform represents a transformation in the XY plane.

transform
```
public void transform(RotationMatrixReadOnly matrixOriginal,
                      RotationMatrix matrixTransformed)
```
Transforms the given matrixOriginal by this transform and stores the result in matrixTransformed.
RigidBodyTransform, QuaternionBasedTransform, and AffineTransform prepend their rotation part the given rotation matrix. No scale or translation is applied to the rotation matrix such that the output of this method is still a proper rotation matrix.

Specified by:

transform in interface Transform

Parameters:

matrixOriginal - the rotation matrix to transform. Not modified.

matrixTransformed - the rotation matrix in which the result is stored. Modified.

transform
```
public void transform(Matrix3DReadOnly matrixOriginal,
                      Matrix3D matrixTransformed)
```
Transforms the given matrixOriginal by this transform and stores the result in matrixTransformed.
WARNING: This is different from concatenating orientations.

The transformation depends on the implementation of the transform, here are a few examples:
- RigidBodyTransform rotates a matrix.
- QuaternionBasedTransform rotates a matrix.
- AffineTransform scales then rotates a matrix.
Specified by:

transform in interface Transform

Parameters:

matrixOriginal - the matrix to transform. Not modified.

matrixTransformed - the matrix in which the result in stored. Modified.

transform
```
public void transform(RigidBodyTransform original,
                      RigidBodyTransform transformed)
```
Transforms the given original by this transform and stores the result in transformed.
The given transform is only rotated and translated, no scaling is applied.

Specified by:

transform in interface Transform

Parameters:

original - the rigid-body transform to transform. Not modified.

transformed - the rigid-body transform in which the result is stored. Modified.

transform
```
public void transform(QuaternionBasedTransform original,
                      QuaternionBasedTransform transformed)
```
Transforms the given original by this transform and stores the result in transformed.
The given transform is only rotated and translated, no scaling is applied.

Specified by:

transform in interface Transform

Parameters:

original - the quaternion based transform to transform. Not modified.

transformed - the quaternion based transform in which the result is stored. Modified.

transform
```
public void transform(AffineTransform original,
                      AffineTransform transformed)
```
Transforms the given original by this transform and stores the result in transformed.
The given transform is only rotated and translated, no scaling is applied.

Specified by:

transform in interface Transform

Parameters:

original - the affine transform to transform. Not modified.

transformed - the affine transform in which the result is stored. Modified.

inverseTransform
```
public void inverseTransform(Point3DReadOnly pointOriginal,
                             Point3DBasics pointTransformed)
```
Performs the inverse of the transform on the given point pointOriginal and stores the result in pointTransformed.
This is equivalent to calling Transform.transform(Point3DReadOnly, Point3DBasics) with the inverse of this transform.

Specified by:

inverseTransform in interface Transform

Parameters:

pointOriginal - the point to transform. Not modified.

pointTransformed - the point in which the result is stored. Modified.

inverseTransform
```
public void inverseTransform(Vector3DReadOnly vectorOriginal,
                             Vector3DBasics vectorTransformed)
```
Performs the inverse of the transform on the given vector vectorOriginal and stores the result in vectorTransformed.
This is equivalent to calling Transform.transform(Vector3DReadOnly, Vector3DBasics) with the inverse of this transform.

Specified by:

inverseTransform in interface Transform

Parameters:

vectorOriginal - the vector to transform. Not modified.

vectorTransformed - the vector in which the result is stored. Modified.

inverseTransform
```
public void inverseTransform(QuaternionReadOnly quaternionOriginal,
                             QuaternionBasics quaternionTransformed)
```
Performs the inverse of the transform on the given quaternion quaternionOriginal and stores the result in quaternionTransformed.
This is equivalent to calling Transform.transform(QuaternionReadOnly, QuaternionBasics) with the inverse of this transform.

Specified by:

inverseTransform in interface Transform

Parameters:

quaternionOriginal - the quaternion to transform. Not modified.

quaternionTransformed - the quaternion in which the result is stored. Modified.

inverseTransform
```
public void inverseTransform(Vector4DReadOnly vectorOriginal,
                             Vector4DBasics vectorTransformed)
```
Performs the inverse of the transform on the given vector vectorOriginal and stores the result in vectorTransformed.
This is equivalent to calling Transform.transform(Vector4DReadOnly, Vector4DBasics) with the inverse of this transform.

Specified by:

inverseTransform in interface Transform

Parameters:

vectorOriginal - the 4D vector to transform. Not modified.

vectorTransformed - the 4D vector in which the result is stored. Modified.

inverseTransform
```
public void inverseTransform(Point2DReadOnly pointOriginal,
                             Point2DBasics pointTransformed,
                             boolean checkIfTransformInXYPlane)
```
Performs the inverse of the transform on the given point pointOriginal and stores the result in pointTransformed.
This is equivalent to calling Transform.transform(Point2DReadOnly, Point2DBasics, boolean) with the inverse of this transform.

Specified by:

inverseTransform in interface Transform

Parameters:

pointOriginal - the point to transform. Not modified.

pointTransformed - the point in which the result is stored. Modified.

checkIfTransformInXYPlane - whether this method should assert that the rotation part of this transform represents a transformation in the XY plane.

inverseTransform
```
public void inverseTransform(Vector2DReadOnly vectorOriginal,
                             Vector2DBasics vectorTransformed,
                             boolean checkIfTransformInXYPlane)
```
Performs the inverse of the transform on the given vector vectorOriginal and stores the result in vectorTransformed.
This is equivalent to calling Transform.transform(Vector2DReadOnly, Vector2DBasics, boolean) with the inverse of this transform.

Specified by:

inverseTransform in interface Transform

Parameters:

vectorOriginal - the vector to transform. Not modified.

vectorTransformed - the vector in which the result is stored. Modified.

checkIfTransformInXYPlane - whether this method should assert that the rotation part of this transform represents a transformation in the XY plane.

inverseTransform
```
public void inverseTransform(RotationMatrixReadOnly matrixOriginal,
                             RotationMatrix matrixTransformed)
```
Performs the inverse of the transform on the given matrix matrixOriginal and stores the result in matrixTransformed.
This is equivalent to calling Transform.transform(RotationMatrixReadOnly, RotationMatrix) with the inverse of this transform.

Specified by:

inverseTransform in interface Transform

Parameters:

matrixOriginal - the rotation matrix to transform. Not modified.

matrixTransformed - the rotation matrix in which the result is stored. Modified.

inverseTransform
```
public void inverseTransform(Matrix3DReadOnly matrixOriginal,
                             Matrix3D matrixTransformed)
```
Performs the inverse of the transform on the given matrix matrixOriginal and stores the result in matrixTransformed.
This is equivalent to calling Transform.transform(Matrix3DReadOnly, Matrix3D) with the inverse of this transform.

Specified by:

inverseTransform in interface Transform

Parameters:

matrixOriginal - the matrix to transform. Not modified.

matrixTransformed - the matrix in which the result in stored. Modified.

inverseTransform
```
public void inverseTransform(RigidBodyTransform original,
                             RigidBodyTransform transformed)
```
Performs the inverse of the transform on the given original and stores the result in transformed.
This is equivalent to calling Transform.transform(RigidBodyTransform, RigidBodyTransform) with the inverse of this transform.

The given transform is only rotated and translated, no scaling is applied.

Specified by:

inverseTransform in interface Transform

Parameters:

original - the rigid-body transform to transform. Not modified.

transformed - the rigid-body transform in which the result is stored. Modified.

inverseTransform
```
public void inverseTransform(QuaternionBasedTransform original,
                             QuaternionBasedTransform transformed)
```
Performs the inverse of the transform on the given original stores the result in transformed.
This is equivalent to calling Transform.transform(QuaternionBasedTransform, QuaternionBasedTransform) with the inverse of this transform.

The given transform is only rotated and translated, no scaling is applied.

Specified by:

inverseTransform in interface Transform

Parameters:

original - the quaternion based transform to transform. Not modified.

transformed - the quaternion based transform in which the result is stored. Modified.

inverseTransform
```
public void inverseTransform(AffineTransform original,
                             AffineTransform transformed)
```
Performs the inverse of the transform on the given original and stores the result in transformed.
This is equivalent to calling Transform.transform(AffineTransform, AffineTransform) with the inverse of this transform.

The given transform is only rotated and translated, no scaling is applied.

Specified by:

inverseTransform in interface Transform

Parameters:

original - the affine transform to transform. Not modified.

transformed - the affine transform in which the result is stored. Modified.

get
```
public void get(org.ejml.data.DenseMatrix64F matrixToPack)
```
Packs this transform as a 4-by-4 matrix.
```
     / R(0, 0) R(0, 1) R(0, 2) Tx \
 H = | R(1, 0) R(1, 1) R(1, 2) Ty |
     | R(2, 0) R(2, 1) R(2, 2) Tz |
     \    0       0       0     1 /
 
```
where R is the 3-by-3 rotation matrix and (Tx, Ty, Tz) is the translation part of this transform.
Parameters:

matrixToPack - the matrix in which this transform is stored. Modified.

get
```
public void get(int startRow,
                int startColumn,
                org.ejml.data.DenseMatrix64F matrixToPack)
```
Packs this transform as a 4-by-4 matrix.
```
     / R(0, 0) R(0, 1) R(0, 2) Tx \
 H = | R(1, 0) R(1, 1) R(1, 2) Ty |
     | R(2, 0) R(2, 1) R(2, 2) Tz |
     \    0       0       0     1 /
 
```
where R is the 3-by-3 rotation matrix and (Tx, Ty, Tz) is the translation part of this transform.
Parameters:

startRow - the first row index to start writing in matrixToPack.

startColumn - the first column index to start writing in matrixToPack.

matrixToPack - the matrix in which this transform is stored. Modified.

get
```
public void get(double[] transformArrayToPack)
```
Packs this transform as a 4-by-4 matrix into a 1D row-major array.
```
     / R(0, 0) R(0, 1) R(0, 2) Tx \
 H = | R(1, 0) R(1, 1) R(1, 2) Ty |
     | R(2, 0) R(2, 1) R(2, 2) Tz |
     \    0       0       0     1 /
 
```
where R is the 3-by-3 rotation matrix and (Tx, Ty, Tz) is the translation part of this transform.
Parameters:

transformArrayToPack - the array in which this transform is stored. Modified.

get
```
public void get(float[] transformArrayToPack)
```
Packs this transform as a 4-by-4 matrix into a 1D row-major array.
```
     / R(0, 0) R(0, 1) R(0, 2) Tx \
 H = | R(1, 0) R(1, 1) R(1, 2) Ty |
     | R(2, 0) R(2, 1) R(2, 2) Tz |
     \    0       0       0     1 /
 
```
where R is the 3-by-3 rotation matrix and (Tx, Ty, Tz) is the translation part of this transform.
Parameters:

transformArrayToPack - the array in which this transform is stored. Modified.

get
```
public void get(Orientation3DBasics orientationToPack,
                Tuple3DBasics translationToPack)
```
Packs the rotation matrix and translation vector of this rigid-body transform.

Parameters:

orientationToPack - the orientation to set to the rotation of this transform. Modified.

translationToPack - the tuple to set to the translation of this transform. Modified.

get
```
public void get(Vector3DBasics rotationVectorToPack,
                Tuple3DBasics translationToPack)
```
Packs the rotation matrix and translation vector of this rigid-body transform.
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.

Parameters:

rotationVectorToPack - the rotation vector to set to the rotation of this transform. Modified.

translationToPack - the tuple to set to the translation of this transform. Modified.

get
```
public void get(Matrix3DBasics rotationMarixToPack,
                Tuple3DBasics translationToPack)
```
Packs the rotation matrix and translation vector of this rigid-body transform.

Parameters:

rotationMarixToPack - the matrix to set to the rotation of this transform. Modified.

translationToPack - the tuple to set to the translation of this transform. Modified.

get
```
public void get(RotationMatrix rotationMarixToPack,
                Tuple3DBasics translationToPack)
```
Packs the rotation matrix and translation vector of this rigid-body transform.

Parameters:

rotationMarixToPack - the matrix to set to the rotation of this transform. Modified.

translationToPack - the tuple to set to the translation of this transform. Modified.

get
```
public void get(RotationScaleMatrix rotationMarixToPack,
                Tuple3DBasics translationToPack)
```
Packs the rotation matrix and translation vector of this rigid-body transform.

Parameters:

rotationMarixToPack - the matrix to set to the rotation of this transform. The scale part is reset. Modified.

translationToPack - the tuple to set to the translation of this transform. Modified.

getRotationMatrix
```
public RotationMatrixReadOnly getRotationMatrix()
```
Gets the read-only reference to the rotation part of this transform.

Returns:

the rotation part of this transform.

getRotation
```
public void getRotation(Matrix3DBasics rotationMatrixToPack)
```
Packs the rotation part of this rigid-body transform.

Parameters:

rotationMatrixToPack - the matrix in which the rotation part of this transform is stored. Modified.

getRotation
```
public void getRotation(RotationMatrix rotationMatrixToPack)
```
Packs the rotation part of this rigid-body transform.

Parameters:

rotationMatrixToPack - the matrix in which the rotation part of this transform is stored. Modified.

getRotation
```
public void getRotation(RotationScaleMatrix rotationMatrixToPack)
```
Packs the rotation part of this rigid-body transform.

Parameters:

rotationMatrixToPack - the rotation-scale matrix that is set to this transform's rotation. The scale part is reset. Modified.

getRotation
```
public void getRotation(org.ejml.data.DenseMatrix64F rotationMatrixToPack)
```
Packs the rotation part of this rigid-body transform.

Parameters:

rotationMatrixToPack - the matrix in which the rotation part of this transform is stored. Modified.

getRotation
```
public void getRotation(double[] rotationMatrixArrayToPack)
```
Packs the rotation part of this rigid-body transform in 1D row-major array.

Parameters:

rotationMatrixArrayToPack - the array in which the rotation part of this transform is stored. Modified.

getRotation
```
public void getRotation(Orientation3DBasics orientationToPack)
```
Packs the rotation part of this rigid-body transform as a quaternion.

Parameters:

orientationToPack - the orientation that is set to the rotation part of this transform. Modified.

getRotation
```
public void getRotation(Vector3DBasics rotationVectorToPack)
```
Packs the rotation part of this rigid-body transform as a rotation vector.
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.

Parameters:

rotationVectorToPack - the rotation vector that is set to the rotation part of this transform. Modified.

getRotationYawPitchRoll
```
public void getRotationYawPitchRoll(double[] yawPitchRollToPack)
```
Computes and packs the orientation described by the rotation part of this transform as the yaw-pitch-roll angles.
WARNING: the Euler angles or yaw-pitch-roll representation is sensitive to gimbal lock and is sometimes undefined.

Parameters:

yawPitchRollToPack - the array in which the yaw-pitch-roll angles are stored. Modified.

getRotationEuler
```
public void getRotationEuler(Vector3DBasics eulerAnglesToPack)
```
Computes and packs the orientation described by the rotation part of this transform as the Euler angles.
WARNING: the Euler angles or yaw-pitch-roll representation is sensitive to gimbal lock and is sometimes undefined.

Parameters:

eulerAnglesToPack - the tuple in which the Euler angles are stored. Modified.

getTranslationVector
```
public Vector3DReadOnly getTranslationVector()
```
Gets the read-only reference of the translation part of this rigid-body transform.

Returns:

the translation part of this transform.

getTranslation
```
public void getTranslation(Tuple3DBasics translationToPack)
```
Packs the translation part of this rigid-body transform.

Parameters:

translationToPack - the tuple in which the translation part of this transform is stored. Modified.

getTranslationX
```
public double getTranslationX()
```
Gets the x-component of the translation part of this transform.

Returns:

the x-component of the translation part.

getTranslationY
```
public double getTranslationY()
```
Gets the y-component of the translation part of this transform.

Returns:

the y-component of the translation part.

getTranslationZ
```
public double getTranslationZ()
```
Gets the z-component of the translation part of this transform.

Returns:

the z-component of the translation part.

getElement
```
public double getElement(int row,
                         int column)
```
Retrieves and returns a coefficient of this transform given its row and column indices.

Parameters:

row - the row of the coefficient to return.

column - the column of the coefficient to return.

Returns:

the coefficient's value.

Throws:

java.lang.ArrayIndexOutOfBoundsException - if either row ∉ [0, 3] or column ∉ [0, 3].

getM00
```
public double getM00()
```
Gets the 1st row 1st column coefficient of this transform.

Returns:

the 1st row 1st column coefficient.

getM01
```
public double getM01()
```
Gets the 1st row 2nd column coefficient of this transform.

Returns:

the 1st row 2nd column coefficient.

getM02
```
public double getM02()
```
Gets the 1st row 3rd column coefficient of this transform.

Returns:

the 1st row 3rd column coefficient.

getM03
```
public double getM03()
```
Gets the 1st row 4th column coefficient of this transform.

Returns:

the 1st row 4th column coefficient.

getM10
```
public double getM10()
```
Gets the 2nd row 1st column coefficient of this transform.

Returns:

the 2nd row 1st column coefficient.

getM11
```
public double getM11()
```
Gets the 2nd row 2nd column coefficient of this transform.

Returns:

the 2nd row 2nd column coefficient.

getM12
```
public double getM12()
```
Gets the 2nd row 3rd column coefficient of this transform.

Returns:

the 2nd row 3rd column coefficient.

getM13
```
public double getM13()
```
Gets the 2nd row 4th column coefficient of this transform.

Returns:

the 2nd row 4th column coefficient.

getM20
```
public double getM20()
```
Gets the 3rd row 1st column coefficient of this transform.

Returns:

the 3rd row 1st column coefficient.

getM21
```
public double getM21()
```
Gets the 3rd row 2nd column coefficient of this transform.

Returns:

the 3rd row 2nd column coefficient.

getM22
```
public double getM22()
```
Gets the 3rd row 3rd column coefficient of this transform.

Returns:

the 3rd row 3rd column coefficient.

getM23
```
public double getM23()
```
Gets the 3rd row 4th column coefficient of this transform.

Returns:

the 3rd row 4th column coefficient.

getM30
```
public double getM30()
```
Gets the 4th row 1st column coefficient of this transform.
Note: m30 = 0.0.

Returns:

the 4th row 1st column coefficient.

getM31
```
public double getM31()
```
Gets the 4th row 2nd column coefficient of this transform.
Note: m31 = 0.0.

Returns:

the 4th row 2nd column coefficient.

getM32
```
public double getM32()
```
Gets the 4th row 3rd column coefficient of this transform.
Note: m32 = 0.0.

Returns:

the 4th row 3rd column coefficient.

getM33
```
public double getM33()
```
Gets the 4th row 4th column coefficient of this transform.
Note: m33 = 1.0.

Returns:

the 4th row 4th column coefficient.

epsilonEquals
```
public boolean epsilonEquals(RigidBodyTransform other,
                             double epsilon)
```
Tests separately and on a per component basis if the rotation part and the translation part of this transform and other are equal to an epsilon.

Specified by:

epsilonEquals in interface EpsilonComparable<RigidBodyTransform>

Parameters:

other - the other rigid-body transform to compare against this. Not modified.

epsilon - tolerance to use when comparing each component.

Returns:

true if the two objects are equal component-wise, false otherwise.

equals
```
public boolean equals(java.lang.Object object)
```
Tests if the given object's class is the same as this, in which case the method returns equals(RigidBodyTransform), it returns false otherwise or if the object is null.

Overrides:

equals in class java.lang.Object

Parameters:

object - the object to compare against this. Not modified.

Returns:

true if object and this are exactly equal, false otherwise.

equals
```
public boolean equals(RigidBodyTransform other)
```
Tests separately and on a per component basis if the rotation part and the translation part of this transform and other are exactly equal.
The method returns false if the given transform is null.

Parameters:

other - the other transform to compare against this. Not modified.

Returns:

true if the two transforms are exactly equal, false otherwise.

geometricallyEquals
```
public boolean geometricallyEquals(RigidBodyTransform other,
                                   double epsilon)
```
Two rigid body transforms are considered geometrically equal if both the rotation matrices and translation vectors are equal.

Specified by:

geometricallyEquals in interface GeometricallyComparable<RigidBodyTransform>

Parameters:

other - the other rigid body transform to compare against this. Not modified.

epsilon - the tolerance to use when comparing each component.

Returns:

true if the two rigid body transforms are equal, false otherwise.

toString
```
public java.lang.String toString()
```
Provides a String representation of this transform as follows:
m00, m01, m02 | m03
m10, m11, m12 | m13
m20, m21, m22 | m23

Overrides:

toString in class java.lang.Object

Returns:

the String representing this transform.

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class java.lang.Object

Class RigidBodyTransform

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface us.ihmc.euclid.transform.interfaces.Transform

Constructor Detail

RigidBodyTransform

RigidBodyTransform

RigidBodyTransform

RigidBodyTransform

RigidBodyTransform

RigidBodyTransform

RigidBodyTransform

Method Detail

setIdentity

setToZero

setRotationToZero

setTranslationToZero

setToNaN

setRotationToNaN

setTranslationToNaN

containsNaN

isRotation2D

checkIfRotation2D

normalizeRotationPart

determinantRotationPart

set

setUnsafe

set

setAndInvert

set

set

set

set

setAsTranspose

set

setAsTranspose

set

set

set

set

setRotation

setRotationUnsafe

setRotation

setRotation

setRotation

setRotation

setRotation

setRotationYaw

setRotationPitch

setRotationRoll

setRotationYawPitchRoll

setRotationYawPitchRoll

setRotationEuler

setRotationEuler

setRotationAndZeroTranslation

setRotationAndZeroTranslation

setRotationAndZeroTranslation

setRotationAndZeroTranslation

setRotationAndZeroTranslation

setRotationYawAndZeroTranslation

setRotationPitchAndZeroTranslation

setRotationRollAndZeroTranslation

setRotationYawPitchRollAndZeroTranslation

setRotationYawPitchRollAndZeroTranslation

setRotationEulerAndZeroTranslation

setRotationEulerAndZeroTranslation

setTranslationX

setTranslationY

setTranslationZ

setTranslation

setTranslation

setTranslationAndIdentityRotation

setTranslationAndIdentityRotation

invert

invertRotation

multiply

multiply

multiply

multiplyInvertThis