PushFrameCameraDetectorMap.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "PushFrameCameraDetectorMap.h"
 
#include <QDebug>
 
#include <iomanip>
 
#include "CameraFocalPlaneMap.h"
#include "iTime.h"
 
namespace Isis {
  PushFrameCameraDetectorMap::PushFrameCameraDetectorMap(Camera *parent, const double etStart, 
                             const double frameletRate, int frameletHeight):
  CameraDetectorMap(parent) {
    p_etStart = etStart;
    p_exposureDuration = 0.0;
    p_frameletRate = frameletRate;
    p_frameletHeight = frameletHeight;
    p_frameletOffset = 0;
    p_flippedFramelets = true;
    p_timeAscendingFramelets = true;
    p_nframelets = 0;
    p_bandStartDetector = 0;
  }
 
  PushFrameCameraDetectorMap::~PushFrameCameraDetectorMap() {
  }
 
 
 
  bool PushFrameCameraDetectorMap::SetDetector(const double sample,
                                               const double line) {
    // Sometime folks want to write the framelets flipped in the EDR so
    // features match.  Take care of this.
    double unsummedFrameletLine;
    // first we need to determine the cube line number for the framelet that contains the given line
    // ??? comment this section...
    if (p_flippedFramelets) {
      unsummedFrameletLine = p_bandStartDetector + p_frameletHeight - line;
    }
    else {
      unsummedFrameletLine = line - p_bandStartDetector;
    }
 
    double unsummedFrameletSample = sample;
 
    // Convert framelet sample/line to summed framelet sample/line,
    // parent sample will be computed correctly
    if (!CameraDetectorMap::SetDetector(unsummedFrameletSample, unsummedFrameletLine)) {
      return false;
    }
 
    p_frameletSample = p_detectorSample;
    p_frameletLine = p_detectorLine;
 
    // Compute the height of a framelet taking into account the summing mode
    int actualFrameletHeight = (int)(p_frameletHeight / LineScaleFactor());
 
    p_parentLine = (p_framelet - 1) * actualFrameletHeight + p_parentLine;
 
    // Save the detector sample/line
    p_detectorSample = sample;
    p_detectorLine = line;
 
    // Didn't succeed if framelet line doesn't make sense
    if (p_frameletLine > p_frameletHeight + 0.5) {
      return false;
    }
 
    if (p_frameletLine < 0.5) {
      return false;
    }
 
    return true;
  }
 
 
  bool PushFrameCameraDetectorMap::SetParent(const double sample, const double line) {
    return SetParent(sample, line, 0.0);
  }
 
 
  bool PushFrameCameraDetectorMap::SetParent(const double sample,
                                             const double line, 
                                             const double deltaT) {
    // Compute the height of a framelet taking into account the summing mode
    int actualFrameletHeight = (int)(p_frameletHeight / LineScaleFactor());
 
    // Compute the framelet number.  We could have padded with null framelets
    // at the top of the image so take that into account.  Setting the framelet
    // changes the time for the observation. Line starts at 0.5 (top of first framelet)
    // and framelet needs to start at 1.
    int framelet             = (int)((line - 0.5) / actualFrameletHeight) + 1;
    SetFramelet(framelet, deltaT);
 
    // Convert the parent line/sample to a framelet line/sample
    p_frameletLine = line - actualFrameletHeight * (framelet - 1);
    p_frameletSample = sample;
 
    // Convert the framelet line/sample to an unsummed framelet line/sample
    if (!CameraDetectorMap::SetParent(p_frameletSample, p_frameletLine, deltaT)) return false;
    double unsummedFrameletLine = p_detectorLine;
 
    // Sometime folks want to write the framelets flipped in the EDR so
    // features match.  Take care of this. p_bandStartDetector is 0-based and
    // unsummedFrameletLine is the correct base for p_detectorLine so these calculations
    // are valid.
    if (p_flippedFramelets) {
      p_detectorLine = p_bandStartDetector + p_frameletHeight - unsummedFrameletLine;
    }
    else {
      p_detectorLine = p_bandStartDetector + unsummedFrameletLine;
    }
 
    // Save the parent line/sample
    p_parentSample = sample;
    p_parentLine = line;
 
    return true;
  }
 
 
 
  void PushFrameCameraDetectorMap::SetFramelet(int framelet, const double deltaT) {
    p_framelet = framelet;
 
    // We can add framelet padding to each band.  Compute the adjusted framelet
    // number
    int adjustedFramelet = (int) framelet - p_frameletOffset;
    double etTime = 0.0;
 
    // Use this information to compute the time of the framelet
    if (p_timeAscendingFramelets) {
      etTime = p_etStart + (adjustedFramelet - 1) * p_frameletRate;
    }
    else {
      etTime = p_etStart + (p_nframelets - adjustedFramelet) * p_frameletRate;
    }
 
    etTime += p_exposureDuration / 2.0;
    p_camera->setTime(etTime + deltaT);
  }
 
 
 
  void PushFrameCameraDetectorMap::SetStartTime(const double etStart) {
    p_etStart = etStart;
  }
 
 
 
  void PushFrameCameraDetectorMap::SetExposureDuration(double exposureDuration) {
    p_exposureDuration = exposureDuration;
  }
 
 
 
  void PushFrameCameraDetectorMap::SetFrameletRate(const double frameletRate) {
    p_frameletRate = frameletRate;
  }
 
 
 
  double PushFrameCameraDetectorMap::FrameletRate() const {
    return p_frameletRate;
  }
 
 
 
  void PushFrameCameraDetectorMap::SetFrameletOffset(int frameletOffset) {
    p_frameletOffset = frameletOffset;
  }
 
 
 
  int PushFrameCameraDetectorMap::FrameletOffset() const {
    return p_frameletOffset;
  }
 
 
  int PushFrameCameraDetectorMap::Framelet() {
    return p_framelet;
  }
 
 
 
  void PushFrameCameraDetectorMap::SetBandFirstDetectorLine(int firstLine) {
    p_bandStartDetector = firstLine;
  }
 
 
 
  int PushFrameCameraDetectorMap::GetBandFirstDetectorLine() {
    return p_bandStartDetector;
  }
 
 
 
  void PushFrameCameraDetectorMap::SetFrameletOrderReversed(bool frameletOrderReversed, int nframelets) {
    p_timeAscendingFramelets = !frameletOrderReversed;
    p_nframelets = nframelets;
  }
 
 
 
  void PushFrameCameraDetectorMap::SetFrameletsGeometricallyFlipped(bool frameletsFlipped) {
    p_flippedFramelets = frameletsFlipped;
  }
 
 
 
  double PushFrameCameraDetectorMap::StartEphemerisTime() const {
    return p_etStart;
  }
 
 
 
  int PushFrameCameraDetectorMap::TotalFramelets() const {
    return (int)(p_camera->ParentLines() / (p_frameletHeight / LineScaleFactor()));
  }
 
 
 
  double PushFrameCameraDetectorMap::frameletSample() const {
    return p_frameletSample;
  }
 
 
 
  double PushFrameCameraDetectorMap::frameletLine() const {
    return p_frameletLine;
  }
 
 
 
  int PushFrameCameraDetectorMap::frameletHeight() const {
    return p_frameletHeight;
  }
 
 
 
  bool PushFrameCameraDetectorMap::timeAscendingFramelets() {
    return p_timeAscendingFramelets;
  }
 
 
  double PushFrameCameraDetectorMap::exposureDuration(const double sample,
                                                      const double line,
                                                      const int band) const {
    if (p_exposureDuration > 0) {
      return p_exposureDuration;
    }
    return p_frameletRate;
  }
 
}