>  Docs Center  >  Libraries  >  Markwardt  >  QTERP






  Craig B. Markwardt, NASA/GSFC Code 662, Greenbelt, MD 20770
  UPDATED VERSIONs can be found on my WEB PAGE:


  Smoothly interpolate from a grid of quaternions (spline or slerp)

Major Topics


Calling Sequence



  The function QTERP is used to interplate from a set of known unit
  quaternions specified on a grid of independent values, to a new set
  of independent values. For example, given a set of quaternions at
  specified key times, QTERP can interpolate at any points between
  those times. This has applications for computer animation and
  spacecraft attitude control.
  The "grid" of quaternions can be regularly or irregularly sampled.
  The new values can also be regularly or irregularly sampled.
  The simplest case comes when one wants to interpolate between two
  quaternions Q1 and Q2. In that case the user should specify the
  gridded quaterion as QGRID = [[Q1], [Q2]], with grid points at
  TGRID = [0d, 1d]. Then the user can sample any intermediate
  orientation by specifying TNEW anywhere between 0 and 1.
  The user has the option of performing pure spline interpolation of
  the quaternion components (the default technique). The resulting
  interpolants are normalized to be unit quaternions. This option is
  useful for fast interpolation of quaternions, but suffers if the
  grid is not well sampled enough. Spline interpolation will not
  strictly find the shortest path between two orientations.
  The second option is to use Spherical Linear IntERPolation, or
  SLERPing, to interpolate between quaternions (by specifying the
  SLERP keyword). This technique is guaranteed to find the shortest
  path between two orientations, but is somewhat slower than spline
  interpolation. This approach involves computing a finite
  difference of the data. To avoid repeated computation of the
  difference on every call, users can pass a named variable in the
  QDIFF keyword. This value can be reset with the RESET keyword.
  Conventions for storing quaternions vary in the literature and from
  library to library. This library uses the convention that the
  first three components of each quaternion are the 3-vector axis of
  rotation, and the 4th component is the rotation angle. Expressed
  in formulae, a single quaternion is given by:
    Q(0:2) = [VX, VY, VZ]*SIN(PHI/2)
    Q(3) = COS(PHI/2)
  where PHI is the rotation angle, and VAXIS = [VX, VY, VZ] is the
  rotation eigen axis expressed as a unit vector. This library
  accepts quaternions of both signs, but by preference returns
  quaternions with a positive 4th component.
  Users must have the VALUE_LOCATE() function, available either in
  IDL 5.3 or later, or from the Markwardt web page.


  TGRID - a vector of N independent variable values. In the
          simplest case, this can be [0, 1, ...] up to the number of
          quaternions in the grid. The grid sampling does not have
          to be uniform.
  QGRID - an 4xN array of unit quaternions specified on the grid.
  TNEW - a vector of M desired independent variable values which
          sample the grid specified by TGRID. The desired values do
          not have to be uniformly sampled.


  A 4xM array of unit quaternions, where is M is the number of
  desired samples.

Keyword Parameters

  SLERP - if set, then spherical linear interpolation is performed.
          The default is to perform spline interpolation on the
          quaternion coefficients.
  QDIFF - upon return, QDIFF is filled with finite difference values
          which can be used to speed computations in subsequent
          calls. Users should be aware that QDIFF may be
          inadvertently reused from one call to the next. When the
          difference data should no longer be reused, the named
          variable passed to the QDIFF keyword should be set to a
          scalar, or the /RESET keyword should be used.
  RESET - if set, then the QDIFF finite difference will be forced to
          be recalculated, even if there is already data present and
          passed to the QDIFF keyword.


  This example starts with two quaternions representing rotations of
  0 degrees and 45 degrees, and forms 1001 quaternions which are
  smooth interpolations between 0 and 45 degrees.
  ;; Create a grid of two quaternions at times 0 and 1
  Q0 = qtcompose([1,0,0], 0D) & T0 = 0D
  Q1 = qtcompose([1,0,0], !dpi/4) & T1 = 1D
  ;; Put the grid elements into an array
  TGRID = [T0, T1]
  QGRID = [[Q0], [Q1]]
  ;; Make an array of 11 values smoothly varying from 0 to 1
  TNEW = dindgen(11)/10d
  ;; Perform spherical linear interpolation
  ---> (interpolated results in QNEW)
      0.0000000 0.0000000 0.0000000 1.0000000
    0.039259816 0.0000000 0.0000000 0.99922904
    0.078459096 0.0000000 0.0000000 0.99691733
      0.11753740 0.0000000 0.0000000 0.99306846
      0.15643447 0.0000000 0.0000000 0.98768834
      0.19509032 0.0000000 0.0000000 0.98078528
      0.23344536 0.0000000 0.0000000 0.97236992
      0.27144045 0.0000000 0.0000000 0.96245524
      0.30901699 0.0000000 0.0000000 0.95105652
      0.34611706 0.0000000 0.0000000 0.93819134
      0.38268343 0.0000000 0.0000000 0.92387953

See Also


Modification History

  Written, July 2001, CM
  Documented, Dec 2001, CM
  Usage message; check for 0- and 1-length quaternions; handle case
      when quaternions are GE 180 degrees apart; handle case of
      interpolating beyond end of known grid, 15 Mar 2002, CM
  Use simplified QTMULT with /INV, 21 Sep 2007, CM
  Added sample output, 29 Sep 2008, CM

© 2020 Harris Geospatial Solutions, Inc. |  Legal
My Account    |    Store    |    Contact Us