2022.1.05

• All Implemented Interfaces:
ILcdXYZRotation, Serializable

```public class TLcdXYZRotation
extends Object
implements ILcdXYZRotation```
Implements `ILcdXYZRotation` (3D rotation in a cartesian coordinate system), forward and inverse rotations. An `ILcdXYZRotation` is a cartesian 3D rotation defined by three Eulerian angles (a, b, g). The angles are in decimal degrees and measured counterclockwise around the X, Y, and Z axes of a cartesian coordinate system.
• rotation a around the X-axis
• rotation b around the Y-axis
• rotation g around the Z-axis
The order of the rotations is important! We assume rotations are always in the order as below since this is the order for changing the origin of the projection.

For geodetic projections with an origin of the projection (l0,j0) and with an oblique central meridianin an azimuthal direction Az the rotations are applied in following order:

1. l0 around Z-axis
2. -j0 around Y-axis
3. -Az around X-axis

Note that for the assigned cartesian coordinate axes to an ellipsoid angles are measured:

• l0 is positive counterclockwise
• j0 is positive clockwise
• Az is positive clockwise and measured from the north
Serialized Form
• ### Constructor Summary

Constructors
Constructor and Description
`TLcdXYZRotation()`
Default constructor creates a no-rotation.
```TLcdXYZRotation(double aAlpha, double aBeta, double aGamma)```
Constructor creates a rotation with the three given angles.
• ### Method Summary

All Methods
Modifier and Type Method and Description
`boolean` `equals(Object aXYZRotation)`
Two 3D rotations are equal if they have the same rotation angles around the three cartesian axes (applied in the same order).
`double` `getAlpha()`
Gets the eulerian angle a around the X-axis in decimal degrees and positive counterclockwise (right hand rule).
`double` `getBeta()`
Gets the eulerian angle b around the Y-axis in decimal degrees and positive counterclockwise (right hand rule).
`double` `getGamma()`
Gets the eulerian angle g around the Z-axis in decimal degrees and positive counterclockwise (right hand rule).
`int` `hashCode()`
`void` ```inverseRotateSFCT(ILcdPoint aXYZPoint, ILcd3DEditablePoint aXYZPointOut)```
Application of the 3D inverse rotation to `aXYZPoint` results in the `ILcd3DEditablePoint` `aXYZPointOut`.
`void` ```rotateSFCT(ILcdPoint aXYZPoint, ILcd3DEditablePoint aXYZPointOut)```
Apply the three rotations a, b, and g to the cartesian `ILcdPoint` `aXYZPoint`.
`void` `setAlpha(double aAlpha)`
Sets the Eulerian angle a around the X-axis to `aAlpha`.
`void` `setBeta(double aBeta)`
Sets the Eulerian angle b around the Y-axis to `aBeta`.
`void` `setGamma(double aGamma)`
Sets the Eulerian angle g around the Z-axis to `aGamma`.
• ### Methods inherited from class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`
• ### Constructor Detail

• #### TLcdXYZRotation

`public TLcdXYZRotation()`
Default constructor creates a no-rotation.
• #### TLcdXYZRotation

```public TLcdXYZRotation(double aAlpha,
double aBeta,
double aGamma)```
Constructor creates a rotation with the three given angles.
Parameters:
`aAlpha` - rotation a around the X-axis (decimal degrees).
`aBeta` - rotation b around the Y-axis (decimal degrees).
`aGamma` - rotation g around the Z-axis (decimal degrees).
`ILcdXYZRotation`
• ### Method Detail

• #### setAlpha

`public void setAlpha(double aAlpha)`
Description copied from interface: `ILcdXYZRotation`
Sets the Eulerian angle a around the X-axis to `aAlpha`. The angle is in decimal degrees and positive counterclockwise (right hand rule).
Specified by:
`setAlpha` in interface `ILcdXYZRotation`
Parameters:
`aAlpha` - the Eulerian angle a around the X-axis.
`ILcdXYZRotation.getAlpha()`
• #### getAlpha

`public double getAlpha()`
Description copied from interface: `ILcdXYZRotation`
Gets the eulerian angle a around the X-axis in decimal degrees and positive counterclockwise (right hand rule).
Specified by:
`getAlpha` in interface `ILcdXYZRotation`
Returns:
the eulerian angle a around the X-axis in decimal degrees and positive counterclockwise (right hand rule).
`ILcdXYZRotation.setAlpha(double)`
• #### setBeta

`public void setBeta(double aBeta)`
Description copied from interface: `ILcdXYZRotation`
Sets the Eulerian angle b around the Y-axis to `aBeta`. The angle is in decimal degrees and positive counterclockwise (right hand rule).
Specified by:
`setBeta` in interface `ILcdXYZRotation`
Parameters:
`aBeta` - the Eulerian angle b around the Y-axis.
`ILcdXYZRotation.getBeta()`
• #### getBeta

`public double getBeta()`
Description copied from interface: `ILcdXYZRotation`
Gets the eulerian angle b around the Y-axis in decimal degrees and positive counterclockwise (right hand rule).
Specified by:
`getBeta` in interface `ILcdXYZRotation`
Returns:
the eulerian angle b around the Y-axis in decimal degrees and positive counterclockwise (right hand rule).
`ILcdXYZRotation.setBeta(double)`
• #### setGamma

`public void setGamma(double aGamma)`
Description copied from interface: `ILcdXYZRotation`
Sets the Eulerian angle g around the Z-axis to `aGamma`. The angle is in decimal degrees and positive counterclockwise (right hand rule).
Specified by:
`setGamma` in interface `ILcdXYZRotation`
Parameters:
`aGamma` - the Eulerian angle g around the Z-axis.
`ILcdXYZRotation.getGamma()`
• #### getGamma

`public double getGamma()`
Description copied from interface: `ILcdXYZRotation`
Gets the eulerian angle g around the Z-axis in decimal degrees and positive counterclockwise (right hand rule).
Specified by:
`getGamma` in interface `ILcdXYZRotation`
Returns:
the eulerian angle g around the Z-axis in decimal degrees and positive counterclockwise (right hand rule).
`ILcdXYZRotation.setGamma(double)`
• #### rotateSFCT

```public void rotateSFCT(ILcdPoint aXYZPoint,
ILcd3DEditablePoint aXYZPointOut)```
Description copied from interface: `ILcdXYZRotation`
Apply the three rotations a, b, and g to the cartesian `ILcdPoint` `aXYZPoint`. The resulting cartesian coordinate is `aXYZPointOut`.
Specified by:
`rotateSFCT` in interface `ILcdXYZRotation`
Parameters:
`aXYZPoint` - the point to be rotated.
`aXYZPointOut` - the resulting point of the rotation as side effect.
• #### inverseRotateSFCT

```public void inverseRotateSFCT(ILcdPoint aXYZPoint,
ILcd3DEditablePoint aXYZPointOut)```
Description copied from interface: `ILcdXYZRotation`
Application of the 3D inverse rotation to `aXYZPoint` results in the `ILcd3DEditablePoint` `aXYZPointOut`.
Specified by:
`inverseRotateSFCT` in interface `ILcdXYZRotation`
Parameters:
`aXYZPoint` - the point to be rotated.
`aXYZPointOut` - the resulting point of the rotation as side effect.
• #### equals

`public boolean equals(Object aXYZRotation)`
Two 3D rotations are equal if they have the same rotation angles around the three cartesian axes (applied in the same order).
Specified by:
`equals` in interface `ILcdXYZRotation`
Overrides:
`equals` in class `Object`
• #### hashCode

`public int hashCode()`
Overrides:
`hashCode` in class `Object`