Isis 3 Programmer Reference
SpiceRotation.h
1#ifndef SpiceRotation_h
2#define SpiceRotation_h
8/* SPDX-License-Identifier: CC0-1.0 */
9#include <string>
10#include <vector>
11
12#include <nlohmann/json.hpp>
13#include <ale/Orientations.h>
14
15#include "Angle.h"
16#include "Table.h"
17#include "PolynomialUnivariate.h"
18#include "Quaternion.h"
19
20
21
22#define J2000Code 1
23
24namespace Isis {
209 public:
210 // Constructors
211 SpiceRotation(int frameCode);
212 /* SpiceRotation( int NaifCode );
213 We would like to call refchg instead to avoid the strings. Currently Naif does
214 not have refchg_c, but only the f2c'd refchg.c.*/
215 SpiceRotation(int frameCode, int targetCode);
216 SpiceRotation(const SpiceRotation &rotToCopy);
217
218 // Destructor
219 virtual ~SpiceRotation();
220
221 // Change the frame (has no effect if cached)
222 void SetFrame(int frameCode);
223 int Frame();
224
225 void SetTimeBias(double timeBias);
226
251
261
270
276 INERTL = 1,
277 PCK = 2,
278 CK = 3,
279 TK = 4,
280 DYN = 5,
281 BPC = 6,
282 NOTJ2000PCK = 7
283 };
284
285 void SetEphemerisTime(double et);
286 double EphemerisTime() const;
287
288 std::vector<double> GetCenterAngles();
289
290 std::vector<double> Matrix();
291 std::vector<double> AngularVelocity();
292
293 // TC
294 std::vector<double> ConstantRotation();
295 std::vector<double> &ConstantMatrix();
296 void SetConstantMatrix(std::vector<double> constantMatrix);
297
298 // CJ
299 std::vector<double> TimeBasedRotation();
300 std::vector<double> &TimeBasedMatrix();
301 void SetTimeBasedMatrix(std::vector<double> timeBasedMatrix);
302
303 std::vector<double> J2000Vector(const std::vector<double> &rVec);
304
305 std::vector<Angle> poleRaCoefs();
306
307 std::vector<Angle> poleDecCoefs();
308
309 std::vector<Angle> pmCoefs();
310
311 std::vector<double> poleRaNutPrecCoefs();
312
313 std::vector<double> poleDecNutPrecCoefs();
314
315 std::vector<double> pmNutPrecCoefs();
316
317 std::vector<Angle> sysNutPrecConstants();
318
319 std::vector<Angle> sysNutPrecCoefs();
320
321 std::vector<double> ReferenceVector(const std::vector<double> &jVec);
322
323 std::vector<double> EvaluatePolyFunction();
324
325 void loadPCFromSpice(int CenterBodyCode);
326 void loadPCFromTable(const PvlObject &Label);
327
328 void MinimizeCache(DownsizeStatus status);
329
330 void LoadCache(double startTime, double endTime, int size);
331
332 void LoadCache(double time);
333
334 void LoadCache(Table &table);
335
336 void LoadCache(nlohmann::json &isd);
337
338 Table LineCache(const QString &tableName);
339
340 void ReloadCache();
341
342 Table Cache(const QString &tableName);
343 void CacheLabel(Table &table);
344
345 void LoadTimeCache();
346
347 std::vector<double> Angles(int axis3, int axis2, int axis1);
348 void SetAngles(std::vector<double> angles, int axis3, int axis2, int axis1);
349
350 bool IsCached() const;
351
352 void SetPolynomial(const Source type=PolyFunction);
353
354 void SetPolynomial(const std::vector<double> &abcAng1,
355 const std::vector<double> &abcAng2,
356 const std::vector<double> &abcAng3,
357 const Source type = PolyFunction);
358
359 void usePckPolynomial();
360 void setPckPolynomial(const std::vector<Angle> &raCoeff,
361 const std::vector<Angle> &decCoeff,
362 const std::vector<Angle> &pmCoeff);
363
364 void GetPolynomial(std::vector<double> &abcAng1,
365 std::vector<double> &abcAng2,
366 std::vector<double> &abcAng3);
367
368 void getPckPolynomial(std::vector<Angle> &raCoeff,
369 std::vector<Angle> &decCoeff,
370 std::vector<Angle> &pmCoeff);
371
372 // Set the polynomial degree
373 void SetPolynomialDegree(int degree);
374 Source GetSource();
375 void SetSource(Source source);
376 void ComputeBaseTime();
377 FrameType getFrameType();
378 double GetBaseTime();
379 double GetTimeScale();
380
381 void SetOverrideBaseTime(double baseTime, double timeScale);
382 void SetCacheTime(std::vector<double> cacheTime);
383
384 // Derivative methods
385 double DPolynomial(const int coeffIndex);
386 double DPckPolynomial(PartialType partialVar, const int coeffIndex);
387
388 std::vector<double> toJ2000Partial(const std::vector<double> &lookT,
389 PartialType partialVar, int coeffIndex);
390 std::vector<double> ToReferencePartial(std::vector<double> &lookJ,
391 PartialType partialVar, int coeffIndex);
392 void DCJdt(std::vector<double> &dRJ);
393
394 double WrapAngle(double compareAngle, double angle);
395 void SetAxes(int axis1, int axis2, int axis3);
396 std::vector<double> GetFullCacheTime();
397 void FrameTrace(double et);
398
399 // Return the frame chain for the constant part of the rotation (ends in target)
400 std::vector<int> ConstantFrameChain();
401 std::vector<int> TimeFrameChain();
402 void InitConstantRotation(double et);
403 bool HasAngularVelocity();
404
405 void ComputeAv();
406 std::vector<double> Extrapolate(double timeEt);
407
408 void checkForBinaryPck();
409
410 int cacheSize() {
411 if (m_orientation) {
412 return m_orientation->getRotations().size();
413 }
414 return 0;
415 }
416
417 protected:
418 void SetFullCacheParameters(double startTime, double endTime, int cacheSize);
425 std::vector<double> p_cacheTime;
430 ale::Orientations *m_orientation;
431
432 private:
433 // method
434 void setFrameType();
435 std::vector<int> p_constantFrames;
438 std::vector<int> p_timeFrames;
441 double p_timeBias;
442
443 double p_et;
449
450
458
459 double p_baseTime;
460 double p_timeScale;
464 std::vector<double> p_coefficients[3];
473 std::vector<double> p_TC;
476 std::vector<double> p_CJ;
478 std::vector<double> p_av;
481 std::vector<double> StateTJ();
483 // The remaining items are only used for PCK frame types. In this case the
484 // rotation is stored as a cache, but the coefficients are available for display
485 // or comparison, and the first three coefficient sets can be solved for and
486 // updated in jigsaw. The initial coefficient values are read from a Naif PCK.
487 //
488 // The general equation for the right ascension of the pole is
489 //
490 // raPole = raPole[0] + raPole[1]*Time + raPole[2]*Time**2 + raNutPrec,
491 // where
492 // raNutPrec = raNutPrec1[0]*sin(sysNutPrec[0][0] + sysNutPrec[0][1]*Time) +
493 // raNutPrec1[1]*sin(sysNutPrec[1][0] + sysNutPrec[1][1]*Time) + ...
494 // raNutPrec1[N-1]*sin(sysNutPrec[N-1][0] + sysNutPrec[N-1][1]*Time) +
495 // (optional for multiples of nutation precession angles)
496 // raNutPrec2[0]*sin(2*(sysNutPrec[0][0] + sysNutPrec[0][1]*Time)) +
497 // raNutPrec2[1]*sin(2*(sysNutPrec[1][0] + sysNutPrec[1][1]*Time)) + ...
498 // raNutPrec2[N-1]*sin(2*(sysNutPrec[N-1][0] + sysNutPrec[N-1][1]*Time)) +
499 // raNutPrecM[0]*sin(M*(sysNutPrec[0][0] + sysNutPrec[0][1]*Time)) +
500 // raNutPrecM[1]*sin(M*(sysNutPrec[1][0] + sysNutPrec[1][1]*Time)) + ...
501 // raNutPrecM[N-1]*sin(M*(sysNutPrec[N-1][0] + sysNutPrec[N-1][1]*Time)) +
502 //
503 // The general equation for the declination of the pole is
504 //
505 // decPole = p_decPole[0] + p_decPole[1]*Time + p_decPole[2]*Time**2 + decNutPrec,
506 // where
507 // decNutPrec = decNutPrec1[0]*cos(sysNutPrec[0][0] + sysNutPrec[0][1]*Time) +
508 // decNutPrec1[1]*cos(sysNutPrec[1][0] + sysNutPrec[1][1]*Time) + ...
509 // decNutPrec1[N-1]*cos(sysNutPrec[N-1][0] + sysNutPrec[N-1][1]*Time) +
510 // decNutPrec2[0]*cos(2*(sysNutPrec[0][0] + sysNutPrec[0][1]*Time)) +
511 // decNutPrec2[1]*cos(2*(sysNutPrec[1][0] + sysNutPrec[1][1]*Time)) + ...
512 // decNutPrec2[N-1]*cos(2*(sysNutPrec[N-1][0] + sysNutPrec[N-1][1]*Time)) +
513 // (optional for multiples of nutation precession angles)
514 // decNutPrecM[0]*sin(M*(sysNutPrec[0][0] + sysNutPrec[0][1]*Time)) +
515 // decNutPrecM[1]*sin(M*(sysNutPrec[1][0] + sysNutPrec[1][1]*Time)) + ...
516 // decNutPrecM[N-1]*sin(M*(sysNutPrec[N-1][0] + sysNutPrec[N-1][1]*Time))
517 //
518 // and Time is julian centuries since J2000.
519 //
520 // The general equation for the prime meridian rotation is
521 //
522 // pm = p_pm[0] + p_pm[1]*Dtime + p_pm[2]*Dtime**2 + pmNutPrec,
523 // where
524 // pmNutPrec = pmNutPrec1[0]*sin(sysNutPrec[0][0] + sysNutPrec[0][1]*Time) +
525 // pmNutPrec1[1]*sin(sysNutPrec[1][0] + sysNutPrec[1][1]*Time) + ...
526 // pmNutPrec1[N-1]*sin(sysNutPrec[N-1][0] + sysNutPrec[N-1][1]*Time) +
527 // (optional for multiples of nutation precession angles)
528 // pmNutPrec2[0]*sin(2*(sysNutPrec[0][0] + sysNutPrec[0][1]*Time)) +
529 // pmNutPrec2[1]*sin(2*(sysNutPrec[1][0] + sysNutPrec[1][1]*Time)) + ...
530 // pmNutPrec2[N-1]*sin(2*(sysNutPrec[N-1][0] + sysNutPrec[N-1][1]*Time)) +
531 // pmNutPrecM[0]*sin(M*(sysNutPrec[0][0] + sysNutPrec[0][1]*Time)) +
532 // pmNutPrecM[1]*sin(M*(sysNutPrec[1][0] + sysNutPrec[1][1]*Time)) + ...
533 // pmNutPrecM[N-1]*sin(M*(sysNutPrec[N-1][0] + sysNutPrec[N-1][1]*Time))
534 //
535 // Time is interval in Julian centuries since the standard epoch,
536 // dTime is interval in days from the standard epoch (J2000),
537 //
538 // N is the number of nutation/precession terms for the planetary system of the target
539 // body, (possibly including multiple angles as unique terms,
540 // ie. 2*sysNutPrec[0][0] + sysNutPrec[][1]*Time).
541 //
542 // Many of the constants in this equation are 0. for a given body.
543 //
544 // M is included as an option for future improvements. M = highest multiple (period)
545 // of any of the nutation/precession angles included in the equations.
546 //
547 // ***NOTE*** Currently Naif stores multiples (amplitudes) as if they were additional
548 // nutation/precession terms (periods) in the equation. This method works as
549 // long as jigsaw does not solve for those values. In order to solve for
550 // those values, the multiples will need to be known so that the partial
551 // derivatives can be correctly calculated. Some possible ways of doing this
552 // are 1) Convince Naif to change their data format indicating the relation
553 // 2) Make an Isis version of the PCK data and have Isis software to
554 // calculate the rotation and partials.
555 // 3) Have an Isis addendum file that identifies the repeated periods
556 // and software to apply them when calculating the rotation and partials.
557 //
558 // For now this software will handle any terms with the same period and different
559 // amplitudes as unique terms in the equation (raNutPrec, decNutPrec,
560 // and pmNutPrec).
561 //
562 // The next three vectors will have length 3 (for a quadratic polynomial) if used.
563 std::vector<Angle>m_raPole;
564 std::vector<Angle>m_decPole;
565 std::vector<Angle>m_pm ;
566 //
567 // Currently multiples (terms with periods matching other terms but varying amplitudes)
568 // are handled as additional terms added to the end of the vector as Naif does (see
569 // comments in any of the standard Naif PCK.
570 std::vector<double>m_raNutPrec;
571 std::vector<double>m_decNutPrec;
572 std::vector<double>m_pmNutPrec;
573
574 // The periods of bodies in the same system are modeled with a linear equation
575 std::vector<Angle>m_sysNutPrec0;
576 std::vector<Angle>m_sysNutPrec1;
577
578 // The following scalars are used in the IAU equations to convert p_et to the appropriate time
579 // units for calculating target body ra, dec, and w. These need to be initialized in every
580 // constructor.
582 static const double m_centScale;
584 static const double m_dayScale;
585
586 };
587};
588
589#endif
Contains Pvl Groups and Pvl Objects.
Definition PvlObject.h:61
Provide operations for quaternion arithmetic.
Definition Quaternion.h:36
Obtain SPICE rotation information for a body.
std::vector< double > toJ2000Partial(const std::vector< double > &lookT, PartialType partialVar, int coeffIndex)
Given a direction vector in the reference frame, compute the derivative with respect to one of the co...
static const double m_dayScale
Seconds per day for scaling time in seconds to get target body w.
void setEphemerisTimePolyFunction()
When setting the ephemeris time, updates the rotation according to a polynomial that defines the thre...
std::vector< double > GetFullCacheTime()
Return full listing (cache) of original time coverage requested.
void SetPolynomial(const Source type=PolyFunction)
Set the coefficients of a polynomial fit to each of the three camera angles for the time period cover...
std::vector< double > m_decNutPrec
Coefficients of pole decliniation nut/prec terms.
void loadPCFromTable(const PvlObject &Label)
Initialize planetary orientation constants from an cube body rotation label.
void SetConstantMatrix(std::vector< double > constantMatrix)
Set the constant 3x3 rotation TC matrix from a vector of length 9.
void SetFullCacheParameters(double startTime, double endTime, int cacheSize)
Set the full cache time parameters.
double GetTimeScale()
Accessor method to get the rotation time scale.
int Frame()
Accessor method that returns the frame code.
void setPckPolynomial(const std::vector< Angle > &raCoeff, const std::vector< Angle > &decCoeff, const std::vector< Angle > &pmCoeff)
Set the coefficients of a polynomial fit to each of the three planet angles for the time period cover...
void setFrameType()
Cached orientation information.
FrameType getFrameType()
Accessor method to get the rotation frame type.
int p_targetCode
For computing Nadir rotation only.
double p_fullCacheStartTime
Initial requested starting time of cache.
int p_degree
Degree of fit polynomial for angles.
Source p_source
The source of the rotation data.
void setEphemerisTimePckPolyFunction()
When setting the ephemeris time, updates the rotation state based on the PcK polynomial.
void CacheLabel(Table &table)
Add labels to a SpiceRotation table.
void SetTimeBasedMatrix(std::vector< double > timeBasedMatrix)
Set the time-based 3x3 rotation CJ matrix from a vector of length 9.
double p_fullCacheEndTime
Initial requested ending time of cache.
std::vector< double > Matrix()
Return the full rotation TJ as a matrix.
double EphemerisTime() const
Accessor method to get current ephemeris time.
void SetAxes(int axis1, int axis2, int axis3)
Set the axes of rotation for decomposition of a rotation matrix into 3 angles.
double GetBaseTime()
Accessor method to get the rotation base time.
std::vector< double > EvaluatePolyFunction()
Evaluate the polynomial fit function for the three pointing angles for the current ephemeris time.
std::vector< double > ToReferencePartial(std::vector< double > &lookJ, PartialType partialVar, int coeffIndex)
Compute the derivative with respect to one of the coefficients in the angle polynomial fit equation o...
int p_axisV
The axis defined by the velocity vector for defining a nadir rotation.
void ReloadCache()
Cache J2000 rotation over existing cached time range using polynomials.
bool p_hasAngularVelocity
Flag indicating whether the rotation includes angular velocity.
double p_baseTime
Base time used in fit equations.
std::vector< Angle > poleDecCoefs()
Return the coefficients used to calculate the target body pole dec.
int p_axisP
The axis defined by the spacecraft vector for defining a nadir rotation.
std::vector< Angle > m_pm
Coefficients of a quadratic polynomial fitting pole pm.
double WrapAngle(double compareAngle, double angle)
Wrap the input angle to keep it within 2pi radians of the angle to compare.
std::vector< double > GetCenterAngles()
Return the camera angles at the center time of the observation.
void setEphemerisTimeNadir()
When setting the ephemeris time, uses spacecraft nadir source to update the rotation state.
Source GetSource()
Accessor method to get the rotation source.
std::vector< Angle > m_decPole
Coefficients of a quadratic polynomial fitting pole dec.
void LoadTimeCache()
Load the time cache.
std::vector< double > & TimeBasedMatrix()
Return time-based 3x3 rotation CJ matrix as a vector of length 9.
std::vector< double > p_CJ
Rotation matrix from J2000 to first constant rotation.
std::vector< double > Angles(int axis3, int axis2, int axis1)
Return the camera angles (right ascension, declination, and twist) for the time-based matrix CJ.
void InitConstantRotation(double et)
Initialize the constant rotation.
int p_axis1
Axis of rotation for angle 1 of rotation.
int p_axis3
Axis of rotation for angle 3 of rotation.
Table Cache(const QString &tableName)
Return a table with J2000 to reference rotations.
void LoadCache(double startTime, double endTime, int size)
Cache J2000 rotation quaternion over a time range.
std::vector< double > ConstantRotation()
Return the constant 3x3 rotation TC matrix as a quaternion.
std::vector< double > ReferenceVector(const std::vector< double > &jVec)
Given a direction vector in J2000, return a reference frame direction.
std::vector< double > AngularVelocity()
Accessor method to get the angular velocity.
double p_overrideBaseTime
Value set by caller to override computed base time.
double p_overrideTimeScale
Value set by caller to override computed time scale.
std::vector< Angle > sysNutPrecCoefs()
Return the coefficients used to calculate the target body system nut/prec angles.
void SetOverrideBaseTime(double baseTime, double timeScale)
Set an override base time to be used with observations on scanners to allow all images in an observat...
Table LineCache(const QString &tableName)
Return a table with J2000 to reference rotations.
std::vector< double > J2000Vector(const std::vector< double > &rVec)
Given a direction vector in the reference frame, return a J2000 direction.
double DPckPolynomial(PartialType partialVar, const int coeffIndex)
Evaluate the derivative of the fit polynomial defined by the given coefficients with respect to the c...
DownsizeStatus p_minimizeCache
Status of downsizing the cache (set to No to ignore)
void SetEphemerisTime(double et)
Return the J2000 to reference frame quaternion at given time.
void SetFrame(int frameCode)
Change the frame to the given frame code.
std::vector< double > m_raNutPrec
Coefficients of pole right ascension nut/prec terms.
std::vector< int > TimeFrameChain()
Accessor method to get the frame chain for the rotation (begins in J2000).
std::vector< double > p_coefficients[3]
Coefficients defining functions fit to 3 pointing angles.
SpiceRotation(int frameCode)
Construct an empty SpiceRotation class using a valid Naif frame code to set up for getting rotation f...
double p_timeScale
Time scale used in fit equations.
std::vector< Angle > sysNutPrecConstants()
Return the constants used to calculate the target body system nut/prec angles.
std::vector< double > Extrapolate(double timeEt)
Extrapolate pointing for a given time assuming a constant angular velocity.
bool p_degreeApplied
Flag indicating whether or not a polynomial of degree p_degree has been created and used to fill the ...
std::vector< double > poleRaNutPrecCoefs()
Return the coefficients used to calculate the target body pole ra nut/prec coefficients.
std::vector< double > p_cacheTime
iTime for corresponding rotation
DownsizeStatus
Status of downsizing the cache.
@ Done
Cache is downsized.
@ No
Do not downsize the cache.
@ Yes
Downsize the cache.
void checkForBinaryPck()
Check loaded pck to see if any are binary and set frame type to indicate binary pck.
std::vector< Angle > poleRaCoefs()
Return the coefficients used to calculate the target body pole ra.
void setEphemerisTimePolyFunctionOverSpice()
When setting the ephemeris time, updates the rotation state based on a polynomial fit over spice kern...
static const double m_centScale
Seconds per Julian century for scaling time in seconds.
std::vector< double > p_av
Angular velocity for rotation at time p_et.
void SetSource(Source source)
Resets the source of the rotation to the given value.
int p_fullCacheSize
Initial requested cache size.
void setEphemerisTimeSpice()
When setting the ephemeris time, updates the rotation state based on data read directly from NAIF ker...
bool p_noOverride
Flag to compute base time;.
bool m_tOrientationAvailable
Target orientation constants are available.
void GetPolynomial(std::vector< double > &abcAng1, std::vector< double > &abcAng2, std::vector< double > &abcAng3)
Return the coefficients of a polynomial fit to each of the three camera angles for the time period co...
std::vector< double > StateTJ()
State matrix (6x6) for rotating state vectors from J2000 to target frame.
Source
The rotation can come from one of 3 places for an Isis cube.
@ PolyFunction
From nth degree polynomial.
@ Spice
Directly from the kernels.
@ Nadir
Nadir pointing.
@ PckPolyFunction
Quadratic polynomial function with linear trignometric terms.
@ Memcache
From cached table.
@ PolyFunctionOverSpice
Kernels plus nth degree polynomial.
PartialType
This enumeration indicates whether the partial derivative is taken with respect to Right Ascension,...
@ WRT_RightAscension
With respect to Right Ascension.
@ WRT_Twist
With respect to Twist or Prime Meridian Rotation.
@ WRT_Declination
With respect to Declination.
void loadPCFromSpice(int CenterBodyCode)
Initialize planetary orientation constants from Spice PCK.
void setEphemerisTimeMemcache()
Updates rotation state based on the rotation cache.
void ComputeAv()
Compute the angular velocity from the time-based functions fit to the pointing angles This method com...
double DPolynomial(const int coeffIndex)
Evaluate the derivative of the fit polynomial defined by the given coefficients with respect to the c...
void ComputeBaseTime()
Compute the base time using cached times.
void SetPolynomialDegree(int degree)
Set the degree of the polynomials to be fit to the three camera angles for the time period covered by...
void MinimizeCache(DownsizeStatus status)
Set the downsize status to minimize cache.
void SetAngles(std::vector< double > angles, int axis3, int axis2, int axis1)
Set the rotation angles (phi, delta, and w) for the current time to define the time-based matrix CJ.
bool HasAngularVelocity()
Checks whether the rotation has angular velocities.
double p_et
Current ephemeris time.
std::vector< double > m_pmNutPrec
Coefficients of prime meridian nut/prec terms.
std::vector< Angle > m_raPole
Coefficients of a quadratic polynomial fitting pole ra.
std::vector< int > p_timeFrames
Chain of Naif frame codes in time-based rotation CJ.
void DCJdt(std::vector< double > &dRJ)
Compute the derivative of the 3x3 rotation matrix CJ with respect to time.
void SetTimeBias(double timeBias)
Apply a time bias when invoking SetEphemerisTime method.
bool p_matrixSet
Flag indicating p_TJ has been set.
std::vector< int > ConstantFrameChain()
Accessor method to get the frame chain for the constant part of the rotation (ends in target)
std::vector< double > p_TC
Rotation matrix from first constant rotation (after all time-based rotations in frame chain from J200...
void FrameTrace(double et)
Compute frame trace chain from target frame to J2000.
int p_axis2
Axis of rotation for angle 2 of rotation.
std::vector< Angle > m_sysNutPrec0
Constants of planetary system nut/prec periods.
std::vector< double > & ConstantMatrix()
Return the constant 3x3 rotation TC matrix as a vector of length 9.
void getPckPolynomial(std::vector< Angle > &raCoeff, std::vector< Angle > &decCoeff, std::vector< Angle > &pmCoeff)
Return the coefficients of a polynomial fit to each of the three planet angles.
double p_timeBias
iTime bias when reading kernels
std::vector< double > pmNutPrecCoefs()
Return the coefficients used to calculate the target body pm nut/prec coefficients.
FrameType
Enumeration for the frame type of the rotation.
@ INERTL
See Naif Frames.req document for.
@ NOTJ2000PCK
PCK frame not referenced to J2000.
@ UNKNOWN
Isis specific code for unknown frame type.
@ BPC
Isis specific code for binary pck.
bool IsCached() const
Checks if the cache is empty.
FrameType m_frameType
The type of rotation frame.
std::vector< double > poleDecNutPrecCoefs()
Return the coefficients used to calculate the target body pole dec nut/prec coefficients.
std::vector< Angle > pmCoefs()
Return the coefficients used to calculate the target body prime meridian.
std::vector< Angle > m_sysNutPrec1
Linear terms of planetary system nut/prec periods.
std::vector< int > p_constantFrames
Chain of Naif frame codes in constant rotation TC.
virtual ~SpiceRotation()
Destructor for SpiceRotation object.
Quaternion p_quaternion
Quaternion for J2000 to reference rotation at et.
void usePckPolynomial()
Set the coefficients of a polynomial fit to each of the three planet angles for the time period cover...
std::vector< double > TimeBasedRotation()
Return time-based 3x3 rotation CJ matrix as a quaternion.
Class for storing Table blobs information.
Definition Table.h:61
This is free and unencumbered software released into the public domain.
Definition Apollo.h:16