Kernels.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "Kernels.h"
 
#include <string>
#include <vector>
#include <numeric>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <sstream>
 
#include <QVector>
 
#include <SpiceUsr.h>
 
#include "FileName.h"
#include "IException.h"
#include "NaifStatus.h"
#include "PvlKeyword.h"
#include "Pvl.h"
#include "spiceql.h"
 
using namespace std;
 
namespace Isis {

  Kernels::Kernels() {
    _kernels.clear();
    _camVersion = -1;
  }
 

  Kernels::Kernels(const Kernels &kernels) {
    _kernels = kernels._kernels;
    _camVersion = kernels._camVersion;
    UpdateLoadStatus();
    UpdateManagedStatus();
  }

  Kernels &Kernels::operator=(const Kernels &kernels) {
    if (this != &kernels) {
      Clear();
      _kernels = kernels._kernels;
      _camVersion = kernels._camVersion;
      UpdateLoadStatus();
      UpdateManagedStatus();
    }
    return (*this);
  }

  Kernels::Kernels(const QString &filename) {
    Pvl pvl(filename);
    Init(pvl);
  }

  Kernels::Kernels(Cube &cube) {
    Init(*cube.label());
  }

  Kernels::Kernels(Pvl &pvl) {
    Init(pvl);
  }

  int Kernels::Missing() const {
    int nMissing(0);
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      if (!_kernels[i].exists) nMissing++;
    }
    return (nMissing);
  }

  void Kernels::Init(Pvl &pvl) {
    UnLoad();
    _kernels.clear();
    addKernels(findKernels(pvl, "TargetPosition"));
    addKernels(findKernels(pvl, "InstrumentPosition"));
    addKernels(findKernels(pvl, "InstrumentPointing"));
    addKernels(findKernels(pvl, "Frame"));
    addKernels(findKernels(pvl, "TargetAttitudeShape"));
    addKernels(findKernels(pvl, "Instrument"));
    addKernels(findKernels(pvl, "InstrumentAddendum"));
    addKernels(findKernels(pvl, "LeapSecond"));
    addKernels(findKernels(pvl, "SpacecraftClock"));
    addKernels(findKernels(pvl, "ShapeModel"));
    addKernels(findKernels(pvl, "Extra"));
    _camVersion = getCameraVersion(pvl);
    return;
  }

  bool Kernels::Add(const QString &kfile) {
    if (!findByName(kfile)) {
      _kernels.push_back(examine(kfile, true));
      return (true);
    }
    return (false);
  }

  void Kernels::Clear() {
    _kernels.clear();
  }

  int Kernels::Discover() {
    _kernels.clear();
    SpiceInt count;
    NaifStatus::CheckErrors();
    ktotal_c("ALL", &count);
    int nfound(0);
    for (int i = 0 ; i < count ; i++) {
      SpiceChar file[128];
      SpiceChar ktype[32];
      SpiceChar source[128];
      SpiceInt  handle;
      SpiceBoolean found;
      kdata_c(i, "ALL", sizeof(file), sizeof(ktype), sizeof(source),
              file, ktype,source, &handle, &found);
      if (found == SPICETRUE) {
        _kernels.push_back(examine(file, false));
        nfound++;
      }
    }
    NaifStatus::CheckErrors();
    return (nfound);
  }
 

  void Kernels::Manage() {
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      _kernels[i].managed = true;
    }
    return;
  }
 

  void Kernels::UnManage() {
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      _kernels[i].managed = false;
    }
    return;
  }

  bool Kernels::IsManaged() const {
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      if (!_kernels[i].managed) return (false);;
    }
    return (true);
  }
 

  void Kernels::InitializeNaifKernelPool() {
    NaifStatus::CheckErrors();
    kclear_c();
    NaifStatus::CheckErrors();
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      _kernels[i].loaded = false;
    }
    return;
  }
 

  int Kernels::Load(const QString &ktypes) {
    //  If no types specified, return them all
    int nLoaded(0);
    if (ktypes.isEmpty()) {
      for (unsigned int k = 0 ; k < _kernels.size() ; k++) {
        if (Load(_kernels[k])) { nLoaded++; }
      }
    }
    else {
      // Find types and return requested types
      QStringList tlist = getTypes(ktypes);
      for (int t = 0 ; t < tlist.size() ; t++) {
        for (unsigned int k = 0; k < _kernels.size() ; k++) {
          if (_kernels[k].ktype == tlist[t]) {
            if (Load(_kernels[k])) { nLoaded++; }
          }
        }
      }
    }
    return (nLoaded);
  }
 

  int Kernels::Load() {
    //  If not types specified, return them all
    int nLoaded(0);
    for (unsigned int k = 0 ; k < _kernels.size() ; k++) {
      if (Load(_kernels[k])) { nLoaded++; }
    }
    return (nLoaded);
  }
 

  int Kernels::UnLoad() {
    int nUnloaded(0);
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      if (UnLoad(_kernels[i])) nUnloaded++;
    }
    return (nUnloaded);
  }

  int Kernels::UnLoad(const QString &ktypes) {
    //  If not types specified, return them all
    int nUnloaded(0);
    if (ktypes.isEmpty()) {
      nUnloaded = UnLoad();
    }
    else {
      // Find types and return requested types
      QStringList tlist = getTypes(ktypes);
      for (int t = 0 ; t < tlist.size() ; t++) {
        for (unsigned int k = 0; k < _kernels.size() ; k++) {
          if (_kernels[k].ktype == tlist[t]) {
            if (UnLoad(_kernels[k])) nUnloaded++;
          }
        }
      }
    }
    return (nUnloaded);
  }

  int Kernels::UpdateLoadStatus() {
    int nchanged(0);
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      // Use NAIF to determine if it is loaded
      if (IsNaifType(_kernels[i].ktype)) {
        SpiceChar ktype[32];
        SpiceChar source[128];
        SpiceInt  handle;
        SpiceBoolean found;
 
        NaifStatus::CheckErrors();
        kinfo_c(_kernels[i].fullpath.toLatin1().data(), sizeof(ktype), sizeof(source),
                 ktype,source, &handle, &found);
        NaifStatus::CheckErrors();
 
        if (found == SPICETRUE) {
          if (!_kernels[i].loaded) nchanged++;
          _kernels[i].loaded = true;
        }
        else {
          if (_kernels[i].loaded)  nchanged++;
          _kernels[i].loaded = false;
        }
      }
    }
 
    return (nchanged);
  }

  int Kernels::UpdateManagedStatus() {
    int nchanged(0);
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      if (_kernels[i].loaded) {
        _kernels[i].managed = false;
        nchanged++;
      }
      else {
        _kernels[i].managed = true;
      }
    }
    return (nchanged);
  }

  int Kernels::Merge(const Kernels &other) {
    int nAdded(0);
    for (unsigned int i = 0 ; i < other._kernels.size() ; i++) {
      KernelFile *kernel = findByName(other._kernels[i].fullpath);
      if (kernel == 0) {
        KernelFile kfile = other._kernels[i];
        kfile.managed = false;
        _kernels.push_back(kfile);
        nAdded++;
      }
      else {
        if (other._kernels[i].loaded) {
          kernel->loaded = true;
          kernel->managed = false;
        }
      }
    }
    return (nAdded);
  }
 

  QStringList Kernels::getKernelTypes() const {
    TypeList kmap = categorizeByType();
    QStringList types;
    for (int i = 0 ; i < kmap.size() ; i++) {
      types.append(kmap.key(i));
    }
    return (types);
  }
 

  QStringList Kernels::getKernelList(const QString &ktypes) const {
 
    //  If not types specified, return them all
    QStringList flist;
    if (ktypes.isEmpty()) {
      for (unsigned int k = 0; k < _kernels.size() ; k++) {
        flist.push_back(_kernels[k].pathname);
      }
    }
    else {
      // Find types and return requested types
      QStringList tlist = getTypes(ktypes);
      for (int t = 0 ; t < tlist.size() ; t++) {
        for (unsigned int k = 0; k < _kernels.size() ; k++) {
          if (_kernels[k].ktype == tlist[t]) {
            flist.push_back(_kernels[k].pathname);
          }
        }
      }
    }
    return (flist);
  }
 

  QStringList Kernels::getLoadedList(const QString &ktypes)
                                                 const {
    QStringList flist;
    if (ktypes.isEmpty()) {
      for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
        if (_kernels[i].loaded) flist.push_back(_kernels[i].pathname);
      }
    }
    else {
      QStringList tlist = getTypes(ktypes);
      for (int t = 0 ; t < tlist.size() ; t++ ) {
        for (unsigned int k = 0; k < _kernels.size() ; k++) {
          if (_kernels[k].ktype == tlist[t]) {
            flist.push_back(_kernels[k].pathname);
          }
        }
      }
    }
    return (flist);
  }
 

  QStringList Kernels::getMissingList() const {
    QStringList flist;
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      if (!_kernels[i].exists) flist.push_back(_kernels[i].pathname);
    }
    return (flist);
  }

  bool Kernels::Load(Kernels::KernelFile &kfile) {
    if (IsNaifType(kfile.ktype)) {
      if (!kfile.loaded) {
        NaifStatus::CheckErrors();
        try {
          SpiceQL::load(kfile.fullpath.toLatin1().data());
          NaifStatus::CheckErrors();
          kfile.loaded = true;
          kfile.managed = true;
        }
        catch (IException &ie) {
          return (false);
        }
      }
    }
    return (kfile.loaded);
  }

  bool Kernels::UnLoad(KernelFile &kfile) {
    //  If its loaded assume its a loaded NAIF kernel and unload it
    bool wasLoaded(false);
    if (kfile.loaded) {
      if (kfile.managed) {
         NaifStatus::CheckErrors();
         try {
           unload_c(kfile.fullpath.toLatin1().data());
           NaifStatus::CheckErrors();
         }
         catch (IException &) {
           // Errors are trapped and ignored.  It may be unloaded by other source
         }
         kfile.loaded = false;
         wasLoaded = true;
      }
    }
    return (wasLoaded);
  }

  QStringList Kernels::getTypes(const QString &ktypes) const {
   // Find types and return requested types
    QStringList tlist = ktypes.split(",");
    for (int k = 0 ; k < tlist.size() ; k++) {
      tlist[k] = IString(tlist[k]).Trim(" \r\n\t\v\b\f").UpCase().ToQt();
    }
    return (tlist);
  }

  void Kernels::addKernels(const KernelList &klist) {
    copy(klist.begin(), klist.end(), back_inserter(_kernels));
    return;
  }
 

  Kernels::KernelList Kernels::findKernels(Pvl &pvl,
                                           const QString &kname,
                                           const bool &manage) {
    KernelList klist;
    // Get the kernel group and load main kernels
    PvlGroup &kernels = pvl.findGroup("Kernels",Pvl::Traverse);
    // Check for the keyword
    if (kernels.hasKeyword(kname)) {
      PvlKeyword &kkey = kernels[kname];
      for (int i = 0 ; i < kkey.size() ; i++) {
        if (!kkey.isNull(i)) {
          if (kkey[i].toLower() != "table") {
            klist.push_back(examine(kkey[i], manage));
          }
        }
      }
    }
 
    return (klist);
  }
 

  Kernels::KernelFile *Kernels::findByName(const QString &kfile)  {
    KernelList::iterator klist;
    for (klist = _kernels.begin() ; klist != _kernels.end() ; ++klist) {
      if (klist->pathname == kfile) { return (&(*klist)); }
      if (klist->name     == kfile) { return (&(*klist)); }
      if (klist->fullpath == kfile) { return (&(*klist)); }
    }
    return (0);
  }
 

  Kernels::TypeList Kernels::categorizeByType() const {
    TypeList ktypes;
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      KernelFile *kfile = const_cast<KernelFile *> (&_kernels[i]);
      if (ktypes.exists(_kernels[i].ktype)) {
        ktypes.get(_kernels[i].ktype).push_back(kfile);
      }
      else {
        ktypes.add(_kernels[i].ktype, KernelFileList(1, kfile));
      }
    }
    return (ktypes);
  }
 

  bool Kernels::IsNaifType(const QString &ktype) const {
    if (ktype.toUpper() == "UNKNOWN") return (false);
    if (ktype.toUpper() == "DEM") return (false);
    return (true);
  }

  Kernels::KernelFile Kernels::examine(const QString &kfile,
                                       const bool &manage) const {
 
    FileName kernfile(kfile);
    KernelFile kf;
    kf.pathname = kfile;
    kf.name = kernfile.name();
    kf.fullpath = kernfile.expanded();
    kf.exists = kernfile.fileExists();
    kf.ktype = "UNKNOWN";
    kf.loaded = false;     // Assumes its not loaded
    kf.managed = manage;
 
    // Determine type and load info
    if (kf.exists) {
      kf.ktype = resolveType(kf.fullpath);
 
      // Use NAIF to determine if it is loaded
      if (IsNaifType(kf.ktype)) {
        SpiceChar ktype[32];
        SpiceChar source[128];
        SpiceInt  handle;
        SpiceBoolean found;
 
        NaifStatus::CheckErrors();
        kinfo_c(kf.fullpath.toLatin1().data(), sizeof(ktype), sizeof(source), ktype,
                source, &handle, &found);
        NaifStatus::CheckErrors();
 
        if (found == SPICETRUE) {
          kf.loaded = true;
          kf.managed = false;
          kf.ktype = IString(ktype).UpCase().ToQt();
        }
      }
    }
 
    return (kf);
  }

  QString Kernels::resolveType(const QString &kfile) const {
    FileName kernFile(kfile);
    QString kpath = kernFile.expanded();
    ifstream ifile(kpath.toLatin1().data(), ios::in | ios::binary);
    QString ktype("UNKNOWN");
    if (ifile) {
      char ibuf[10];
      ifile.read(ibuf, 8);
      ibuf[8] = '\0';
      for (int i = 0 ; i < 8 ; i++)
        if (ibuf[i] == '\n') ibuf[i] = '\0';
 
      // See if the file is a known NAIF type.  Assume it has been
      // extracted from a NAIF compliant kernel
      QString istr = IString(ibuf).Trim(" \n\r\f\t\v\b").ToQt();
      if (istr.contains("/")) {
        ktype = istr.split("/").last();
      }
 
      // If type is not resolved, check file extensions and special ISIS types
      if ((ktype == "UNKNOWN") || (ktype == "DAF")) {
        ktype = resolveTypeByExt(kfile, ktype);
      }
 
    }
    return (ktype);
  }

  QString Kernels::resolveTypeByExt(const QString &kfile,
                                    const QString &iktype) const {
 
    QString ktype(iktype);  // Set default condition
 
    //  Deciminate file parts
    FileName kf(kfile);
    string ext = IString(kf.extension()).DownCase();
 
    //  Check extensions for types
    if (ext == "cub") {
      ktype = "DEM";
    }
    else if (ext == "ti") {
      //  Assume its an instrument kernel but check for ISIS IAK file
      ktype = "IK";
      string base = IString(kf.baseName()).DownCase();
      string::size_type idx = base.find("addendum");
      if (idx != string::npos) {   // This is an ISIS IK addendum (IAK)
        ktype = "IAK";
      }
    }
    else if (ext == "tsc") {
      ktype = "SCLK";
    }
    else if (ext == "tf") {
      ktype = "FK";
    }
    else if (ext == "tls") {
      ktype = "LSK";
    }
    else if (ext == "tpc") {
      ktype = "PCK";
    }
    else if (ext == "bc") {
      ktype = "CK";
    }
    else if (ext == "bsp") {
      ktype = "SPK";
    }
    else if (ext == "bes") {
      ktype = "EK";
    }
    else if (ext == "bds") {
      ktype = "DSK";
    }
    else if (ext == "meta") {
      ktype = "META";
    }
    return (ktype);
  }
 
 

  int Kernels::getCameraVersion(Pvl &pvl) const {
    PvlGroup &kernels = pvl.findGroup("Kernels",Pvl::Traverse);
    int cv(0);
    // Check for the keyword
    if (kernels.hasKeyword("CameraVersion")) {
      PvlKeyword &kkey = kernels["CameraVersion"];
      cv = IString(kkey[0]).ToInteger();
    }
    return (cv);
  }
 
}  // namespace Isis