ClipperNacRollingShutterCamera.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "ClipperNacRollingShutterCamera.h"
 
#include <QString>
 
#include "CameraDistortionMap.h"
#include "CameraFocalPlaneMap.h"
#include "CameraGroundMap.h"
#include "CameraSkyMap.h"
#include "Cube.h"
#include "iTime.h"
#include "NaifStatus.h"
#include "Pvl.h"
#include "PvlGroup.h"
#include "RollingShutterCamera.h"
#include "RollingShutterCameraDetectorMap.h"
#include "Table.h"
#include "TableRecord.h"
 
namespace Isis {
  ClipperNacRollingShutterCamera::ClipperNacRollingShutterCamera(Cube &cube) :
    RollingShutterCamera(cube) {
 
    m_spacecraftNameLong = "Europa Clipper";
    m_spacecraftNameShort = "Clipper";
 
    m_instrumentNameLong  = "Europa Imaging System Rolling Shutter Narrow Angle Camera";
    m_instrumentNameShort = "EIS-RSNAC";
 
    NaifStatus::CheckErrors();
 
    SetFocalLength();
    SetPixelPitch();
 
    Pvl &lab = *cube.label();
    PvlGroup &inst = lab.findGroup("Instrument", Pvl::Traverse);
 
    // Set up start time and exposure duration
    QString startTime = inst["StartTime"];
    iTime etStart(startTime);
 
    // Use to calculate center time when exposure duration is available
    // double exposureDuration = ((double) inst["ExposureDuration"]);
 
    // Grab the coefficients for the polynomial that fit the jitter and the normal readout times of
    // the lines of the image
 
    // The two keywords and table below are _all_ required for remove/addJitter in the
    // RollingShutterCameraDetectorMap to work. If any are missing, just leave the below arrays
    //  unitialized, and add/removeJitter will default to 0.
 
    std::vector<double> sampleCoeffs, lineCoeffs, readoutTimes;
 
    if ( (inst.hasKeyword("JitterSampleCoefficients") && inst.hasKeyword("JitterLineCoefficients") )
        && cube.hasTable("Normalized Main Readout Line Times")) {
      PvlKeyword sampleCoefficients = inst.findKeyword("JitterSampleCoefficients");
      for (int i = 0; i < sampleCoefficients.size(); i++) {
        sampleCoeffs.push_back(sampleCoefficients[i].toDouble());
      }
 
      PvlKeyword lineCoefficients = inst.findKeyword("JitterLineCoefficients");
      for (int i = 0; i < lineCoefficients.size(); i++) {
        lineCoeffs.push_back(lineCoefficients[i].toDouble());
      }
 
      Table normalizedReadoutTimes("Normalized Main Readout Line Times", lab.fileName(), lab);
 
      for (int i = 0; i < normalizedReadoutTimes.Records(); i++) {
        TableRecord record = normalizedReadoutTimes[i];
        readoutTimes.push_back((double) record["time"]);
      }
    }
 
    // Set up camera detector map with the coefficients and readout times
    new RollingShutterCameraDetectorMap(this, readoutTimes, sampleCoeffs, lineCoeffs);
 
    // Setup focal plane map, and detector origin
    CameraFocalPlaneMap *focalMap = new CameraFocalPlaneMap(this, naifIkCode());
    focalMap->SetDetectorOrigin(2048.5, 1024.5);
 
    // Set up distortion map (use default for now)
    CameraDistortionMap *distMap = new CameraDistortionMap(this);
    distMap->SetDistortion(naifIkCode());
 
    // Set up the ground and sky map
    new CameraGroundMap(this);
    new CameraSkyMap(this);
 
    setTime(etStart.Et()); // Consider changing to center in future.
    LoadCache();
    NaifStatus::CheckErrors();
  }
 
 
  ClipperNacRollingShutterCamera::~ClipperNacRollingShutterCamera() {
  }
 
 
  int ClipperNacRollingShutterCamera::CkFrameId() const {
    return (-159000);
  }
 
 
  int ClipperNacRollingShutterCamera::CkReferenceId() const {
    return (1);
  }
 
 
  int ClipperNacRollingShutterCamera::SpkReferenceId() const {
    return (1);
  }
}
 
 
extern "C" Isis::Camera *ClipperNacRollingShutterCameraPlugin(Isis::Cube &cube) {
  return new Isis::ClipperNacRollingShutterCamera(cube);
}