PhotometricFunction.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include <SpiceUsr.h>
#include <SpiceZfc.h>
#include <SpiceZmc.h>
 
#include "Angle.h"
#include "Camera.h"
#include "DbProfile.h"
#include "PhotometricFunction.h"
#include "PvlObject.h"
 
using namespace std;
 
namespace Isis {
  PhotometricFunction::PhotometricFunction( PvlObject &pvl, Cube &cube , bool useCamera ) {
    if (useCamera) {
      m_camera = cube.camera();
    }
  }
 
 
  PhotometricFunction::~PhotometricFunction() {}
 
 
  void PhotometricFunction::setCamera(Camera *cam) {
    m_camera = cam;
  }
 
 
  QString PhotometricFunction::algorithmName( const PvlObject &pvl ) {
    return pvl.findObject("PhotometricModel").findGroup("Algorithm", Pvl::Traverse).findKeyword("Name")[0];
  }
 
 
  double PhotometricFunction::compute( const double &line, const double &sample, int band, bool useDem) {
    // Update band if necessary
    if (m_camera->Band() != band) {
       m_camera->SetBand(band);
    }
    // Return null if not able to set image
    if (!m_camera->SetImage(sample, line)) {
      return (Null);
    }
    // calculate photometric angles
    double i = m_camera->IncidenceAngle();
    double e = m_camera->EmissionAngle();
    double g = m_camera->PhaseAngle();
    bool success = true;
 
    if (useDem) {
      Angle phase, incidence, emission;
      m_camera->LocalPhotometricAngles(phase, incidence, emission, success);
 
      if (success) {
        g = phase.degrees();
        i = incidence.degrees();
        e = emission.degrees();
      }
    }
 
    if ( !success || i < minimumIncidenceAngle() || i > maximumIncidenceAngle() || e < minimumEmissionAngle() || e
                        > maximumEmissionAngle() || g < minimumPhaseAngle() || g > maximumPhaseAngle()) {
      return (Null);
    }
 
    return photometry(i, e, g, band);
  }
 
 
  void PhotometricFunction::setMinimumIncidenceAngle(double angle) {
    m_minimumIncidenceAngle = angle;
  }
 
 
  void PhotometricFunction::setMaximumIncidenceAngle(double angle) {
    m_maximumIncidenceAngle = angle;
  }
 
 
  void PhotometricFunction::setMinimumEmissionAngle(double angle) {
    m_minimumEmissionAngle = angle;
  }
 
 
  void PhotometricFunction::setMaximumEmissionAngle(double angle) {
    m_maximumEmissionAngle = angle;
  }
 
 
  void PhotometricFunction::setMinimumPhaseAngle(double angle) {
    m_minimumPhaseAngle = angle;
  }
 
 
  void PhotometricFunction::setMaximumPhaseAngle(double angle) {
    m_maximumPhaseAngle = angle;
  }
 
 
  double PhotometricFunction::minimumIncidenceAngle() {
    return m_minimumIncidenceAngle;
  }
 
 
  double PhotometricFunction::maximumIncidenceAngle() {
    return m_maximumIncidenceAngle;
  }
 
 
  double PhotometricFunction::minimumEmissionAngle() {
    return m_minimumEmissionAngle;
  }
 
 
  double PhotometricFunction::maximumEmissionAngle() {
    return m_maximumEmissionAngle;
  }
 
 
  double PhotometricFunction::minimumPhaseAngle() {
    return m_minimumPhaseAngle;
  }
 
 
  double PhotometricFunction::maximumPhaseAngle() {
    return m_maximumPhaseAngle;
  }
 
}