GeoCoords.hpp

Go to the documentation of this file.

#if !defined(GEOGRAPHICLIB_GEOCOORDS_HPP)
#define GEOGRAPHICLIB_GEOCOORDS_HPP 1

#include <GeographicLib/UTMUPS.hpp>
#include <GeographicLib/Constants.hpp>

namespace GeographicLib {

  class GEOGRAPHICLIB_EXPORT GeoCoords {
  private:
    typedef Math::real real;
    real _lat, _long, _easting, _northing, _gamma, _k;
    bool _northp;
    int _zone;                  // See UTMUPS::zonespec
    mutable real _alt_easting, _alt_northing, _alt_gamma, _alt_k;
    mutable int _alt_zone;

    void CopyToAlt() const {
      _alt_easting = _easting;
      _alt_northing = _northing;
      _alt_gamma = _gamma;
      _alt_k = _k;
      _alt_zone = _zone;
    }
    static void UTMUPSString(int zone, bool northp,
                             real easting, real northing,
                             int prec, bool abbrev, std::string& utm);
    void FixHemisphere();
  public:


    GeoCoords()
      : _lat(Math::NaN())
      , _long(Math::NaN())
      , _easting(Math::NaN())
      , _northing(Math::NaN())
      , _gamma(Math::NaN())
      , _k(Math::NaN())
      , _northp(false)
      , _zone(UTMUPS::INVALID)
    { CopyToAlt(); }

    explicit GeoCoords(const std::string& s,
                       bool centerp = true, bool longfirst = false)
    { Reset(s, centerp, longfirst); }

    GeoCoords(real latitude, real longitude, int zone = UTMUPS::STANDARD) {
      Reset(latitude, longitude, zone);
    }

    GeoCoords(int zone, bool northp, real easting, real northing) {
      Reset(zone, northp, easting, northing);
    }

    void Reset(const std::string& s,
               bool centerp = true, bool longfirst = false);

    void Reset(real latitude, real longitude, int zone = UTMUPS::STANDARD) {
      UTMUPS::Forward(latitude, longitude,
                      _zone, _northp, _easting, _northing, _gamma, _k,
                      zone);
      _lat = latitude;
      _long = longitude;
      if (_long >= 180) _long -= 360;
      else if (_long < -180) _long += 360;
      CopyToAlt();
    }

    void Reset(int zone, bool northp, real easting, real northing) {
      UTMUPS::Reverse(zone, northp, easting, northing,
                      _lat, _long, _gamma, _k);
      _zone = zone;
      _northp = northp;
      _easting = easting;
      _northing = northing;
      FixHemisphere();
      CopyToAlt();
    }


    Math::real Latitude() const { return _lat; }

    Math::real Longitude() const { return _long; }

    Math::real Easting() const { return _easting; }

    Math::real Northing() const { return _northing; }

    Math::real Convergence() const { return _gamma; }

    Math::real Scale() const { return _k; }

    bool Northp() const { return _northp; }

    char Hemisphere() const { return _northp ? 'n' : 's'; }

    int Zone() const { return _zone; }



    void SetAltZone(int zone = UTMUPS::STANDARD) const {
      if (zone == UTMUPS::MATCH)
        return;
      zone = UTMUPS::StandardZone(_lat, _long, zone);
      if (zone == _zone)
        CopyToAlt();
      else {
        bool northp;
        UTMUPS::Forward(_lat, _long,
                        _alt_zone, northp,
                        _alt_easting, _alt_northing, _alt_gamma, _alt_k,
                        zone);
      }
    }

    int AltZone() const { return _alt_zone; }

    Math::real AltEasting() const { return _alt_easting; }

    Math::real AltNorthing() const { return _alt_northing; }

    Math::real AltConvergence() const { return _alt_gamma; }

    Math::real AltScale() const { return _alt_k; }


    std::string GeoRepresentation(int prec = 0, bool longfirst = false) const;

    std::string DMSRepresentation(int prec = 0, bool longfirst = false,
                                  char dmssep = char(0))
      const;

    std::string MGRSRepresentation(int prec = 0) const;

    std::string UTMUPSRepresentation(int prec = 0, bool abbrev = true) const;

    std::string UTMUPSRepresentation(bool northp, int prec = 0,
                                     bool abbrev = true) const;

    std::string AltMGRSRepresentation(int prec = 0) const;

    std::string AltUTMUPSRepresentation(int prec = 0, bool abbrev = true)
      const;

    std::string AltUTMUPSRepresentation(bool northp, int prec = 0,
                                        bool abbrev = true) const;


    Math::real MajorRadius() const { return UTMUPS::MajorRadius(); }

    Math::real Flattening() const { return UTMUPS::Flattening(); }

  };

} // namespace GeographicLib

#endif  // GEOGRAPHICLIB_GEOCOORDS_HPP