TgoCassisCamera.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "TgoCassisCamera.h"
 
#include <cmath>
 
#include <QByteArray>
#include <QString>
#include <QVariant>
 
#include "CameraDetectorMap.h"
#include "CameraFocalPlaneMap.h"
#include "CameraGroundMap.h"
#include "CameraSkyMap.h"
#include "EndianSwapper.h"
#include "IException.h"
#include "IString.h"
#include "iTime.h"
#include "NaifStatus.h"
#include "TgoCassisDistortionMap.h"
 
using namespace std;
 
namespace Isis {
  TgoCassisCamera::TgoCassisCamera(Cube &cube) : FramingCamera(cube) {
 
    m_instrumentNameLong = "Colour and Stereo Surface Imaging System";
    m_instrumentNameShort = "CaSSIS";
 
    m_spacecraftNameLong = "Trace Gas Orbiter";
    m_spacecraftNameShort = "TGO";
 
    NaifStatus::CheckErrors();
 
    // CaSSIS codes
    int cassisCode = naifIkCode();
    QString cassis = toString(cassisCode);
 
    // Get all the necessary stuff from the labels
    Pvl &lab = *cube.label();
    const PvlGroup &inst    = lab.findGroup("Instrument", Pvl::Traverse);
 
    // Set up the camera characteristics
    instrumentRotation()->SetFrame(-143420);
    SetFocalLength();
    SetPixelPitch();
 
    // Get the Start time from the labels
    // TODO: This is currently using UTC time. Once the timestamp is figured out,
    //       this will change to use SCLK. JAM 2017-02-06
    QString stime = inst["SpacecraftClockStartCount"];
    QString startT = inst["StartTime"];
    iTime et(startT);
 
    // Get summing mode
    // Summing modes are:
    //   0 = 1x1 (No summing)
    //   1 = 2x2
    //   2 = 4x4
    int sumMode = toInt(inst["SummingMode"][0]);
    int summing = sumMode * 2;
 
    //  Setup camera detector map
    CameraDetectorMap *detMap = new CameraDetectorMap(this);
    if ( summing > 0 ) {
      detMap->SetDetectorSampleSumming(summing);
      detMap->SetDetectorLineSumming(summing);
    }
 
    // Setup focal plane map
    CameraFocalPlaneMap *focalMap = new CameraFocalPlaneMap(this, cassisCode);
 
    // Get CASSIS detector boresight
    double bsSample = getDouble("INS" + cassis + "_BORESIGHT_SAMPLE");
    double bsLine = getDouble("INS" + cassis + "_BORESIGHT_LINE");
    focalMap->SetDetectorOrigin(bsSample, bsLine);
 
    // Setup distortion map
    try {
      new TgoCassisDistortionMap(this, naifIkCode());
    }
    catch (IException &e) {
      // Set NULL so that cameras destructor wont seg fault trying to delete
      SetDistortionMap(NULL, false);
      QString msg = "Unable to Create TgoCassisDistortionMap";
      throw IException(e, IException::Unknown, msg, _FILEINFO_);
    }
    // Setup the ground and sky map
    new CameraGroundMap(this);
    new CameraSkyMap(this);
 
    // Set start time to center of exposure time to ensure
    // the proper SPICE data is cached.
    double p_exposureDur = toDouble(inst["ExposureDuration"]);
    iTime p_etStart = et + ( p_exposureDur / 2.0);
 
    setTime(p_etStart);
    LoadCache();
    NaifStatus::CheckErrors();
  }
  TgoCassisCamera::TgoCassisCamera(Cube &cube) : FramingCamera(cube) {…}
 

  TgoCassisCamera::~TgoCassisCamera() {
  }
  TgoCassisCamera::~TgoCassisCamera() {…}
 

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

  int TgoCassisCamera::CkFrameId() const {
    return (-143000);
  }
  int TgoCassisCamera::CkFrameId() const  {…}
 

  int TgoCassisCamera::CkReferenceId() const {
    return (1);
  }
  int TgoCassisCamera::CkReferenceId() const  {…}
 

  int TgoCassisCamera::SpkTargetId() const {
    return (-143);
  }
  int TgoCassisCamera::SpkTargetId() const  {…}
 

  int TgoCassisCamera::SpkReferenceId() const {
    return (1);
  }
  int TgoCassisCamera::SpkReferenceId() const  {…}
 
}

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