Table of contents
CSPICE_RAXISA computes the axis of the rotation given by an
input matrix and the angle of the rotation about that axis.
Given:
matrix a double precision 3x3 rotation matrix.
help, matrix
DOUBLE = Array[3,3]
the call:
cspice_raxisa, matrix, axis, angle
returns:
axis a unit vector pointing along the axis of the rotation.
help, axis
DOUBLE = Array[3]
In other words, `axis' is a unit eigenvector of the input
matrix, corresponding to the eigenvalue 1. If the input matrix
is the identity matrix, `axis' will be the vector (0, 0, 1). If
the input rotation is a rotation by pi radians, both `axis' and
-axis may be regarded as the axis of the rotation.
angle the scalar, double precision angle between `v' and matrix * v
for any non-zero vector `v' orthogonal to `axis'.
help, angle
DOUBLE = Scalar
`angle' is given in radians. The angle returned will be in the
range from 0 to pi radians.
Please note cspice_raxisa is not guaranteed to invert the
operation of cspice_axisar.
None.
Any numerical results shown for these examples may differ between
platforms as the results depend on the SPICE kernels used as input
and the machine specific arithmetic implementation.
1) Given an axis and an angle of rotation about that axis,
determine the rotation matrix. Using this matrix as input,
compute the axis and angle of rotation, and verify that
the later are equivalent by subtracting the original matrix
and the one resulting from using the computed axis and angle
of rotation on the cspice_axisar call.
Example code begins here.
PRO raxisa_ex1
;;
;; Define an axis and an angle for rotation.
;;
axis = [ 1.d, 2.d, 3.d ]
angle = .1d * cspice_twopi()
;;
;; Determine the rotation matrix.
;;
cspice_axisar, axis, angle, rot_mat
;;
;; Now calculate the rotation axis and angle based on the
;; matrix as input.
;;
cspice_raxisa, rot_mat, axout, angout
print, 'Axis :', axout
print, 'Angle:', angout
print
;;
;; Now input the axout and angout to cspice_axisar to
;; compare against the original rotation matrix rot_mat.
;;
cspice_axisar, axout, angout, rot_out
print, 'Difference between input and output matrices:'
print, rot_mat - rot_out
END
When this program was executed on a Mac/Intel/IDL8.x/64-bit
platform, the output was:
Axis : 0.26726124 0.53452248 0.80178373
Angle: 0.62831853
Difference between input and output matrices:
1.1102230e-16 0.0000000 0.0000000
-5.5511151e-17 1.1102230e-16 0.0000000
0.0000000 -8.3266727e-17 0.0000000
Note, the zero matrix is accurate to round-off error. A numerical
demonstration of equality.
2) This routine can be used to numerically approximate the
instantaneous angular velocity vector of a rotating object.
Suppose that R(t) is the rotation matrix whose columns
represent the inertial pointing vectors of the body-fixed axes
of an object at time t.
Then the angular velocity vector points along the vector given
by:
T
limit axis( R(t+h)R )
h-->0
And the magnitude of the angular velocity at time t is given
by:
T
d angle ( R(t+h)R(t) )
---------------------- at h = 0
dh
This code example computes the instantaneous angular velocity
vector of the Earth at 2000 Jan 01 12:00:00 TDB.
Use the PCK kernel below to load the required triaxial
ellipsoidal shape model and orientation data for the Earth.
pck00010.tpc
Example code begins here.
PRO raxisa_ex2
;;
;; Load a PCK file containing a triaxial
;; ellipsoidal shape model and orientation
;; data for the Earth.
;;
cspice_furnsh, 'pck00010.tpc'
;;
;; Load time into the double precision variable `t'
;; and the delta time (1 ms) into the double precision
;; variable TH
;;
t = 0.0
h = 1d-3
;;
;; Get the rotation matrices from IAU_EARTH to J2000
;; at `t' and TH.
;;
cspice_pxform, 'IAU_EARTH', 'J2000', t, rt
cspice_pxform, 'IAU_EARTH', 'J2000', t+h, rth
;;
;; Compute the infinitesimal rotation r[t+h-1]r(t)^T
;;
cspice_mxmt, rth, rt, infrot
;;
;; Compute the `axis' and `angle' of the infinitesimal rotation
;;
cspice_raxisa, infrot, axis, angle
;;
;; Scale `axis' to get the angular velocity vector
;;
cspice_vscl, angle/h, axis, angvel
;;
;; Output the results.
;;
print, 'Instantaneous angular velocity vector:'
print, format='(3F15.10)', angvel[0], angvel[1], angvel[2]
;;
;; It's always good form to unload kernels after use,
;; particularly in IDL due to data persistence.
;;
cspice_kclear
END
When this program was executed on a Mac/Intel/IDL8.x/64-bit
platform, the output was:
Instantaneous angular velocity vector:
0.0000000000 0.0000000000 0.0000729212
Every rotation matrix has an axis `a' such any vector `v'
parallel to that axis satisfies the equation
v = matrix * v
This routine returns a unit vector `axis' parallel to the axis of
the input rotation matrix. Moreover for any vector `w' orthogonal
to the axis of the rotation, the two vectors
axis,
w x ( matrix * w )
(where "x" denotes the cross product operation)
will be positive scalar multiples of one another (at least
to within the ability to make such computations with double
precision arithmetic, and under the assumption that `matrix'
does not represent a rotation by zero or pi radians).
The angle returned will be the angle between `w' and matrix*w
for any vector orthogonal to `axis'.
If the input matrix is a rotation by 0 or pi radians some
choice must be made for the axis returned. In the case of
a rotation by 0 radians, `axis' is along the positive Z-axis.
In the case of a rotation by 180 degrees, two choices are
possible. The choice made this routine is unspecified.
1) If the input matrix is not a rotation matrix (where a fairly
loose tolerance is used to check this), an error is signaled
by a routine in the call tree of this routine.
2) If the input matrix is the identity matrix, this routine
returns an angle of 0.0, and an axis of ( 0.0, 0.0, 1.0 ).
3) If the input argument `matrix' is undefined, an error is
signaled by the IDL error handling system.
4) If the input argument `matrix' is not of the expected type, or
it does not have the expected dimensions and size, an error is
signaled by the Icy interface.
5) If any of the output arguments, `axis' or `angle', is not a
named variable, an error is signaled by the Icy interface.
None.
1) If the input matrix is not a rotation matrix but is close
enough to pass the tests this routine performs on it, no error
will be signaled, but the results may have poor accuracy.
2) The input matrix is taken to be an object that acts on
(rotates) vectors---it is not regarded as a coordinate
transformation. To find the axis and angle of a coordinate
transformation, input the transpose of that matrix to this
routine.
ICY.REQ
ROTATION.REQ
None.
J. Diaz del Rio (ODC Space)
E.D. Wright (JPL)
-Icy Version 1.0.2, 10-AUG-2021 (JDR)
Added missing description of changes for Version 1.0.1.
Edited the -Examples section to comply with NAIF standard. Added
example's problem statement, reformatted example's output and
added second 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, 05-JAN-2005 (EDW)
Updated the -I/O section to extended the description of the output
arguments.
-Icy Version 1.0.0, 16-JUN-2003 (EDW)
rotation axis of a matrix
|