NaifDskShape.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "NaifDskShape.h"
 
#include <numeric>
 
#include <QtGlobal>
#include <QVector>
 
#include "IException.h"
#include "Intercept.h"
#include "IString.h"
#include "Latitude.h"
#include "Longitude.h"
#include "NaifDskApi.h"
#include "NaifDskPlateModel.h"
#include "NaifStatus.h"
#include "Pvl.h"
#include "ShapeModel.h"
#include "SpecialPixel.h"
#include "Statistics.h"
#include "SurfacePoint.h"
#include "Target.h"
 
 
using namespace std;
 
namespace Isis {

  NaifDskShape::NaifDskShape() : ShapeModel(), m_intercept(NULL) {
    // defaults for ShapeModel parent class include:
    //     name = empty string
    //     surfacePoint = null sp
    //     hasIntersection = false
    //     hasNormal = false
    //     normal = (0,0,0)
    //     hasEllipsoidIntersection = false
    setName("DSK");
  }
  NaifDskShape::NaifDskShape() : ShapeModel(), m_intercept(NULL) {…}
 

  NaifDskShape::NaifDskShape(Target *target, Pvl &pvl) : ShapeModel(target),
                                       m_intercept(NULL) {
 
    // defaults for ShapeModel parent class include:
    //     name = empty string
    //     surfacePoint = null sp
    //     hasIntersection = false
    //     hasNormal = false
    //     normal = (0,0,0)
    //     hasEllipsoidIntersection = false
 
    setName("DSK");  // Really is used as type in the system at present!
 
    PvlGroup &kernels = pvl.findGroup("Kernels", Pvl::Traverse);
 
    QString dskFile;
    if (kernels.hasKeyword("ElevationModel")) {
      dskFile = (QString) kernels["ElevationModel"];
    }
    else { // if (kernels.hasKeyword("ShapeModel")) {
      dskFile = (QString) kernels["ShapeModel"];
    }
 
    // Attempt to initialize the DSK file - exception ensues if errors occur
    // error thrown if ShapeModel=Null (i.e. Ellipsoid)
    m_model = NaifDskPlateModel(dskFile);
 
  }
  NaifDskShape::NaifDskShape(Target *target, Pvl &pvl) : ShapeModel(target), {…}
 

  NaifDskShape::NaifDskShape(const NaifDskPlateModel &model) :
                                       m_model(model), m_intercept(NULL) {
 
    // TODO create valid Target
    // Using this constructor, ellipsoidNormal(),
    // calculateSurfaceNormal(), and setLocalNormalFromIntercept()
    // methods can not be called
  }
  NaifDskShape::NaifDskShape(const NaifDskPlateModel &model) : {…}
 

  NaifDskShape::~NaifDskShape() { }
 

  bool NaifDskShape::intersectSurface(std::vector<double> observerPos,
                                           std::vector<double> lookDirection) {
    NaifVertex obs(3, &observerPos[0]);
    NaifVector raydir(3, &lookDirection[0]);
    m_intercept.reset(m_model.intercept(obs, raydir));
 
    bool success = !m_intercept.isNull();
    if (success) {
      SurfacePoint point = m_intercept->location();
      setSurfacePoint(point); // sets ShapeModel::m_hasIntersection=t, ShapeModel::m_hasNormal=f
    }
    return ( success );
  }
  bool NaifDskShape::intersectSurface(std::vector<double> observerPos, {…}
 

  bool NaifDskShape::intersectSurface(const SurfacePoint &surfpt,
                                    const std::vector<double> &observerPos,
                                    const bool &backCheck) {
 
    std::vector<double> look(3);
    look[0] = surfpt.GetX().kilometers() - observerPos[0];
    look[1] = surfpt.GetY().kilometers() - observerPos[1];
    look[2] = surfpt.GetZ().kilometers() - observerPos[2];
 
    return intersectSurface(observerPos, look);
 
  }
  bool NaifDskShape::intersectSurface(const SurfacePoint &surfpt, {…}
 

  Distance NaifDskShape::localRadius(const Latitude &lat,
                                          const Longitude &lon) {
    QScopedPointer<SurfacePoint> pnt(m_model.point(lat, lon));
    if ( !pnt.isNull() )  return (pnt->GetLocalRadius());
    return (Distance());
  }
  Distance NaifDskShape::localRadius(const Latitude &lat, {…}
 

  void NaifDskShape::setLocalNormalFromIntercept()  {
 
    // Sanity check
    if ( !hasIntersection() ) { // hasIntersection()  <==>  !m_intercept.isNull()
      QString mess = "Intercept point does not exist - cannot provide normal vector";
      throw IException(IException::Programmer, mess, _FILEINFO_);
    }
 
    // Got it, use the existing intercept point (plate) normal
    NaifVector norm(m_intercept->normal());
    setLocalNormal(norm[0], norm[1], norm[2]); // this also takes care of setHasLocalNormal(true);
    return;
  }
  void NaifDskShape::setLocalNormalFromIntercept() {…}
 

  bool NaifDskShape::isDEM() const {
    return false;
  }
  bool NaifDskShape::isDEM() const  {…}
 

  void NaifDskShape::calculateLocalNormal(QVector<double *> neighborPoints) {
    // Sanity check
    if ( !hasIntersection() ) { // hasIntersection()  <==>  !m_intercept.isNull()
      QString mess = "Intercept point does not exist - cannot provide normal vector";
      throw IException(IException::Programmer, mess, _FILEINFO_);
    }
 
    setLocalNormalFromIntercept();
    return;
  }
  void NaifDskShape::calculateLocalNormal(QVector<double *> neighborPoints) {…}
 

  void NaifDskShape::calculateDefaultNormal() {
    // ShapeModel (parent class) throws error if no intersection
     calculateSurfaceNormal();
  }
  void NaifDskShape::calculateDefaultNormal() {…}
 

  void NaifDskShape::calculateSurfaceNormal() {
    // ShapeModel (parent class) throws error if no intersection
    QVector<double> norm = ellipsoidNormal(); 
    setNormal(std::vector<double>(norm.begin(), norm.end()));// this takes care of setHasNormal(true);
    return;
  }
  void NaifDskShape::calculateSurfaceNormal() {…}
 

  QVector<double> NaifDskShape::ellipsoidNormal()  {
 
    // Sanity check on state
    if ( !hasIntersection() ) {
       QString msg = "An intersection must be defined before computing the surface normal.";
       throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    if ( !surfaceIntersection()->Valid() ) {
       QString msg = "The surface point intersection must be valid to compute the surface normal.";
       throw IException(IException::Programmer, msg, _FILEINFO_);
    }
    if (!hasValidTarget()) {
       QString msg = "A valid target must be defined before computing the surface normal.";
       throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    // Get the coordinates of the current surface point
    SpiceDouble pB[3];
    surfaceIntersection()->ToNaifArray(pB);
 
    // Get the body radii and compute the true normal of the ellipsoid
    QVector<double> norm(3);
    // need a case for target == NULL
    std::vector<Distance> stdRadii = targetRadii();
    QVector<Distance> radii = QVector<Distance>(stdRadii.begin(), stdRadii.end());
    NaifStatus::CheckErrors();
    surfnm_c(radii[0].kilometers(), radii[1].kilometers(), radii[2].kilometers(),
             pB, &norm[0]);
    NaifStatus::CheckErrors();
 
    return (norm);
  }
  QVector<double> NaifDskShape::ellipsoidNormal() {…}
 

  const NaifDskPlateModel &NaifDskShape::model() const {
    return (m_model);
  }
  const NaifDskPlateModel &NaifDskShape::model() const  {…}
 

  const Intercept *NaifDskShape::intercept() const {
    return ( m_intercept.data() );
  }
  const Intercept *NaifDskShape::intercept() const  {…}
 
}; // namespace Isis