MGRS.hpp

Go to the documentation of this file.

#if !defined(GEOGRAPHICLIB_MGRS_HPP)
#define GEOGRAPHICLIB_MGRS_HPP 1

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

#if defined(_MSC_VER)
// Squelch warnings about dll vs string
#  pragma warning (push)
#  pragma warning (disable: 4251)
#endif

namespace GeographicLib {

  class GEOGRAPHICLIB_EXPORT MGRS {
  private:
    typedef Math::real real;
    static const char* const hemispheres_;
    static const char* const utmcols_[3];
    static const char* const utmrow_;
    static const char* const upscols_[4];
    static const char* const upsrows_[2];
    static const char* const latband_;
    static const char* const upsband_;
    static const char* const digits_;

    static const int mineasting_[4];
    static const int maxeasting_[4];
    static const int minnorthing_[4];
    static const int maxnorthing_[4];
    enum {
      base_ = 10,
      // Top-level tiles are 10^5 m = 100 km on a side
      tilelevel_ = 5,
      // Period of UTM row letters
      utmrowperiod_ = 20,
      // Row letters are shifted by 5 for even zones
      utmevenrowshift_ = 5,
      // Maximum precision is um
      maxprec_ = 5 + 6,
      // For generating digits at maxprec
      mult_ = 1000000,
    };
    static void CheckCoords(bool utmp, bool& northp, real& x, real& y);
    static int UTMRow(int iband, int icol, int irow);

    friend class UTMUPS;        // UTMUPS::StandardZone calls LatitudeBand
    // Return latitude band number [-10, 10) for the given latitude (degrees).
    // The bands are reckoned in include their southern edges.
    static int LatitudeBand(real lat) {
      using std::floor;
      int ilat = int(floor(lat));
      return (std::max)(-10, (std::min)(9, (ilat + 80)/8 - 10));
    }
    // Return approximate latitude band number [-10, 10) for the given northing
    // (meters).  With this rule, each 100km tile would have a unique band
    // letter corresponding to the latitude at the center of the tile.  This
    // function isn't currently used.
    static int ApproxLatitudeBand(real y) {
      // northing at tile center in units of tile = 100km
      using std::floor; using std::abs;
      real ya = floor( (std::min)(real(88), abs(y/tile_)) ) +
        real(0.5);
      // convert to lat (mult by 90/100) and then to band (divide by 8)
      // the +1 fine tunes the boundary between bands 3 and 4
      int b = int(floor( ((ya * 9 + 1) / 10) / 8 ));
      // For the northern hemisphere we have
      // band rows  num
      // N 0   0:8    9
      // P 1   9:17   9
      // Q 2  18:26   9
      // R 3  27:34   8
      // S 4  35:43   9
      // T 5  44:52   9
      // U 6  53:61   9
      // V 7  62:70   9
      // W 8  71:79   9
      // X 9  80:94  15
      return y >= 0 ? b : -(b + 1);
    }
    // UTMUPS access these enums
    enum {
      tile_ = 100000,            // Size MGRS blocks
      minutmcol_ = 1,
      maxutmcol_ = 9,
      minutmSrow_ = 10,
      maxutmSrow_ = 100,         // Also used for UTM S false northing
      minutmNrow_ = 0,           // Also used for UTM N false northing
      maxutmNrow_ = 95,
      minupsSind_ = 8,           // These 4 ind's apply to easting and northing
      maxupsSind_ = 32,
      minupsNind_ = 13,
      maxupsNind_ = 27,
      upseasting_ = 20,          // Also used for UPS false northing
      utmeasting_ = 5,           // UTM false easting
      // Difference between S hemisphere northing and N hemisphere northing
      utmNshift_ = (maxutmSrow_ - minutmNrow_) * tile_
    };
    MGRS();                     // Disable constructor

  public:

    static void Forward(int zone, bool northp, real x, real y,
                        int prec, std::string& mgrs);

    static void Forward(int zone, bool northp, real x, real y, real lat,
                        int prec, std::string& mgrs);

    static void Reverse(const std::string& mgrs,
                        int& zone, bool& northp, real& x, real& y,
                        int& prec, bool centerp = true);


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

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

    static void Check();

  };

} // namespace GeographicLib

#if defined(_MSC_VER)
#  pragma warning (pop)
#endif

#endif  // GEOGRAPHICLIB_MGRS_HPP