Table of contents
CSPICE_EUL2XF computes a state transformation from an Euler angle
factorization of a rotation and the derivatives of those Euler angles.
Given:
eulang the double precision 6-dimensional vector of Euler angles
corresponding to the specified factorization.
help, eulang
DOUBLE = Array[6]
If we represent `r' as shown here:
r = [ alpha ] [ beta ] [ gamma ]
axisa axisb axisc
then
eulang[0] = alpha
eulang[1] = beta
eulang[2] = gamma
eulang[3] = d(alpha)/dt
eulang[4] = d(beta)/dt
eulang[5] = d(gamma)/dt
axisa,
axisb,
axisc the integer scalar identifying the axes desired for the
factorization of `r'.
help, axisa
LONG = Scalar
help, axisb
LONG = Scalar
help, axisc
LONG = Scalar
All must be in the range from 1 to 3. Moreover
it must be the case that `axisa' and `axisb' are distinct
and that `axisb' and `axisc' are distinct.
Every rotation matrix can be represented as a product
of three rotation matrices about the principal axes
of a reference frame.
r = [ alpha ] [ beta ] [ gamma ]
axisa axisb axisc
The value 1 corresponds to the X axis.
The value 2 corresponds to the Y axis.
The value 3 corresponds to the Z axis.
the call:
cspice_eul2xf, eulang, axisa, axisb, axisc, xform
returns:
xform the double precision 6x6 state transformation matrix
corresponding to `r' and dr/dt as described above.
help, xform
DOUBLE = Array[6,6]
Pictorially,
.- -.
| | |
| r | 0 |
| | |
|-------+-------|
| | |
| dr/dt | r |
| | |
`- -'
where `r' is a rotation matrix that varies with respect to
time and dr/dt is its time derivative.
None.
Any numerical results shown for this example may differ between
platforms as the results depend on the SPICE kernels used as input
and the machine specific arithmetic implementation.
1) Suppose you have a set of Euler angles and their derivatives
for a 3 1 3 rotation, and that you would like to determine
the equivalent angles and derivatives for a 1 2 3 rotation.
r = [alpha] [beta] [gamma]
3 1 3
r = [roll] [pitch] [yaw]
1 2 3
The following code example will perform the desired
computation.
Example code begins here.
PRO eul2xf_ex1
;;
;; Define the initial set of Euler angles.
;;
abgang = [ 0.01D0, 0.03D0, 0.09D0, -0.001D0, -0.003D0, -0.009D0 ]
;;
;; Compute the equivalent angles and derivatives for a
;; 1-2-3 rotation.
;;
cspice_eul2xf, abgang, 3L, 1L, 3L, xform
cspice_xf2eul, xform, 1L, 2L, 3L, rpyang, unique
if ( unique ) then begin
print, format='(A)', '1-2-3 equivalent rotation to' + $
' input (radians):'
print, format='(2(A,F13.9))', 'Roll ', rpyang[0], $
', droll/dt ', rpyang[3]
print, format='(2(A,F13.9))', 'Pitch ', rpyang[1], $
', dpitch/dt ', rpyang[4]
print, format='(2(A,F13.9))', 'Yaw ', rpyang[2], $
', dyaw/dt ', rpyang[5]
endif else begin
print, 'The values in `rpyang'' are not uniquely determined.'
endelse
END
When this program was executed on a Mac/Intel/IDL8.x/64-bit
platform, the output was:
1-2-3 equivalent rotation to input (radians):
Roll 0.029998501, droll/dt -0.002999550
Pitch -0.000299950, dpitch/dt 0.000059980
Yaw 0.099995501, dyaw/dt -0.009998650
A word about notation: the symbol
[ x ]
i
indicates a coordinate system rotation of x radians about the
ith coordinate axis. To be specific, the symbol
[ x ]
1
indicates a coordinate system rotation of x radians about the
first, or x-, axis; the corresponding matrix is
.- -.
| 1 0 0 |
| |
| 0 cos(x) sin(x) |
| |
| 0 -sin(x) cos(x) |
`- -'
Remember, this is a COORDINATE SYSTEM rotation by x radians; this
matrix, when applied to a vector, rotates the vector by -x
radians, not x radians. Applying the matrix to a vector yields
the vector's representation relative to the rotated coordinate
system.
The analogous rotation about the second, or y-, axis is
represented by
[ x ]
2
which symbolizes the matrix
.- -.
| cos(x) 0 -sin(x) |
| |
| 0 1 0 |
| |
| sin(x) 0 cos(x) |
`- -'
and the analogous rotation about the third, or z-, axis is
represented by
[ x ]
3
which symbolizes the matrix
.- -.
| cos(x) sin(x) 0 |
| |
| -sin(x) cos(x) 0 |
| |
| 0 0 1 |
`- -'
The input matrix is assumed to be the product of three
rotation matrices, each one of the form
.- -.
| 1 0 0 |
| |
| 0 cos(r) sin(r) | (rotation of r radians about the
| | x-axis),
| 0 -sin(r) cos(r) |
`- -'
.- -.
| cos(s) 0 -sin(s) |
| |
| 0 1 0 | (rotation of s radians about the
| | y-axis),
| sin(s) 0 cos(s) |
`- -'
or
.- -.
| cos(t) sin(t) 0 |
| |
| -sin(t) cos(t) 0 | (rotation of t radians about the
| | z-axis),
| 0 0 1 |
`- -'
where the second rotation axis is not equal to the first or
third. Any rotation matrix can be factored as a sequence of
three such rotations, provided that this last criterion is met.
This routine is intended to provide an inverse for cspice_xf2eul.
The two procedure calls shown here will not change
`xform' except for round off errors.
cspice_xf2eul, xform, axisa, axisb, axisc, eulang, unique
cspice_eul2xf, eulang, axisa, axisb, axisc, xform'
On the other hand the two calls
cspice_eul2xf, eulang, axisa, axisb, axisc, xform
cspice_xf2eul, xform, axisa, axisb, axisc, eulang, unique
will leave `eulang' unchanged only if the components of `eulang'
are in the range produced by cspice_xf2eul and the Euler representation
of the rotation component of `xform' is unique within that range.
1) If any of `axisa', `axisb', or `axisc' do not have values in
{ 1, 2, 3 }
an error is signaled by a routine in the call tree of this
routine.
2) If any of the input arguments, `eulang', `axisa', `axisb' or
`axisc', is undefined, an error is signaled by the IDL error
handling system.
3) If any of the input arguments, `eulang', `axisa', `axisb' or
`axisc', is not of the expected type, or it does not have the
expected dimensions and size, an error is signaled by the Icy
interface.
4) If the output argument `xform' is not a named variable, an
error is signaled by the Icy interface.
None.
None.
ICY.REQ
ROTATION.REQ
None.
J. Diaz del Rio (ODC Space)
E.D. Wright (JPL)
-Icy Version 1.0.2, 10-AUG-2021 (JDR)
Edited the header to comply with NAIF standard. Added complete
code example.
Added -Parameters, -Exceptions, -Files, -Restrictions,
-Literature_References and -Author_and_Institution sections, and
completed -Particulars section.
Removed reference to the routine's corresponding CSPICE header from
-Abstract section.
Added arguments' type and size information in the -I/O section.
-Icy Version 1.0.1, 09-DEC-2005 (EDW)
Added -Examples section.
-Icy Version 1.0.0, 16-JUN-2003 (EDW)
State transformation from Euler angles and derivatives
|