Isis 3.0 Object Programmers' Reference

Home

---

Kernels.cpp

Go to the documentation of this file.

#include <string>
#include <vector>
#include <numeric>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <sstream>

#include "Kernels.h"
#include "Filename.h"
#include "PvlKeyword.h"
#include "Pvl.h"
#include "iException.h"
#include "naif/SpiceUsr.h"
#include "NaifStatus.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 std::string &filename) {
    Pvl pvl(filename);
    Init(pvl);
  } 

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

  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 std::string &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;
    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++;
      }
    }
    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() {
    kclear_c();
    for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
      _kernels[i].loaded = false;
    }
    return;
  }


  int Kernels::Load(const std::string &ktypes) {
    //  If no types specified, return them all
    int nLoaded(0);
    if (ktypes.empty()) { 
      for (unsigned int k = 0 ; k < _kernels.size() ; k++) {
        if (Load(_kernels[k])) { nLoaded++; }
      }
    }
    else {
      // Find types and return requested types
      vector<string> tlist = getTypes(ktypes);
      for (unsigned 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 std::string &ktypes) {
    //  If not types specified, return them all
    int nUnloaded(0);
    if (ktypes.empty()) { 
      nUnloaded = UnLoad();     
    }
    else {
      // Find types and return requested types
      vector<string> tlist = getTypes(ktypes);
      for (unsigned 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;
        kinfo_c(_kernels[i].fullpath.c_str(), sizeof(ktype), sizeof(source),
                 ktype,source, &handle, &found);
        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);
  }


  std::vector<std::string> Kernels::getKernelTypes() const {
    TypeList kmap = categorizeByType();
    std::vector<std::string> types;
    for (int i = 0 ; i < kmap.size() ; i++) {
      types.push_back(kmap.key(i));
    }
    return (types);
  }


  std::vector<std::string> Kernels::getKernelList(const std::string &ktypes) const { 

    //  If not types specified, return them all
    vector<string> flist;
    if (ktypes.empty()) { 
      for (unsigned int k = 0; k < _kernels.size() ; k++) {
        flist.push_back(_kernels[k].pathname);
      }
    }
    else {
      // Find types and return requested types
      vector<string> tlist = getTypes(ktypes);
      for (unsigned 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);
  }


  std::vector<std::string> Kernels::getLoadedList(const std::string &ktypes) 
                                                 const {
    std::vector<std::string> flist;
    if (ktypes.empty()) {
      for (unsigned int i = 0 ; i < _kernels.size() ; i++) {
        if (_kernels[i].loaded) flist.push_back(_kernels[i].pathname);
      }
    }
    else {
      std::vector<std::string> tlist = getTypes(ktypes);
      for (unsigned 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);
  }


  std::vector<std::string> Kernels::getMissingList() const {
    std::vector<std::string> 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 {
          furnsh_c(kfile.fullpath.c_str());
          NaifStatus::CheckErrors();
          kfile.loaded = true;
          kfile.managed = true;
        } catch (iException &ie) {
          ie.Clear();
          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.c_str());
           NaifStatus::CheckErrors();
         } catch (iException &ie) {
           // Errors are trapped and ignored.  It may be unloaded by other source
           ie.Clear();
         }
         kfile.loaded = false;
         wasLoaded = true;
      }
    }
    return (wasLoaded);
  }

  std::vector<std::string> Kernels::getTypes(const std::string &ktypes) const {
   // Find types and return requested types
    vector<string> tlist;
    iString::Split(',', ktypes, tlist);
    for (unsigned int k = 0 ; k < tlist.size() ; k++) {
      tlist[k] = iString(tlist[k]).Trim(" \r\n\t\v\b\f").UpCase();
    }
    return (tlist);
  }

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


  Kernels::KernelList Kernels::findKernels(Pvl &pvl, 
                                           const std::string &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 (!iString::Equal(kkey[i], "Table")) {
            klist.push_back(examine(kkey[i], manage));
          }
        }
      }
    }

    return (klist);
  }


  Kernels::KernelFile *Kernels::findByName(const std::string &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 std::string &ktype) const {
    if (iString::Equal(ktype, "UNKNOWN")) return (false);
    if (iString::Equal(ktype, "DEM")) return (false);
    return (true);
  }
  Kernels::KernelFile Kernels::examine(const std::string &kfile, 
                                       const bool &manage) const {

    Filename kernfile(kfile);
    KernelFile kf;
    kf.pathname = kfile;
    kf.name = kernfile.Name();
    kf.fullpath = kernfile.Expanded();
    kf.exists = kernfile.Exists();
    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;
        kinfo_c(kf.fullpath.c_str(), sizeof(ktype), sizeof(source), ktype,
                source, &handle, &found);
        if (found == SPICETRUE) {
          kf.loaded = true;
          kf.managed = false;
          kf.ktype = iString(ktype).UpCase();
        }
      }
    }

    return (kf);
  }

  std::string Kernels::resolveType(const std::string &kfile) const {
    Filename kernFile(kfile);
    string kpath = kernFile.Expanded();
    ifstream ifile(kpath.c_str(), ios::in | ios::binary);
    string 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
      string istr = iString(ibuf).Trim(" \n\r\f\t\v\b");
      if (!istr.empty()) {
        vector<string> parts;
        iString::Split('/', istr, parts);
        if (parts.size() > 1) {
          ktype = parts[parts.size()-1];
        }
      }

      // If type is not resolved, check file extensions and special ISIS types
      if ((ktype == "UNKNOWN") || (ktype == "DAF")) {
        ktype = resolveTypeByExt(kfile, ktype);
      }

    }
    return (ktype);
  }

  std::string Kernels::resolveTypeByExt(const std::string &kfile, 
                                        const std::string &iktype) const {

    string 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";
    }

    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