geographiclib 0.0.1

data/ext/geographiclib/AzimuthalEquidistant.cpp

@@ -0,0 +1,41 @@
+/**
+ * \file AzimuthalEquidistant.cpp
+ * \brief Implementation for GeographicLib::AzimuthalEquidistant class
+ *
+ * Copyright (c) Charles Karney (2009-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <GeographicLib/AzimuthalEquidistant.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  AzimuthalEquidistant::AzimuthalEquidistant(const Geodesic& earth)
+      : eps_(real(0.01) * sqrt(numeric_limits<real>::min()))
+      , _earth(earth) {}
+
+  void AzimuthalEquidistant::Forward(real lat0, real lon0, real lat, real lon,
+                                     real& x, real& y, real& azi, real& rk)
+    const {
+    real sig, s, azi0, m;
+    sig = _earth.Inverse(lat0, lon0, lat, lon, s, azi0, azi, m);
+    Math::sincosd(azi0, x, y);
+    x *= s; y *= s;
+    rk = !(sig <= eps_) ? m / s : 1;
+  }
+
+  void AzimuthalEquidistant::Reverse(real lat0, real lon0, real x, real y,
+                                     real& lat, real& lon, real& azi, real& rk)
+    const {
+    real
+      azi0 = Math::atan2d(x, y),
+      s = Math::hypot(x, y);
+    real sig, m;
+    sig = _earth.Direct(lat0, lon0, azi0, s, lat, lon, azi, m);
+    rk = !(sig <= eps_) ? m / s : 1;
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/CassiniSoldner.cpp

@@ -0,0 +1,89 @@
+/**
+ * \file CassiniSoldner.cpp
+ * \brief Implementation for GeographicLib::CassiniSoldner class
+ *
+ * Copyright (c) Charles Karney (2009-2015) <charles@karney.com> and licensed
+ * under the MIT/X11 License.  For more information, see
+ * http://geographiclib.sourceforge.net/
+ **********************************************************************/
+
+#include <GeographicLib/CassiniSoldner.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  CassiniSoldner::CassiniSoldner(const Geodesic& earth)
+    : _earth(earth) {}
+
+  CassiniSoldner::CassiniSoldner(real lat0, real lon0, const Geodesic& earth)
+    : _earth(earth)
+  { Reset(lat0, lon0); }
+
+  void CassiniSoldner::Reset(real lat0, real lon0) {
+    _meridian = _earth.Line(lat0, lon0, real(0),
+                            Geodesic::LATITUDE | Geodesic::LONGITUDE |
+                            Geodesic::DISTANCE | Geodesic::DISTANCE_IN |
+                            Geodesic::AZIMUTH);
+    real f = _earth.Flattening();
+    Math::sincosd(LatitudeOrigin(), _sbet0, _cbet0);
+    _sbet0 *= (1 - f);
+    Math::norm(_sbet0, _cbet0);
+  }
+
+  void CassiniSoldner::Forward(real lat, real lon, real& x, real& y,
+                               real& azi, real& rk) const {
+    if (!Init())
+      return;
+    real dlon = Math::AngDiff(LongitudeOrigin(), lon);
+    real sig12, s12, azi1, azi2;
+    sig12 = _earth.Inverse(lat, -abs(dlon), lat, abs(dlon), s12, azi1, azi2);
+    sig12 *= real(0.5);
+    s12 *= real(0.5);
+    if (s12 == 0) {
+      real da = Math::AngDiff(azi1, azi2)/2;
+      if (abs(dlon) <= 90) {
+        azi1 = 90 - da;
+        azi2 = 90 + da;
+      } else {
+        azi1 = -90 - da;
+        azi2 = -90 + da;
+      }
+    }
+    if (dlon < 0) {
+      azi2 = azi1;
+      s12 = -s12;
+      sig12 = -sig12;
+    }
+    x = s12;
+    azi = Math::AngNormalize(azi2);
+    GeodesicLine perp(_earth.Line(lat, dlon, azi, Geodesic::GEODESICSCALE));
+    real t;
+    perp.GenPosition(true, -sig12,
+                     Geodesic::GEODESICSCALE,
+                     t, t, t, t, t, t, rk, t);
+
+    real salp0, calp0;
+    Math::sincosd(perp.EquatorialAzimuth(), salp0, calp0);
+    real
+      sbet1 = lat >=0 ? calp0 : -calp0,
+      cbet1 = abs(dlon) <= 90 ? abs(salp0) : -abs(salp0),
+      sbet01 = sbet1 * _cbet0 - cbet1 * _sbet0,
+      cbet01 = cbet1 * _cbet0 + sbet1 * _sbet0,
+      sig01 = atan2(sbet01, cbet01) / Math::degree();
+    _meridian.GenPosition(true, sig01,
+                          Geodesic::DISTANCE,
+                          t, t, t, y, t, t, t, t);
+  }
+
+  void CassiniSoldner::Reverse(real x, real y, real& lat, real& lon,
+                               real& azi, real& rk) const {
+    if (!Init())
+      return;
+    real lat1, lon1;
+    real azi0, t;
+    _meridian.Position(y, lat1, lon1, azi0);
+    _earth.Direct(lat1, lon1, azi0 + 90, x, lat, lon, azi, rk, t);
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/CircularEngine.cpp

@@ -0,0 +1,96 @@
+/**
+ * \file CircularEngine.cpp
+ * \brief Implementation for GeographicLib::CircularEngine 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 <GeographicLib/CircularEngine.hpp>
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  Math::real CircularEngine::Value(bool gradp, real sl, real cl,
+                                   real& gradx, real& grady, real& gradz)
+    const {
+    gradp = _gradp && gradp;
+    const vector<real>& root_( SphericalEngine::root_ );
+
+    // Initialize outer sum
+    real vc  = 0, vc2  = 0, vs  = 0, vs2  = 0;   // v [N + 1], v [N + 2]
+    // vr, vt, vl and similar w variable accumulate the sums for the
+    // derivatives wrt r, theta, and lambda, respectively.
+    real vrc = 0, vrc2 = 0, vrs = 0, vrs2 = 0;   // vr[N + 1], vr[N + 2]
+    real vtc = 0, vtc2 = 0, vts = 0, vts2 = 0;   // vt[N + 1], vt[N + 2]
+    real vlc = 0, vlc2 = 0, vls = 0, vls2 = 0;   // vl[N + 1], vl[N + 2]
+    for (int m = _M; m >= 0; --m) {   // m = M .. 0
+      // Now Sc[m] = wc, Ss[m] = ws
+      // Sc'[m] = wtc, Ss'[m] = wtc
+      if (m) {
+        real v, A, B;           // alpha[m], beta[m + 1]
+        switch (_norm) {
+        case FULL:
+          v = root_[2] * root_[2 * m + 3] / root_[m + 1];
+          A = cl * v * _uq;
+          B = - v * root_[2 * m + 5] / (root_[8] * root_[m + 2]) * _uq2;
+          break;
+        case SCHMIDT:
+          v = root_[2] * root_[2 * m + 1] / root_[m + 1];
+          A = cl * v * _uq;
+          B = - v * root_[2 * m + 3] / (root_[8] * root_[m + 2]) * _uq2;
+          break;
+        default:
+          A = B = 0;
+        }
+        v = A * vc  + B * vc2  +  _wc[m] ; vc2  = vc ; vc  = v;
+        v = A * vs  + B * vs2  +  _ws[m] ; vs2  = vs ; vs  = v;
+        if (gradp) {
+          v = A * vrc + B * vrc2 +  _wrc[m]; vrc2 = vrc; vrc = v;
+          v = A * vrs + B * vrs2 +  _wrs[m]; vrs2 = vrs; vrs = v;
+          v = A * vtc + B * vtc2 +  _wtc[m]; vtc2 = vtc; vtc = v;
+          v = A * vts + B * vts2 +  _wts[m]; vts2 = vts; vts = v;
+          v = A * vlc + B * vlc2 + m*_ws[m]; vlc2 = vlc; vlc = v;
+          v = A * vls + B * vls2 - m*_wc[m]; vls2 = vls; vls = v;
+        }
+      } else {
+        real A, B, qs;
+        switch (_norm) {
+        case FULL:
+          A = root_[3] * _uq;       // F[1]/(q*cl) or F[1]/(q*sl)
+          B = - root_[15]/2 * _uq2; // beta[1]/q
+          break;
+        case SCHMIDT:
+          A = _uq;
+          B = - root_[3]/2 * _uq2;
+          break;
+        default:
+          A = B = 0;
+        }
+        qs = _q / SphericalEngine::scale();
+        vc = qs * (_wc[m] + A * (cl * vc + sl * vs ) + B * vc2);
+        if (gradp) {
+          qs /= _r;
+          // The components of the gradient in circular coordinates are
+          // r: dV/dr
+          // theta: 1/r * dV/dtheta
+          // lambda: 1/(r*u) * dV/dlambda
+          vrc =    - qs * (_wrc[m] + A * (cl * vrc + sl * vrs) + B * vrc2);
+          vtc =      qs * (_wtc[m] + A * (cl * vtc + sl * vts) + B * vtc2);
+          vlc = qs / _u * (          A * (cl * vlc + sl * vls) + B * vlc2);
+        }
+      }
+    }
+
+    if (gradp) {
+      // Rotate into cartesian (geocentric) coordinates
+      gradx = cl * (_u * vrc + _t * vtc) - sl * vlc;
+      grady = sl * (_u * vrc + _t * vtc) + cl * vlc;
+      gradz =           _t * vrc - _u * vtc                ;
+    }
+    return vc;
+  }
+
+} // namespace GeographicLib

data/ext/geographiclib/DMS.cpp

@@ -0,0 +1,381 @@
+/**
+ * \file DMS.cpp
+ * \brief Implementation for GeographicLib::DMS 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/DMS.hpp>
+#include <GeographicLib/Utility.hpp>
+
+#if defined(_MSC_VER)
+// Squelch warnings about constant conditional expressions
+#  pragma warning (disable: 4127)
+#endif
+
+namespace GeographicLib {
+
+  using namespace std;
+
+  const string DMS::hemispheres_ = "SNWE";
+  const string DMS::signs_ = "-+";
+  const string DMS::digits_ = "0123456789";
+  const string DMS::dmsindicators_ = "D'\":";
+  const string DMS::components_[] = {"degrees", "minutes", "seconds"};
+
+  Math::real DMS::Decode(const std::string& dms, flag& ind) {
+    string dmsa = dms;
+    replace(dmsa, "\xc2\xb0", 'd');      // U+00b0 degree symbol
+    replace(dmsa, "\xc2\xba", 'd');      // U+00ba alt symbol
+    replace(dmsa, "\xe2\x81\xb0", 'd');  // U+2070 sup zero
+    replace(dmsa, "\xcb\x9a", 'd');      // U+02da ring above
+    replace(dmsa, "\xe2\x80\xb2", '\''); // U+2032 prime
+    replace(dmsa, "\xc2\xb4", '\'');     // U+00b4 acute accent
+    replace(dmsa, "\xe2\x80\x99", '\''); // U+2019 right single quote
+    replace(dmsa, "\xe2\x80\xb3", '"');  // U+2033 double prime
+    replace(dmsa, "\xe2\x80\x9d", '"');  // U+201d right double quote
+    replace(dmsa, "\xe2\x88\x92", '-');  // U+2212 minus sign
+    replace(dmsa, "\xb0", 'd');          // 0xb0 bare degree symbol
+    replace(dmsa, "\xba", 'd');          // 0xba bare alt symbol
+    replace(dmsa, "\xb4", '\'');         // 0xb4 bare acute accent
+    replace(dmsa, "''", '"');            // '' -> "
+    string::size_type
+      beg = 0,
+      end = unsigned(dmsa.size());
+    while (beg < end && isspace(dmsa[beg]))
+      ++beg;
+    while (beg < end && isspace(dmsa[end - 1]))
+      --end;
+    // The trimmed string in [beg, end)
+    real v = 0;
+    int i = 0;
+    flag ind1 = NONE;
+    // p is pointer to the next piece that needs decoding
+    for (string::size_type p = beg, pb; p < end; p = pb, ++i) {
+      string::size_type pa = p;
+      // Skip over initial hemisphere letter (for i == 0)
+      if (i == 0 && Utility::lookup(hemispheres_, dmsa[pa]) >= 0)
+        ++pa;
+      // Skip over initial sign (checking for it if i == 0)
+      if (i > 0 || (pa < end && Utility::lookup(signs_, dmsa[pa]) >= 0))
+        ++pa;
+      // Find next sign
+      pb = min(dmsa.find_first_of(signs_, pa), end);
+      flag ind2 = NONE;
+      v += InternalDecode(dmsa.substr(p, pb - p), ind2);
+      if (ind1 == NONE)
+        ind1 = ind2;
+      else if (!(ind2 == NONE || ind1 == ind2))
+        throw GeographicErr("Incompatible hemisphere specifies in " +
+                            dmsa.substr(beg, pb - beg));
+    }
+    if (i == 0)
+      throw GeographicErr("Empty or incomplete DMS string " +
+                          dmsa.substr(beg, end - beg));
+    ind = ind1;
+    return v;
+  }
+
+  Math::real DMS::InternalDecode(const std::string& dmsa, flag& ind) {
+    string errormsg;
+    do {                       // Executed once (provides the ability to break)
+      int sign = 1;
+      unsigned
+        beg = 0,
+        end = unsigned(dmsa.size());
+      flag ind1 = NONE;
+      int k = -1;
+      if (end > beg && (k = Utility::lookup(hemispheres_, dmsa[beg])) >= 0) {
+        ind1 = (k / 2) ? LONGITUDE : LATITUDE;
+        sign = k % 2 ? 1 : -1;
+        ++beg;
+      }
+      if (end > beg && (k = Utility::lookup(hemispheres_, dmsa[end-1])) >= 0) {
+        if (k >= 0) {
+          if (ind1 != NONE) {
+            if (toupper(dmsa[beg - 1]) == toupper(dmsa[end - 1]))
+              errormsg = "Repeated hemisphere indicators "
+                + Utility::str(dmsa[beg - 1])
+                + " in " + dmsa.substr(beg - 1, end - beg + 1);
+            else
+              errormsg = "Contradictory hemisphere indicators "
+                + Utility::str(dmsa[beg - 1]) + " and "
+                + Utility::str(dmsa[end - 1]) + " in "
+                + dmsa.substr(beg - 1, end - beg + 1);
+            break;
+          }
+          ind1 = (k / 2) ? LONGITUDE : LATITUDE;
+          sign = k % 2 ? 1 : -1;
+          --end;
+        }
+      }
+      if (end > beg && (k = Utility::lookup(signs_, dmsa[beg])) >= 0) {
+        if (k >= 0) {
+          sign *= k ? 1 : -1;
+          ++beg;
+        }
+      }
+      if (end == beg) {
+        errormsg = "Empty or incomplete DMS string " + dmsa;
+        break;
+      }
+      real ipieces[] = {0, 0, 0};
+      real fpieces[] = {0, 0, 0};
+      unsigned npiece = 0;
+      real icurrent = 0;
+      real fcurrent = 0;
+      unsigned ncurrent = 0, p = beg;
+      bool pointseen = false;
+      unsigned digcount = 0, intcount = 0;
+      while (p < end) {
+        char x = dmsa[p++];
+        if ((k = Utility::lookup(digits_, x)) >= 0) {
+          ++ncurrent;
+          if (digcount > 0)
+            ++digcount;         // Count of decimal digits
+          else {
+            icurrent = 10 * icurrent + k;
+            ++intcount;
+          }
+        } else if (x == '.') {
+          if (pointseen) {
+            errormsg = "Multiple decimal points in "
+              + dmsa.substr(beg, end - beg);
+            break;
+          }
+          pointseen = true;
+          digcount = 1;
+        } else if ((k = Utility::lookup(dmsindicators_, x)) >= 0) {
+          if (k >= 3) {
+            if (p == end) {
+              errormsg = "Illegal for : to appear at the end of " +
+                dmsa.substr(beg, end - beg);
+              break;
+            }
+            k = npiece;
+          }
+          if (unsigned(k) == npiece - 1) {
+            errormsg = "Repeated " + components_[k] +
+              " component in " + dmsa.substr(beg, end - beg);
+            break;
+          } else if (unsigned(k) < npiece) {
+            errormsg = components_[k] + " component follows "
+              + components_[npiece - 1] + " component in "
+              + dmsa.substr(beg, end - beg);
+            break;
+          }
+          if (ncurrent == 0) {
+            errormsg = "Missing numbers in " + components_[k] +
+              " component of " + dmsa.substr(beg, end - beg);
+            break;
+          }
+          if (digcount > 0) {
+            istringstream s(dmsa.substr(p - intcount - digcount - 1,
+                                        intcount + digcount));
+            s >> fcurrent;
+            icurrent = 0;
+          }
+          ipieces[k] = icurrent;
+          fpieces[k] = icurrent + fcurrent;
+          if (p < end) {
+            npiece = k + 1;
+            icurrent = fcurrent = 0;
+            ncurrent = digcount = intcount = 0;
+          }
+        } else if (Utility::lookup(signs_, x) >= 0) {
+          errormsg = "Internal sign in DMS string "
+            + dmsa.substr(beg, end - beg);
+          break;
+        } else {
+          errormsg = "Illegal character " + Utility::str(x) + " in DMS string "
+            + dmsa.substr(beg, end - beg);
+          break;
+        }
+      }
+      if (!errormsg.empty())
+        break;
+      if (Utility::lookup(dmsindicators_, dmsa[p - 1]) < 0) {
+        if (npiece >= 3) {
+          errormsg = "Extra text following seconds in DMS string "
+            + dmsa.substr(beg, end - beg);
+          break;
+        }
+        if (ncurrent == 0) {
+          errormsg = "Missing numbers in trailing component of "
+            + dmsa.substr(beg, end - beg);
+          break;
+        }
+        if (digcount > 0) {
+          istringstream s(dmsa.substr(p - intcount - digcount,
+                                      intcount + digcount));
+          s >> fcurrent;
+          icurrent = 0;
+        }
+        ipieces[npiece] = icurrent;
+        fpieces[npiece] = icurrent + fcurrent;
+      }
+      if (pointseen && digcount == 0) {
+        errormsg = "Decimal point in non-terminal component of "
+          + dmsa.substr(beg, end - beg);
+        break;
+      }
+      // Note that we accept 59.999999... even though it rounds to 60.
+      if (ipieces[1] >= 60 || fpieces[1] > 60 ) {
+        errormsg = "Minutes " + Utility::str(fpieces[1])
+          + " not in range [0, 60)";
+        break;
+      }
+      if (ipieces[2] >= 60 || fpieces[2] > 60) {
+        errormsg = "Seconds " + Utility::str(fpieces[2])
+          + " not in range [0, 60)";
+        break;
+      }
+      ind = ind1;
+      // Assume check on range of result is made by calling routine (which
+      // might be able to offer a better diagnostic).
+      return real(sign) *
+        ( fpieces[2] ? (60*(60*fpieces[0] + fpieces[1]) + fpieces[2]) / 3600 :
+          ( fpieces[1] ? (60*fpieces[0] + fpieces[1]) / 60 : fpieces[0] ) );
+    } while (false);
+    real val = Utility::nummatch<real>(dmsa);
+    if (val == 0)
+      throw GeographicErr(errormsg);
+    else
+      ind = NONE;
+    return val;
+  }
+
+  void DMS::DecodeLatLon(const std::string& stra, const std::string& strb,
+                         real& lat, real& lon,
+                         bool longfirst) {
+    real a, b;
+    flag ia, ib;
+    a = Decode(stra, ia);
+    b = Decode(strb, ib);
+    if (ia == NONE && ib == NONE) {
+      // Default to lat, long unless longfirst
+      ia = longfirst ? LONGITUDE : LATITUDE;
+      ib = longfirst ? LATITUDE : LONGITUDE;
+    } else if (ia == NONE)
+      ia = flag(LATITUDE + LONGITUDE - ib);
+    else if (ib == NONE)
+      ib = flag(LATITUDE + LONGITUDE - ia);
+    if (ia == ib)
+      throw GeographicErr("Both " + stra + " and "
+                          + strb + " interpreted as "
+                          + (ia == LATITUDE ? "latitudes" : "longitudes"));
+    real
+      lat1 = ia == LATITUDE ? a : b,
+      lon1 = ia == LATITUDE ? b : a;
+    if (abs(lat1) > 90)
+      throw GeographicErr("Latitude " + Utility::str(lat1)
+                          + "d not in [-90d, 90d]");
+    lat = lat1;
+    lon = lon1;
+  }
+
+  Math::real DMS::DecodeAngle(const std::string& angstr) {
+    flag ind;
+    real ang = Decode(angstr, ind);
+    if (ind != NONE)
+      throw GeographicErr("Arc angle " + angstr
+                          + " includes a hemisphere, N/E/W/S");
+    return ang;
+  }
+
+  Math::real DMS::DecodeAzimuth(const std::string& azistr) {
+    flag ind;
+    real azi = Decode(azistr, ind);
+    if (ind == LATITUDE)
+      throw GeographicErr("Azimuth " + azistr
+                          + " has a latitude hemisphere, N/S");
+    return Math::AngNormalize(azi);
+  }
+
+  string DMS::Encode(real angle, component trailing, unsigned prec, flag ind,
+                     char dmssep) {
+    // Assume check on range of input angle has been made by calling
+    // routine (which might be able to offer a better diagnostic).
+    if (!Math::isfinite(angle))
+      return angle < 0 ? string("-inf") :
+        (angle > 0 ? string("inf") : string("nan"));
+
+    // 15 - 2 * trailing = ceiling(log10(2^53/90/60^trailing)).
+    // This suffices to give full real precision for numbers in [-90,90]
+    prec = min(15 + Math::extra_digits() - 2 * unsigned(trailing), prec);
+    real scale = 1;
+    for (unsigned i = 0; i < unsigned(trailing); ++i)
+      scale *= 60;
+    for (unsigned i = 0; i < prec; ++i)
+      scale *= 10;
+    if (ind == AZIMUTH)
+      angle -= floor(angle/360) * 360;
+    int sign = angle < 0 ? -1 : 1;
+    angle *= sign;
+
+    // Break off integer part to preserve precision in manipulation of
+    // fractional part.
+    real
+      idegree = floor(angle),
+      fdegree = (angle - idegree) * scale + real(0.5);
+    {
+      // Implement the "round ties to even" rule
+      real f = floor(fdegree);
+      fdegree = (f == fdegree && fmod(f, real(2)) == 1) ? f - 1 : f;
+    }
+    fdegree /= scale;
+    if (fdegree >= 1) {
+      idegree += 1;
+      fdegree -= 1;
+    }
+    real pieces[3] = {fdegree, 0, 0};
+    for (unsigned i = 1; i <= unsigned(trailing); ++i) {
+      real
+        ip = floor(pieces[i - 1]),
+        fp = pieces[i - 1] - ip;
+      pieces[i] = fp * 60;
+      pieces[i - 1] = ip;
+    }
+    pieces[0] += idegree;
+    ostringstream s;
+    s << fixed << setfill('0');
+    if (ind == NONE && sign < 0)
+      s << '-';
+    switch (trailing) {
+    case DEGREE:
+      if (ind != NONE)
+        s << setw(1 + min(int(ind), 2) + prec + (prec ? 1 : 0));
+      s << Utility::str(pieces[0], prec);
+      // Don't include degree designator (d) if it is the trailing component.
+      break;
+    default:
+      if (ind != NONE)
+        s << setw(1 + min(int(ind), 2));
+      s << int(pieces[0])
+        << (dmssep ? dmssep : char(tolower(dmsindicators_[0])));
+      switch (trailing) {
+      case MINUTE:
+        s << setw(2 + prec + (prec ? 1 : 0)) << Utility::str(pieces[1], prec);
+        if (!dmssep)
+          s << char(tolower(dmsindicators_[1]));
+        break;
+      case SECOND:
+        s << setw(2)
+          << int(pieces[1])
+          << (dmssep ? dmssep : char(tolower(dmsindicators_[1])))
+          << setw(2 + prec + (prec ? 1 : 0)) << Utility::str(pieces[2], prec);
+        if (!dmssep)
+          s << char(tolower(dmsindicators_[2]));
+        break;
+      default:
+        break;
+      }
+    }
+    if (ind != NONE && ind != AZIMUTH)
+      s << hemispheres_[(ind == LATITUDE ? 0 : 2) + (sign < 0 ? 0 : 1)];
+    return s.str();
+  }
+
+} // namespace GeographicLib