HiCalConf.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <iostream>
#include <numeric>
#include <sstream>
#include <vector>
 
#include <QString>
 
#include <SpiceUsr.h>
 
#include "Brick.h"
#include "Camera.h"
#include "Cube.h"
#include "FileName.h"
#include "HiCalConf.h"
#include "HiCalUtil.h"
#include "IString.h"
#include "IException.h"
#include "Preference.h"
#include "Pvl.h"
#include "spiceql.h"
#include "SpecialPixel.h"
#include "NaifStatus.h"
 
using namespace std;
 
namespace Isis {
 
bool HiCalConf::_naifLoaded = false;

  HiCalConf::HiCalConf() : DbAccess() {
    _profName.clear();
    init();
  }
 

  HiCalConf::HiCalConf(Pvl &label) : DbAccess() {
    _profName.clear();
    init(label);
  }

  HiCalConf::HiCalConf(Pvl &label, const QString &conf) :
       DbAccess(Pvl(filepath(conf)).findObject("Hical", PvlObject::Traverse)) {
    _profName.clear();
    init(label);
  }

  void HiCalConf::setLabel(Pvl &label) {
    init(label);
    return;
  }

  QString HiCalConf::filepath(const QString &fname) const {
    FileName efile(fname);
    if (efile.isVersioned()) {
      QString path(efile.originalPath());
      if (!path.isEmpty()) path += "/";
 
      efile = efile.highestVersion();
 
      return (path + efile.name());
    }
    return (fname);
  }
 

  void HiCalConf::setConf(const QString &conf) {
    load(Pvl(filepath(conf)).findObject("Hical", PvlObject::Traverse));
  }

  void HiCalConf::selectProfile(const QString &profile) {
    _profName = profile;
    return;
  }

  QString HiCalConf::getProfileName() const {
    return (_profName);
  }

  QString HiCalConf::getMatrixSource(const QString &name) const {
    return (getMatrixSource(name, getMatrixProfile()));
  }

  QString HiCalConf::getMatrixSource(const QString &name,
                                         const DbProfile &matconf) const {
 
    QString mfile = parser(matconf.value(name),
                               getList(matconf,"OptionKeywords"),
                               matconf);
 
//  Translate and return
    return (filepath(mfile));
  }
 
  HiVector HiCalConf::getMatrix(const QString &name,
                                int expected_size) const {
    return (getMatrix(name,getMatrixProfile(), expected_size));
  }
 
 
  QString HiCalConf::resolve(const QString &composite,
                                 const DbProfile &matconf) const {
    return (parser(composite,getList(matconf,"OptionKeywords"), matconf));
  }
 
 

  HiVector HiCalConf::getMatrix(const QString &name,
                                const DbProfile &profile,
                                int expected_size) const {
 
    QString mfile = getMatrixSource(name, profile);
 
// Crack the file and read the appropriate band
    Cube cube;
    cube.open(mfile);
 
//  Check for proper size if specifeid
    if (expected_size != 0) {
      if (cube.sampleCount() != expected_size) {
        ostringstream mess;
        mess << "Specifed matrix  (" << name
             << ") from file \"" << mfile
             << "\" does not have expected samples (" << expected_size
             << ") but has " << cube.sampleCount();
        cube.close();
        throw IException(IException::User, mess.str(), _FILEINFO_);
      }
    }
 
//  Read the specifed region
    Brick bandio(cube.sampleCount(), 1, 1, Real);
    bandio.SetBasePosition(1,1,getMatrixBand(profile));
    cube.read(bandio);
 
//  Now create the output buffer with some TNT funny business
    HiVector temp(cube.sampleCount(), bandio.DoubleBuffer());
    HiVector out(cube.sampleCount());
    out.inject(temp);
    cube.close();
    return (out);
  }

  HiVector HiCalConf::getScalar(const QString &name,
                                const DbProfile &profile,
                                int expected_size) const {
    int nvals = profile.count(name);
 
    //  Check for proper size if specifeid
    if (expected_size != 0) {
      if (nvals != expected_size) {
        ostringstream mess;
        mess << "Specifed scalar (" << name
             << ") does not have expected size (" << expected_size
             << ") but has " << nvals;
        throw IException(IException::User, mess.str(), _FILEINFO_);
      }
    }
//  All is OK
    HiVector mtx(nvals, Null);
    for (int i = 0  ; i < nvals ; i++) {
      mtx[i] = ToDouble(profile(name, i));
    }
    return (mtx);
  }

  double HiCalConf::sunDistanceAU(Cube *cube) {
    double sunkm = 0.0;
    try {
      Camera *cam;
      cam = cube->camera();
      cam->SetImage(0.5, 0.5);
      sunkm = cam->sunToBodyDist();
      NaifStatus::CheckErrors();
    }
    catch (IException &e) {
      try {
        QString scStartTime = getKey("SpacecraftClockStartCount", "Instrument");
        NaifStatus::CheckErrors();
        bool useWeb = QString(Preference::Preferences().findGroup("SpiceQL")["UseSpiceQL"]).toUpper() == "TRUE";
        double obsStartTime = SpiceQL::strSclkToEt(-74999, scStartTime.toLatin1().data(), "hirise", useWeb).first;
 
        QString targetName = getKey("TargetName", "Instrument");
        if (targetName.toLower() == "sky" ||
            targetName.toLower() == "cal" ||
            targetName.toLower() == "phobos" ||
            targetName.toLower() == "deimos") {
          targetName = "mars";
        }
        double sunv[3];
 
        std::vector<double> etStart = {obsStartTime};
        vector<vector<double>> sunLt = SpiceQL::getTargetStates(etStart, targetName.toLatin1().data(), "sun", "J2000", "LT+S", "hirise", {"reconstructed"}, {"reconstructed"}, useWeb).first;
        std::copy(sunLt[0].begin(), sunLt[0].begin()+3, sunv);
 
        sunkm = vnorm_c(sunv);
 
        NaifStatus::CheckErrors();
      }
      catch(IException &e) {
        QString msg = "Unable to determine the distance from the target to the sun";
        throw IException(e, IException::User, msg, _FILEINFO_);
      }
    }
 
    //  Return in AU units
    return (sunkm/1.49597870691E8);
  }
 

  int HiCalConf::getMatrixBand() const {
    Pvl label = _label;
    DbProfile parms = makeParameters(label);
    return (getMatrixBand(parms));
  }

 
  int HiCalConf::getMatrixBand(const DbProfile &p) const {
    return (getChannelIndex(ToInteger(p("CCD")), ToInteger(p("CHANNEL"))));
  }

  HiCalConf::ValueList HiCalConf::getList(const DbProfile &profile,
                                          const QString &key) const {
    ValueList slist;
 
//  Get keyword parameters
    if ( profile.exists(key) ) {
      int nvals = profile.count(key);
      for (int i = 0 ; i < nvals ; i++) {
        slist.push_back(profile.value(key, i));
      }
    }
    return (slist);
  }

void HiCalConf::init() {
  _label.clear();
  return;
}

void HiCalConf::init(Pvl &label) {
  init();
  _label = label;
  return;
}

PvlKeyword &HiCalConf::getKey(const QString &key,
                              const QString &group) {
  if (!group.isEmpty()) {
    PvlGroup &grp = _label.findGroup(group, Pvl::Traverse);
    return (grp[key]);
  }
  else {
    return (_label.findKeyword(key));
  }
}

DbProfile HiCalConf::getMatrixProfile(const QString &profile) const {
  QString myprof = (!profile.isEmpty()) ? profile : _profName;
  DbProfile matconf = getProfile(myprof);
  if (!matconf.isValid()) {
    ostringstream mess;
    mess << "Specifed matrix profile (" << matconf.Name()
         << ") does not exist or is invalid!";
    throw IException(IException::User, mess.str(), _FILEINFO_);
  }
 
  //  Profile the label and merge them.  Order is important.
  matconf = DbProfile(getLabelProfile(matconf), matconf, matconf.Name());
 
  //  Add special parameters.  Again, order is important.
  matconf = DbProfile(matconf, makeParameters(matconf), matconf.Name());
 
//  Load any optional ones
  ValueList profkeys = getList(matconf,"OptionKeywords");
  ValueList proforder = getList(matconf,"ProfileOptions");
  QString pName(matconf.Name());
  for (unsigned int i = 0 ; i < proforder.size() ; i++) {
    QString profile = parser(proforder[i], profkeys, matconf);
    if (profileExists(profile)) {
      pName += "+[" + profile + "]";
      matconf = DbProfile(matconf,getProfile(profile), pName);
    }
  }
  return (matconf);
}
 
 
DbProfile HiCalConf::getLabelProfile(const DbProfile &profile) const {
  DbProfile lblprof("Label");
  if ( profile.exists("LabelGroups") ) {
    int ngroups = profile.count("LabelGroups");
    Pvl label = _label;
    for ( int g = 0 ; g < ngroups ; g++ ) {
      QString group = profile("LabelGroups", g);
      PvlGroup grp = label.findGroup(group, Pvl::Traverse);
      lblprof = DbProfile(lblprof,DbProfile(grp));
    }
  }
  return (lblprof);
}
 
int HiCalConf::getChannelIndex(const int &ccd, const int &channel) const {
  return(1 + (ccd*2) + channel);
}
 
DbProfile HiCalConf::makeParameters(Pvl &label) const {
  PvlGroup inst = label.findGroup("Instrument", Pvl::Traverse);
  DbProfile parms("Parameters");
 
  int ccd = CpmmToCcd((int) inst["CpmmNumber"]);
  int channel = inst["ChannelNumber"];
  parms.add("CCD",ToString(ccd));
  parms.add("CHANNEL", ToString(channel));
  parms.add("TDI", inst["Tdi"]);
  parms.add("BIN", inst["Summing"]);
  parms.add("FILTER", CcdToFilter(ccd));
  parms.add("CCDCHANNELINDEX", ToString(getChannelIndex(ccd, channel)));
  return (parms);
}
 
DbProfile HiCalConf::makeParameters(const DbProfile &profile) const {
  DbProfile parms("Parameters");
  int ccd = CpmmToCcd(ToInteger(profile("CpmmNumber")));
  int channel = ToInteger(profile("ChannelNumber"));
  parms.add("CCD",ToString(ccd));
  parms.add("CHANNEL", ToString(channel));
  parms.add("TDI", profile("Tdi"));
  parms.add("BIN", profile("Summing"));
  parms.add("FILTER", CcdToFilter(ccd));
  parms.add("CCDCHANNELINDEX", ToString(getChannelIndex(ccd, channel)));
  return (parms);
}
 
QString  HiCalConf::makePattern(const QString &str) const {
  return (QString("{" + str + "}"));
}

QString HiCalConf::parser(const QString &s, const ValueList &vlist,
                          const DbProfile &prof) const {
    QString sout(s);
 
    ValueList::const_iterator ciVlist;
    for ( ciVlist = vlist.begin() ; ciVlist != vlist.end() ; ++ciVlist ) {
      QString str(*ciVlist);
      if ( prof.exists(str) ) {
        sout = sout.replace(makePattern(str), prof(str));
      }
    }
 
    return (sout);
}
 
}  // namespace Isis