UTMPoint.h

Go to the documentation of this file.

#ifndef _utl_UTMPoint_h_
#define _utl_UTMPoint_h_

#include <utl/CoordinateSystem.h>
#include <utl/ReferenceEllipsoid.h>

#include <boost/tuple/tuple.hpp>
#include <string>


namespace utl {

  class Point;


  class UTMPoint {
  public:
    enum ZoneRange {
      eZoneMin = 1,                
      eZoneMax = 60                
    };


    UTMPoint(const double theNorthing, const double theEasting,
             const double theHeight,
             const int theZone, const char theBand,
             const ReferenceEllipsoid& theEllipsoid) :
      fNorthing(theNorthing),
      fEasting(theEasting),
      fHeight(theHeight),
      fZone(theZone),
      fBand(theBand),
      fEllipsoid(&theEllipsoid)
    {
      VerifyZone();
    }


    UTMPoint(const double theNorthing, const double theEasting,
             const double theHeight,
             const int theZone, const char theBand,
             const ReferenceEllipsoid::EllipsoidID theEllipsoidID) :
      fNorthing(theNorthing),
      fEasting(theEasting),
      fHeight(theHeight),
      fZone(theZone),
      fBand(theBand),
      fEllipsoid(&ReferenceEllipsoid::Get(theEllipsoidID))
    {
      VerifyZone();
    }


    UTMPoint(const UTMPoint& theUTMPoint,
             const ReferenceEllipsoid& theEllipsoid)
      : fEllipsoid(&theEllipsoid) { SetFromOtherDatum(theUTMPoint); }


    UTMPoint(const UTMPoint& theUTMPoint,
             const ReferenceEllipsoid::EllipsoidID theEllipsoidID) :
      fEllipsoid(&ReferenceEllipsoid::Get(theEllipsoidID))
    {
      SetFromOtherDatum(theUTMPoint);
    }


    UTMPoint(const Point& thePoint, const ReferenceEllipsoid& theEllipsoid)
      : fEllipsoid(&theEllipsoid) { SetFromCartesian(thePoint); }


    UTMPoint(const Point& thePoint,
             const ReferenceEllipsoid::EllipsoidID theEllipsoidID) :
      fEllipsoid(&ReferenceEllipsoid::Get(theEllipsoidID))
    {
      SetFromCartesian(thePoint);
    }


    UTMPoint(const double theLatitude,
             const double theLongitude,
             const double theHeight,
             const ReferenceEllipsoid& theEllipsoid) :
      fHeight(theHeight),
      fEllipsoid(&theEllipsoid)
    {
      SetFromLatitudeLongitude(theLatitude, theLongitude);
    }


    UTMPoint(const double theLatitude,
             const double theLongitude,
             const double theHeight,
             const ReferenceEllipsoid::EllipsoidID theEllipsoidID) :
      fHeight(theHeight),
      fEllipsoid(&ReferenceEllipsoid::Get(theEllipsoidID))
    {
      SetFromLatitudeLongitude(theLatitude, theLongitude);
    }

    ~UTMPoint() { }

    bool
    operator==(const UTMPoint& rhs)
      const
    {
      return fNorthing == rhs.fNorthing &&
             fEasting == rhs.fEasting &&
             fHeight == rhs.fHeight &&
             fZone == rhs.fZone &&
             fBand == rhs.fBand &&
             *fEllipsoid == *rhs.fEllipsoid;
    }

    bool operator!=(const UTMPoint& rhs) const
    { return !operator==(rhs); }

    double GetNorthing() const { return fNorthing; }

    double GetEasting() const { return fEasting; }

    double GetHeight() const { return fHeight; }

    int GetZone() const { return fZone; }

    char GetBand() const { return fBand; }

    const ReferenceEllipsoid& GetEllipsoid() const { return *fEllipsoid; }

    boost::tuple<double, double, double> GetCoordinates3() const
    { return boost::make_tuple(fNorthing, fEasting, fHeight); }

    boost::tuple<double, double, double, int> GetCoordinates4() const
    { return boost::make_tuple(fNorthing, fEasting, fHeight, fZone); }

    boost::tuple<double, double, double, int, char> GetCoordinates() const
    { return boost::make_tuple(fNorthing, fEasting, fHeight, fZone, fBand); }

    boost::tuple<double, double, double> GetGeodeticCoordinates() const;


    Point GetPoint(const CoordinateSystemPtr& theCS = CoordinateSystemPtr()) const;

    class UTMException;

    class UTMZoneException;

  private:
    void VerifyZone();

    void SetFromOtherDatum(const UTMPoint& theUTMPoint);
    void SetFromCartesian(const Point& thePoint);
    void SetFromLatitudeLongitude(const double theLatitude,
                                  const double theLongitude);

    static char BandFromLatitude(const double theLatitude);
    static int  ZoneFromLatitudeLongitude(const double theLatitude,
                                          const double theLongitude);

    double fNorthing;
    double fEasting;
    double fHeight;
    int fZone;
    char fBand;
    const ReferenceEllipsoid* fEllipsoid; // pretend-reference
  };


  class UTMPoint::UTMException : public AugerException {
  public:
    UTMException(std::string message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Invalid UTM operation exception"; }
  };


  class UTMPoint::UTMZoneException : public UTMPoint::UTMException {
  public:
    UTMZoneException(std::string message = std::string())
      : UTMException(message) { }

    virtual std::string GetExceptionName() const
    { return "Invalid UTM zone exception"; }
  };


  std::ostream& operator<<(std::ostream& s, const UTMPoint& p);

}


#endif