FieldTransform (ORbit Extrapolation KIT 10.0 API)

java.lang.Object
- org.orekit.frames.FieldTransform<T>

Type Parameters:

T - the type of the field elements

All Implemented Interfaces:

TimeShiftable<FieldTransform<T>>, TimeStamped
```
public class FieldTransform<T extends RealFieldElement<T>>
extends Object
implements TimeStamped, TimeShiftable<FieldTransform<T>>
```
Transformation class in three dimensional space.
This class represents the transformation engine between frames. It is used both to define the relationship between each frame and its parent frame and to gather all individual transforms into one operation when converting between frames far away from each other.

The convention used in OREKIT is vectorial transformation. It means that a transformation is defined as a transform to apply to the coordinates of a vector expressed in the old frame to obtain the same vector expressed in the new frame.
Instances of this class are guaranteed to be immutable.

Examples

Example of translation from R_A to R_B

We want to transform the FieldPVCoordinates PV_A to PV_B with :
PV_A = ({1, 0, 0}, {2, 0, 0}, {3, 0, 0});
PV_B = ({0, 0, 0}, {0, 0, 0}, {0, 0, 0});
The transform to apply then is defined as follows :
```
 Vector3D translation  = new Vector3D(-1, 0, 0);
 Vector3D velocity     = new Vector3D(-2, 0, 0);
 Vector3D acceleration = new Vector3D(-3, 0, 0);

 Transform R1toR2 = new Transform(date, translation, velocity, acceleration);

 PVB = R1toR2.transformPVCoordinate(PVA);
 
```
Example of rotation from R_A to R_B

We want to transform the FieldPVCoordinates PV_A to PV_B with
PV_A = ({1, 0, 0}, { 1, 0, 0});
PV_B = ({0, 1, 0}, {-2, 1, 0});
The transform to apply then is defined as follows :
```
 Rotation rotation = new Rotation(Vector3D.PLUS_K, FastMath.PI / 2);
 Vector3D rotationRate = new Vector3D(0, 0, -2);

 Transform R1toR2 = new Transform(rotation, rotationRate);

 PVB = R1toR2.transformPVCoordinates(PVA);
 
```
Since:

9.0

Author:

Luc Maisonobe, Fabien Maussion

Constructor Summary

Constructors
Constructor and Description
`FieldTransform(Field<T> field, Transform transform)` Build a transform from a regular transform.
`FieldTransform(FieldAbsoluteDate<T> date, FieldAngularCoordinates<T> angular)` Build a rotation transform.
`FieldTransform(FieldAbsoluteDate<T> date, FieldPVCoordinates<T> cartesian)` Build a translation transform, with its first time derivative.
`FieldTransform(FieldAbsoluteDate<T> date, FieldRotation<T> rotation)` Build a rotation transform.
`FieldTransform(FieldAbsoluteDate<T> date, FieldRotation<T> rotation, FieldVector3D<T> rotationRate)` Build a rotation transform.
`FieldTransform(FieldAbsoluteDate<T> date, FieldRotation<T> rotation, FieldVector3D<T> rotationRate, FieldVector3D<T> rotationAcceleration)` Build a rotation transform.
`FieldTransform(FieldAbsoluteDate<T> date, FieldTransform<T> first, FieldTransform<T> second)` Build a transform by combining two existing ones.
`FieldTransform(FieldAbsoluteDate<T> date, FieldVector3D<T> translation)` Build a translation transform.
`FieldTransform(FieldAbsoluteDate<T> date, FieldVector3D<T> translation, FieldVector3D<T> velocity)` Build a translation transform, with its first time derivative.
`FieldTransform(FieldAbsoluteDate<T> date, FieldVector3D<T> translation, FieldVector3D<T> velocity, FieldVector3D<T> acceleration)` Build a translation transform, with its first and second time derivatives.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FieldTransform<T>`	`freeze()` Get a frozen transform.
`FieldVector3D<T>`	`getAcceleration()` Get the second time derivative of the translation.
`FieldAngularCoordinates<T>`	`getAngular()` Get the underlying elementary angular part.
`FieldPVCoordinates<T>`	`getCartesian()` Get the underlying elementary Cartesian part.
`AbsoluteDate`	`getDate()` Get the date.
`FieldAbsoluteDate<T>`	`getFieldDate()` Get the date.
`static <T extends RealFieldElement<T>> FieldTransform<T>`	`getIdentity(Field<T> field)` Get the identity transform.
`FieldTransform<T>`	`getInverse()` Get the inverse transform of the instance.
`void`	`getJacobian(CartesianDerivativesFilter selector, T[][] jacobian)` Compute the Jacobian of the `transformPVCoordinates(FieldPVCoordinates)` method of the transform.
`FieldRotation<T>`	`getRotation()` Get the underlying elementary rotation.
`FieldVector3D<T>`	`getRotationAcceleration()` Get the second time derivative of the rotation.
`FieldVector3D<T>`	`getRotationRate()` Get the first time derivative of the rotation.
`FieldVector3D<T>`	`getTranslation()` Get the underlying elementary translation.
`FieldVector3D<T>`	`getVelocity()` Get the first time derivative of the translation.
`static <T extends RealFieldElement<T>> FieldTransform<T>`	`interpolate(FieldAbsoluteDate<T> date, CartesianDerivativesFilter cFilter, AngularDerivativesFilter aFilter, Collection<FieldTransform<T>> sample)` Interpolate a transform from a sample set of existing transforms.
`static <T extends RealFieldElement<T>> FieldTransform<T>`	`interpolate(FieldAbsoluteDate<T> date, CartesianDerivativesFilter cFilter, AngularDerivativesFilter aFilter, Stream<FieldTransform<T>> sample)` Interpolate a transform from a sample set of existing transforms.
`static <T extends RealFieldElement<T>> FieldTransform<T>`	`interpolate(FieldAbsoluteDate<T> interpolationDate, Collection<FieldTransform<T>> sample)` Interpolate a transform from a sample set of existing transforms.
`FieldTransform<T>`	`shiftedBy(double dt)` Get a time-shifted instance.
`FieldTransform<T>`	`shiftedBy(T dt)` Get a time-shifted instance.
`FieldLine<T>`	`transformLine(FieldLine<T> line)` Transform a line.
`FieldLine<T>`	`transformLine(Line line)` Transform a line.
`FieldVector3D<T>`	`transformPosition(FieldVector3D<T> position)` Transform a position vector (including translation effects).
`FieldVector3D<T>`	`transformPosition(Vector3D position)` Transform a position vector (including translation effects).
`FieldPVCoordinates<T>`	`transformPVCoordinates(FieldPVCoordinates<T> pv)` Transform `TimeStampedFieldPVCoordinates` including kinematic effects.
`FieldPVCoordinates<T>`	`transformPVCoordinates(PVCoordinates pv)` Transform `TimeStampedPVCoordinates` including kinematic effects.
`TimeStampedFieldPVCoordinates<T>`	`transformPVCoordinates(TimeStampedFieldPVCoordinates<T> pv)` Transform `TimeStampedFieldPVCoordinates` including kinematic effects.
`TimeStampedFieldPVCoordinates<T>`	`transformPVCoordinates(TimeStampedPVCoordinates pv)` Transform `TimeStampedPVCoordinates` including kinematic effects.
`FieldVector3D<T>`	`transformVector(FieldVector3D<T> vector)` Transform a vector (ignoring translation effects).
`FieldVector3D<T>`	`transformVector(Vector3D vector)` Transform a vector (ignoring translation effects).

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

- Constructor Detail
  - FieldTransform
```
public FieldTransform(Field<T> field,
                      Transform transform)
```
    Build a transform from a regular transform.
    
    Parameters:
    
    field - field of the elements
    
    transform - regular transform to convert
  - FieldTransform
```
public FieldTransform(FieldAbsoluteDate<T> date,
                      FieldVector3D<T> translation)
```
    Build a translation transform.
    
    Parameters:
    
    date - date of the transform
    
    translation - translation to apply (i.e. coordinates of the transformed origin, or coordinates of the origin of the old frame in the new frame)
  - FieldTransform
```
public FieldTransform(FieldAbsoluteDate<T> date,
                      FieldRotation<T> rotation)
```
    Build a rotation transform.
    
    Parameters:
    
    date - date of the transform
    
    rotation - rotation to apply ( i.e. rotation to apply to the coordinates of a vector expressed in the old frame to obtain the same vector expressed in the new frame )
  - FieldTransform
```
public FieldTransform(FieldAbsoluteDate<T> date,
                      FieldVector3D<T> translation,
                      FieldVector3D<T> velocity)
```
    Build a translation transform, with its first time derivative.
    
    Parameters:
    
    date - date of the transform
    
    translation - translation to apply (i.e. coordinates of the transformed origin, or coordinates of the origin of the old frame in the new frame)
    
    velocity - the velocity of the translation (i.e. origin of the old frame velocity in the new frame)
  - FieldTransform
```
public FieldTransform(FieldAbsoluteDate<T> date,
                      FieldVector3D<T> translation,
                      FieldVector3D<T> velocity,
                      FieldVector3D<T> acceleration)
```
    Build a translation transform, with its first and second time derivatives.
    
    Parameters:
    
    date - date of the transform
    
    translation - translation to apply (i.e. coordinates of the transformed origin, or coordinates of the origin of the old frame in the new frame)
    
    velocity - the velocity of the translation (i.e. origin of the old frame velocity in the new frame)
    
    acceleration - the acceleration of the translation (i.e. origin of the old frame acceleration in the new frame)
  - FieldTransform
```
public FieldTransform(FieldAbsoluteDate<T> date,
                      FieldPVCoordinates<T> cartesian)
```
    Build a translation transform, with its first time derivative.
    
    Parameters:
    
    date - date of the transform
    
    cartesian - Cartesian part of the transformation to apply (i.e. coordinates of the transformed origin, or coordinates of the origin of the old frame in the new frame, with their derivatives)
  - FieldTransform
```
public FieldTransform(FieldAbsoluteDate<T> date,
                      FieldRotation<T> rotation,
                      FieldVector3D<T> rotationRate)
```
    Build a rotation transform.
    
    Parameters:
    
    date - date of the transform
    
    rotation - rotation to apply ( i.e. rotation to apply to the coordinates of a vector expressed in the old frame to obtain the same vector expressed in the new frame )
    
    rotationRate - the axis of the instant rotation expressed in the new frame. (norm representing angular rate)
  - FieldTransform
```
public FieldTransform(FieldAbsoluteDate<T> date,
                      FieldRotation<T> rotation,
                      FieldVector3D<T> rotationRate,
                      FieldVector3D<T> rotationAcceleration)
```
    Build a rotation transform.
    
    Parameters:
    
    date - date of the transform
    
    rotation - rotation to apply ( i.e. rotation to apply to the coordinates of a vector expressed in the old frame to obtain the same vector expressed in the new frame )
    
    rotationRate - the axis of the instant rotation
    
    rotationAcceleration - the axis of the instant rotation expressed in the new frame. (norm representing angular rate)
  - FieldTransform
```
public FieldTransform(FieldAbsoluteDate<T> date,
                      FieldAngularCoordinates<T> angular)
```
    Build a rotation transform.
    
    Parameters:
    
    date - date of the transform
    
    angular - angular part of the transformation to apply (i.e. rotation to apply to the coordinates of a vector expressed in the old frame to obtain the same vector expressed in the new frame, with its rotation rate)
  - FieldTransform
```
public FieldTransform(FieldAbsoluteDate<T> date,
                      FieldTransform<T> first,
                      FieldTransform<T> second)
```
    Build a transform by combining two existing ones.
    Note that the dates of the two existing transformed are ignored, and the combined transform date is set to the date supplied in this constructor without any attempt to shift the raw transforms. This is a design choice allowing user full control of the combination.
    
    Parameters:
    
    date - date of the transform
    
    first - first transform applied
    
    second - second transform applied
- Method Detail
  - getIdentity
```
public static <T extends RealFieldElement<T>> FieldTransform<T> getIdentity(Field<T> field)
```
    Get the identity transform.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    identity transform
  - getDate
```
public AbsoluteDate getDate()
```
    Get the date.
    
    Specified by:
    
    getDate in interface TimeStamped
    
    Returns:
    
    date attached to the object
  - getFieldDate
```
public FieldAbsoluteDate<T> getFieldDate()
```
    Get the date.
    
    Returns:
    
    date attached to the object
  - shiftedBy
```
public FieldTransform<T> shiftedBy(double dt)
```
    Get a time-shifted instance.
    
    Specified by:
    
    shiftedBy in interface TimeShiftable<FieldTransform<T extends RealFieldElement<T>>>
    
    Parameters:
    
    dt - time shift in seconds
    
    Returns:
    
    a new instance, shifted with respect to instance (which is not changed)
  - shiftedBy
```
public FieldTransform<T> shiftedBy(T dt)
```
    Get a time-shifted instance.
    
    Parameters:
    
    dt - time shift in seconds
    
    Returns:
    
    a new instance, shifted with respect to instance (which is not changed)
  - interpolate
```
public static <T extends RealFieldElement<T>> FieldTransform<T> interpolate(FieldAbsoluteDate<T> interpolationDate,
                                                                            Collection<FieldTransform<T>> sample)
```
    Interpolate a transform from a sample set of existing transforms.
    Calling this method is equivalent to call interpolate(FieldAbsoluteDate, CartesianDerivativesFilter, AngularDerivativesFilter, Collection) with cFilter set to CartesianDerivativesFilter.USE_PVA and aFilter set to AngularDerivativesFilter.USE_RRA set to true.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    interpolationDate - interpolation date
    
    sample - sample points on which interpolation should be done
    
    Returns:
    
    a new instance, interpolated at specified date
  - interpolate
```
public static <T extends RealFieldElement<T>> FieldTransform<T> interpolate(FieldAbsoluteDate<T> date,
                                                                            CartesianDerivativesFilter cFilter,
                                                                            AngularDerivativesFilter aFilter,
                                                                            Collection<FieldTransform<T>> sample)
```
    Interpolate a transform from a sample set of existing transforms.
    Note that even if first time derivatives (velocities and rotation rates) from sample can be ignored, the interpolated instance always includes interpolated derivatives. This feature can be used explicitly to compute these derivatives when it would be too complex to compute them from an analytical formula: just compute a few sample points from the explicit formula and set the derivatives to zero in these sample points, then use interpolation to add derivatives consistent with the positions and rotations.
    
    As this implementation of interpolation is polynomial, it should be used only with small samples (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    date - interpolation date
    
    cFilter - filter for derivatives from the sample to use in interpolation
    
    aFilter - filter for derivatives from the sample to use in interpolation
    
    sample - sample points on which interpolation should be done
    
    Returns:
    
    a new instance, interpolated at specified date
  - interpolate
```
public static <T extends RealFieldElement<T>> FieldTransform<T> interpolate(FieldAbsoluteDate<T> date,
                                                                            CartesianDerivativesFilter cFilter,
                                                                            AngularDerivativesFilter aFilter,
                                                                            Stream<FieldTransform<T>> sample)
```
    Interpolate a transform from a sample set of existing transforms.
    Note that even if first time derivatives (velocities and rotation rates) from sample can be ignored, the interpolated instance always includes interpolated derivatives. This feature can be used explicitly to compute these derivatives when it would be too complex to compute them from an analytical formula: just compute a few sample points from the explicit formula and set the derivatives to zero in these sample points, then use interpolation to add derivatives consistent with the positions and rotations.
    
    As this implementation of interpolation is polynomial, it should be used only with small samples (about 10-20 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    date - interpolation date
    
    cFilter - filter for derivatives from the sample to use in interpolation
    
    aFilter - filter for derivatives from the sample to use in interpolation
    
    sample - sample points on which interpolation should be done
    
    Returns:
    
    a new instance, interpolated at specified date
  - getInverse
```
public FieldTransform<T> getInverse()
```
    Get the inverse transform of the instance.
    
    Returns:
    
    inverse transform of the instance
  - freeze
```
public FieldTransform<T> freeze()
```
    Get a frozen transform.
    This method creates a copy of the instance but frozen in time, i.e. with velocity, acceleration and rotation rate forced to zero.
    
    Returns:
    
    a new transform, without any time-dependent parts
  - transformPosition
```
public FieldVector3D<T> transformPosition(Vector3D position)
```
    Transform a position vector (including translation effects).
    
    Parameters:
    
    position - vector to transform
    
    Returns:
    
    transformed position
  - transformPosition
```
public FieldVector3D<T> transformPosition(FieldVector3D<T> position)
```
    Transform a position vector (including translation effects).
    
    Parameters:
    
    position - vector to transform
    
    Returns:
    
    transformed position
  - transformVector
```
public FieldVector3D<T> transformVector(Vector3D vector)
```
    Transform a vector (ignoring translation effects).
    
    Parameters:
    
    vector - vector to transform
    
    Returns:
    
    transformed vector
  - transformVector
```
public FieldVector3D<T> transformVector(FieldVector3D<T> vector)
```
    Transform a vector (ignoring translation effects).
    
    Parameters:
    
    vector - vector to transform
    
    Returns:
    
    transformed vector
  - transformLine
```
public FieldLine<T> transformLine(Line line)
```
    Transform a line.
    
    Parameters:
    
    line - to transform
    
    Returns:
    
    transformed line
  - transformLine
```
public FieldLine<T> transformLine(FieldLine<T> line)
```
    Transform a line.
    
    Parameters:
    
    line - to transform
    
    Returns:
    
    transformed line
  - transformPVCoordinates
```
public FieldPVCoordinates<T> transformPVCoordinates(PVCoordinates pv)
```
    Transform TimeStampedPVCoordinates including kinematic effects.
    In order to allow the user more flexibility, this method does not check for consistency between the transform date and the time-stamped position-velocity date. The returned value will always have the same date as the input argument, regardless of the instance date.
    
    Parameters:
    
    pv - time-stamped position-velocity to transform.
    
    Returns:
    
    transformed time-stamped position-velocity
  - transformPVCoordinates
```
public TimeStampedFieldPVCoordinates<T> transformPVCoordinates(TimeStampedPVCoordinates pv)
```
    Transform TimeStampedPVCoordinates including kinematic effects.
    In order to allow the user more flexibility, this method does not check for consistency between the transform date and the time-stamped position-velocity date. The returned value will always have the same date as the input argument, regardless of the instance date.
    
    Parameters:
    
    pv - time-stamped position-velocity to transform.
    
    Returns:
    
    transformed time-stamped position-velocity
  - transformPVCoordinates
```
public FieldPVCoordinates<T> transformPVCoordinates(FieldPVCoordinates<T> pv)
```
    Transform TimeStampedFieldPVCoordinates including kinematic effects.
    BEWARE! This method does explicit computation of velocity and acceleration by combining the transform velocity, acceleration, rotation rate and rotation acceleration with the velocity and acceleration from the argument. This implies that this method should not be used when derivatives are contained in the field elements (typically when using DerivativeStructure elements where time is one of the differentiation parameter), otherwise the time derivatives would be computed twice, once explicitly in this method and once implicitly in the field operations. If time derivatives are contained in the field elements themselves, then rather than this method the transformPosition method should be used, so the derivatives are computed once, as part of the field. This method is rather expected to be used when the field elements are DerivativeStructure instances where the differentiation parameters are not time (they can typically be initial state for computing state transition matrices or force models parameters, or ground stations positions, ...).
    
    In order to allow the user more flexibility, this method does not check for consistency between the transform date and the time-stamped position-velocity date. The returned value will always have the same date as the input argument, regardless of the instance date.
    
    Parameters:
    
    pv - time-stamped position-velocity to transform.
    
    Returns:
    
    transformed time-stamped position-velocity
  - transformPVCoordinates
```
public TimeStampedFieldPVCoordinates<T> transformPVCoordinates(TimeStampedFieldPVCoordinates<T> pv)
```
    Transform TimeStampedFieldPVCoordinates including kinematic effects.
    BEWARE! This method does explicit computation of velocity and acceleration by combining the transform velocity, acceleration, rotation rate and rotation acceleration with the velocity and acceleration from the argument. This implies that this method should not be used when derivatives are contained in the field elements (typically when using DerivativeStructure elements where time is one of the differentiation parameter), otherwise the time derivatives would be computed twice, once explicitly in this method and once implicitly in the field operations. If time derivatives are contained in the field elements themselves, then rather than this method the transformPosition method should be used, so the derivatives are computed once, as part of the field. This method is rather expected to be used when the field elements are DerivativeStructure instances where the differentiation parameters are not time (they can typically be initial state for computing state transition matrices or force models parameters, or ground stations positions, ...).
    
    In order to allow the user more flexibility, this method does not check for consistency between the transform date and the time-stamped position-velocity date. The returned value will always have the same date as the input argument, regardless of the instance date.
    
    Parameters:
    
    pv - time-stamped position-velocity to transform.
    
    Returns:
    
    transformed time-stamped position-velocity
  - getJacobian
```
public void getJacobian(CartesianDerivativesFilter selector,
                        T[][] jacobian)
```
    Compute the Jacobian of the transformPVCoordinates(FieldPVCoordinates) method of the transform.
    Element jacobian[i][j] is the derivative of Cartesian coordinate i of the transformed FieldPVCoordinates with respect to Cartesian coordinate j of the input FieldPVCoordinates in method transformPVCoordinates(FieldPVCoordinates).
    
    This definition implies that if we define position-velocity coordinates
```
PV₁ = transform.transformPVCoordinates(PV₀)
```
    then their differentials dPV₁ and dPV₀ will obey the following relation where J is the matrix computed by this method:
```
dPV₁ = J × dPV₀
```
    Parameters:
    
    selector - selector specifying the size of the upper left corner that must be filled (either 3x3 for positions only, 6x6 for positions and velocities, 9x9 for positions, velocities and accelerations)
    
    jacobian - placeholder matrix whose upper-left corner is to be filled with the Jacobian, the rest of the matrix remaining untouched
  - getCartesian
```
public FieldPVCoordinates<T> getCartesian()
```
    Get the underlying elementary Cartesian part.
    A transform can be uniquely represented as an elementary translation followed by an elementary rotation. This method returns this unique elementary translation with its derivative.
    
    Returns:
    
    underlying elementary Cartesian part
    
    See Also:
    
    getTranslation(), getVelocity()
  - getTranslation
```
public FieldVector3D<T> getTranslation()
```
    Get the underlying elementary translation.
    A transform can be uniquely represented as an elementary translation followed by an elementary rotation. This method returns this unique elementary translation.
    
    Returns:
    
    underlying elementary translation
    
    See Also:
    
    getCartesian(), getVelocity(), getAcceleration()
  - getVelocity
```
public FieldVector3D<T> getVelocity()
```
    Get the first time derivative of the translation.
    
    Returns:
    
    first time derivative of the translation
    
    See Also:
    
    getCartesian(), getTranslation(), getAcceleration()
  - getAcceleration
```
public FieldVector3D<T> getAcceleration()
```
    Get the second time derivative of the translation.
    
    Returns:
    
    second time derivative of the translation
    
    See Also:
    
    getCartesian(), getTranslation(), getVelocity()
  - getAngular
```
public FieldAngularCoordinates<T> getAngular()
```
    Get the underlying elementary angular part.
    A transform can be uniquely represented as an elementary translation followed by an elementary rotation. This method returns this unique elementary rotation with its derivative.
    
    Returns:
    
    underlying elementary angular part
    
    See Also:
    
    getRotation(), getRotationRate(), getRotationAcceleration()
  - getRotation
```
public FieldRotation<T> getRotation()
```
    Get the underlying elementary rotation.
    A transform can be uniquely represented as an elementary translation followed by an elementary rotation. This method returns this unique elementary rotation.
    
    Returns:
    
    underlying elementary rotation
    
    See Also:
    
    getAngular(), getRotationRate(), getRotationAcceleration()
  - getRotationRate
```
public FieldVector3D<T> getRotationRate()
```
    Get the first time derivative of the rotation.
    The norm represents the angular rate.
    
    Returns:
    
    First time derivative of the rotation
    
    See Also:
    
    getAngular(), getRotation(), getRotationAcceleration()
  - getRotationAcceleration
```
public FieldVector3D<T> getRotationAcceleration()
```
    Get the second time derivative of the rotation.
    
    Returns:
    
    Second time derivative of the rotation
    
    See Also:
    
    getAngular(), getRotation(), getRotationRate()

Class FieldTransform<T extends RealFieldElement<T>>

Examples

Example of translation from RA to RB

Example of rotation from RA to RB

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FieldTransform

FieldTransform

FieldTransform

FieldTransform

FieldTransform

FieldTransform

FieldTransform

FieldTransform

FieldTransform

FieldTransform

Method Detail

getIdentity

getDate

getFieldDate

shiftedBy

shiftedBy

interpolate

interpolate

interpolate

getInverse

freeze

transformPosition

transformPosition

transformVector

transformVector

transformLine

transformLine

transformPVCoordinates

transformPVCoordinates

transformPVCoordinates

transformPVCoordinates

getJacobian

getCartesian

getTranslation

getVelocity

getAcceleration

getAngular

getRotation

getRotationRate

getRotationAcceleration

Example of translation from R_A to R_B

Example of rotation from R_A to R_B