Target.cpp

Go to the documentation of this file.

#include "Target.h"

#include "Angle.h"
#include "Distance.h"
#include "EllipsoidShape.h"
#include "FileName.h"
#include "IException.h"
#include "NaifStatus.h"
#include "Pvl.h"
#include "PvlGroup.h"
#include "ShapeModelFactory.h"
#include "SpecialPixel.h"
#include "Spice.h"


using namespace std;

namespace Isis {

  // TODO: what is needed to initialize?
  Target::Target(Spice *spice, Pvl &lab) {

    // Initialize members
    init();
    m_bodyCode = new SpiceInt;
    m_systemCode = new SpiceInt;
    m_radii.resize(3, Distance());

      m_spice = spice;

    // If we get this far, we know we have a kernels group.  Spice requires it.
    PvlGroup &kernels = lab.findGroup("Kernels", Pvl::Traverse);

    PvlGroup &inst = lab.findGroup("Instrument", Pvl::Traverse);
    m_name = new QString;
    *m_name = inst["TargetName"][0];
    QString trykey = "NaifIkCode";

    m_systemName = new QString;

    if (kernels.hasKeyword("NaifFrameCode")) {
      trykey = "NaifFrameCode";
    }

    if (name().toUpper() == "SKY") {
      m_radii[0] = m_radii[1] = m_radii[2] = Distance(1000.0, Distance::Meters);
      m_sky = true;
      int ikCode = toInt(kernels[trykey][0]);
      *m_bodyCode  = ikCode / 1000;
      // Check for override in kernel group
      if (kernels.hasKeyword("NaifSpkCode")) {
        *m_bodyCode = (int) kernels["NaifSpkCode"];
      }

      *m_systemCode = -1;
      (*m_systemName).append("THE COSMOS");

    }
    else {
      *m_bodyCode = lookupNaifBodyCode(lab);
      m_sky = false;

      *m_systemCode = (*m_bodyCode/100)*100 + 99;

      SpiceChar naifBuf[40];
      SpiceBoolean found;
      bodc2n_c((SpiceInt) *m_systemCode, sizeof(naifBuf), naifBuf, &found);
      string s(naifBuf);
      (*m_systemName).append(s.c_str());

      // QString radiiKey = "BODY" + QString((BigInt) naifBodyCode()) + "_RADII";
      // m_radii[0] = Distance(getDouble(radiiKey, 0), Distance::Kilometers);
      // m_radii[1] = Distance(getDouble(radiiKey, 1), Distance::Kilometers);
      // m_radii[2] = Distance(getDouble(radiiKey, 2), Distance::Kilometers);
    }
    // Override it if it exists in the labels
    if (kernels.hasKeyword("NaifBodyCode")) {
      *m_bodyCode = (int) kernels["NaifBodyCode"];
    }
    m_shape = ShapeModelFactory::create(this, lab);
  }


  Target::Target() {
    m_bodyCode = NULL;
    m_systemCode = NULL;
    m_name = NULL;
    m_systemName = NULL;
    m_spice = NULL;
    init();
  }


  void Target::init() {
    m_shape = NULL;
    m_originalShape = NULL;
    m_sky = false;
  }


  Target::~Target() {
    NaifStatus::CheckErrors();

    delete m_bodyCode;
    m_bodyCode = NULL;

    delete m_systemCode;
    m_systemCode = NULL;

    delete m_name;
    m_name = NULL;

    delete m_systemName;
    m_systemName = NULL;

    if (m_radii.size() != 0) {
      m_radii.clear();
    }

    delete m_originalShape;
    m_originalShape = NULL;

    delete m_shape;
    m_shape = NULL;
  }


  bool Target::isSky() const {
    return m_sky;
  }


  SpiceInt Target::lookupNaifBodyCode(Pvl &lab) const {
    SpiceInt code;
    try {
      code = lookupNaifBodyCode(*m_name);
      return code;
    }
    catch (IException &e) {
      try {
        // Get body code from Isis Naif object if it exists or Naif data pool
        if (m_spice) {
          code = m_spice->getInteger("BODY_CODE", 0);
          return code;
        }
        // getInteger automatically calls Spice::readValue which looks in the NaifKeywords
        else if (lab.hasObject("NaifKeywords") 
                 && lab.findObject("NaifKeywords").hasKeyword("BODY_CODE") ) {
          code = int(lab.findObject("NaifKeywords").findKeyword("BODY_CODE"));
          return code;
        }
        else {
          throw IException(e, 
                           IException::Unknown, 
                           "BODY_CODE not found for this Target.", 
                           _FILEINFO_);
        }
      }
      catch (IException &e2) {
        e.append(e2);
        throw IException(e, 
                         IException::Unknown, 
                         "Unable to look up NAIF body code for this Target.", 
                           _FILEINFO_);
      }
    }
  }


  SpiceInt Target::lookupNaifBodyCode(QString name) {

    NaifStatus::CheckErrors();
    SpiceInt code;
    SpiceBoolean found;
    bodn2c_c(name.toLatin1().data(), &code, &found);
    if (!found) {
      QString msg = "Could not convert Target [" + name +
                   "] to NAIF body code";
      throw IException(IException::Io, msg, _FILEINFO_);
    }
    NaifStatus::CheckErrors();
    return  code;

  }


  PvlGroup Target::radiiGroup(Pvl &cubeLab, const PvlGroup &mapGroup) {
    PvlGroup mapping = mapGroup;

    // Check to see if the mapGroup already has the target radii.
    // If BOTH radii are already in the mapGroup then just return the given
    // mapping group as is.
    if (mapping.hasKeyword("EquatorialRadius") 
        && mapping.hasKeyword("PolarRadius")) {
      return mapping;
    }
 
    // If radii values are not in the given mapping group, we will get the target from the mapping
    // group or cube label and attempt to use NAIF routines to find the radii.
    QString target = "";
    try {
      if (mapping.hasKeyword("TargetName")) {
        target = mapping["TargetName"][0];
      }

      // if target name not found in mapping group or value was empty string, try instrument group
      if (target.isEmpty()) {
        bool hasInstrumentGroup = cubeLab.findObject("IsisCube").hasGroup("Instrument");
        if (hasInstrumentGroup) {
          PvlGroup inst = cubeLab.findGroup("Instrument", Pvl::Traverse);
          if (inst.hasKeyword("TargetName")) {
            target = inst["TargetName"][0];
            mapping.addKeyword( PvlKeyword("TargetName", target), PvlContainer::Replace );
          }
        }
      }

      // target name still not found, throw error
      if (target.isEmpty()) {
        throw IException(IException::Unknown, 
                         "Unable to find a TargetName keyword in the given PVL.",
                         _FILEINFO_);
      }

      // first, attempt to use cached values or run NAIF routine on the target name to get the
      // radii values. if this fails, the exception will be caught and we will try to find
      // radii in the NaifKeywords object of the labels
      PvlGroup radii = Target::radiiGroup(target);

      // Successfully found radii using target name. 
      // Copy the EquatorialRadius and PolorRadius and we are done.
      mapping.addKeyword( radii.findKeyword("EquatorialRadius"), PvlContainer::Replace );
      mapping.addKeyword( radii.findKeyword("PolarRadius"),      PvlContainer::Replace );
      return mapping;
    }
    catch (IException &e) {
      // If all previous attempts fail, look for the radii using the body frame
      // code in the NaifKeywords object.
      // Note: We will only look in the given label for the values after SPICELIB 
      // routines have failed, to preserve backwards compatibility (since this
      // label check is new).
      if (cubeLab.hasObject("NaifKeywords")) {

        PvlObject naifKeywords = cubeLab.findObject("NaifKeywords");
        
        // Try using the target bodycode_RADII keyword in the NaifKeywords PVL object
        
        try {
          
          SpiceInt bodyCode = 0;
          try {
            // Try using the target bodycode_RADII keyword in the NaifKeywords PVL object
            bodyCode = lookupNaifBodyCode(target);
          }
          catch (IException &e2) {
            throw IException(e, IException::Unknown, e2.what(), _FILEINFO_);
          }
          QString radiiKeyword = "BODY" + toString(int(bodyCode)) + "_RADII";

          if (naifKeywords.hasKeyword(radiiKeyword)) {
            PvlKeyword radii =  naifKeywords.findKeyword(radiiKeyword);
            mapping.addKeyword( PvlKeyword("EquatorialRadius",
                                           toString(toDouble(radii[0]) * 1000.0), "meters"),
                                PvlContainer::Replace);
            mapping.addKeyword( PvlKeyword("PolarRadius",
                                           toString(toDouble(radii[2]) * 1000.0), "meters"),
                                PvlContainer::Replace);
            return mapping;
          }
        }
        catch (IException &e) {
        // Try using the value of the BODY_FRAME_CODE keyword in the NaifKeywords PVL object
          if (naifKeywords.hasKeyword("BODY_FRAME_CODE")) {

            PvlKeyword bodyFrame = naifKeywords.findKeyword("BODY_FRAME_CODE");
            QString radiiKeyword = "BODY" + bodyFrame[0] + "_RADII";

            if (naifKeywords.hasKeyword(radiiKeyword)) {
              PvlKeyword radii =  naifKeywords.findKeyword(radiiKeyword);
              mapping.addKeyword( PvlKeyword("EquatorialRadius",
                                             toString(toDouble(radii[0]) * 1000.0),
                                             "meters"),
                                  PvlContainer::Replace);
              mapping.addKeyword( PvlKeyword("PolarRadius",
                                             toString(toDouble(radii[2]) * 1000.0), 
                                             "meters"),
                                  PvlContainer::Replace);
              return mapping;
            }
          }
        }
      }

      // If we get this far, we know the cube has no NaifKeywords object and previous attempts to
      // find radii in the mapping group or using spice IDs have failed
      QString msg = "Unable to find Equatorial and Polar radii for target [" + target + "].";
      throw IException(e, IException::Unknown, msg, _FILEINFO_);
    }
  }


  PvlGroup Target::radiiGroup(QString target) {

    if (target.isEmpty()) {
      throw IException(IException::Unknown,
                       "Unable to find TargetRadii. The given TargetName is empty.",
                       _FILEINFO_);
    }

    static QMap<QString, PvlGroup> cachedResults;

    PvlGroup mapping("Mapping");
    if (cachedResults.contains(target)) {
      mapping = cachedResults[target];
    }
    else {

      SpiceInt bodyCode = 0;
      try {
        bodyCode = lookupNaifBodyCode(target);
      }
      catch (IException &e) {
        QString msg = "Unable to find target radii for given target [" 
                      + target + "].";
        throw IException(IException::Io, msg, _FILEINFO_);
      }

      PvlGroup radiiGroup = Target::radiiGroup(int(bodyCode));
      mapping += PvlKeyword("TargetName",  target);
      mapping += radiiGroup.findKeyword("EquatorialRadius");
      mapping += radiiGroup.findKeyword("PolarRadius");
      cachedResults[target] = mapping;
    }

    return mapping;
  }


  PvlGroup Target::radiiGroup(int bodyCode) {

    // Load the most recent target attitude and shape kernel for NAIF
    static bool pckLoaded = false;

    NaifStatus::CheckErrors();

    FileName kern("$base/kernels/pck/pck?????.tpc");
    kern = kern.highestVersion();
    QString kernName = kern.expanded();

    if(!pckLoaded) {
      furnsh_c(kernName.toLatin1().data());
      pckLoaded = true;
    }
    
    // Get the radii from NAIF
    SpiceInt n;
    SpiceDouble radii[3];
    bodvar_c(bodyCode, "RADII", &n, radii);
    
    try {
      NaifStatus::CheckErrors();
    }
    catch (IException &e) {
      QString msg = "Unable to find radii for target code [" + toString(bodyCode)
                    + "]. Target code was not found in furnished kernels.";
    
      throw IException(e, IException::Unknown, msg, _FILEINFO_);
    }

    PvlGroup radiiGroup;
    radiiGroup += PvlKeyword("EquatorialRadius", toString(radii[0] * 1000.0), "meters");
    radiiGroup += PvlKeyword("PolarRadius", toString(radii[2] * 1000.0), "meters");

    return radiiGroup;

  }


  SpiceInt Target::naifBodyCode() const {
    return *m_bodyCode;
  }


  SpiceInt Target::naifPlanetSystemCode() const {
    return *m_systemCode;
  }


  QString Target::name() const {
    return *m_name;
  }


  QString Target::systemName() const {
    return *m_systemName;
  }


  std::vector<Distance> Target::radii() const {
    return m_radii;
  }


  int Target::frameType() {
    return spice()->bodyRotation()->getFrameType();
  }


  std::vector<Angle> Target::poleRaCoefs() {
    return spice()->bodyRotation()->poleRaCoefs();
  }


  std::vector<Angle> Target::poleDecCoefs() {
    return spice()->bodyRotation()->poleDecCoefs();
  }


  std::vector<Angle> Target::pmCoefs() {
    return spice()->bodyRotation()->pmCoefs();
  }


  std::vector<double> Target::poleRaNutPrecCoefs() {
    return spice()->bodyRotation()->poleRaNutPrecCoefs();
  }


  std::vector<double> Target::poleDecNutPrecCoefs() {
    return spice()->bodyRotation()->poleDecNutPrecCoefs();
  }


  std::vector<double> Target::pmNutPrecCoefs() {
    return spice()->bodyRotation()->pmNutPrecCoefs();
  }


  std::vector<Angle> Target::sysNutPrecConstants() {
    return spice()->bodyRotation()->sysNutPrecConstants();
  }


  std::vector<Angle> Target::sysNutPrecCoefs() {
    return spice()->bodyRotation()->sysNutPrecCoefs();
  }


  void Target::restoreShape() {
    if (m_shape->name()  != "Ellipsoid") {
      // Nothing to do
      return;
    }
    // If we don't have a saved original shape, just stick to the current shape
    else if (m_originalShape == NULL) {
      // Nothing to do
      return;
    }
    m_shape = m_originalShape;
    m_originalShape = NULL;
  }


  void Target::setShapeEllipsoid() {
    // Save the current shape to restore later
    m_originalShape = m_shape;
    m_shape = new EllipsoidShape(this);
  }


  void Target::setRadii(std::vector<Distance> radii) {
    m_radii[0] = radii[0];
    m_radii[1] = radii[1];
    m_radii[2] = radii[2];
  }


  ShapeModel *Target::shape() const {
    return m_shape;
  }


  Spice *Target::spice() const {
    return m_spice;
  }
}