SurfacePoint.h

Go to the documentation of this file.

#ifndef SurfacePoint_h
#define SurfacePoint_h

#include <vector>
#include <cmath>

#include "boost/numeric/ublas/symmetric.hpp"
#include "boost/numeric/ublas/io.hpp"

#include "Displacement.h"
#include "Distance.h"
#include "Angle.h"

namespace Isis {
  class Latitude;
  class Longitude;

  class SurfacePoint {
    public:
      // Constructors
//      SurfacePoint(const std::vector <double> radii);
      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 SetRectangularSigmas(const Distance &xSigma, const Distance &ySigma,
                                const Distance &zSigma);


      void SetRectangularMatrix(
        const boost::numeric::ublas::symmetric_matrix<double,boost::numeric::ublas::upper>& covar);

// 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);

      void SetSphericalSigmas(const Angle &latSigma, const Angle &lonSigma,
                              const Distance &radiusSigma);

      void SetSphericalSigmasDistance(const Distance &latSigma,
                                      const Distance &lonSigma,
                                      const Distance &radiusSigma);

      void SetRadii(const Distance &majorRadius, const Distance &minorRadius,
                    const Distance &polarRadius);

      void ResetLocalRadius(const Distance &radius);
      bool Valid() const;

// Output methods
      Displacement GetX() const;
      Displacement GetY() const;
      Displacement GetZ() const;
      Distance GetXSigma() const;
      Distance GetYSigma() const;
      Distance GetZSigma() const;
      boost::numeric::ublas::symmetric_matrix<double,boost::numeric::ublas::upper> 
        GetRectangularMatrix() 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() const;

// Computational methods
      Distance GetDistanceToPoint(const SurfacePoint &other) const;
      Distance GetDistanceToPoint(const SurfacePoint &other,
          const Distance &sphereRadius) const;

// 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 InitCovariance();
      void InitPoint();
      void InitRadii();
      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_majorAxis;
      Distance *p_minorAxis;
      Distance *p_polarAxis;
      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