RollingShutterCameraDetectorMap.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "RollingShutterCameraDetectorMap.h"
 
#include "iTime.h"
 
#include <QtMath>
#include <utility>
#include <vector>
 
 
namespace Isis {
  RollingShutterCameraDetectorMap::RollingShutterCameraDetectorMap(
        Camera *parent,
        std::vector<double> times,
        std::vector<double> sampleCoeffs,
        std::vector<double> lineCoeffs) : CameraDetectorMap(parent) {
    m_times = times;
    m_sampleCoeffs = sampleCoeffs;
    m_lineCoeffs = lineCoeffs;
  }
 

  RollingShutterCameraDetectorMap::~RollingShutterCameraDetectorMap() {
 
  }
 

  bool RollingShutterCameraDetectorMap::SetParent(const double sample,
                                                  const double line) {
    return RollingShutterCameraDetectorMap::SetParent(sample, line, 0.0);
  }
 

  bool RollingShutterCameraDetectorMap::SetParent(const double sample,
                                                  const double line,
                                                  const double deltaT) {
    std::pair<double, double> jittered = removeJitter(sample, line);
    p_parentSample = jittered.first;
    p_parentLine = jittered.second;
    p_detectorSample = (p_parentSample - 1.0) * p_detectorSampleSumming + p_ss;
    p_detectorLine   = (p_parentLine   - 1.0) * p_detectorLineSumming + p_sl;
    if (p_camera->isTimeSet()) {
      p_camera->setTime(p_camera->time().Et() + deltaT);
    }
    return true;
  }
 

  bool RollingShutterCameraDetectorMap::SetDetector(const double sample, const double line) {
    p_detectorSample = sample;
    p_detectorLine   = line;
    p_parentSample   = (p_detectorSample - p_ss) / p_detectorSampleSumming + 1.0;
    p_parentLine     = (p_detectorLine   - p_sl) / p_detectorLineSumming   + 1.0;
    std::pair<double, double> jittered = applyJitter(p_parentSample, p_parentLine);
    p_parentSample = jittered.first;
    p_parentLine = jittered.second;
    return true;
  }
 

  std::pair<double, double> RollingShutterCameraDetectorMap::applyJitter(const double sample,
                                                                         const double line) {
    std::pair<double, double> jittered = removeJitter(sample, line);
    double currentSample = sample;
    double currentLine = line;
 
    int iterations = 0;
    int maxIterations = 50;
 
    while((qFabs(sample - jittered.first) > 1e-7) ||
          (qFabs(line - jittered.second) > 1e-7)) {
 
      currentSample = sample + (currentSample - jittered.first);
      currentLine = line + (currentLine - jittered.second);
 
      jittered = removeJitter(currentSample, currentLine);
 
      iterations++;
      if (iterations > maxIterations) {
        QString message = "Max Iterations reached.";
        throw IException(IException::Unknown, message, _FILEINFO_);
      }
 
    }
 
    return std::pair<double, double>(currentSample, currentLine);
  }

  std::pair<double, double> RollingShutterCameraDetectorMap::removeJitter(const double sample,
                                                                          const double line) {
    // De-jitter equation in form:
    //   c1(t^n) + c2(t^(n-2)) + ... + cn(t)
    double sampleDejitter = 0.0;
    double lineDejitter = 0.0;
    // Note that # sample coeffs == # line coeffs
    for (unsigned int n = 1; n <= m_lineCoeffs.size(); n++) {
      double sampleCoeff = m_sampleCoeffs[n - 1];
      double lineCoeff = m_lineCoeffs[n - 1];
      // Round to nearest line
      int timeEntry = 0;
      // Any lines that round past last time entry will use last time entry as index
      if (line > m_times.size()) {
        timeEntry = m_times.size();
      }
      else {
        timeEntry = (int)round(line);
      }
      double time = m_times[timeEntry - 1];
      int exponent = m_lineCoeffs.size() - (n - 1);
      time = pow(time, exponent);
      sampleDejitter += (sampleCoeff * time);
      lineDejitter += (lineCoeff * time);
    }
    return std::pair<double, double>(sample - sampleDejitter, line - lineDejitter);
  }
}