JunoCamera.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "JunoCamera.h"
 
#include <QDebug>
#include <QString>
 
#include "CameraDetectorMap.h"
#include "CameraFocalPlaneMap.h"
#include "CameraGroundMap.h"
#include "CameraSkyMap.h"
#include "iTime.h"
#include "JunoDistortionMap.h"
#include "NaifStatus.h"
 
using namespace std;
 
namespace Isis {
  JunoCamera::JunoCamera(Cube &cube) : FramingCamera(cube) {
 
    m_instrumentNameLong = "Juno EPO Camera";
    m_instrumentNameShort = "JNC"; // or JunoCam?
 
    m_spacecraftNameLong = "Juno";
    m_spacecraftNameShort = "Juno";
 
    NaifStatus::CheckErrors();
 
    // Set up the camera characteristics
    instrumentRotation()->SetFrame( CkFrameId() );
    SetFocalLength();
    SetPixelPitch();
 
    // Get all the necessary stuff from the labels
    Pvl &lab = *cube.label();
    const PvlGroup &inst = lab.findGroup("Instrument", Pvl::Traverse);
 
    // Get summing mode
    // Summing modes are:
    //   1 = 1x1 (No summing)
    //   2 = 2x2
    int sumMode = (int) inst["SummingMode"];
    int summing = sumMode;
 
    //  Setup camera detector map
    CameraDetectorMap *detMap = new CameraDetectorMap(this);
    if ( summing > 0 ) {
      detMap->SetDetectorSampleSumming(summing);
      detMap->SetDetectorLineSumming(summing);
    }
 
    // Juno codes
    int junoCode = naifIkCode();
    QString juno = toString(junoCode);
 
    // Setup focal plane map and set Juno detector boresight
    new CameraFocalPlaneMap(this, junoCode);
    CameraFocalPlaneMap *focalMap = new CameraFocalPlaneMap(this, junoCode);
    double bsSample = getDouble("INS" + juno + "_BORESIGHT_SAMPLE");
    double bsLine = getDouble("INS" + juno + "_BORESIGHT_LINE");
    focalMap->SetDetectorOrigin(bsSample, bsLine);
 
    // Set starting filter location on the detector
    const PvlGroup &bandBin = lab.findGroup("BandBin", Pvl::Traverse);
    QString filterIkCode = bandBin.findKeyword("NaifIkCode")[0];
    detMap->SetStartingDetectorLine(getDouble("INS" + filterIkCode + "_FILTER_OFFSET"));
 
    // Set up distortion map, keeping z-direction positive JunoDistortion map defaults to z+
    JunoDistortionMap *distortionMap = new JunoDistortionMap(this);
    distortionMap->SetDistortion(CkFrameId());
 
    // Setup the ground and sky map
    new CameraGroundMap(this);
    new CameraSkyMap(this);
 
    // Set time based on clock count, frame number, exposure duration, and interframe delay
    QString startClockCount   = inst["SpacecraftClockStartCount"];
    double observationStartEt = getClockTime(startClockCount).Et(); // in seconds
    double frameNumber     = (double) inst["FrameNumber"];
    double interFrameDelay    = (double) inst["InterFrameDelay"];  // in seconds
    double exposureDur        = ((double) inst["ExposureDuration"]) / 1000.0; // in seconds
 
    // Get the fixed time biases
    double startTimeBias       = getDouble("INS" + juno + "_START_TIME_BIAS");
    double interFrameDelayBias = getDouble("INS" + juno + "_INTERFRAME_DELTA");
 
    // get start et for this frame, in seconds
    double frameStartEt = observationStartEt + startTimeBias + (frameNumber - 1)
                             * (interFrameDelay + interFrameDelayBias);
    // Set start time to center of exposure time to ensure the proper SPICE data is cached.
    setTime(frameStartEt + exposureDur / 2.0);
 
    LoadCache();
    NaifStatus::CheckErrors();
  }
 
 
  JunoCamera::~JunoCamera() {
  }
 
 
  pair <iTime, iTime> JunoCamera::ShutterOpenCloseTimes(double time,
                                                        double exposureDuration) {
 
    return FramingCamera::ShutterOpenCloseTimes(time, exposureDuration);
  }
 
 
  int JunoCamera::CkFrameId() const {
    return -61500;
  }
 
 
  int JunoCamera::CkReferenceId() const {
    return 1;
  }
 
 
  int JunoCamera::SpkTargetId() const {
    return -61;
  }
 
 
  int JunoCamera::SpkReferenceId() const {
    return 1;
  }
 
}
 
extern "C" Isis::Camera *JunoCameraPlugin(Isis::Cube &cube) {
  return new Isis::JunoCamera(cube);
}