geographiclib 0.0.1

data/ext/geographiclib/OSGB.cpp

@@ -0,0 +1,167 @@
+/**
+ * \file OSGB.cpp
+ * \brief Implementation for GeographicLib::OSGB class
+ *
+ * Copyright (c) Charles Karney (2010-2014) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <GeographicLib/OSGB.hpp>
+#include <GeographicLib/Utility.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  const string OSGB::letters_ = "ABCDEFGHJKLMNOPQRSTUVWXYZ";
+  const string OSGB::digits_ = "0123456789";
+
+  const TransverseMercator& OSGB::OSGBTM() {
+    static const TransverseMercator osgbtm(MajorRadius(), Flattening(),
+                                           CentralScale());
+    return osgbtm;
+  }
+
+  Math::real OSGB::computenorthoffset() {
+    real x, y;
+    static const real northoffset =
+      ( OSGBTM().Forward(real(0), OriginLatitude(), real(0), x, y),
+        FalseNorthing() - y );
+    return northoffset;
+  }
+
+  void OSGB::GridReference(real x, real y, int prec, std::string& gridref) {
+    CheckCoords(x, y);
+    if (!(prec >= 0 && prec <= maxprec_))
+      throw GeographicErr("OSGB precision " + Utility::str(prec)
+                          + " not in [0, "
+                          + Utility::str(int(maxprec_)) + "]");
+    if (Math::isnan(x) || Math::isnan(y)) {
+      gridref = "INVALID";
+      return;
+    }
+    char grid[2 + 2 * maxprec_];
+    int
+      xh = int(floor(x / tile_)),
+      yh = int(floor(y / tile_));
+    real
+      xf = x - tile_ * xh,
+      yf = y - tile_ * yh;
+    xh += tileoffx_;
+    yh += tileoffy_;
+    int z = 0;
+    grid[z++] = letters_[(tilegrid_ - (yh / tilegrid_) - 1)
+                        * tilegrid_ + (xh / tilegrid_)];
+    grid[z++] = letters_[(tilegrid_ - (yh % tilegrid_) - 1)
+                        * tilegrid_ + (xh % tilegrid_)];
+    real mult = pow(real(base_), max(tilelevel_ - prec, 0));
+    int
+      ix = int(floor(xf / mult)),
+      iy = int(floor(yf / mult));
+    for (int c = min(prec, int(tilelevel_)); c--;) {
+      grid[z + c] = digits_[ ix % base_ ];
+      ix /= base_;
+      grid[z + c + prec] = digits_[ iy % base_ ];
+      iy /= base_;
+    }
+    if (prec > tilelevel_) {
+      xf -= floor(xf / mult);
+      yf -= floor(yf / mult);
+      mult = pow(real(base_), prec - tilelevel_);
+      ix = int(floor(xf * mult));
+      iy = int(floor(yf * mult));
+      for (int c = prec - tilelevel_; c--;) {
+        grid[z + c + tilelevel_] = digits_[ ix % base_ ];
+        ix /= base_;
+        grid[z + c + tilelevel_ + prec] = digits_[ iy % base_ ];
+        iy /= base_;
+      }
+    }
+    int mlen = z + 2 * prec;
+    gridref.resize(mlen);
+    copy(grid, grid + mlen, gridref.begin());
+  }
+
+  void OSGB::GridReference(const std::string& gridref,
+                           real& x, real& y, int& prec,
+                           bool centerp) {
+    int
+      len = int(gridref.size()),
+      p = 0;
+    if (len >= 2 &&
+        toupper(gridref[0]) == 'I' &&
+        toupper(gridref[1]) == 'N') {
+      x = y = Math::NaN();
+      prec = -2;                // For compatibility with MGRS::Reverse.
+      return;
+    }
+    char grid[2 + 2 * maxprec_];
+    for (int i = 0; i < len; ++i) {
+      if (!isspace(gridref[i])) {
+        if (p >= 2 + 2 * maxprec_)
+          throw GeographicErr("OSGB string " + gridref + " too long");
+        grid[p++] = gridref[i];
+      }
+    }
+    len = p;
+    p = 0;
+    if (len < 2)
+      throw GeographicErr("OSGB string " + gridref + " too short");
+    if (len % 2)
+      throw GeographicErr("OSGB string " + gridref +
+                          " has odd number of characters");
+    int
+      xh = 0,
+      yh = 0;
+    while (p < 2) {
+      int i = Utility::lookup(letters_, grid[p++]);
+      if (i < 0)
+        throw GeographicErr("Illegal prefix character " + gridref);
+      yh = yh * tilegrid_ + tilegrid_ - (i / tilegrid_) - 1;
+      xh = xh * tilegrid_ + (i % tilegrid_);
+    }
+    xh -= tileoffx_;
+    yh -= tileoffy_;
+
+    int prec1 = (len - p)/2;
+    real
+      unit = tile_,
+      x1 = unit * xh,
+      y1 = unit * yh;
+    for (int i = 0; i < prec1; ++i) {
+      unit /= base_;
+      int
+        ix = Utility::lookup(digits_, grid[p + i]),
+        iy = Utility::lookup(digits_, grid[p + i + prec1]);
+      if (ix < 0 || iy < 0)
+        throw GeographicErr("Encountered a non-digit in " + gridref);
+      x1 += unit * ix;
+      y1 += unit * iy;
+    }
+    if (centerp) {
+      x1 += unit/2;
+      y1 += unit/2;
+    }
+    x = x1;
+    y = y1;
+    prec = prec1;
+  }
+
+  void OSGB::CheckCoords(real x, real y) {
+    // Limits are all multiples of 100km and are all closed on the lower end
+    // and open on the upper end -- and this is reflected in the error
+    // messages.  NaNs are let through.
+    if (x < minx_ || x >= maxx_)
+      throw GeographicErr("Easting " + Utility::str(int(floor(x/1000)))
+                          + "km not in OSGB range ["
+                          + Utility::str(minx_/1000) + "km, "
+                          + Utility::str(maxx_/1000) + "km)");
+    if (y < miny_ || y >= maxy_)
+      throw GeographicErr("Northing " + Utility::str(int(floor(y/1000)))
+                          + "km not in OSGB range ["
+                          + Utility::str(miny_/1000) + "km, "
+                          + Utility::str(maxy_/1000) + "km)");
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/PolarStereographic.cpp

@@ -0,0 +1,108 @@
+/**
+ * \file PolarStereographic.cpp
+ * \brief Implementation for GeographicLib::PolarStereographic class
+ *
+ * Copyright (c) Charles Karney (2008-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <GeographicLib/PolarStereographic.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  PolarStereographic::PolarStereographic(real a, real f, real k0)
+    : _a(a)
+    , _f(f)
+    , _e2(_f * (2 - _f))
+    , _es((_f < 0 ? -1 : 1) * sqrt(abs(_e2)))
+    , _e2m(1 - _e2)
+    , _c( (1 - _f) * exp(Math::eatanhe(real(1), _es)) )
+    , _k0(k0)
+  {
+    if (!(Math::isfinite(_a) && _a > 0))
+      throw GeographicErr("Major radius is not positive");
+    if (!(Math::isfinite(_f) && _f < 1))
+      throw GeographicErr("Minor radius is not positive");
+    if (!(Math::isfinite(_k0) && _k0 > 0))
+      throw GeographicErr("Scale is not positive");
+  }
+
+  const PolarStereographic& PolarStereographic::UPS() {
+    static const PolarStereographic ups(Constants::WGS84_a(),
+                                        Constants::WGS84_f(),
+                                        Constants::UPS_k0());
+    return ups;
+  }
+
+  // This formulation converts to conformal coordinates by tau = tan(phi) and
+  // tau' = tan(phi') where phi' is the conformal latitude.  The formulas are:
+  //    tau = tan(phi)
+  //    secphi = hypot(1, tau)
+  //    sig = sinh(e * atanh(e * tau / secphi))
+  //    taup = tan(phip) = tau * hypot(1, sig) - sig * hypot(1, tau)
+  //    c = (1 - f) * exp(e * atanh(e))
+  //
+  // Forward:
+  //   rho = (2*k0*a/c) / (hypot(1, taup) + taup)  (taup >= 0)
+  //       = (2*k0*a/c) * (hypot(1, taup) - taup)  (taup <  0)
+  //
+  // Reverse:
+  //   taup = ((2*k0*a/c) / rho - rho / (2*k0*a/c))/2
+  //
+  // Scale:
+  //   k = (rho/a) * secphi * sqrt((1-e2) + e2 / secphi^2)
+  //
+  // In limit rho -> 0, tau -> inf, taup -> inf, secphi -> inf, secphip -> inf
+  //   secphip = taup = exp(-e * atanh(e)) * tau = exp(-e * atanh(e)) * secphi
+
+  void PolarStereographic::Forward(bool northp, real lat, real lon,
+                                   real& x, real& y, real& gamma, real& k)
+    const {
+    lat = Math::LatFix(lat);
+    lat *= northp ? 1 : -1;
+    real
+      tau = Math::tand(lat),
+      secphi = Math::hypot(real(1), tau),
+      taup = Math::taupf(tau, _es),
+      rho = Math::hypot(real(1), taup) + abs(taup);
+    rho = taup >= 0 ? (lat != 90 ? 1/rho : 0) : rho;
+    rho *= 2 * _k0 * _a / _c;
+    k = lat != 90 ? (rho / _a) * secphi * sqrt(_e2m + _e2 / Math::sq(secphi)) :
+      _k0;
+    Math::sincosd(lon, x, y);
+    x *= rho;
+    y *= (northp ? -rho : rho);
+    gamma = Math::AngNormalize(northp ? lon : -lon);
+  }
+
+  void PolarStereographic::Reverse(bool northp, real x, real y,
+                                   real& lat, real& lon, real& gamma, real& k)
+    const {
+    real
+      rho = Math::hypot(x, y),
+      t = rho ? rho / (2 * _k0 * _a / _c) :
+      Math::sq(numeric_limits<real>::epsilon()),
+      taup = (1 / t - t) / 2,
+      tau = Math::tauf(taup, _es),
+      secphi = Math::hypot(real(1), tau);
+    k = rho ? (rho / _a) * secphi * sqrt(_e2m + _e2 / Math::sq(secphi)) : _k0;
+    lat = (northp ? 1 : -1) * Math::atand(tau);
+    lon = Math::atan2d(x, northp ? -y : y );
+    gamma = Math::AngNormalize(northp ? lon : -lon);
+  }
+
+  void PolarStereographic::SetScale(real lat, real k) {
+    if (!(Math::isfinite(k) && k > 0))
+      throw GeographicErr("Scale is not positive");
+    if (!(-90 < lat && lat <= 90))
+      throw GeographicErr("Latitude must be in (-90d, 90d]");
+    real x, y, gamma, kold;
+    _k0 = 1;
+    Forward(true, lat, 0, x, y, gamma, kold);
+    _k0 *= k/kold;
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/PolygonArea.cpp

@@ -0,0 +1,204 @@
+/**
+ * \file PolygonArea.cpp
+ * \brief Implementation for GeographicLib::PolygonAreaT class
+ *
+ * Copyright (c) Charles Karney (2010-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <GeographicLib/PolygonArea.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  template <class GeodType>
+  void PolygonAreaT<GeodType>::AddPoint(real lat, real lon) {
+    lat = Math::LatFix(lat);
+    lon = Math::AngNormalize(lon);
+    if (_num == 0) {
+      _lat0 = _lat1 = lat;
+      _lon0 = _lon1 = lon;
+    } else {
+      real s12, S12, t;
+      _earth.GenInverse(_lat1, _lon1, lat, lon, _mask, s12, t, t, t, t, t, S12);
+      _perimetersum += s12;
+      if (!_polyline) {
+        _areasum += S12;
+        _crossings += transit(_lon1, lon);
+      }
+      _lat1 = lat; _lon1 = lon;
+    }
+    ++_num;
+  }
+
+  template <class GeodType>
+  void PolygonAreaT<GeodType>::AddEdge(real azi, real s) {
+    if (_num) {                 // Do nothing if _num is zero
+      real lat, lon, S12, t;
+      _earth.GenDirect(_lat1, _lon1, azi, false, s, _mask,
+                       lat, lon, t, t, t, t, t, S12);
+      _perimetersum += s;
+      if (!_polyline) {
+        _areasum += S12;
+        _crossings += transitdirect(_lon1, lon);
+        lon = Math::AngNormalize(lon);
+      }
+      _lat1 = lat; _lon1 = lon;
+      ++_num;
+    }
+  }
+
+  template <class GeodType>
+  unsigned PolygonAreaT<GeodType>::Compute(bool reverse, bool sign,
+                                           real& perimeter, real& area) const {
+    real s12, S12, t;
+    if (_num < 2) {
+      perimeter = 0;
+      if (!_polyline)
+        area = 0;
+      return _num;
+    }
+    if (_polyline) {
+      perimeter = _perimetersum();
+      return _num;
+    }
+    _earth.GenInverse(_lat1, _lon1, _lat0, _lon0, _mask,
+                      s12, t, t, t, t, t, S12);
+    perimeter = _perimetersum(s12);
+    Accumulator<> tempsum(_areasum);
+    tempsum += S12;
+    int crossings = _crossings + transit(_lon1, _lon0);
+    if (crossings & 1)
+      tempsum += (tempsum < 0 ? 1 : -1) * _area0/2;
+    // area is with the clockwise sense.  If !reverse convert to
+    // counter-clockwise convention.
+    if (!reverse)
+      tempsum *= -1;
+    // If sign put area in (-area0/2, area0/2], else put area in [0, area0)
+    if (sign) {
+      if (tempsum > _area0/2)
+        tempsum -= _area0;
+      else if (tempsum <= -_area0/2)
+        tempsum += _area0;
+    } else {
+      if (tempsum >= _area0)
+        tempsum -= _area0;
+      else if (tempsum < 0)
+        tempsum += _area0;
+    }
+    area = 0 + tempsum();
+    return _num;
+  }
+
+  template <class GeodType>
+  unsigned PolygonAreaT<GeodType>::TestPoint(real lat, real lon,
+                                             bool reverse, bool sign,
+                                             real& perimeter, real& area) const
+  {
+    if (_num == 0) {
+      perimeter = 0;
+      if (!_polyline)
+        area = 0;
+      return 1;
+    }
+    perimeter = _perimetersum();
+    real tempsum = _polyline ? 0 : _areasum();
+    int crossings = _crossings;
+    unsigned num = _num + 1;
+    for (int i = 0; i < (_polyline ? 1 : 2); ++i) {
+      real s12, S12, t;
+      _earth.GenInverse(i == 0 ? _lat1 : lat, i == 0 ? _lon1 : lon,
+                        i != 0 ? _lat0 : lat, i != 0 ? _lon0 : lon,
+                        _mask, s12, t, t, t, t, t, S12);
+      perimeter += s12;
+      if (!_polyline) {
+        tempsum += S12;
+        crossings += transit(i == 0 ? _lon1 : lon,
+                             i != 0 ? _lon0 : lon);
+      }
+    }
+
+    if (_polyline)
+      return num;
+
+    if (crossings & 1)
+      tempsum += (tempsum < 0 ? 1 : -1) * _area0/2;
+    // area is with the clockwise sense.  If !reverse convert to
+    // counter-clockwise convention.
+    if (!reverse)
+      tempsum *= -1;
+    // If sign put area in (-area0/2, area0/2], else put area in [0, area0)
+    if (sign) {
+      if (tempsum > _area0/2)
+        tempsum -= _area0;
+      else if (tempsum <= -_area0/2)
+        tempsum += _area0;
+    } else {
+      if (tempsum >= _area0)
+        tempsum -= _area0;
+      else if (tempsum < 0)
+        tempsum += _area0;
+    }
+    area = 0 + tempsum;
+    return num;
+  }
+
+  template <class GeodType>
+  unsigned PolygonAreaT<GeodType>::TestEdge(real azi, real s,
+                                            bool reverse, bool sign,
+                                            real& perimeter, real& area) const {
+    if (_num == 0) {            // we don't have a starting point!
+      perimeter = Math::NaN();
+      if (!_polyline)
+        area = Math::NaN();
+      return 0;
+    }
+    unsigned num = _num + 1;
+    perimeter = _perimetersum() + s;
+    if (_polyline)
+      return num;
+
+    real tempsum =  _areasum();
+    int crossings = _crossings;
+    {
+      real lat, lon, s12, S12, t;
+      _earth.GenDirect(_lat1, _lon1, azi, false, s, _mask,
+                       lat, lon, t, t, t, t, t, S12);
+      tempsum += S12;
+      crossings += transitdirect(_lon1, lon);
+      lon = Math::AngNormalize(lon);
+      _earth.GenInverse(lat, lon, _lat0, _lon0, _mask, s12, t, t, t, t, t, S12);
+      perimeter += s12;
+      tempsum += S12;
+      crossings += transit(lon, _lon0);
+    }
+
+    if (crossings & 1)
+      tempsum += (tempsum < 0 ? 1 : -1) * _area0/2;
+    // area is with the clockwise sense.  If !reverse convert to
+    // counter-clockwise convention.
+    if (!reverse)
+      tempsum *= -1;
+    // If sign put area in (-area0/2, area0/2], else put area in [0, area0)
+    if (sign) {
+      if (tempsum > _area0/2)
+        tempsum -= _area0;
+      else if (tempsum <= -_area0/2)
+        tempsum += _area0;
+    } else {
+      if (tempsum >= _area0)
+        tempsum -= _area0;
+      else if (tempsum < 0)
+        tempsum += _area0;
+    }
+    area = 0 + tempsum;
+    return num;
+  }
+
+  template class GEOGRAPHICLIB_EXPORT PolygonAreaT<Geodesic>;
+  template class GEOGRAPHICLIB_EXPORT PolygonAreaT<GeodesicExact>;
+  template class GEOGRAPHICLIB_EXPORT PolygonAreaT<Rhumb>;
+
+} // namespace GeographicLib