public interface Transform
 In this library, a geometric transformation typically includes: scaling, rotation, and
 translation. For instance, RigidBodyTransform represents a 4-by-4 homogeneous
 transformation matrix that can rotate and translate a Point3D.
 
| Modifier and Type | Method and Description | 
|---|---|
default void | 
inverseTransform(AffineTransform affineTransformToTransform)
Performs the inverse of the transform on the given  
affineTransformToTransform. | 
void | 
inverseTransform(AffineTransform original,
                AffineTransform transformed)
Performs the inverse of the transform on the given  
original and stores the result in
 transformed. | 
default void | 
inverseTransform(Matrix3D matrixToTransform)
Performs the inverse of the transform on the given matrix  
matrixToTransform. | 
void | 
inverseTransform(Matrix3DReadOnly matrixOriginal,
                Matrix3D matrixTransformed)
Performs the inverse of the transform on the given matrix  
matrixOriginal and stores
 the result in matrixTransformed. | 
default void | 
inverseTransform(Point2DBasics point2DToTransform)
Performs the inverse of the transform on the given point  
pointToTransform. | 
default void | 
inverseTransform(Point2DBasics point2DToTransform,
                boolean checkIfTransformInXYPlane)
Performs the inverse of the transform on the given point  
pointToTransform. | 
default void | 
inverseTransform(Point2DReadOnly point2DOriginal,
                Point2DBasics point2DTransformed)
Performs the inverse of the transform on the given point  
pointOriginal and stores the
 result in pointTransformed. | 
void | 
inverseTransform(Point2DReadOnly point2DOriginal,
                Point2DBasics point2DTransformed,
                boolean checkIfTransformInXYPlane)
Performs the inverse of the transform on the given point  
pointOriginal and stores the
 result in pointTransformed. | 
default void | 
inverseTransform(Point3DBasics pointToTransform)
Performs the inverse of the transform on the given point  
pointToTransform. | 
void | 
inverseTransform(Point3DReadOnly pointOriginal,
                Point3DBasics pointTransformed)
Performs the inverse of the transform on the given point  
pointOriginal and stores the
 result in pointTransformed. | 
default void | 
inverseTransform(QuaternionBasedTransform quaternionBasedTransformToTransform)
Performs the inverse of the transform on the given
  
quaternionBasedTransformToTransform. | 
void | 
inverseTransform(QuaternionBasedTransform original,
                QuaternionBasedTransform transformed)
Performs the inverse of the transform on the given  
original stores the result in
 transformed. | 
default void | 
inverseTransform(QuaternionBasics quaternionToTransform)
Performs the inverse of the transform on the given quaternion  
quaternionToTransform. | 
void | 
inverseTransform(QuaternionReadOnly quaternionOriginal,
                QuaternionBasics quaternionTransformed)
Performs the inverse of the transform on the given quaternion  
quaternionOriginal and
 stores the result in quaternionTransformed. | 
default void | 
inverseTransform(RigidBodyTransform rigidBodyTransformToTransform)
Performs the inverse of the transform on the given  
rigidBodyTransformToTransform. | 
void | 
inverseTransform(RigidBodyTransform original,
                RigidBodyTransform transformed)
Performs the inverse of the transform on the given  
original and stores the result in
 transformed. | 
default void | 
inverseTransform(RotationMatrix matrixToTransform)
Performs the inverse of the transform on the given rotation matrix  
matrixToTransform. | 
void | 
inverseTransform(RotationMatrixReadOnly matrixOriginal,
                RotationMatrix matrixTransformed)
Performs the inverse of the transform on the given matrix  
matrixOriginal and stores
 the result in matrixTransformed. | 
default void | 
inverseTransform(Vector2DBasics vector2DToTransform)
Performs the inverse of the transform on the given vector  
vectorToTransform. | 
default void | 
inverseTransform(Vector2DBasics vector2DToTransform,
                boolean checkIfTransformInXYPlane)
Performs the inverse of the transform on the given vector  
vectorToTransform. | 
default void | 
inverseTransform(Vector2DReadOnly vector2DOriginal,
                Vector2DBasics vector2DTransformed)
Performs the inverse of the transform on the given vector  
vectorOriginal and stores
 the result in vectorTransformed. | 
void | 
inverseTransform(Vector2DReadOnly vector2DOriginal,
                Vector2DBasics vector2DTransformed,
                boolean checkIfTransformInXYPlane)
Performs the inverse of the transform on the given vector  
vectorOriginal and stores
 the result in vectorTransformed. | 
default void | 
inverseTransform(Vector3DBasics vectorToTransform)
Performs the inverse of the transform on the given vector  
vectorToTransform. | 
void | 
inverseTransform(Vector3DReadOnly vectorOriginal,
                Vector3DBasics vectorTransformed)
Performs the inverse of the transform on the given vector  
vectorOriginal and stores
 the result in vectorTransformed. | 
default void | 
inverseTransform(Vector4DBasics vectorToTransform)
Performs the inverse of the transform on the given vector  
vectorToTransform. | 
void | 
inverseTransform(Vector4DReadOnly vectorOriginal,
                Vector4DBasics vectorTransformed)
Performs the inverse of the transform on the given vector  
vectorOriginal and stores
 the result in vectorTransformed. | 
default void | 
transform(AffineTransform affineTransformToTransform)
Transforms the given  
affineTransformToTransform by this transform. | 
void | 
transform(AffineTransform original,
         AffineTransform transformed)
Transforms the given  
original by this transform and stores the result in
 transformed. | 
default void | 
transform(Matrix3D matrixToTransform)
Transforms the given  
matrixToTransform by this transform. | 
void | 
transform(Matrix3DReadOnly matrixOriginal,
         Matrix3D matrixTransformed)
Transforms the given  
matrixOriginal by this transform and stores the result in
 matrixTransformed. | 
default void | 
transform(Point2DBasics pointToTransform)
Transforms the given  
point2DToTransform by this transform. | 
default void | 
transform(Point2DBasics pointToTransform,
         boolean checkIfTransformInXYPlane)
Transforms the given  
point2DToTransform by this transform. | 
default void | 
transform(Point2DReadOnly pointOriginal,
         Point2DBasics pointTransformed)
Transforms the given  
point2DOriginal by this transform and stores the result in
 point2DTransformed. | 
void | 
transform(Point2DReadOnly pointOriginal,
         Point2DBasics pointTransformed,
         boolean checkIfTransformInXYPlane)
Transforms the given  
point2DOriginal by this transform and stores the result in
 point2DTransformed. | 
default void | 
transform(Point3DBasics pointToTransform)
Transforms the given  
pointToTransform by this transform. | 
void | 
transform(Point3DReadOnly pointOriginal,
         Point3DBasics pointTransformed)
Transforms the given  
pointOriginal by this transform and stores the result in
 pointTransformed. | 
default void | 
transform(QuaternionBasedTransform quaternionBasedTransformToTransform)
Transforms the given  
quaternionBasedTransformToTransform by this transform. | 
void | 
transform(QuaternionBasedTransform original,
         QuaternionBasedTransform transformed)
Transforms the given  
original by this transform and stores the result in
 transformed. | 
default void | 
transform(QuaternionBasics quaternionToTransform)
Transforms the given  
quaternionToTransform by this transform. | 
void | 
transform(QuaternionReadOnly quaternionOriginal,
         QuaternionBasics quaternionTransformed)
Transforms the given  
quaternionOriginal by this transform and stores the result in
 quaternionTransformed. | 
default void | 
transform(RigidBodyTransform rigidBodyTransformToTransform)
Transforms the given  
rigidBodyTransformToTransform by this transform. | 
void | 
transform(RigidBodyTransform original,
         RigidBodyTransform transformed)
Transforms the given  
original by this transform and stores the result in
 transformed. | 
default void | 
transform(RotationMatrix matrixToTransform)
Transforms the given  
rotationMatrix by this transform. | 
void | 
transform(RotationMatrixReadOnly matrixOriginal,
         RotationMatrix matrixTransformed)
Transforms the given  
matrixOriginal by this transform and stores the result in
 matrixTransformed. | 
default void | 
transform(Vector2DBasics vectorToTransform)
Transforms the given  
vector2DToTransform by this transform. | 
default void | 
transform(Vector2DBasics vectorToTransform,
         boolean checkIfTransformInXYPlane)
Transforms the given  
vector2DToTransform by this transform. | 
default void | 
transform(Vector2DReadOnly vectorOriginal,
         Vector2DBasics vectorTransformed)
Transforms the given  
vector2DOriginal by this transform and stores the result in
 vector2DTransformed. | 
void | 
transform(Vector2DReadOnly vectorOriginal,
         Vector2DBasics vectorTransformed,
         boolean checkIfTransformInXYPlane)
Transforms the given  
vector2DOriginal by this transform and stores the result in
 vector2DTransformed. | 
default void | 
transform(Vector3DBasics vectorToTransform)
Transforms the given  
vectorToTransform by this transform. | 
void | 
transform(Vector3DReadOnly vectorOriginal,
         Vector3DBasics vectorTransformed)
Transforms the given  
vectorOriginal by this transform and stores the result in
 vectorTransformed. | 
default void | 
transform(Vector4DBasics vectorToTransform)
Transforms the vector part (x, y, z) of the given  
vector4DToTransform as a 3D vector
 and translates it by s times the translation part of the transform. | 
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. | 
default void transform(Point3DBasics pointToTransform)
pointToTransform by this transform.
 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.
 pointToTransform - the point to transform. Modified.void transform(Point3DReadOnly pointOriginal, Point3DBasics pointTransformed)
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.
 pointOriginal - the point to transform. Not modified.pointTransformed - the point in which the result is stored. Modified.default void transform(Vector3DBasics vectorToTransform)
vectorToTransform by this transform.
 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 a vector.
 QuaternionBasedTransform rotates a vector.
 AffineTransform scales then rotates a vector.
 vectorToTransform - the vector to transform. Modified.void transform(Vector3DReadOnly vectorOriginal, Vector3DBasics vectorTransformed)
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.
 vectorOriginal - the vector to transform. Not modified.vectorTransformed - the vector in which the result is stored. Modified.default void transform(QuaternionBasics quaternionToTransform)
quaternionToTransform by this transform.
 
 RigidBodyTransform, QuaternionBasedTransform, and AffineTransform
 prepend their rotation part the given quaternion. No scale or translation is applied to the
 quaternion such that the output of this method is still a unit-quaternion.
 
quaternionToTransform - the quaternion to transform. Modified.void transform(QuaternionReadOnly quaternionOriginal, QuaternionBasics quaternionTransformed)
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.
 
quaternionOriginal - the quaternion to transform. Not modified.quaternionTransformed - the quaternion in which the result is stored. Modified.default void transform(Vector4DBasics vectorToTransform)
vector4DToTransform 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.
 vectorToTransform - the 4D vector to transform. Modified.void transform(Vector4DReadOnly vectorOriginal, Vector4DBasics vectorTransformed)
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.
 vectorOriginal - the 4D vector to transform. Not modified.vectorTransformed - the 4D vector in which the result is stored. Modified.default void transform(Point2DBasics pointToTransform)
point2DToTransform by this transform.
 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.
 pointToTransform - the point to transform. Modified.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.default void transform(Point2DReadOnly pointOriginal, Point2DBasics pointTransformed)
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.
 pointOriginal - the point to transform. Not modified.pointTransformed - the point in which the result is stored. Modified.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.default void transform(Point2DBasics pointToTransform, boolean checkIfTransformInXYPlane)
point2DToTransform by this transform.
 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.
 pointToTransform - the point to transform. Modified.checkIfTransformInXYPlane - whether this method should assert that the rotation part of
           this transform represents a transformation in the XY plane.NotAMatrix2DException - if checkIfTransformInXYPlane == true and the rotation
            part of this transform is not a transformation in the XY plane.void transform(Point2DReadOnly pointOriginal, Point2DBasics pointTransformed, boolean checkIfTransformInXYPlane)
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.
 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.NotAMatrix2DException - if checkIfTransformInXYPlane == true and the rotation
            part of this transform is not a transformation in the XY plane.default void transform(Vector2DBasics vectorToTransform)
vector2DToTransform by this transform.
 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 a vector.
 QuaternionBasedTransform rotates a vector.
 AffineTransform scales then rotates a vector.
 vectorToTransform - the vector to transform. Modified.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.default void transform(Vector2DReadOnly vectorOriginal, Vector2DBasics vectorTransformed)
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 a vector.
 QuaternionBasedTransform rotates a vector.
 AffineTransform scales then rotates a vector.
 vectorOriginal - the vector to transform. Not modified.vectorTransformed - the vector in which the result is stored. Modified.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.default void transform(Vector2DBasics vectorToTransform, boolean checkIfTransformInXYPlane)
vector2DToTransform by this transform.
 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.
 vectorToTransform - the vector to transform. Modified.checkIfTransformInXYPlane - whether this method should assert that the rotation part of
           this transform represents a transformation in the XY plane.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.void transform(Vector2DReadOnly vectorOriginal, Vector2DBasics vectorTransformed, boolean checkIfTransformInXYPlane)
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.
 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.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.default void transform(Matrix3D matrixToTransform)
matrixToTransform by this transform.
 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.
 matrixToTransform - the matrix to transform. Modified.void transform(Matrix3DReadOnly matrixOriginal, Matrix3D matrixTransformed)
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.
 matrixOriginal - the matrix to transform. Not modified.matrixTransformed - the matrix in which the result in stored. Modified.default void transform(RotationMatrix matrixToTransform)
rotationMatrix by this transform.
 
 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.
 
matrixToTransform - the rotation matrix to transform. Modified.void transform(RotationMatrixReadOnly matrixOriginal, RotationMatrix matrixTransformed)
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.
 
matrixOriginal - the rotation matrix to transform. Not modified.matrixTransformed - the rotation matrix in which the result is stored. Modified.default void transform(RigidBodyTransform rigidBodyTransformToTransform)
rigidBodyTransformToTransform by this transform.
 The given transform is only rotated and translated, no scaling is applied.
rigidBodyTransformToTransform - the rigid-body transform to transform. Modified.void transform(RigidBodyTransform original, RigidBodyTransform transformed)
original by this transform and stores the result in
 transformed.
 The given transform is only rotated and translated, no scaling is applied.
original - the rigid-body transform to transform. Not modified.transformed - the rigid-body transform in which the result is stored. Modified.default void transform(QuaternionBasedTransform quaternionBasedTransformToTransform)
quaternionBasedTransformToTransform by this transform.
 The given transform is only rotated and translated, no scaling is applied.
quaternionBasedTransformToTransform - the quaternion based transform to transform.
           Modified.void transform(QuaternionBasedTransform original, QuaternionBasedTransform transformed)
original by this transform and stores the result in
 transformed.
 The given transform is only rotated and translated, no scaling is applied.
original - the quaternion based transform to transform. Not modified.transformed - the quaternion based transform in which the result is stored. Modified.default void transform(AffineTransform affineTransformToTransform)
affineTransformToTransform by this transform.
 The given transform is only rotated and translated, no scaling is applied.
affineTransformToTransform - the affine transform to transform. Modified.void transform(AffineTransform original, AffineTransform transformed)
original by this transform and stores the result in
 transformed.
 The given transform is only rotated and translated, no scaling is applied.
original - the affine transform to transform. Not modified.transformed - the affine transform in which the result is stored. Modified.default void inverseTransform(Point3DBasics pointToTransform)
pointToTransform.
 
 This is equivalent to calling transform(Point3DBasics) with the inverse of this
 transform.
 
pointToTransform - the point to transform. Modified.void inverseTransform(Point3DReadOnly pointOriginal, Point3DBasics pointTransformed)
pointOriginal and stores the
 result in pointTransformed.
 
 This is equivalent to calling transform(Point3DReadOnly, Point3DBasics) with the
 inverse of this transform.
 
pointOriginal - the point to transform. Not modified.pointTransformed - the point in which the result is stored. Modified.default void inverseTransform(Vector3DBasics vectorToTransform)
vectorToTransform.
 
 This is equivalent to calling transform(Vector3DBasics) with the inverse of this
 transform.
 
vectorToTransform - the vector to transform. Modified.void inverseTransform(Vector3DReadOnly vectorOriginal, Vector3DBasics vectorTransformed)
vectorOriginal and stores
 the result in vectorTransformed.
 
 This is equivalent to calling transform(Vector3DReadOnly, Vector3DBasics) with the
 inverse of this transform.
 
vectorOriginal - the vector to transform. Not modified.vectorTransformed - the vector in which the result is stored. Modified.default void inverseTransform(QuaternionBasics quaternionToTransform)
quaternionToTransform.
 
 This is equivalent to calling transform(QuaternionBasics) with the inverse of this
 transform.
 
quaternionToTransform - the quaternion to transform. Modified.void inverseTransform(QuaternionReadOnly quaternionOriginal, QuaternionBasics quaternionTransformed)
quaternionOriginal and
 stores the result in quaternionTransformed.
 
 This is equivalent to calling transform(QuaternionReadOnly, QuaternionBasics) with
 the inverse of this transform.
 
quaternionOriginal - the quaternion to transform. Not modified.quaternionTransformed - the quaternion in which the result is stored. Modified.default void inverseTransform(Vector4DBasics vectorToTransform)
vectorToTransform.
 
 This is equivalent to calling transform(Vector4DBasics) with the inverse of this
 transform.
 
vectorToTransform - the 4D vector to transform. Modified.void inverseTransform(Vector4DReadOnly vectorOriginal, Vector4DBasics vectorTransformed)
vectorOriginal and stores
 the result in vectorTransformed.
 
 This is equivalent to calling transform(Vector4DReadOnly, Vector4DBasics) with the
 inverse of this transform.
 
vectorOriginal - the 4D vector to transform. Not modified.vectorTransformed - the 4D vector in which the result is stored. Modified.default void inverseTransform(Point2DBasics point2DToTransform)
pointToTransform.
 
 This is equivalent to calling transform(Point2DBasics) with the inverse of this
 transform.
 
point2DToTransform - the point to transform. Modified.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.default void inverseTransform(Point2DReadOnly point2DOriginal, Point2DBasics point2DTransformed)
pointOriginal and stores the
 result in pointTransformed.
 
 This is equivalent to calling transform(Point2DReadOnly, Point2DBasics) with the
 inverse of this transform.
 
point2DOriginal - the point to transform. Not modified.point2DTransformed - the point in which the result is stored. Modified.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.default void inverseTransform(Point2DBasics point2DToTransform, boolean checkIfTransformInXYPlane)
pointToTransform.
 
 This is equivalent to calling transform(Point2DBasics, boolean) with the inverse of
 this transform.
 
point2DToTransform - the point to transform. Modified.checkIfTransformInXYPlane - whether this method should assert that the rotation part of
           this transform represents a transformation in the XY plane.NotAMatrix2DException - if checkIfTransformInXYPlane == true and the rotation
            part of this transform is not a transformation in the XY plane.void inverseTransform(Point2DReadOnly point2DOriginal, Point2DBasics point2DTransformed, boolean checkIfTransformInXYPlane)
pointOriginal and stores the
 result in pointTransformed.
 
 This is equivalent to calling transform(Point2DReadOnly, Point2DBasics, boolean) with
 the inverse of this transform.
 
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.NotAMatrix2DException - if checkIfTransformInXYPlane == true and the rotation
            part of this transform is not a transformation in the XY plane.default void inverseTransform(Vector2DBasics vector2DToTransform)
vectorToTransform.
 
 This is equivalent to calling transform(Vector2DBasics) with the inverse of this
 transform.
 
vector2DToTransform - the vector to transform. Modified.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.default void inverseTransform(Vector2DReadOnly vector2DOriginal, Vector2DBasics vector2DTransformed)
vectorOriginal and stores
 the result in vectorTransformed.
 
 This is equivalent to calling transform(Vector2DReadOnly, Vector2DBasics) with the
 inverse of this transform.
 
vector2DOriginal - the vector to transform. Not modified.vector2DTransformed - the vector in which the result is stored. Modified.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.default void inverseTransform(Vector2DBasics vector2DToTransform, boolean checkIfTransformInXYPlane)
vectorToTransform.
 
 This is equivalent to calling transform(Vector2DBasics, boolean) with the inverse of
 this transform.
 
vector2DToTransform - the vector to transform. Modified.checkIfTransformInXYPlane - whether this method should assert that the rotation part of
           this transform represents a transformation in the XY plane.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.void inverseTransform(Vector2DReadOnly vector2DOriginal, Vector2DBasics vector2DTransformed, boolean checkIfTransformInXYPlane)
vectorOriginal and stores
 the result in vectorTransformed.
 
 This is equivalent to calling transform(Vector2DReadOnly, Vector2DBasics, boolean)
 with the inverse of this transform.
 
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.NotAMatrix2DException - if the rotation part of this transform is not a transformation
            in the XY plane.default void inverseTransform(Matrix3D matrixToTransform)
matrixToTransform.
 
 This is equivalent to calling transform(Matrix3D) with the inverse of this transform.
 
matrixToTransform - the matrix to transform. Modified.void inverseTransform(Matrix3DReadOnly matrixOriginal, Matrix3D matrixTransformed)
matrixOriginal and stores
 the result in matrixTransformed.
 
 This is equivalent to calling transform(Matrix3DReadOnly, Matrix3D) with the inverse
 of this transform.
 
matrixOriginal - the matrix to transform. Not modified.matrixTransformed - the matrix in which the result in stored. Modified.default void inverseTransform(RotationMatrix matrixToTransform)
matrixToTransform.
 
 This is equivalent to calling transform(RotationMatrix) with the inverse of this
 transform.
 
matrixToTransform - the rotation matrix to transform. Modified.void inverseTransform(RotationMatrixReadOnly matrixOriginal, RotationMatrix matrixTransformed)
matrixOriginal and stores
 the result in matrixTransformed.
 
 This is equivalent to calling transform(RotationMatrixReadOnly, RotationMatrix) with
 the inverse of this transform.
 
matrixOriginal - the rotation matrix to transform. Not modified.matrixTransformed - the rotation matrix in which the result is stored. Modified.default void inverseTransform(RigidBodyTransform rigidBodyTransformToTransform)
rigidBodyTransformToTransform.
 
 This is equivalent to calling transform(RigidBodyTransform) with the inverse of this
 transform.
 
The given transform is only rotated and translated, no scaling is applied.
rigidBodyTransformToTransform - the rigid-body transform to transform. Modified.void inverseTransform(RigidBodyTransform original, RigidBodyTransform transformed)
original and stores the result in
 transformed.
 
 This is equivalent to calling transform(RigidBodyTransform, RigidBodyTransform) with
 the inverse of this transform.
 
The given transform is only rotated and translated, no scaling is applied.
original - the rigid-body transform to transform. Not modified.transformed - the rigid-body transform in which the result is stored. Modified.default void inverseTransform(QuaternionBasedTransform quaternionBasedTransformToTransform)
quaternionBasedTransformToTransform.
 
 This is equivalent to calling transform(QuaternionBasedTransform) with the inverse of
 this transform.
 
The given transform is only rotated and translated, no scaling is applied.
quaternionBasedTransformToTransform - the quaternion based transform to transform.
           Modified.void inverseTransform(QuaternionBasedTransform original, QuaternionBasedTransform transformed)
original stores the result in
 transformed.
 
 This is equivalent to calling
 transform(QuaternionBasedTransform, QuaternionBasedTransform) with the inverse of
 this transform.
 
The given transform is only rotated and translated, no scaling is applied.
original - the quaternion based transform to transform. Not modified.transformed - the quaternion based transform in which the result is stored. Modified.default void inverseTransform(AffineTransform affineTransformToTransform)
affineTransformToTransform.
 
 This is equivalent to calling transform(AffineTransform) with the inverse of this
 transform.
 
The given transform is only rotated and translated, no scaling is applied.
affineTransformToTransform - the affine transform to transform. Modified.void inverseTransform(AffineTransform original, AffineTransform transformed)
original and stores the result in
 transformed.
 
 This is equivalent to calling transform(AffineTransform, AffineTransform) with the
 inverse of this transform.
 
The given transform is only rotated and translated, no scaling is applied.
original - the affine transform to transform. Not modified.transformed - the affine transform in which the result is stored. Modified.