LightTimeCorrectionState.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "LightTimeCorrectionState.h"
 
#include <cfloat>
#include <iomanip>
 
#include <string>
#include <vector>
 
#include <QString>
 
#include <SpiceZdf.h>
 
#include "IException.h"
#include "IString.h"
#include "Kernels.h"
#include "Pvl.h"
#include "PvlGroup.h"
#include "NaifStatus.h"
#include "Spice.h"
 
namespace Isis {
 
  LightTimeCorrectionState::LightTimeCorrectionState() {
    setDefaultState();
  }
 
 
  LightTimeCorrectionState::LightTimeCorrectionState(int ikCode,
                                                     Spice *spice) {
    setDefaultState();
    checkObserverTargetSwap(ikCode, spice);
    checkAberrationCorrection(ikCode, spice);
    checkLightTimeToSurfaceCorrect(ikCode, spice);
  }
 
 
  bool LightTimeCorrectionState::operator==(const LightTimeCorrectionState &state) 
                                            const {
    if (getAberrationCorrection() != state.getAberrationCorrection()) {
      return (false);
    }
    if (isObserverTargetSwapped() != state.isObserverTargetSwapped()) {
      return (false);
    }
    if (isLightTimeToSurfaceCorrected() != state.isLightTimeToSurfaceCorrected()) {
      return (false);
    }
    return (true);
  }
 
  bool LightTimeCorrectionState::checkAberrationCorrection(int ikCode, 
                                                         Spice *spice) {
    try {
      QString ikernKey = "INS" + toString(ikCode) + "_LIGHTTIME_CORRECTION";
      QString abcorr = spice->getString(ikernKey);
      m_abcorr = abcorr;
      return (true);
    }
    catch (IException &ie) {
      // Keyword not found or error encountered - ignore
    }
    return (false);
  }
 
 
  void LightTimeCorrectionState::setAberrationCorrection(const QString &correction) { 
    m_abcorr = correction;
    return;
  }
 
 
  QString LightTimeCorrectionState::getAberrationCorrection() const {
    return (m_abcorr);
  }
 
 
  bool LightTimeCorrectionState::checkSpkKernelsForAberrationCorrection() {
    //  Determine loaded-only kernels.  Our search is restricted to only 
    //  kernels that are loaded and, currently, only of SPK type is of 
    //  interest.
    Kernels kernels;
    kernels.Discover();
 
    //  Init the tag to Qt QString for effective searching
    QString qtag("ID:USGS_SPK_ABCORR");
    QString abcorr("");
 
    //  Retrieve list of loaded SPKs from Kernel object
    QStringList spks = kernels.getKernelList("SPK");
    NaifStatus::CheckErrors(); 
    for ( int k = 0 ; k < spks.size() ; k++ ) {
      QString spkFile = spks[k];
      SpiceChar ktype[32];
      SpiceChar source[128];
      SpiceInt  handle;
      SpiceBoolean found;
      //  Get info on SPK kernel mainly the NAIF handle for comment parsing
      (void) kinfo_c(spkFile.toLatin1().data(), sizeof(ktype), sizeof(source), ktype,
                     source, &handle, &found);
      if (found == SPICETRUE) {
        // SPK is open so read and parse all the comments.
        SpiceChar commnt[1001];
        SpiceBoolean done(SPICEFALSE);
        SpiceInt n;
 
        // NOTE it is specially important to read all comments so this routine
        // is reentrant!  NAIF will automatically reset the pointer to the
        // first comment line when and only when the last comment line is
        // read.  This is not apparent in the NAIF documentation.
        while ( !done ) {
          dafec_c(handle, 1, sizeof(commnt), &n, commnt, &done);
          QString cmmt(commnt);
          int pos = 0;
          if ( (pos = cmmt.indexOf(qtag, pos, Qt::CaseInsensitive)) != -1 ) {
            //  We can put more effort into this when the need arises and
            //  we have a better handle on options.
             abcorr = "NONE";
          }
        }
        // Don't need to read any more kernel comments if we found one with
        // the tag in it.
        if ( !abcorr.isEmpty() )  break;
      }
    }
    NaifStatus::CheckErrors();
  
    // Set internal state only if it was found in the kernels, otherwise the 
    // existing state is preserved.
    if (!abcorr.isEmpty()) {  m_abcorr = abcorr; }
    return (!abcorr.isEmpty());
  }
        
  bool LightTimeCorrectionState::isLightTimeCorrected() const {
    return ("NONE" != m_abcorr);
  }
 
 
  bool LightTimeCorrectionState::checkObserverTargetSwap(int ikCode, 
                                                         Spice *spice) {
 
    try {
      QString ikernKey = "INS" + toString(ikCode) + "_SWAP_OBSERVER_TARGET";
      QString value = spice->getString(ikernKey).toUpper();
      m_swapObserverTarget = ("TRUE" == value);
    }
    catch (IException &ie) {
      // Not there is a false condition
      m_swapObserverTarget = false;
    }
 
    return (m_swapObserverTarget);
  }
 
 
  bool LightTimeCorrectionState::isObserverTargetSwapped() const {
    return (m_swapObserverTarget);
  }
 
  void LightTimeCorrectionState::setSwapObserverTarget() {
      m_swapObserverTarget = true;
  }
 
  void LightTimeCorrectionState::setNoSwapObserverTarget() { 
    m_swapObserverTarget = false;
  }
 
 
  bool LightTimeCorrectionState::checkLightTimeToSurfaceCorrect(int ikCode, 
                                                                Spice *spice) {
 
    try {
      QString ikernKey = "INS" + toString(ikCode) + "_LT_SURFACE_CORRECT";
      QString value = spice->getString(ikernKey).toUpper();
      m_sc_to_surf_ltcorr = ("TRUE" == value);
    }
    catch (IException &ie) {
      // Not there is a false condition
      m_sc_to_surf_ltcorr = false;
    }
    
    return (m_sc_to_surf_ltcorr);
  }
 
  bool LightTimeCorrectionState::isLightTimeToSurfaceCorrected() const {
    return (m_sc_to_surf_ltcorr);
  }
 
  void LightTimeCorrectionState::setCorrectLightTimeToSurface()  {
      m_sc_to_surf_ltcorr = true;
  }
 
  void LightTimeCorrectionState::setNoCorrectLightTimeToSurface() {
      m_sc_to_surf_ltcorr = false;
  }
 
 
  void LightTimeCorrectionState::setDefaultState() {
    m_abcorr = "LT+S";
    m_swapObserverTarget = false;
    m_sc_to_surf_ltcorr = false;
    return;  
  }
 
 
}  // namespace Isis