eul2m_c

 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 eul2m_c ( SpiceDouble  angle3,
SpiceDouble  angle2,
SpiceDouble  angle1,
SpiceInt     axis3,
SpiceInt     axis2,
SpiceInt     axis1,
SpiceDouble  r  )

```

#### Abstract

```   Construct a rotation matrix from a set of Euler angles.
```

```   ROTATION
```

#### Keywords

```   MATRIX
ROTATION
TRANSFORMATION

```

#### Brief_I/O

```   Variable  I/O  Description
--------  ---  --------------------------------------------------
angle3,
angle2,
angle1     I   Rotation angles about third, second, and first
axis3,
axis2,
axis1      I   Axis numbers of third, second, and first rotation
axes.

r          O   Product of the 3 rotations.
```

#### Detailed_Input

```   angle3,
angle2,
angle1,

axis3,
axis2,
axis1          are, respectively, a set of three angles and three
coordinate axis numbers; each pair angleX and
axisX specifies a coordinate transformation
the coordinate axis indexed by axisX.  These
coordinate transformations are typically
symbolized by

[ angleX ]     .
axisX

See the -Particulars section below for details
concerning this notation.

Note that these coordinate transformations rotate
vectors by

-angleX

The values of axisX may be 1, 2, or 3, indicating
the x, y, and z axes respectively.
```

#### Detailed_Output

```   r              is a rotation matrix representing the composition
of the rotations defined by the input angle-axis
pairs.  Together, the three pairs specify a
composite transformation that is the result of
performing the rotations about the axes indexed
by axis1, axis2, and axis3, in that order.  So,

r = [ angle3 ]     [ angle2 ]      [ angle1 ]
axis3          axis2           axis1

See the -Particulars section below for details
concerning this notation.

The resulting matrix r may be thought of as a
coordinate transformation; applying it to a vector
yields the vector's coordinates in the rotated
system.

Viewing r as a coordinate transformation matrix,
the basis that r transforms vectors to is created
by rotating the original coordinate axes first by
coordinate axis indexed by axis2, and finally by
axis3.  At the second and third steps of this
process, the coordinate axes about which rotations
are performed belong to the bases resulting from
the previous rotations.
```

#### Parameters

```   None.
```

#### Exceptions

```   1)   If any of axis3, axis2, or axis1 do not have values in

{ 1, 2, 3 },

```

#### Files

```   None.
```

#### Particulars

``` section below for details
concerning this notation.

Note that these coordinate transformations rotate
vectors by

-angleX

The values of axisX may be 1, 2, or 3, indicating
the x, y, and z axes respectively.
```

#### Examples

```   1)  Create a coordinate transformation matrix by rotating
the original coordinate axes first by 30 degrees about
the z axis, next by 60 degrees about the y axis resulting
from the first rotation, and finally by -50 degrees about
the z axis resulting from the first two rotations.

/.

Create the coordinate transformation matrix

o          o          o
R  =  [ -50  ]   [  60  ]   [  30  ]
3          2          3

function rpd_c (radians per degree) gives the
conversion factor.

The z axis is `axis 3'; the y axis is `axis 2'.
./

angle1 = rpd_c() *  30.;
angle2 = rpd_c() *  60.;
angle3 = rpd_c() * -50.;

axis1  = 3;
axis2  = 2;
axis3  = 3;

eul2m_c (  angle3, angle2, angle1,
axis3,  axis2,  axis1,   r  );

2)  A trivial example using actual numbers.

The call

eul2m_c (  0.,     0.,     halfpi_c(),
1,        1,            3,      r  );

sets r equal to the matrix

+-                  -+
|  0      1       0  |
|                    |
| -1      0       0  |.
|                    |
|  0      0       1  |
+-                  -+

3)  Finding the rotation matrix specified by a set of `clock,
cone, and twist' angles, as defined on the Voyager 2 project:

Voyager 2 narrow angle camera pointing, relative to the
Sun-Canopus coordinate system, was frequently specified
by a set of Euler angles called `clock, cone, and twist'.
These defined a 3-2-3 coordinate transformation matrix
TSCTV as the product

[ twist ]  [ cone ]   [ clock ] .
3         2           3

Given the angles clock, cone, and twist (in units of
radians), we can compute tsctv with the call

eul2m_c (  twist,  cone,  clock,
3,      2,     3,      tsctv  );

4)  Finding the rotation matrix specified by a set of `right
ascension, declination, and twist' angles, as defined on the
Galileo project:

Galileo scan platform pointing, relative to an inertial
reference frame, (EME50 variety) is frequently specified
by a set of Euler angles called `right ascension (RA),
declination (Dec), and twist'. These define a 3-2-3
coordinate transformation matrix TISP as the product

[ Twist ]  [ pi/2 - Dec ]   [ RA ] .
3               2        3

Given the angles ra, dec, and twist (in units of radians),
we can compute tisp with the code fragment

eul2m_c (  twist,   halfpi_c()-dec,   ra,
3,       2,                3,   tisp  );
```

#### Restrictions

```   Beware:  more than one definition of "RA, DEC and twist" exists.
```

#### Literature_References

```     `Galileo Attitude and Camera Models', JPL IOM 314-323,
W. M. Owen, Jr.,  Nov. 11, 1983.  NAIF document number
204.0.
```

#### Author_and_Institution

```   N.J. Bachman   (JPL)
```

#### Version

```   -CSPICE Version 1.0.2, 26-DEC-2006 (NJB)

-CSPICE Version 1.0.1, 13-OCT-2004 (NJB)

```   euler angles to matrix
`Wed Apr  5 17:54:35 2017`