SurfacePoint.h

#ifndef SurfacePoint_h
#define SurfacePoint_h
/* SPDX-License-Identifier: CC0-1.0 */
#include <vector>
#include <cmath>
 
// Qt library
#include <QString>
 
#include "boost/numeric/ublas/symmetric.hpp"
#include "boost/numeric/ublas/io.hpp"
 
// ISIS library
#include "Displacement.h"
#include "Distance.h"
#include "Angle.h"
 
namespace Isis {
  class Latitude;
  class Longitude;
 
  class SurfacePoint {
    public:
 
      // definitions
      enum CoordinateType {
        Latitudinal,                  
        Rectangular                   
      }; 
      enum CoordUnits {
        Degrees,
        Kilometers,
        Meters,
        Radians
      };
      enum CoordIndex {
        One=0,
        Two=1,
        Three=2
    };
      
      // Constructors
      SurfacePoint();
      SurfacePoint(const SurfacePoint &other);
      SurfacePoint(const Latitude &lat, const Longitude &lon,
                   const Distance &radius);
      SurfacePoint(const Latitude &lat, const Longitude &lon,
          const Distance &radius, const Angle &latSigma, const Angle &lonSigma,
          const Distance &radiusSigma);
      SurfacePoint(const Latitude &lat, const Longitude &lon,
                   const Distance &radius,
                   const boost::numeric::ublas::symmetric_matrix
                     <double,boost::numeric::ublas::upper>& covar);
      SurfacePoint(const Displacement &x, const Displacement &y,
                   const Displacement &z);
      SurfacePoint(const Displacement &x, const Displacement &y,
          const Displacement &z, const Distance &xSigma, const Distance &ySigma,
          const Distance &zSigma);
      SurfacePoint(const Displacement &x, const Displacement &y,
                   const Displacement &z,
                   const boost::numeric::ublas::symmetric_matrix
                     <double,boost::numeric::ublas::upper>& covar);
      ~SurfacePoint();
 
// Rectangular loading utilities
      void SetRectangular(const Displacement &x, const Displacement &y,
          const Displacement &z, const Distance &xSigma=Distance(),
          const Distance &ySigma=Distance(), const Distance &zSigma=Distance());
 
      void SetRectangular(const Displacement x, const Displacement y, const Displacement z,
        const boost::numeric::ublas::symmetric_matrix<double,boost::numeric::ublas::upper>& covar);
 
      void SetRectangularCoordinates(const Displacement &x, const Displacement &y,
                                   const Displacement &z);
 
      void SetRectangularSigmas(const Distance &xSigma, const Distance &ySigma,
                                const Distance &zSigma);
 
      void SetRectangularMatrix(
                                const boost::numeric::ublas::symmetric_matrix<double,boost::numeric::ublas::upper>& covar,
                                SurfacePoint::CoordUnits units = SurfacePoint::Meters);
 
// Spherical loading utilities
 
      void SetSpherical (const Latitude &lat, const Longitude &lon,
          const Distance &radius, const Angle &latSigma=Angle(),
          const Angle &lonSigma=Angle(),
          const Distance &radiusSigma=Distance());
 
      void SetSpherical (const Latitude &lat, const Longitude &lon,
          const Distance &radius,
          const boost::numeric::ublas::symmetric_matrix
            <double,boost::numeric::ublas::upper>& covar);
 
      void SetSphericalCoordinates(const Latitude &lat, const Longitude &lon,
                                   const Distance &radius);
 
      void SetSphericalMatrix(
                              const boost::numeric::ublas::symmetric_matrix<double,boost::numeric::ublas::upper>& covar,
                              SurfacePoint::CoordUnits units = SurfacePoint::Meters);
 
      void SetSphericalSigmas(const Angle &latSigma, const Angle &lonSigma,
                              const Distance &radiusSigma);
 
      void SetSphericalSigmasDistance(const Distance &latSigma,
                                      const Distance &lonSigma,
                                      const Distance &radiusSigma);
 
      void ResetLocalRadius(const Distance &radius);
      bool Valid() const;
      
// Generic utilities for convenience
      
      void SetMatrix(CoordinateType type,
         const boost::numeric::ublas::symmetric_matrix<double,boost::numeric::ublas::upper>& covar);        
   
      //    coordinate type with respect to the indicated coordinate (specified by index).     
      std::vector<double> Partial(CoordinateType type, CoordIndex index);
      
// Output methods
      double GetCoord(CoordinateType type, CoordIndex index, CoordUnits units);
      // Consider making this GetSigmaDistance and use the Distance methods to specify units for
      // maximum flexibility and safety. ***TBD***
      double GetSigma(CoordinateType type, CoordIndex index, CoordUnits units);
      Distance GetSigmaDistance(CoordinateType type, CoordIndex index);
      double GetWeight(CoordinateType type, CoordIndex index);
      Displacement GetX() const;
      Displacement GetY() const;
      Displacement GetZ() const;
      Distance GetXSigma() const;
      Distance GetYSigma() const;
      Distance GetZSigma() const;
      double GetXWeight() const;
      double GetYWeight() const;
      double GetZWeight() const;
      boost::numeric::ublas::symmetric_matrix<double,boost::numeric::ublas::upper> 
        GetRectangularMatrix(SurfacePoint::CoordUnits units = SurfacePoint::Meters) const;
      Latitude GetLatitude() const; 
      Longitude GetLongitude() const;
      Distance GetLocalRadius() const;
      Angle GetLatSigma() const;
      Distance GetLatSigmaDistance() const;
      double GetLatWeight() const;
      Angle GetLonSigma() const;
      Distance GetLonSigmaDistance() const;
      double GetLonWeight() const;
      Distance GetLocalRadiusSigma() const;
      double GetLocalRadiusWeight() const;
      boost::numeric::ublas::symmetric_matrix
          <double,boost::numeric::ublas::upper> GetSphericalMatrix
            (SurfacePoint::CoordUnits units = SurfacePoint::Meters) const;
 
// Conversion methods (for convenience)
      double DisplacementToDouble(Displacement disp, CoordUnits units);
      double DistanceToDouble(Distance dist, CoordUnits units);
      double MetersToLatitude(double latLength);
      double MetersToLongitude(double lonLength);
      double LatitudeToMeters(double latitude) const;
      double LongitudeToMeters(double longitude) const;
      double LatToDouble(Latitude lat, CoordUnits units);
      double LonToDouble(Longitude lon, CoordUnits units);
      static CoordinateType stringToCoordinateType(QString type);
      static QString coordinateTypeToString(CoordinateType type);
        
// Computational methods
      Distance GetDistanceToPoint(const SurfacePoint &other) const;
      Distance GetDistanceToPoint(const SurfacePoint &other,
          const Distance &sphereRadius) const;
      std::vector<double> LatitudinalDerivative(CoordIndex index);
      std::vector<double> RectangularDerivative(CoordIndex index);
 
// Misc methods
      void ToNaifArray(double naifOutput[3]) const;
      void FromNaifArray(const double naifValues[3]);
 
// Operators
      bool operator==(const SurfacePoint &other) const;
      SurfacePoint &operator=(const SurfacePoint &other);
 
    private:
      void ComputeLocalRadius();
      void InitCovariance();
      void InitPoint();
      void SetRectangularPoint(const Displacement &x, const Displacement &y, const Displacement &z);
      void SetSphericalPoint(const Latitude &lat, const Longitude &lon, const Distance &radius);
      void FreeAllocatedMemory();
 
      Distance p_localRadius;
      Displacement *p_x;
      Displacement *p_y;
      Displacement *p_z;
      boost::numeric::ublas::symmetric_matrix
          <double,boost::numeric::ublas::upper> *p_rectCovar;
      boost::numeric::ublas::symmetric_matrix
          <double,boost::numeric::ublas::upper> *p_sphereCovar;
  };
};
 
#endif