Index Page
eul2xf_c
A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X 

Procedure
Abstract
Required_Reading
Keywords
Brief_I/O
Detailed_Input
Detailed_Output
Parameters
Exceptions
Files
Particulars
Examples
Restrictions
Literature_References
Author_and_Institution
Version
Index_Entries

Procedure

   void eul2xf_c ( ConstSpiceDouble    eulang[6],
                   SpiceInt            axisa,
                   SpiceInt            axisb,
                   SpiceInt            axisc,
                   SpiceDouble         xform [6][6] )

Abstract

 
   This routine computes a state transformation from an Euler angle 
   factorization of a rotation and the derivatives of those Euler 
   angles. 
 

Required_Reading

 
   ROTATION
 

Keywords

 
   ANGLES 
   STATE 
   DERIVATIVES 
 

Brief_I/O

 
   VARIABLE  I/O  DESCRIPTION 
   --------  ---  -------------------------------------------------- 
   eulang     I   An array of Euler angles and their derivatives. 
   axisa      I   Axis A of the Euler angle factorization. 
   axisb      I   Axis B of the Euler angle factorization. 
   axisc      I   Axis C of the Euler angle factorization. 
   xform      O   A state transformation matrix. 
 

Detailed_Input

 
 
   eulang      is the set of Euler angles corresponding to the 
               specified factorization. 
 
               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] = dalpha/dt 
                  eulang[4] = dbeta/dt 
                  eulang[5] = dgamma/dt 
 
 
   axisa       are the axes desired for the factorization of r. 
   axisb       All must be in the range from 1 to 3.  Moreover 
   axisc       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. 
               
 

Detailed_Output

 
   xform       is the state transformation corresponding r and dr/dt 
               as described above.  Pictorially, 
 
                    [       |        ] 
                    |  r    |    0   | 
                    |       |        | 
                    |-------+--------| 
                    |       |        | 
                    | dr/dt |    r   | 
                    [       |        ] 
 
               where r is a rotation that varies with respect to time 
               and dr/dt is its time derivative. 
 

Parameters

 
   None. 
 

Exceptions

 
   All erroneous inputs are diagnosed by routines in the call 
   tree to this routine.  These include 
 
   1)   If any of axisa, axisb, or axisc do not have values in 
 
           { 1, 2, 3 }, 
 
        then the error SPICE(INPUTOUTOFRANGE) is signaled. 
 

Files

 
   None. 
 

Particulars

 
   This function is intended to provide an inverse for the function 
   xf2eul_c.    
 
 
   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 related to the routine eul2xf_c which produces 
   a state transformation from an input set of axes, Euler angles 
   and derivatives. 
 
   The two function calls shown here will not change xform except for 
   round off errors. 
 
      xf2eul_c ( xform,  axisa, axisb, axisc, eulang, &unique );
      eul2xf_c ( eulang, axisa, axisb, axisc, xform           ); 
 
   On the other hand the two calls 
 
      eul2xf_c ( eulang, axisa, axisb, axisc, xform           ); 
      xf2eul_c ( xform,  axisa, axisb, axisc, eulang, &unique );
 
   will leave eulang unchanged only if the components of eulang 
   are in the range produced by xf2eul_c and the Euler representation 
   of the rotation component of xform is unique within that range. 

 

Examples

 
   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 fragment will perform the desired computation. 
 
      abgang[0] = alpha; 
      abgang[1] = beta; 
      abgang[2] = gamma; 
      abgang[3] = dalpha; 
      abgang[4] = dbeta; 
      abgang[5] = dgamma; 
 
      eul2xf_c ( abgang, 3, 1, 3, xform  ); 
      xf2eul_c ( xform,  1, 2, 3, rpyang, &unique ); 
 
      roll     = rpyang[0]; 
      pitch    = rpyang[1]; 
      yaw      = rpyang[2]; 
      droll    = rpyang[3]; 
      dpitch   = rpyang[4]; 
      dyaw     = rpyang[5];
       
 

Restrictions

 
   None. 
 

Literature_References

 
   None. 
 

Author_and_Institution

 
   N.J. Bachman    (JPL)
   W.L. Taber      (JPL) 
   

Version

   -CSPICE Version 2.0.1, 25-APR-2007 (EDW)

      Corrected code in Examples section, example showed
      a xf2eul_c call:
      
            xf2eul_c( xform,  1, 2, 3, rpyang); 
       
      The proper form of the call:
      
            xf2eul_c( xform,  1, 2, 3, rpyang, &unique );

   -CSPICE Version 2.0.0, 31-OCT-2005 (NJB)

      Restriction that second axis must differ from the first
      and third was removed.

   -CSPICE Version 1.0.1, 03-JUN-2003 (EDW)

      Correct typo in Procedure line.
 
   -CSPICE Version 1.0.0, 18-MAY-1999 (WLT) (NJB)

Index_Entries

 
   State transformation from Euler angles and derivatives 
 
Wed Apr  5 17:54:35 2017