OsirisRexOcamsCamera.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "OsirisRexOcamsCamera.h"
 
#include <QDebug>
#include <QString>
 
#include "CameraDetectorMap.h"
#include "CameraFocalPlaneMap.h"
#include "CameraGroundMap.h"
#include "CameraSkyMap.h"
#include "IrregularBodyCameraGroundMap.h"
#include "IString.h"
#include "iTime.h"
#include "NaifStatus.h"
#include "OsirisRexDistortionMap.h"
#include "OsirisRexOcamsOpenCVDistortionMap.h"
 
using namespace std;
 
namespace Isis {

  OsirisRexOcamsCamera::OsirisRexOcamsCamera(Cube &cube) : FramingCamera(cube) {
 
    NaifStatus::CheckErrors();
 
    m_spacecraftNameLong = "OSIRIS-REx";
    m_spacecraftNameShort = "OSIRIS-REx";
 
    // The general IK code will be used to retrieve the transx,
    // transy, transs and transl from the iak. The focus position specific
    // IK code will be used to find pixel pitch and ccd center in the ik.
    int frameCode = naifIkCode();
 
    if (frameCode == -64361) {
      m_instrumentNameLong = "Mapping Camera";
      m_instrumentNameShort = "MapCam";
    }
    else if (frameCode == -64362) {
      m_instrumentNameLong = "Sampling Camera";
      m_instrumentNameShort = "SamCam";
    } // IK values for polycam: -64360 (general) and -64616 to -64500 (focus specific)
    else if ((frameCode == -64360) || (frameCode >= -64616 && frameCode <= -64500)) {
      m_instrumentNameLong = "PolyMath Camera";
      m_instrumentNameShort = "PolyCam";
    }
    else {
      QString msg = "Unable to construct OSIRIS-REx camera model. "
                    "Unrecognized NaifFrameCode [" + toString(frameCode) + "].";
      throw IException(IException::User, msg, _FILEINFO_);
    }
 
    Pvl &lab = *cube.label();
    PvlGroup inst = lab.findGroup("Instrument", Pvl::Traverse);
    QString ikCode = toString(frameCode);
    int focusIkCode(frameCode);  // Default for all other than PolyCam, too
    // NOTE: This is likely to be use for MapCam's filter IDs that was added on or about
    // 2019-02-20.
    if (inst.hasKeyword("PolyCamFocusPositionNaifId")) {
      if (QString::compare("NONE", inst["PolyCamFocusPositionNaifId"], Qt::CaseInsensitive) != 0) {
        focusIkCode = toInt(inst["PolyCamFocusPositionNaifId"][0]);
      }
    }
 
    // Different distortion model for each instrument and filter
    PvlGroup bandBin = lab.findGroup("BandBin", Pvl::Traverse);
    QString filterName = bandBin["FilterName"];
 
    int distortCode = getFunctionalIkCode(frameCode, focusIkCode, filterName);
    QString dcode(toString(distortCode));
 
    QString focalLength = "INS" + dcode + "_FOCAL_LENGTH";
    SetFocalLength(getDouble(focalLength));
 
    // The instrument kernel contains pixel pitch in microns, so convert it to mm.
    QString pitch = "INS" + dcode + "_PIXEL_SIZE";
    SetPixelPitch(getDouble(pitch) / 1000.0);
 
    // Get the start time in et
    // Set the observation time and exposure duration
    QString clockCount = inst["SpacecraftClockStartCount"];
    double startTime = getClockTime(clockCount).Et();
    double exposureDuration = ((double) inst["ExposureDuration"]) / 1000.0;
    pair<iTime, iTime> shuttertimes = ShutterOpenCloseTimes(startTime, exposureDuration);
 
    // Add half exposure duration to get time at center of image
    iTime centerTime = shuttertimes.first.Et() + exposureDuration / 2.0;
 
    // Setup detector map
    new CameraDetectorMap(this);
 
    // Setup focal plane map using the general IK code for the given camera
    // Note that this is not the specific naifIkCode() value for PolyCam
    CameraFocalPlaneMap *focalMap = new CameraFocalPlaneMap(this, frameCode);
 
    // The instrument kernel contains a CCD_CENTER keyword instead of BORESIGHT_LINE
    // and BORESIGHT_SAMPLE keywords.
    focalMap->SetDetectorOrigin(
        Spice::getDouble("INS" + ikCode + "_CCD_CENTER", 0) + 1.0,
        Spice::getDouble("INS" + ikCode + "_CCD_CENTER", 1) + 1.0);
 
    // Setup distortion map
    // See what type of distortion model the IAK is configured to use
    QString dmodel;
    try {
        dmodel = getString("INS" + ikCode + "_DISTORTION_MODEL").toUpper();
    } catch (IException &ie) {
        // If not able to get the preferred model assume previous distortion
        // model parameters are available.
        dmodel = "OCAMS";
    }
    
    // Set up tangential distortion model
    if ( "OPENCV" == dmodel) {
        // Use OpenCV model
        OsirisRexOcamsOpenCVDistortionMap *dmap = new OsirisRexOcamsOpenCVDistortionMap(this, 
                                                                                        frameCode,
                                                                                        distortCode,
                                                                                        filterName);
        double camHeadTemp(0.0);
        QString camkey = m_instrumentNameShort + "eraHeadTemperature";
        if ( inst.hasKeyword(camkey) ) {
            camHeadTemp = (double) inst[camkey];
        }
        dmap->SetCameraTemperature(camHeadTemp);
    }
    else if ( "OCAMS" == dmodel ) {
        // Original model
        OsirisRexDistortionMap *distortionMap = new OsirisRexDistortionMap(this); 
        if ( !distortionMap->SetDistortion(distortCode, filterName) ) {
            distortionMap->SetDistortion(frameCode, filterName);
        }
    } 
    else {
        new CameraDistortionMap(this); 
    }
 
 
    // Setup the ground and sky map
    new IrregularBodyCameraGroundMap(this);
    new CameraSkyMap(this);
 
    setTime(centerTime);
    LoadCache();
    NaifStatus::CheckErrors();
  }
 

  OsirisRexOcamsCamera::~OsirisRexOcamsCamera() {
  }
 

  int OsirisRexOcamsCamera::CkFrameId() const {
    return -64000;
  }
 

  int OsirisRexOcamsCamera::CkReferenceId() const {
    return 1;
  }
 

  int OsirisRexOcamsCamera::SpkReferenceId() const {
    return 1;
  }
 

  pair<iTime, iTime> OsirisRexOcamsCamera::ShutterOpenCloseTimes(double time,
                                                               double exposureDuration) {
    return FramingCamera::ShutterOpenCloseTimes(time, exposureDuration);
  }

  int OsirisRexOcamsCamera::getFunctionalIkCode(const int naifIkCode, 
                                               const int polyfocusCode,
                                               const QString &filter) const {
 
    if (naifIkCode == -64361) {
      // MapCam needs to determine code based upon filter
      QString fname = filter.toUpper();
     //  if ( "PAN30" == fname ) return ( -64363 );
      if ( "PAN" == fname )   return ( -64364 );
      if ( "B" == fname )     return ( -64365 );
      if ( "V" == fname )     return ( -64366 );
      if ( "W" == fname )     return ( -64367 );
      if ( "X" == fname )     return ( -64368 );
    }
    else if (naifIkCode == -64360) {
      // IK values for polycam: -64360 (general) and -64616 to -64500 (focus specific)
      // PolyCam returns focus code
      return ( polyfocusCode );
    }     
    
    // All other conditions returns the NAIF IK code
    return ( naifIkCode ); 
  }
 
}
 

extern "C" Isis::Camera *OsirisRexOcamsCameraPlugin(Isis::Cube &cube) {
  return new Isis::OsirisRexOcamsCamera(cube);
}