EllipsoidShape.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "EllipsoidShape.h"
 
#include <QVector>
 
 
#include <SpiceUsr.h>
#include <SpiceZfc.h>
#include <SpiceZmc.h>
 
#include "Distance.h"
#include "IException.h"
#include "IString.h"
#include "Latitude.h"
#include "Longitude.h"
#include "NaifStatus.h"
#include "ShapeModel.h"
#include "SurfacePoint.h"
 
using namespace std;
 
namespace Isis {

  EllipsoidShape::EllipsoidShape(Target *target) : ShapeModel (target) {
    setName("Ellipsoid");
  }
 

  EllipsoidShape::EllipsoidShape() : ShapeModel () {
    setName("Ellipsoid");
  }
 

  bool EllipsoidShape::intersectSurface (std::vector<double> observerPos,
                                         std::vector<double> lookDirection) {
 
    return (intersectEllipsoid(observerPos, lookDirection));
  }
 

  bool EllipsoidShape::isDEM() const {
    return false;
  }
 

  void EllipsoidShape::calculateLocalNormal(QVector<double *> cornerNeighborPoints)  {
    if(!hasNormal()) {
      calculateSurfaceNormal();
    }
 
    setLocalNormal(normal());
  }
 

  Distance EllipsoidShape::localRadius(const Latitude &lat, const Longitude &lon) {
 
    std::vector<Distance> radii = targetRadii();
 
    double a = radii[0].kilometers();
    double b = radii[1].kilometers();
    double c = radii[2].kilometers();
 
    double rlat = lat.radians();
    double rlon = lon.radians();
 
    double xyradius = a * b / sqrt(pow(b * cos(rlon), 2) +
                      pow(a * sin(rlon), 2));
    const double &radius = xyradius * c / sqrt(pow(c * cos(rlat), 2) +
                           pow(xyradius * sin(rlat), 2));
 
    return Distance(radius, Distance::Kilometers);
  }
 
}