CameraFocalPlaneMap.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "CameraFocalPlaneMap.h"
 
#include <cmath>
 
#include <QDebug>
#include <QVector>
 
#include "Affine.h"
#include "Camera.h"
#include "Spice.h"
 
namespace Isis {
  CameraFocalPlaneMap::CameraFocalPlaneMap(Camera *parent, const int naifIkCode) {
    Init(parent, naifIkCode);
  }
 
 
  CameraFocalPlaneMap::CameraFocalPlaneMap(const int naifIkCode) {
    Init(0, naifIkCode);
  }
 
 
  CameraFocalPlaneMap::CameraFocalPlaneMap(Camera *parent, Affine &affine) {
    p_detectorSampleOrigin = 0.0;
    p_detectorLineOrigin = 0.0;
    p_detectorSampleOffset = 0.0;
    p_detectorLineOffset = 0.0;
    p_camera = parent;
 
    p_transx[0]  = affine.Coefficients(1)[2];
    p_transx[1]  = affine.Coefficients(1)[0];
    p_transx[2]  = affine.Coefficients(1)[1];
 
    p_transy[0]  = affine.Coefficients(2)[2];
    p_transy[1]  = affine.Coefficients(2)[0];
    p_transy[2]  = affine.Coefficients(2)[1];
 
    p_itranss[0]  = affine.InverseCoefficients(1)[2];
    p_itranss[1]  = affine.InverseCoefficients(1)[0];
    p_itranss[2]  = affine.InverseCoefficients(1)[1];
 
    p_itransl[0]  = affine.InverseCoefficients(2)[2];
    p_itransl[1]  = affine.InverseCoefficients(2)[0];
    p_itransl[2]  = affine.InverseCoefficients(2)[1];
 
    if (parent != 0) {
      p_camera->SetFocalPlaneMap(this);
    }
  }
 
 
  CameraFocalPlaneMap::~CameraFocalPlaneMap(){
  }
 
 
  void CameraFocalPlaneMap::Init(Camera *parent, const int naifIkCode) {
    p_detectorSampleOrigin = 0.0;
    p_detectorLineOrigin = 0.0;
    p_detectorSampleOffset = 0.0;
    p_detectorLineOffset = 0.0;
    p_camera = parent;
 
    if (naifIkCode != 0) {
      QString xkey  = "INS" + toString(naifIkCode) + "_TRANSX";
      QString ykey  = "INS" + toString(naifIkCode) + "_TRANSY";
      QString ixkey = "INS" + toString(naifIkCode) + "_ITRANSS";
      QString iykey = "INS" + toString(naifIkCode) + "_ITRANSL";
      for (int i = 0; i < 3; ++i) {
        p_transx[i]  = parent->getDouble(xkey, i);
        p_transy[i]  = parent->getDouble(ykey, i);
        p_itranss[i] = parent->getDouble(ixkey, i);
        p_itransl[i] = parent->getDouble(iykey, i);
      }
    }
    else {
      QString xkey  = "IDEAL_TRANSX";
      QString ykey  = "IDEAL_TRANSY";
      QString ixkey = "IDEAL_TRANSS";
      QString iykey = "IDEAL_TRANSL";
      for (int i = 0; i < 3; ++i) {
        p_transx[i]  = parent->getDouble(xkey, i);
        p_transy[i]  = parent->getDouble(ykey, i);
        p_itranss[i] = parent->getDouble(ixkey, i);
        p_itransl[i] = parent->getDouble(iykey, i);
      }
    }
 
    if (parent != 0) {
      p_camera->SetFocalPlaneMap(this);
    }
  }
 
 
  bool CameraFocalPlaneMap::SetFocalPlane(const double dx, const double dy) {
    p_focalPlaneX = dx;
    p_focalPlaneY = dy;
 
    p_centeredDetectorSample = p_itranss[0] + (p_itranss[1] * dx) + (p_itranss[2] * dy);
    p_centeredDetectorLine   = p_itransl[0] + (p_itransl[1] * dx) + (p_itransl[2] * dy);
    ComputeUncentered();
    return true;
  }
 
 
  bool CameraFocalPlaneMap::SetDetector(const double sample, const double line) {
    p_detectorSample = sample;
    p_detectorLine = line;
    ComputeCentered();
    p_focalPlaneX = p_transx[0] + (p_transx[1] * p_centeredDetectorSample) + (p_transx[2] * p_centeredDetectorLine) ;
    p_focalPlaneY = p_transy[0] + (p_transy[1] * p_centeredDetectorSample) + (p_transy[2] * p_centeredDetectorLine) ;
    return true;
  }
 
 
//  CameraFocalPlaneMap::FocalPlaneXDependencyType CameraFocalPlaneMap::FocalPlaneXDependency() {
  int CameraFocalPlaneMap::FocalPlaneXDependency() {
    if (p_transx[1] > p_transx[2]) {
      return Sample;
    }
    else {
      return Line;
    }
  }
 
 
  double CameraFocalPlaneMap::SignMostSigX()  {
    double magCoef1 = fabs(p_transx[1]);
    double magCoef2 = fabs(p_transx[2]);
 
    if (magCoef1 > magCoef2) {
      return (magCoef1 / p_transx[1]);
    }
    else {
      return (magCoef2 / p_transx[2]);
    }
  }
 
 
  double CameraFocalPlaneMap::SignMostSigY()  {
    double magCoef1 = fabs(p_transy[1]);
    double magCoef2 = fabs(p_transy[2]);
 
    if (magCoef1 > magCoef2) {
      return (magCoef1 / p_transy[1]);
    }
    else {
      return (magCoef2 / p_transy[2]);
    }
  }
 
 
  double CameraFocalPlaneMap::FocalPlaneX() const {
    return p_focalPlaneX;
  }
 
 
  double CameraFocalPlaneMap::FocalPlaneY() const {
    return p_focalPlaneY;
  }
 
 
  double CameraFocalPlaneMap::DetectorSample() const {
    return p_detectorSample;
  }
 
 
  double CameraFocalPlaneMap::DetectorLine() const {
    return p_detectorLine;
  }
 
 
  double CameraFocalPlaneMap::CenteredDetectorSample() const {
    return p_centeredDetectorSample;
  }
 
 
  double CameraFocalPlaneMap::CenteredDetectorLine() const {
    return p_centeredDetectorLine;
  }
 
 
  void CameraFocalPlaneMap::SetDetectorOrigin(const double sample, const double line) {
    p_detectorSampleOrigin = sample;
    p_detectorLineOrigin = line;
  }
 
 
  double CameraFocalPlaneMap::DetectorLineOrigin() const {
    return p_detectorLineOrigin;
  }
 
 
  double CameraFocalPlaneMap::DetectorSampleOrigin() const {
    return p_detectorSampleOrigin;
  }
 
 
  void CameraFocalPlaneMap::SetDetectorOffset(const double sampleOffset,
                                const double lineOffset) {
    p_detectorSampleOffset = sampleOffset;
    p_detectorLineOffset = lineOffset;
  }
 
 
  double CameraFocalPlaneMap::DetectorLineOffset() const {
    return p_detectorLineOffset;
  }
 
 
  double CameraFocalPlaneMap::DetectorSampleOffset() const {
    return p_detectorSampleOffset;
  }
 
 
  void CameraFocalPlaneMap::SetTransL(const QVector<double> transL) {
   for (int i=0; i<3; ++i) {
     p_itransl[i] = transL[i];
   }
  }
 
 
  void CameraFocalPlaneMap::SetTransS(const QVector<double> transS) {
   for (int i=0; i<3; ++i) {
     p_itranss[i] = transS[i];
   }
  }
 
 
  void CameraFocalPlaneMap::SetTransX(const QVector<double> transX) {
   for (int i=0; i<3; ++i) {
     p_transx[i] = transX[i];
   }
  }
 
 
  void CameraFocalPlaneMap::SetTransY(const QVector<double> transY) {
   for (int i=0; i<3; ++i) {
     p_transy[i] = transY[i];
   }
  }
 
 
  const double *CameraFocalPlaneMap::TransX() const{
    return p_transx;
  }
 
 
  const double *CameraFocalPlaneMap::TransY() const{
    return p_transy;
  }
 
 
  const double *CameraFocalPlaneMap::TransS() const{
    return p_itranss;
  }
 
 
  const double *CameraFocalPlaneMap::TransL() const{
    return p_itransl;
  }
 
 
  void CameraFocalPlaneMap::ComputeCentered() {
    p_centeredDetectorSample = p_detectorSample - p_detectorSampleOrigin;
    p_centeredDetectorLine   = p_detectorLine   - p_detectorLineOrigin;
  }
 
 
  void CameraFocalPlaneMap::ComputeUncentered() {
    p_detectorSample = p_centeredDetectorSample + p_detectorSampleOrigin;
    p_detectorLine   = p_centeredDetectorLine   + p_detectorLineOrigin;
  }
 
}