ReferenceEllipsoid.h

Go to the documentation of this file.

#ifndef _utl_ReferenceEllipsoid_h_
#define _utl_ReferenceEllipsoid_h_

#include <string>
#include <map>
#include <boost/tuple/tuple.hpp>
#include <utl/CoordinateSystem.h>
#include <utl/AugerException.h>

namespace utl {

  class Point;
  class TransformationMatrix;


  class ReferenceEllipsoid {

  public:
    enum EllipsoidID { eWGS84 = 1 };

    typedef boost::tuple<double, double, double> Triple;


    ReferenceEllipsoid(double theEquatorialRadius,
                       double theEccentricity2,
                       const CoordinateSystemPtr theECEF) :
      fEquatorialRadius(theEquatorialRadius),
      fEccentricity2(theEccentricity2),
      fECEF(theECEF)
    { }

    double GetEquatorialRadius() const { return fEquatorialRadius; }
    double GetPolarRadius() const;
    double GetEccentricity2() const { return fEccentricity2; }
    double GetFlattening() const;
    const CoordinateSystemPtr GetECEF() const { return fECEF; }

    bool
    operator==(const ReferenceEllipsoid& r)
      const
    {
      return fEquatorialRadius == r.fEquatorialRadius &&
             fEccentricity2 == r.fEccentricity2 &&
             fECEF == r.fECEF;
    }

    bool operator!=(const ReferenceEllipsoid& r) const
    { return !operator==(r); }

    Triple PointToLatitudeLongitudeHeight(const Point& thePoint) const;

    Point LatitudeLongitudeHeightToPoint(double const latitude,
                                         double const longitude,
                                         double const height) const;

    Point LatitudeLongitudeHeightToPoint(const Triple& theGeodeticCoordinates) const;

    boost::tuple<TransformationMatrix, TransformationMatrix>
    TransformECEFToLocalSystem(const Point& theOrigin) const;

    static const ReferenceEllipsoid& Get(const EllipsoidID theID);

    static const ReferenceEllipsoid& GetWGS84()
    { return Get(eWGS84); }

    static void InitWithECEF(const CoordinateSystemPtr& theECEF);

    static EllipsoidID GetEllipsoidIDFromString(const std::string& str);

    class InvalidEllipsoidException;

  private:
    // don't implement - doesn't make sense to have ellipsoid w/o paramters
    ReferenceEllipsoid();

    double fEquatorialRadius;
    double fEccentricity2;
    CoordinateSystemPtr fECEF;

    typedef std::map<EllipsoidID, const ReferenceEllipsoid> Registry;
    static Registry* gfRegistry;

    static void RegisterOneEllipsoid(const EllipsoidID theID,
                                     double theEquatorialRadius,
                                     double theEccentricity,
                                     const CoordinateSystemPtr& theECEF);

    double GetRn(const double phi) const;

  };


  class ReferenceEllipsoid::InvalidEllipsoidException : public AugerException {

  public:
    InvalidEllipsoidException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Invalid Reference Ellipsoid requested exception"; }

  };

}


#endif

// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// End: