Intercept.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#include "Intercept.h"
 
#include <numeric>
#include <string>
#include <vector>
 
#include <QtGlobal>
 
#include "Angle.h"
#include "AbstractPlate.h"
#include "IException.h"
#include "IString.h"
#include "NaifDskApi.h"
#include "Latitude.h"
#include "Longitude.h"
#include "SurfacePoint.h"
 
using namespace std;
 
namespace Isis {
 
  Intercept::Intercept() : m_observer(), m_raydir(), m_point(0), m_shape(0) { }
  
  
    
  Intercept::Intercept(const NaifVertex &observer, const NaifVector &raydir,
                       SurfacePoint *ipoint, AbstractPlate *shape) :
                       m_observer(observer.copy()), m_raydir(raydir.copy()),
                       m_point(ipoint), m_shape(shape) {}
  
 
 
 
  Intercept::~Intercept() {}
 
 
 
  bool Intercept::isValid() const {
    bool valid = true;
    if ( !validate( m_observer ) ) valid = false;
    if ( !validate( m_raydir ) ) valid = false;
    if ( m_point.isNull() ) valid = false;
    if ( m_shape.isNull() ) valid = false;
    return valid;
  }
  
 
 
  const NaifVertex &Intercept::observer() const {
    return (m_observer);
  }
  
 
 
  const NaifVector &Intercept::lookDirectionRay() const {
    return (m_raydir);
  }
  
 
 
  SurfacePoint Intercept::location() const {
    verify( isValid(), "Unable to return Intercept location. Invalid/undefined Intercept point.");
    return (SurfacePoint(*m_point));
  }
  
 
 
  NaifVector Intercept::normal() const {
    verify( isValid(), "Unable to return Intercept normal. Invalid/undefined Intercept point.");
    return ( m_shape->normal() );
  }
  
 
 
 
  Angle Intercept::emission() const {
    verify( isValid(), 
            "Unable to return Intercept emission angle. Invalid/undefined Intercept point." );
  
    // Point back toward the center of the body 
    NaifVertex point(3);
    m_point->ToNaifArray(&point[0]);
  
    NaifVector raydir(3);
    vsub_c(&m_observer[0], &point[0], &raydir[0]);
  
    // Return the separation angle between them
    return (separationAngle(raydir));
  }
  
 
 
  Angle Intercept::separationAngle(const NaifVector &raydir) const {
    verify( isValid(), 
            "Unable to return Intercept separation angle. Invalid/undefined Intercept point.");
    return (m_shape->separationAngle(raydir));
  }
  
 
 
  bool Intercept::verify(const bool &test, const QString &errmsg,
                         const Intercept::ErrAction &action) const {
    if ( ( Throw == action ) && ( !test ) ) {
      throw IException(IException::Programmer, errmsg, _FILEINFO_);
    }
  
    // Looks good
    return ( test );
  }
  
 
 
  const AbstractPlate *Intercept::shape() const {
    return ( m_shape.data() );
  }
 
}
// namespace Isis