geographiclib 0.0.1

data/ext/geographiclib/UTMUPS.cpp

@@ -0,0 +1,296 @@
+/**
+ * \file UTMUPS.cpp
+ * \brief Implementation for GeographicLib::UTMUPS 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/UTMUPS.hpp>
+#include <GeographicLib/MGRS.hpp>
+#include <GeographicLib/PolarStereographic.hpp>
+#include <GeographicLib/TransverseMercator.hpp>
+#include <GeographicLib/Utility.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  const int UTMUPS::falseeasting_[4] =
+    { MGRS::upseasting_ * MGRS::tile_, MGRS::upseasting_ * MGRS::tile_,
+      MGRS::utmeasting_ * MGRS::tile_, MGRS::utmeasting_ * MGRS::tile_ };
+  const int UTMUPS::falsenorthing_[4] =
+    { MGRS::upseasting_ * MGRS::tile_, MGRS::upseasting_ * MGRS::tile_,
+      MGRS::maxutmSrow_ * MGRS::tile_, MGRS::minutmNrow_ * MGRS::tile_ };
+  const int UTMUPS::mineasting_[4] =
+    { MGRS::minupsSind_ * MGRS::tile_, MGRS::minupsNind_ * MGRS::tile_,
+      MGRS::minutmcol_ * MGRS::tile_, MGRS::minutmcol_ * MGRS::tile_ };
+  const int UTMUPS::maxeasting_[4] =
+    { MGRS::maxupsSind_ * MGRS::tile_, MGRS::maxupsNind_ * MGRS::tile_,
+      MGRS::maxutmcol_ * MGRS::tile_, MGRS::maxutmcol_ * MGRS::tile_ };
+  const int UTMUPS::minnorthing_[4] =
+    { MGRS::minupsSind_ * MGRS::tile_, MGRS::minupsNind_ * MGRS::tile_,
+      MGRS::minutmSrow_ * MGRS::tile_,
+      (MGRS::minutmNrow_ + MGRS::minutmSrow_ - MGRS::maxutmSrow_)
+      * MGRS::tile_ };
+  const int UTMUPS::maxnorthing_[4] =
+    { MGRS::maxupsSind_ * MGRS::tile_, MGRS::maxupsNind_ * MGRS::tile_,
+      (MGRS::maxutmSrow_ + MGRS::maxutmNrow_ - MGRS::minutmNrow_) * MGRS::tile_,
+      MGRS::maxutmNrow_ * MGRS::tile_ };
+
+  int UTMUPS::StandardZone(real lat, real lon, int setzone) {
+    if (!(setzone >= MINPSEUDOZONE && setzone <= MAXZONE))
+      throw GeographicErr("Illegal zone requested " + Utility::str(setzone));
+    if (setzone >= MINZONE || setzone == INVALID)
+      return setzone;
+    if (Math::isnan(lat) || Math::isnan(lon)) // Check if lat or lon is a NaN
+      return INVALID;
+    if (setzone == UTM || (lat >= -80 && lat < 84)) {
+      int ilon = int(floor(fmod(lon, real(360))));
+      if (ilon >= 180)
+        ilon -= 360;
+      else if (ilon < -180)
+        ilon += 360;
+      int zone = (ilon + 186)/6;
+      int band = MGRS::LatitudeBand(lat);
+      if (band == 7 && zone == 31 && ilon >= 3)
+        zone = 32;
+      else if (band == 9 && ilon >= 0 && ilon < 42)
+        zone = 2 * ((ilon + 183)/12) + 1;
+      return zone;
+    } else
+      return UPS;
+  }
+
+  void UTMUPS::Forward(real lat, real lon,
+                       int& zone, bool& northp, real& x, real& y,
+                       real& gamma, real& k,
+                       int setzone, bool mgrslimits) {
+    if (abs(lat) > 90)
+      throw GeographicErr("Latitude " + Utility::str(lat)
+                          + "d not in [-90d, 90d]");
+    bool northp1 = lat >= 0;
+    int zone1 = StandardZone(lat, lon, setzone);
+    if (zone1 == INVALID) {
+      zone = zone1;
+      northp = northp1;
+      x = y = gamma = k = Math::NaN();
+      return;
+    }
+    real x1, y1, gamma1, k1;
+    bool utmp = zone1 != UPS;
+    if (utmp) {
+      real
+        lon0 = CentralMeridian(zone1),
+        dlon = lon - lon0;
+      dlon = abs(dlon - 360 * floor((dlon + 180)/360));
+      if (!(dlon <= 60))
+        // Check isn't really necessary because CheckCoords catches this case.
+        // But this allows a more meaningful error message to be given.
+        throw GeographicErr("Longitude " + Utility::str(lon)
+                            + "d more than 60d from center of UTM zone "
+                            + Utility::str(zone1));
+      TransverseMercator::UTM().Forward(lon0, lat, lon, x1, y1, gamma1, k1);
+    } else {
+      if (abs(lat) < 70)
+        // Check isn't really necessary ... (see above).
+        throw GeographicErr("Latitude " + Utility::str(lat)
+                            + "d more than 20d from "
+                            + (northp1 ? "N" : "S") + " pole");
+      PolarStereographic::UPS().Forward(northp1, lat, lon, x1, y1, gamma1, k1);
+    }
+    int ind = (utmp ? 2 : 0) + (northp1 ? 1 : 0);
+    x1 += falseeasting_[ind];
+    y1 += falsenorthing_[ind];
+    if (! CheckCoords(zone1 != UPS, northp1, x1, y1, mgrslimits, false) )
+      throw GeographicErr("Latitude " + Utility::str(lat)
+                          + ", longitude " + Utility::str(lon)
+                          + " out of legal range for "
+                          + (utmp ? "UTM zone " + Utility::str(zone1) : "UPS"));
+    zone = zone1;
+    northp = northp1;
+    x = x1;
+    y = y1;
+    gamma = gamma1;
+    k = k1;
+  }
+
+  void UTMUPS::Reverse(int zone, bool northp, real x, real y,
+                       real& lat, real& lon, real& gamma, real& k,
+                       bool mgrslimits) {
+    if (zone == INVALID || Math::isnan(x) || Math::isnan(y)) {
+      lat = lon = gamma = k = Math::NaN();
+      return;
+    }
+    if (!(zone >= MINZONE && zone <= MAXZONE))
+      throw GeographicErr("Zone " + Utility::str(zone)
+                          + " not in range [0, 60]");
+    bool utmp = zone != UPS;
+    CheckCoords(utmp, northp, x, y, mgrslimits);
+    int ind = (utmp ? 2 : 0) + (northp ? 1 : 0);
+    x -= falseeasting_[ind];
+    y -= falsenorthing_[ind];
+    if (utmp)
+      TransverseMercator::UTM().Reverse(CentralMeridian(zone),
+                                        x, y, lat, lon, gamma, k);
+    else
+      PolarStereographic::UPS().Reverse(northp, x, y, lat, lon, gamma, k);
+  }
+
+  bool UTMUPS::CheckCoords(bool utmp, bool northp, real x, real y,
+                           bool mgrslimits, bool throwp) {
+    // Limits are all multiples of 100km and are all closed on the both ends.
+    // Failure tests are such that NaNs succeed.
+    real slop = mgrslimits ? 0 : MGRS::tile_;
+    int ind = (utmp ? 2 : 0) + (northp ? 1 : 0);
+    if (x < mineasting_[ind] - slop || x > maxeasting_[ind] + slop) {
+      if (!throwp) return false;
+      throw GeographicErr("Easting " + Utility::str(x/1000) + "km not in "
+                          + (mgrslimits ? "MGRS/" : "")
+                          + (utmp ? "UTM" : "UPS") + " range for "
+                          + (northp ? "N" : "S" ) + " hemisphere ["
+                          + Utility::str((mineasting_[ind] - slop)/1000)
+                          + "km, "
+                          + Utility::str((maxeasting_[ind] + slop)/1000)
+                          + "km]");
+    }
+    if (y < minnorthing_[ind] - slop || y > maxnorthing_[ind] + slop) {
+      if (!throwp) return false;
+      throw GeographicErr("Northing " + Utility::str(y/1000) + "km not in "
+                          + (mgrslimits ? "MGRS/" : "")
+                          + (utmp ? "UTM" : "UPS") + " range for "
+                          + (northp ? "N" : "S" ) + " hemisphere ["
+                          + Utility::str((minnorthing_[ind] - slop)/1000)
+                          + "km, "
+                          + Utility::str((maxnorthing_[ind] + slop)/1000)
+                          + "km]");
+    }
+    return true;
+  }
+
+  void UTMUPS::Transfer(int zonein, bool northpin, real xin, real yin,
+                        int zoneout, bool northpout, real& xout, real& yout,
+                        int& zone) {
+    bool northp = northpin;
+    if (zonein != zoneout) {
+      // Determine lat, lon
+      real lat, lon;
+      GeographicLib::UTMUPS::Reverse(zonein, northpin, xin, yin, lat, lon);
+      // Try converting to zoneout
+      real x, y;
+      int zone1;
+      GeographicLib::UTMUPS::Forward(lat, lon, zone1, northp, x, y,
+                                     zoneout == UTMUPS::MATCH
+                                     ? zonein : zoneout);
+      if (zone1 == 0 && northp != northpout)
+        throw GeographicErr
+          ("Attempt to transfer UPS coordinates between hemispheres");
+      zone = zone1;
+      xout = x;
+      yout = y;
+    } else {
+      if (zoneout == 0 && northp != northpout)
+        throw GeographicErr
+          ("Attempt to transfer UPS coordinates between hemispheres");
+      zone = zoneout;
+      xout = xin;
+      yout = yin;
+    }
+    if (northp != northpout)
+      // Can't get here if UPS
+      yout += (northpout ? -1 : 1) * MGRS::utmNshift_;
+    return;
+  }
+
+  void UTMUPS::DecodeZone(const std::string& zonestr, int& zone, bool& northp) {
+    unsigned zlen = unsigned(zonestr.size());
+    if (zlen == 0)
+      throw GeographicErr("Empty zone specification");
+    // Longest zone spec is 32north, 42south, invalid = 7
+    if (zlen > 7)
+      throw GeographicErr("More than 7 characters in zone specification "
+                          + zonestr);
+
+    const char* c = zonestr.c_str();
+    char* q;
+    int zone1 = strtol(c, &q, 10);
+    // if (zone1 == 0) zone1 = UPS; (not necessary)
+
+    if (zone1 == UPS) {
+      if (!(q == c))
+        // Don't allow 0n as an alternative to n for UPS coordinates
+        throw GeographicErr("Illegal zone 0 in " + zonestr +
+                            ", use just the hemisphere for UPS");
+    } else if (!(zone1 >= MINUTMZONE && zone1 <= MAXUTMZONE))
+      throw GeographicErr("Zone " + Utility::str(zone1)
+                          + " not in range [1, 60]");
+    else if (!isdigit(zonestr[0]))
+      throw GeographicErr("Must use unsigned number for zone "
+                          + Utility::str(zone1));
+    else if (q - c > 2)
+      throw GeographicErr("More than 2 digits use to specify zone "
+                          + Utility::str(zone1));
+
+    string hemi = zonestr.substr(q - c);
+    transform(hemi.begin(), hemi.end(), hemi.begin(), (int(*)(int))tolower);
+    if (q == c && (hemi == "inv" || hemi == "invalid")) {
+      zone = INVALID;
+      northp = false;
+      return;
+    }
+    bool northp1 = hemi == "north" || hemi == "n";
+    if (!(northp1 || hemi == "south" || hemi == "s"))
+      throw GeographicErr(string("Illegal hemisphere ") + hemi + " in "
+                          + zonestr + ", specify north or south");
+    zone = zone1;
+    northp = northp1;
+  }
+
+  std::string UTMUPS::EncodeZone(int zone, bool northp, bool abbrev) {
+    if (zone == INVALID)
+      return string(abbrev ? "inv" : "invalid");
+    if (!(zone >= MINZONE && zone <= MAXZONE))
+      throw GeographicErr("Zone " + Utility::str(zone)
+                          + " not in range [0, 60]");
+    ostringstream os;
+    if (zone != UPS)
+      os << setfill('0') << setw(2) << zone;
+    if (abbrev)
+      os << (northp ? 'n' : 's');
+    else
+      os << (northp ? "north" : "south");
+    return os.str();
+  }
+
+  void UTMUPS::DecodeEPSG(int epsg, int& zone, bool& northp) {
+    northp = false;
+    if (epsg >= epsg01N && epsg <= epsg60N) {
+      zone = (epsg - epsg01N) + MINUTMZONE;
+      northp = true;
+    } else if (epsg == epsgN) {
+      zone = UPS;
+      northp = true;
+    } else if (epsg >= epsg01S && epsg <= epsg60S) {
+      zone = (epsg - epsg01S) + MINUTMZONE;
+    } else if (epsg == epsgS) {
+      zone = UPS;
+    } else {
+      zone = INVALID;
+    }
+  }
+
+  int UTMUPS::EncodeEPSG(int zone, bool northp) {
+    int epsg = -1;
+    if (zone == UPS)
+      epsg = epsgS;
+    else if (zone >= MINUTMZONE && zone <= MAXUTMZONE)
+      epsg = (zone - MINUTMZONE) + epsg01S;
+    if (epsg >= 0 && northp)
+      epsg += epsgN - epsgS;
+    return epsg;
+  }
+
+  Math::real UTMUPS::UTMShift() { return real(MGRS::utmNshift_); }
+
+} // namespace GeographicLib

data/ext/geographiclib/Utility.cpp

@@ -0,0 +1,61 @@
+/**
+ * \file Utility.cpp
+ * \brief Implementation for GeographicLib::Utility class
+ *
+ * Copyright (c) Charles Karney (2011) <charles@karney.com> and licensed under
+ * the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <cstdlib>
+#include <GeographicLib/Utility.hpp>
+
+#if defined(_MSC_VER)
+// Squelch warnings about unsafe use of getenv
+#  pragma warning (disable: 4996)
+#endif
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  bool Utility::ParseLine(const std::string& line,
+                          std::string& key, std::string& val) {
+    const char* spaces = " \t\n\v\f\r";
+    string::size_type n0 = line.find_first_not_of(spaces);
+    if (n0 == string::npos)
+      return false;             // Blank line
+    string::size_type n1 = line.find_first_of('#', n0);
+    if (n0 == n1)
+      return false;             // Only a comment
+    val = line.substr(n0, n1 == string::npos ? n1 : n1 - n0);
+    n0 = val.find_first_of(spaces);
+    key = val.substr(0, n0);
+    if (n0 == string::npos) {
+      val = "";
+      return true;
+    }
+    n0 = val.find_first_not_of(spaces, n0);
+    if (n0 == string::npos) {
+      val = "";
+      return true;
+    }
+    n1 = val.find_last_not_of(spaces);
+    val = val.substr(n0, n1 + 1 - n0);
+    return true;
+  }
+
+  int Utility::set_digits(int ndigits) {
+#if GEOGRAPHICLIB_PRECISION == 5
+    if (ndigits <= 0) {
+      char* digitenv = getenv("GEOGRAPHICLIB_DIGITS");
+      if (digitenv)
+        ndigits = strtol(digitenv, NULL, 0);
+      if (ndigits <= 0)
+        ndigits = 256;
+    }
+#endif
+    return Math::set_digits(ndigits);
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('geographiclib/geographiclib')

data/ext/geographiclib/geographiclib.cpp

@@ -0,0 +1,62 @@
+#include <ruby.h>
+#include <GeographicLib/Constants.hpp>
+#include <GeographicLib/Geodesic.hpp>
+
+static VALUE geographiclib_geodesic_direct(VALUE self, VALUE a, VALUE f, VALUE vlat1, VALUE vlon1, VALUE vazi1, VALUE arcmode, VALUE vs12_a12)
+{
+  GeographicLib::Geodesic g(NUM2DBL(a), NUM2DBL(f));
+  GeographicLib::Math::real lat1, lon1, s12_a12, lat2, lon2, s12, azi1, azi2, m12, M12, M21, S12;
+  lat1 = NUM2DBL(vlat1);
+  lon1 = NUM2DBL(vlon1);
+  azi1 = NUM2DBL(vazi1);
+  s12_a12 = NUM2DBL(vs12_a12);
+  g.GenDirect(lat1, lon1, azi1, arcmode, s12_a12, GeographicLib::Geodesic::ALL, lat2, lon2, azi2, s12, m12, M12, M21, S12);
+  VALUE r = rb_hash_new();
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("lat1")), DBL2NUM(lat1));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("lon1")), DBL2NUM(lon1));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("lat2")), DBL2NUM(lat2));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("lon2")), DBL2NUM(lon2));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("s12")), DBL2NUM(s12));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("azi1")), DBL2NUM(azi1));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("azi2")), DBL2NUM(azi2));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("m12")), DBL2NUM(m12));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("M12")), DBL2NUM(M12));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("M21")), DBL2NUM(M21));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("S12")), DBL2NUM(S12));
+  return r;
+}
+
+static VALUE geographiclib_geodesic_inverse(VALUE self, VALUE a, VALUE f, VALUE vlat1, VALUE vlon1, VALUE vlat2, VALUE vlon2)
+{
+  GeographicLib::Geodesic g(NUM2DBL(a), NUM2DBL(f));
+  GeographicLib::Math::real lat1, lon1, lat2, lon2, s12, azi1, azi2, m12, M12, M21, S12;
+  lat1 = NUM2DBL(vlat1);
+  lon1 = NUM2DBL(vlon1);
+  lat2 = NUM2DBL(vlat2);
+  lon2 = NUM2DBL(vlon2);
+  g.GenInverse(lat1, lon1, lat2, lon2, GeographicLib::Geodesic::ALL, s12, azi1, azi2, m12, M12, M21, S12);
+  VALUE r = rb_hash_new();
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("lat1")), DBL2NUM(lat1));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("lon1")), DBL2NUM(lon1));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("lat2")), DBL2NUM(lat2));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("lon2")), DBL2NUM(lon2));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("s12")), DBL2NUM(s12));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("azi1")), DBL2NUM(azi1));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("azi2")), DBL2NUM(azi2));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("m12")), DBL2NUM(m12));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("M12")), DBL2NUM(M12));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("M21")), DBL2NUM(M21));
+  rb_hash_aset(r, rb_id2sym(rb_intern_const("S12")), DBL2NUM(S12));
+  return r;
+}
+
+extern "C" void Init_geographiclib(void)
+{
+  VALUE geographiclib = rb_define_module("GeographicLib");
+  VALUE constants = rb_define_module_under(geographiclib, "Constants");
+  rb_define_const(constants, "WGS84_a", DBL2NUM(GeographicLib::Constants::WGS84_a()));
+  rb_define_const(constants, "WGS84_f", DBL2NUM(GeographicLib::Constants::WGS84_f()));
+  VALUE geodesic = rb_define_class_under(geographiclib, "Geodesic", rb_cObject);
+  rb_define_singleton_method(geodesic, "direct", (VALUE (*)(...)) geographiclib_geodesic_direct, 7);
+  rb_define_singleton_method(geodesic, "inverse", (VALUE (*)(...)) geographiclib_geodesic_inverse, 6);
+}

data/lib/geographiclib.rb

@@ -0,0 +1,20 @@
+require 'geographiclib/geographiclib'
+
+module GeographicLib
+  class Geodesic
+    def initialize a, f
+      @a = a
+      @f = f
+    end
+
+    def direct lat1, lon1, azi1, arcmode, s12_a12
+      Geodesic.direct @a, @f, lat1, lon1, azi1, !!arcmode, s12_a12
+    end
+
+    def inverse lat1, lon1, lat2, lon2
+      Geodesic.inverse @a, @f, lat1, lon1, lat2, lon2
+    end
+
+    WGS84 = Geodesic.new Constants::WGS84_a, Constants::WGS84_f
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: geographiclib
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Charles Karney <charles@karney.com>
+- Francesco Paolo Lovergine <frankie@debian.org> (autoconfiscation)
+- Mathieu Peyréga <mathieu.peyrega@gmail.com> (help with gravity models)
+- Andrew MacIntyre <Andrew.MacIntyre@acma.gov.au> (python/setup.py)
+- Skip Breidbach <skip@waywally.com> (maven support for Java)
+- Scott Heiman <mrmtdew2@outlook.com> (.NET wrappers + C# examples)
+- Chris Bennight <chris@bennight.com> (deploying Java library)
+- Sebastian Mattheis <Sebastian.Mattheis@bmw.de> (gnomonic projection in Java)
+- Yurij Mikhalevich <0@39.yt> (node.js port)
+- Phil Miller <phillip.miller@sri.com> (putting tests into python/setup.py)
+- Jonathan Takahashi <jtakahashi@gmail.com> (boost-python sample)
+- Lukas Joeressen <lukas@joeressen.net> (Ruby wrapper)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-28 00:00:00.000000000 Z
+dependencies: []
+description: A wrapper for GeograpicLib.
+email: "—"
+executables: []
+extensions:
+- ext/geographiclib/extconf.rb
+extra_rdoc_files: []
+files:
+- AUTHORS
+- LICENSE
+- ext/geographiclib/Accumulator.cpp
+- ext/geographiclib/AlbersEqualArea.cpp
+- ext/geographiclib/AzimuthalEquidistant.cpp
+- ext/geographiclib/CassiniSoldner.cpp
+- ext/geographiclib/CircularEngine.cpp
+- ext/geographiclib/DMS.cpp
+- ext/geographiclib/Ellipsoid.cpp
+- ext/geographiclib/EllipticFunction.cpp
+- ext/geographiclib/GARS.cpp
+- ext/geographiclib/GeoCoords.cpp
+- ext/geographiclib/Geocentric.cpp
+- ext/geographiclib/Geodesic.cpp
+- ext/geographiclib/GeodesicExact.cpp
+- ext/geographiclib/GeodesicExactC4.cpp
+- ext/geographiclib/GeodesicLine.cpp
+- ext/geographiclib/GeodesicLineExact.cpp
+- ext/geographiclib/GeographicLib/Accumulator.hpp
+- ext/geographiclib/GeographicLib/AlbersEqualArea.hpp
+- ext/geographiclib/GeographicLib/AzimuthalEquidistant.hpp
+- ext/geographiclib/GeographicLib/CassiniSoldner.hpp
+- ext/geographiclib/GeographicLib/CircularEngine.hpp
+- ext/geographiclib/GeographicLib/Config.h
+- ext/geographiclib/GeographicLib/Constants.hpp
+- ext/geographiclib/GeographicLib/DMS.hpp
+- ext/geographiclib/GeographicLib/Ellipsoid.hpp
+- ext/geographiclib/GeographicLib/EllipticFunction.hpp
+- ext/geographiclib/GeographicLib/GARS.hpp
+- ext/geographiclib/GeographicLib/GeoCoords.hpp
+- ext/geographiclib/GeographicLib/Geocentric.hpp
+- ext/geographiclib/GeographicLib/Geodesic.hpp
+- ext/geographiclib/GeographicLib/GeodesicExact.hpp
+- ext/geographiclib/GeographicLib/GeodesicLine.hpp
+- ext/geographiclib/GeographicLib/GeodesicLineExact.hpp
+- ext/geographiclib/GeographicLib/Geohash.hpp
+- ext/geographiclib/GeographicLib/Geoid.hpp
+- ext/geographiclib/GeographicLib/Georef.hpp
+- ext/geographiclib/GeographicLib/Gnomonic.hpp
+- ext/geographiclib/GeographicLib/GravityCircle.hpp
+- ext/geographiclib/GeographicLib/GravityModel.hpp
+- ext/geographiclib/GeographicLib/LambertConformalConic.hpp
+- ext/geographiclib/GeographicLib/LocalCartesian.hpp
+- ext/geographiclib/GeographicLib/MGRS.hpp
+- ext/geographiclib/GeographicLib/MagneticCircle.hpp
+- ext/geographiclib/GeographicLib/MagneticModel.hpp
+- ext/geographiclib/GeographicLib/Math.hpp
+- ext/geographiclib/GeographicLib/NormalGravity.hpp
+- ext/geographiclib/GeographicLib/OSGB.hpp
+- ext/geographiclib/GeographicLib/PolarStereographic.hpp
+- ext/geographiclib/GeographicLib/PolygonArea.hpp
+- ext/geographiclib/GeographicLib/Rhumb.hpp
+- ext/geographiclib/GeographicLib/SphericalEngine.hpp
+- ext/geographiclib/GeographicLib/SphericalHarmonic.hpp
+- ext/geographiclib/GeographicLib/SphericalHarmonic1.hpp
+- ext/geographiclib/GeographicLib/SphericalHarmonic2.hpp
+- ext/geographiclib/GeographicLib/TransverseMercator.hpp
+- ext/geographiclib/GeographicLib/TransverseMercatorExact.hpp
+- ext/geographiclib/GeographicLib/UTMUPS.hpp
+- ext/geographiclib/GeographicLib/Utility.hpp
+- ext/geographiclib/Geohash.cpp
+- ext/geographiclib/Geoid.cpp
+- ext/geographiclib/Georef.cpp
+- ext/geographiclib/Gnomonic.cpp
+- ext/geographiclib/GravityCircle.cpp
+- ext/geographiclib/GravityModel.cpp
+- ext/geographiclib/LambertConformalConic.cpp
+- ext/geographiclib/LocalCartesian.cpp
+- ext/geographiclib/MGRS.cpp
+- ext/geographiclib/MagneticCircle.cpp
+- ext/geographiclib/MagneticModel.cpp
+- ext/geographiclib/Math.cpp
+- ext/geographiclib/NormalGravity.cpp
+- ext/geographiclib/OSGB.cpp
+- ext/geographiclib/PolarStereographic.cpp
+- ext/geographiclib/PolygonArea.cpp
+- ext/geographiclib/Rhumb.cpp
+- ext/geographiclib/SphericalEngine.cpp
+- ext/geographiclib/TransverseMercator.cpp
+- ext/geographiclib/TransverseMercatorExact.cpp
+- ext/geographiclib/UTMUPS.cpp
+- ext/geographiclib/Utility.cpp
+- ext/geographiclib/extconf.rb
+- ext/geographiclib/geographiclib.cpp
+- lib/geographiclib.rb
+homepage: https://github.com/kext/ruby-geographiclib
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: GeograpicLib
+test_files: []