geographiclib 0.0.1

data/ext/geographiclib/GARS.cpp

@@ -0,0 +1,122 @@
+/**
+ * \file GARS.cpp
+ * \brief Implementation for GeographicLib::GARS class
+ *
+ * Copyright (c) Charles Karney (2015) <charles@karney.com> and licensed under
+ * the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <GeographicLib/GARS.hpp>
+#include <GeographicLib/Utility.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  const string GARS::digits_ = "0123456789";
+  const string GARS::letters_ = "ABCDEFGHJKLMNPQRSTUVWXYZ";
+
+  void GARS::Forward(real lat, real lon, int prec, std::string& gars) {
+    if (abs(lat) > 90)
+      throw GeographicErr("Latitude " + Utility::str(lat)
+                          + "d not in [-90d, 90d]");
+    if (Math::isnan(lat) || Math::isnan(lon)) {
+      gars = "INVALID";
+      return;
+    }
+    lon = Math::AngNormalize(lon); // lon in [-180,180)
+    if (lat == 90) lat *= (1 - numeric_limits<real>::epsilon() / 2);
+    prec = max(0, min(int(maxprec_), prec));
+    int
+      x = int(floor(lon * m_)) - lonorig_ * m_,
+      y = int(floor(lat * m_)) - latorig_ * m_,
+      ilon = x * mult1_ / m_,
+      ilat = y * mult1_ / m_;
+    x -= ilon * m_ / mult1_; y -= ilat * m_ / mult1_;
+    char gars1[maxlen_];
+    ++ilon;
+    for (int c = lonlen_; c--;) {
+      gars1[c] = digits_[ ilon % baselon_]; ilon /= baselon_;
+    }
+    for (int c = latlen_; c--;) {
+      gars1[lonlen_ + c] = letters_[ilat % baselat_]; ilat /= baselat_;
+    }
+    if (prec > 0) {
+      ilon = x / mult3_; ilat = y / mult3_;
+      gars1[baselen_] = digits_[mult2_ * (mult2_ - 1 - ilat) + ilon + 1];
+      if (prec > 1) {
+        ilon = x % mult3_; ilat = y % mult3_;
+        gars1[baselen_ + 1] = digits_[mult3_ * (mult3_ - 1 - ilat) + ilon + 1];
+      }
+    }
+    gars.resize(baselen_ + prec);
+    copy(gars1, gars1 + baselen_ + prec, gars.begin());
+  }
+
+  void GARS::Reverse(const std::string& gars, real& lat, real& lon,
+                        int& prec, bool centerp) {
+    int len = int(gars.length());
+    if (len >= 3 &&
+        toupper(gars[0]) == 'I' &&
+        toupper(gars[1]) == 'N' &&
+        toupper(gars[2]) == 'V') {
+      lat = lon = Math::NaN();
+      return;
+    }
+    if (len < baselen_)
+      throw GeographicErr("GARS must have at least 5 characters " + gars);
+    if (len > maxlen_)
+      throw GeographicErr("GARS can have at most 7 characters " + gars);
+    int prec1 = len - baselen_;
+    int ilon = 0;
+    for (int c = 0; c < lonlen_; ++c) {
+      int k = Utility::lookup(digits_, gars[c]);
+      if (k < 0)
+        throw GeographicErr("GARS must start with 3 digits " + gars);
+      ilon = ilon * baselon_ + k;
+    }
+    if (!(ilon >= 1 && ilon <= 720))
+        throw GeographicErr("Initial digits in GARS must lie in [1, 720] " +
+                            gars);
+    --ilon;
+    int ilat = 0;
+    for (int c = 0; c < latlen_; ++c) {
+      int k = Utility::lookup(letters_, gars[lonlen_ + c]);
+      if (k < 0)
+        throw GeographicErr("Illegal letters in GARS " + gars.substr(3,2));
+      ilat = ilat * baselat_ + k;
+    }
+    if (!(ilat < 360))
+      throw  GeographicErr("GARS letters must lie in [AA, QZ] " + gars);
+    real
+      unit = mult1_,
+      lat1 = ilat + latorig_ * unit,
+      lon1 = ilon + lonorig_ * unit;
+    if (prec1 > 0) {
+      int k = Utility::lookup(digits_, gars[baselen_]);
+      if (!(k >= 1 && k <= mult2_ * mult2_))
+        throw GeographicErr("6th character in GARS must [1, 4] " + gars);
+      --k;
+      unit *= mult2_;
+      lat1 = mult2_ * lat1 + (mult2_ - 1 - k / mult2_);
+      lon1 = mult2_ * lon1 + (k % mult2_);
+      if (prec1 > 1) {
+        k = Utility::lookup(digits_, gars[baselen_ + 1]);
+        if (!(k >= 1 /* && k <= mult3_ * mult3_ */))
+          throw GeographicErr("7th character in GARS must [1, 9] " + gars);
+        --k;
+        unit *= mult3_;
+        lat1 = mult3_ * lat1 + (mult3_ - 1 - k / mult3_);
+        lon1 = mult3_ * lon1 + (k % mult3_);
+      }
+    }
+    if (centerp) {
+      unit *= 2; lat1 = 2 * lat1 + 1; lon1 = 2 * lon1 + 1;
+    }
+    lat = lat1 / unit;
+    lon = lon1 / unit;
+    prec = prec1;
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/GeoCoords.cpp

@@ -0,0 +1,175 @@
+/**
+ * \file GeoCoords.cpp
+ * \brief Implementation for GeographicLib::GeoCoords 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/GeoCoords.hpp>
+#include <GeographicLib/MGRS.hpp>
+#include <GeographicLib/DMS.hpp>
+#include <GeographicLib/Utility.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  void GeoCoords::Reset(const std::string& s, bool centerp, bool longfirst) {
+    vector<string> sa;
+    const char* spaces = " \t\n\v\f\r,"; // Include comma as a space
+    for (string::size_type pos0 = 0, pos1; pos0 != string::npos;) {
+      pos1 = s.find_first_not_of(spaces, pos0);
+      if (pos1 == string::npos)
+        break;
+      pos0 = s.find_first_of(spaces, pos1);
+      sa.push_back(s.substr(pos1, pos0 == string::npos ? pos0 : pos0 - pos1));
+    }
+    if (sa.size() == 1) {
+      int prec;
+      MGRS::Reverse(sa[0], _zone, _northp, _easting, _northing, prec, centerp);
+      UTMUPS::Reverse(_zone, _northp, _easting, _northing,
+                      _lat, _long, _gamma, _k);
+    } else if (sa.size() == 2) {
+      DMS::DecodeLatLon(sa[0], sa[1], _lat, _long, longfirst);
+      _long = Math::AngNormalize(_long);
+      UTMUPS::Forward( _lat, _long,
+                       _zone, _northp, _easting, _northing, _gamma, _k);
+    } else if (sa.size() == 3) {
+      unsigned zoneind, coordind;
+      if (sa[0].size() > 0 && isalpha(sa[0][sa[0].size() - 1])) {
+        zoneind = 0;
+        coordind = 1;
+      } else if (sa[2].size() > 0 && isalpha(sa[2][sa[2].size() - 1])) {
+        zoneind = 2;
+        coordind = 0;
+      } else
+        throw GeographicErr("Neither " + sa[0] + " nor " + sa[2]
+                            + " of the form UTM/UPS Zone + Hemisphere"
+                            + " (ex: 38n, 09s, n)");
+      UTMUPS::DecodeZone(sa[zoneind], _zone, _northp);
+      for (unsigned i = 0; i < 2; ++i)
+        (i ? _northing : _easting) = Utility::num<real>(sa[coordind + i]);
+      UTMUPS::Reverse(_zone, _northp, _easting, _northing,
+                      _lat, _long, _gamma, _k);
+      FixHemisphere();
+    } else
+      throw GeographicErr("Coordinate requires 1, 2, or 3 elements");
+    CopyToAlt();
+  }
+
+  string GeoCoords::GeoRepresentation(int prec, bool longfirst) const {
+    prec = max(0, min(9 + Math::extra_digits(), prec) + 5);
+    ostringstream os;
+    os << fixed << setprecision(prec);
+    real a = longfirst ? _long : _lat;
+    real b = longfirst ? _lat : _long;
+    if (!Math::isnan(a))
+      os << a;
+    else
+      os << "nan";
+    os << " ";
+    if (!Math::isnan(b))
+      os << b;
+    else
+      os << "nan";
+    return os.str();
+  }
+
+  string GeoCoords::DMSRepresentation(int prec, bool longfirst,
+                                      char dmssep) const {
+    prec = max(0, min(10 + Math::extra_digits(), prec) + 5);
+    return DMS::Encode(longfirst ? _long : _lat, unsigned(prec),
+                       longfirst ? DMS::LONGITUDE : DMS::LATITUDE, dmssep) +
+      " " + DMS::Encode(longfirst ? _lat : _long, unsigned(prec),
+                        longfirst ? DMS::LATITUDE : DMS::LONGITUDE, dmssep);
+  }
+
+  string GeoCoords::MGRSRepresentation(int prec) const {
+    // Max precision is um
+    prec = max(-1, min(6, prec) + 5);
+    string mgrs;
+    MGRS::Forward(_zone, _northp, _easting, _northing, _lat, prec, mgrs);
+    return mgrs;
+  }
+
+  string GeoCoords::AltMGRSRepresentation(int prec) const {
+    // Max precision is um
+    prec = max(-1, min(6, prec) + 5);
+    string mgrs;
+    MGRS::Forward(_alt_zone, _northp, _alt_easting, _alt_northing, _lat, prec,
+                  mgrs);
+    return mgrs;
+  }
+
+  void GeoCoords::UTMUPSString(int zone, bool northp,
+                               real easting, real northing, int prec,
+                               bool abbrev, std::string& utm) {
+    ostringstream os;
+    prec = max(-5, min(9 + Math::extra_digits(), prec));
+    real scale = prec < 0 ? pow(real(10), -prec) : real(1);
+    os << UTMUPS::EncodeZone(zone, northp, abbrev) << fixed << setfill('0');
+    if (Math::isfinite(easting)) {
+      os << " " << Utility::str(easting / scale, max(0, prec));
+      if (prec < 0 && abs(easting / scale) > real(0.5))
+        os << setw(-prec) << 0;
+    } else
+      os << " nan";
+    if (Math::isfinite(northing)) {
+      os << " " << Utility::str(northing / scale, max(0, prec));
+      if (prec < 0 && abs(northing / scale) > real(0.5))
+        os << setw(-prec) << 0;
+    } else
+      os << " nan";
+    utm = os.str();
+  }
+
+  string GeoCoords::UTMUPSRepresentation(int prec, bool abbrev) const {
+    string utm;
+    UTMUPSString(_zone, _northp, _easting, _northing, prec, abbrev, utm);
+    return utm;
+  }
+
+  string GeoCoords::UTMUPSRepresentation(bool northp, int prec, bool abbrev)
+    const {
+    real e, n;
+    int z;
+    UTMUPS::Transfer(_zone, _northp, _easting, _northing,
+                     _zone,  northp,  e,        n,       z);
+    string utm;
+    UTMUPSString(_zone, northp, e, n, prec, abbrev, utm);
+    return utm;
+  }
+
+  string GeoCoords::AltUTMUPSRepresentation(int prec, bool abbrev) const {
+    string utm;
+    UTMUPSString(_alt_zone, _northp, _alt_easting, _alt_northing, prec,
+                 abbrev, utm);
+    return utm;
+  }
+
+  string GeoCoords::AltUTMUPSRepresentation(bool northp, int prec, bool abbrev)
+    const {
+    real e, n;
+    int z;
+    UTMUPS::Transfer(_alt_zone, _northp, _alt_easting, _alt_northing,
+                     _alt_zone,  northp,      e,            n,       z);
+    string utm;
+    UTMUPSString(_alt_zone, northp, e, n, prec, abbrev, utm);
+    return utm;
+  }
+
+  void GeoCoords::FixHemisphere() {
+    if (_lat == 0 || (_northp && _lat >= 0) || (!_northp && _lat < 0) ||
+        Math::isnan(_lat))
+      // Allow either hemisphere for equator
+      return;
+    if (_zone != UTMUPS::UPS) {
+      _northing += (_northp ? 1 : -1) * UTMUPS::UTMShift();
+      _northp = !_northp;
+    } else
+      throw GeographicErr("Hemisphere mixup");
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/Geocentric.cpp

@@ -0,0 +1,172 @@
+/**
+ * \file Geocentric.cpp
+ * \brief Implementation for GeographicLib::Geocentric 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/Geocentric.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  Geocentric::Geocentric(real a, real f)
+    : _a(a)
+    , _f(f)
+    , _e2(_f * (2 - _f))
+    , _e2m(Math::sq(1 - _f))    // 1 - _e2
+    , _e2a(abs(_e2))
+    , _e4a(Math::sq(_e2))
+    , _maxrad(2 * _a / numeric_limits<real>::epsilon())
+  {
+    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");
+  }
+
+  const Geocentric& Geocentric::WGS84() {
+    static const Geocentric wgs84(Constants::WGS84_a(), Constants::WGS84_f());
+    return wgs84;
+  }
+
+  void Geocentric::IntForward(real lat, real lon, real h,
+                              real& X, real& Y, real& Z,
+                              real M[dim2_]) const {
+    real sphi, cphi, slam, clam;
+    Math::sincosd(Math::LatFix(lat), sphi, cphi);
+    Math::sincosd(lon, slam, clam);
+    real n = _a/sqrt(1 - _e2 * Math::sq(sphi));
+    Z = (_e2m * n + h) * sphi;
+    X = (n + h) * cphi;
+    Y = X * slam;
+    X *= clam;
+    if (M)
+      Rotation(sphi, cphi, slam, clam, M);
+  }
+
+  void Geocentric::IntReverse(real X, real Y, real Z,
+                              real& lat, real& lon, real& h,
+                              real M[dim2_]) const {
+    real
+      R = Math::hypot(X, Y),
+      slam = R ? Y / R : 0,
+      clam = R ? X / R : 1;
+    h = Math::hypot(R, Z);      // Distance to center of earth
+    real sphi, cphi;
+    if (h > _maxrad) {
+      // We really far away (> 12 million light years); treat the earth as a
+      // point and h, above, is an acceptable approximation to the height.
+      // This avoids overflow, e.g., in the computation of disc below.  It's
+      // possible that h has overflowed to inf; but that's OK.
+      //
+      // Treat the case X, Y finite, but R overflows to +inf by scaling by 2.
+      R = Math::hypot(X/2, Y/2);
+      slam = R ? (Y/2) / R : 0;
+      clam = R ? (X/2) / R : 1;
+      real H = Math::hypot(Z/2, R);
+      sphi = (Z/2) / H;
+      cphi = R / H;
+    } else if (_e4a == 0) {
+      // Treat the spherical case.  Dealing with underflow in the general case
+      // with _e2 = 0 is difficult.  Origin maps to N pole same as with
+      // ellipsoid.
+      real H = Math::hypot(h == 0 ? 1 : Z, R);
+      sphi = (h == 0 ? 1 : Z) / H;
+      cphi = R / H;
+      h -= _a;
+    } else {
+      // Treat prolate spheroids by swapping R and Z here and by switching
+      // the arguments to phi = atan2(...) at the end.
+      real
+        p = Math::sq(R / _a),
+        q = _e2m * Math::sq(Z / _a),
+        r = (p + q - _e4a) / 6;
+      if (_f < 0) swap(p, q);
+      if ( !(_e4a * q == 0 && r <= 0) ) {
+        real
+          // Avoid possible division by zero when r = 0 by multiplying
+          // equations for s and t by r^3 and r, resp.
+          S = _e4a * p * q / 4, // S = r^3 * s
+          r2 = Math::sq(r),
+          r3 = r * r2,
+          disc = S * (2 * r3 + S);
+        real u = r;
+        if (disc >= 0) {
+          real T3 = S + r3;
+          // Pick the sign on the sqrt to maximize abs(T3).  This minimizes
+          // loss of precision due to cancellation.  The result is unchanged
+          // because of the way the T is used in definition of u.
+          T3 += T3 < 0 ? -sqrt(disc) : sqrt(disc); // T3 = (r * t)^3
+          // N.B. cbrt always returns the real root.  cbrt(-8) = -2.
+          real T = Math::cbrt(T3); // T = r * t
+          // T can be zero; but then r2 / T -> 0.
+          u += T + (T ? r2 / T : 0);
+        } else {
+          // T is complex, but the way u is defined the result is real.
+          real ang = atan2(sqrt(-disc), -(S + r3));
+          // There are three possible cube roots.  We choose the root which
+          // avoids cancellation.  Note that disc < 0 implies that r < 0.
+          u += 2 * r * cos(ang / 3);
+        }
+        real
+          v = sqrt(Math::sq(u) + _e4a * q), // guaranteed positive
+          // Avoid loss of accuracy when u < 0.  Underflow doesn't occur in
+          // e4 * q / (v - u) because u ~ e^4 when q is small and u < 0.
+          uv = u < 0 ? _e4a * q / (v - u) : u + v, // u+v, guaranteed positive
+          // Need to guard against w going negative due to roundoff in uv - q.
+          w = max(real(0), _e2a * (uv - q) / (2 * v)),
+          // Rearrange expression for k to avoid loss of accuracy due to
+          // subtraction.  Division by 0 not possible because uv > 0, w >= 0.
+          k = uv / (sqrt(uv + Math::sq(w)) + w),
+          k1 = _f >= 0 ? k : k - _e2,
+          k2 = _f >= 0 ? k + _e2 : k,
+          d = k1 * R / k2,
+          H = Math::hypot(Z/k1, R/k2);
+        sphi = (Z/k1) / H;
+        cphi = (R/k2) / H;
+        h = (1 - _e2m/k1) * Math::hypot(d, Z);
+      } else {                  // e4 * q == 0 && r <= 0
+        // This leads to k = 0 (oblate, equatorial plane) and k + e^2 = 0
+        // (prolate, rotation axis) and the generation of 0/0 in the general
+        // formulas for phi and h.  using the general formula and division by 0
+        // in formula for h.  So handle this case by taking the limits:
+        // f > 0: z -> 0, k      ->   e2 * sqrt(q)/sqrt(e4 - p)
+        // f < 0: R -> 0, k + e2 -> - e2 * sqrt(q)/sqrt(e4 - p)
+        real
+          zz = sqrt((_f >= 0 ? _e4a - p : p) / _e2m),
+          xx = sqrt( _f <  0 ? _e4a - p : p        ),
+          H = Math::hypot(zz, xx);
+        sphi = zz / H;
+        cphi = xx / H;
+        if (Z < 0) sphi = -sphi; // for tiny negative Z (not for prolate)
+        h = - _a * (_f >= 0 ? _e2m : 1) * H / _e2a;
+      }
+    }
+    lat = Math::atan2d(sphi, cphi);
+    lon = Math::atan2d(slam, clam);
+    if (M)
+      Rotation(sphi, cphi, slam, clam, M);
+  }
+
+  void Geocentric::Rotation(real sphi, real cphi, real slam, real clam,
+                            real M[dim2_]) {
+    // This rotation matrix is given by the following quaternion operations
+    // qrot(lam, [0,0,1]) * qrot(phi, [0,-1,0]) * [1,1,1,1]/2
+    // or
+    // qrot(pi/2 + lam, [0,0,1]) * qrot(-pi/2 + phi , [-1,0,0])
+    // where
+    // qrot(t,v) = [cos(t/2), sin(t/2)*v[1], sin(t/2)*v[2], sin(t/2)*v[3]]
+
+    // Local X axis (east) in geocentric coords
+    M[0] = -slam;        M[3] =  clam;        M[6] = 0;
+    // Local Y axis (north) in geocentric coords
+    M[1] = -clam * sphi; M[4] = -slam * sphi; M[7] = cphi;
+    // Local Z axis (up) in geocentric coords
+    M[2] =  clam * cphi; M[5] =  slam * cphi; M[8] = sphi;
+  }
+
+} // namespace GeographicLib