OSGB.hpp

Go to the documentation of this file.

 
#if !defined(GEOGRAPHICLIB_OSGB_HPP)
#define GEOGRAPHICLIB_OSGB_HPP 1
 
#include <GeographicLib/Constants.hpp>
#include <GeographicLib/TransverseMercator.hpp>
 
#if defined(_MSC_VER)
// Squelch warnings about dll vs string
#  pragma warning (push)
#  pragma warning (disable: 4251)
#endif
 
namespace GeographicLib {
 
  class GEOGRAPHICLIB_EXPORT OSGB {
  private:
    typedef Math::real real;
    static const char* const letters_;
    static const char* const digits_;
    static const TransverseMercator& OSGBTM();
    enum {
      base_ = 10,
      tile_ = 100000,
      tilelevel_ = 5,
      tilegrid_ = 5,
      tileoffx_ = 2 * tilegrid_,
      tileoffy_ = 1 * tilegrid_,
      minx_ = - tileoffx_ * tile_,
      miny_ = - tileoffy_ * tile_,
      maxx_ = (tilegrid_*tilegrid_ - tileoffx_) * tile_,
      maxy_ = (tilegrid_*tilegrid_ - tileoffy_) * tile_,
      // Maximum precision is um
      maxprec_ = 5 + 6,
    };
    static real computenorthoffset();
    static void CheckCoords(real x, real y);
    OSGB();                     // Disable constructor
  public:
 
    static void Forward(real lat, real lon,
                        real& x, real& y, real& gamma, real& k) {
      OSGBTM().Forward(OriginLongitude(), lat, lon, x, y, gamma, k);
      x += FalseEasting();
      y += computenorthoffset();
    }
 
    static void Reverse(real x, real y,
                        real& lat, real& lon, real& gamma, real& k) {
      x -= FalseEasting();
      y -= computenorthoffset();
      OSGBTM().Reverse(OriginLongitude(), x, y, lat, lon, gamma, k);
    }
 
    static void Forward(real lat, real lon, real& x, real& y) {
      real gamma, k;
      Forward(lat, lon, x, y, gamma, k);
    }
 
    static void Reverse(real x, real y, real& lat, real& lon) {
      real gamma, k;
      Reverse(x, y, lat, lon, gamma, k);
    }
 
    static void GridReference(real x, real y, int prec, std::string& gridref);
 
    static void GridReference(const std::string& gridref,
                              real& x, real& y, int& prec,
                              bool centerp = true);
 
 
    static Math::real MajorRadius() {
    // result is about 6377563.3960320664406 m
      using std::pow;
      return pow(real(10), real(48401603 - 100000000) / 100000000)
        * real(20923713);
    }
 
    static Math::real Flattening()
    { return real(20923713 - 20853810) / real(20923713); }
 
    static Math::real CentralScale() {
      using std::pow;
      return pow(real(10), real(9998268 - 10000000) / 10000000);
    }
 
    static Math::real OriginLatitude() { return real(49); }
 
    static Math::real OriginLongitude() { return real(-2); }
 
    static Math::real FalseNorthing() { return real(-100000); }
 
    static Math::real FalseEasting() { return real(400000); }
 
  };
 
} // namespace GeographicLib
 
#if defined(_MSC_VER)
#  pragma warning (pop)
#endif
 
#endif  // GEOGRAPHICLIB_OSGB_HPP