GeographicLib  2.0
DMS.cpp
Go to the documentation of this file.
1 /**
2  * \file DMS.cpp
3  * \brief Implementation for GeographicLib::DMS class
4  *
5  * Copyright (c) Charles Karney (2008-2022) <charles@karney.com> and licensed
6  * under the MIT/X11 License. For more information, see
7  * https://geographiclib.sourceforge.io/
8  **********************************************************************/
9 
10 #include <GeographicLib/DMS.hpp>
12 
13 #if defined(_MSC_VER)
14 // Squelch warnings about constant conditional expressions
15 # pragma warning (disable: 4127)
16 #endif
17 
18 namespace GeographicLib {
19 
20  using namespace std;
21 
22  const char* const DMS::hemispheres_ = "SNWE";
23  const char* const DMS::signs_ = "-+";
24  const char* const DMS::digits_ = "0123456789";
25  const char* const DMS::dmsindicators_ = "D'\":";
26  const char* const DMS::components_[] = {"degrees", "minutes", "seconds"};
27 
28  // Replace all occurrences of pat by c. If c is NULL remove pat.
29  void DMS::replace(std::string& s, const std::string& pat, char c) {
30  string::size_type p = 0;
31  int count = c ? 1 : 0;
32  while (true) {
33  p = s.find(pat, p);
34  if (p == string::npos)
35  break;
36  s.replace(p, pat.length(), count, c);
37  }
38  }
39 
40  Math::real DMS::Decode(const std::string& dms, flag& ind) {
41  // Here's a table of the allowed characters
42 
43  // S unicode dec UTF-8 descripton
44 
45  // DEGREE
46  // d U+0064 100 64 d
47  // D U+0044 68 44 D
48  // ° U+00b0 176 c2 b0 degree symbol
49  // º U+00ba 186 c2 ba alt symbol
50  // ⁰ U+2070 8304 e2 81 b0 sup zero
51  // ˚ U+02da 730 cb 9a ring above
52  // ∘ U+2218 8728 e2 88 98 compose function
53  // * U+002a 42 2a GRiD symbol for degrees
54 
55  // MINUTES
56  // ' U+0027 39 27 apostrophe
57  // ` U+0060 96 60 grave accent
58  // ′ U+2032 8242 e2 80 b2 prime
59  // ‵ U+2035 8245 e2 80 b5 back prime
60  // ´ U+00b4 180 c2 b4 acute accent
61  // ‘ U+2018 8216 e2 80 98 left single quote (also ext ASCII 0x91)
62  // ’ U+2019 8217 e2 80 99 right single quote (also ext ASCII 0x92)
63  // ‛ U+201b 8219 e2 80 9b reversed-9 single quote
64  // ʹ U+02b9 697 ca b9 modifier letter prime
65  // ˊ U+02ca 714 cb 8a modifier letter acute accent
66  // ˋ U+02cb 715 cb 8b modifier letter grave accent
67 
68  // SECONDS
69  // " U+0022 34 22 quotation mark
70  // ″ U+2033 8243 e2 80 b3 double prime
71  // ‶ U+2036 8246 e2 80 b6 reversed double prime
72  // ˝ U+02dd 733 cb 9d double acute accent
73  // “ U+201c 8220 e2 80 9c left double quote (also ext ASCII 0x93)
74  // ” U+201d 8221 e2 80 9d right double quote (also ext ASCII 0x94)
75  // ‟ U+201f 8223 e2 80 9f reversed-9 double quote
76  // ʺ U+02ba 698 ca ba modifier letter double prime
77 
78  // PLUS
79  // + U+002b 43 2b plus sign
80  // ➕ U+2795 10133 e2 9e 95 heavy plus
81  // U+2064 8292 e2 81 a4 invisible plus |⁤|
82 
83  // MINUS
84  // - U+002d 45 2d hyphen
85  // ‐ U+2010 8208 e2 80 90 dash
86  // ‑ U+2011 8209 e2 80 91 non-breaking hyphen
87  // – U+2013 8211 e2 80 93 en dash (also ext ASCII 0x96)
88  // — U+2014 8212 e2 80 94 em dash (also ext ASCII 0x97)
89  // − U+2212 8722 e2 88 92 minus sign
90  // ➖ U+2796 10134 e2 9e 96 heavy minus
91 
92  // IGNORED
93  //   U+00a0 160 c2 a0 non-breaking space
94  // U+2007 8199 e2 80 87 figure space | |
95  // U+2009 8201 e2 80 89 thin space | |
96  // U+200a 8202 e2 80 8a hair space | |
97  // U+200b 8203 e2 80 8b invisible space |​|
98  //   U+202f 8239 e2 80 af narrow space | |
99  // U+2063 8291 e2 81 a3 invisible separator |⁣|
100  // « U+00ab 171 c2 ab left guillemot (for cgi-bin)
101  // » U+00bb 187 c2 bb right guillemot (for cgi-bin)
102 
103  string dmsa = dms;
104  replace(dmsa, "\xc2\xb0", 'd' ); // U+00b0 degree symbol
105  replace(dmsa, "\xc2\xba", 'd' ); // U+00ba alt symbol
106  replace(dmsa, "\xe2\x81\xb0", 'd' ); // U+2070 sup zero
107  replace(dmsa, "\xcb\x9a", 'd' ); // U+02da ring above
108  replace(dmsa, "\xe2\x88\x98", 'd' ); // U+2218 compose function
109 
110  replace(dmsa, "\xe2\x80\xb2", '\''); // U+2032 prime
111  replace(dmsa, "\xe2\x80\xb5", '\''); // U+2035 back prime
112  replace(dmsa, "\xc2\xb4", '\''); // U+00b4 acute accent
113  replace(dmsa, "\xe2\x80\x98", '\''); // U+2018 left single quote
114  replace(dmsa, "\xe2\x80\x99", '\''); // U+2019 right single quote
115  replace(dmsa, "\xe2\x80\x9b", '\''); // U+201b reversed-9 single quote
116  replace(dmsa, "\xca\xb9", '\''); // U+02b9 modifier letter prime
117  replace(dmsa, "\xcb\x8a", '\''); // U+02ca modifier letter acute accent
118  replace(dmsa, "\xcb\x8b", '\''); // U+02cb modifier letter grave accent
119 
120  replace(dmsa, "\xe2\x80\xb3", '"' ); // U+2033 double prime
121  replace(dmsa, "\xe2\x80\xb6", '"' ); // U+2036 reversed double prime
122  replace(dmsa, "\xcb\x9d", '"' ); // U+02dd double acute accent
123  replace(dmsa, "\xe2\x80\x9c", '"' ); // U+201c left double quote
124  replace(dmsa, "\xe2\x80\x9d", '"' ); // U+201d right double quote
125  replace(dmsa, "\xe2\x80\x9f", '"' ); // U+201f reversed-9 double quote
126  replace(dmsa, "\xca\xba", '"' ); // U+02ba modifier letter double prime
127 
128  replace(dmsa, "\xe2\x9e\x95", '+' ); // U+2795 heavy plus
129  replace(dmsa, "\xe2\x81\xa4", '+' ); // U+2064 invisible plus
130 
131  replace(dmsa, "\xe2\x80\x90", '-' ); // U+2010 dash
132  replace(dmsa, "\xe2\x80\x91", '-' ); // U+2011 non-breaking hyphen
133  replace(dmsa, "\xe2\x80\x93", '-' ); // U+2013 en dash
134  replace(dmsa, "\xe2\x80\x94", '-' ); // U+2014 em dash
135  replace(dmsa, "\xe2\x88\x92", '-' ); // U+2212 minus sign
136  replace(dmsa, "\xe2\x9e\x96", '-' ); // U+2796 heavy minus
137 
138  replace(dmsa, "\xc2\xa0", '\0'); // U+00a0 non-breaking space
139  replace(dmsa, "\xe2\x80\x87", '\0'); // U+2007 figure space
140  replace(dmsa, "\xe2\x80\x89", '\0'); // U+2007 thin space
141  replace(dmsa, "\xe2\x80\x8a", '\0'); // U+200a hair space
142  replace(dmsa, "\xe2\x80\x8b", '\0'); // U+200b invisible space
143  replace(dmsa, "\xe2\x80\xaf", '\0'); // U+202f narrow space
144  replace(dmsa, "\xe2\x81\xa3", '\0'); // U+2063 invisible separator
145 
146  replace(dmsa, "\xb0", 'd' ); // 0xb0 bare degree symbol
147  replace(dmsa, "\xba", 'd' ); // 0xba bare alt symbol
148  replace(dmsa, "*", 'd' ); // GRiD symbol for degree
149  replace(dmsa, "`", '\''); // grave accent
150  replace(dmsa, "\xb4", '\''); // 0xb4 bare acute accent
151  // Don't implement these alternatives; they are only relevant for cgi-bin
152  // replace(dmsa, "\x91", '\''); // 0x91 ext ASCII left single quote
153  // replace(dmsa, "\x92", '\''); // 0x92 ext ASCII right single quote
154  // replace(dmsa, "\x93", '"' ); // 0x93 ext ASCII left double quote
155  // replace(dmsa, "\x94", '"' ); // 0x94 ext ASCII right double quote
156  // replace(dmsa, "\x96", '-' ); // 0x96 ext ASCII en dash
157  // replace(dmsa, "\x97", '-' ); // 0x97 ext ASCII em dash
158  replace(dmsa, "\xa0", '\0'); // 0xa0 bare non-breaking space
159  replace(dmsa, "''", '"' ); // '' -> "
160  string::size_type
161  beg = 0,
162  end = unsigned(dmsa.size());
163  while (beg < end && isspace(dmsa[beg]))
164  ++beg;
165  while (beg < end && isspace(dmsa[end - 1]))
166  --end;
167  // The trimmed string in [beg, end)
168  real v = -0.0; // So "-0" returns -0.0
169  int i = 0;
170  flag ind1 = NONE;
171  // p is pointer to the next piece that needs decoding
172  for (string::size_type p = beg, pb; p < end; p = pb, ++i) {
173  string::size_type pa = p;
174  // Skip over initial hemisphere letter (for i == 0)
175  if (i == 0 && Utility::lookup(hemispheres_, dmsa[pa]) >= 0)
176  ++pa;
177  // Skip over initial sign (checking for it if i == 0)
178  if (i > 0 || (pa < end && Utility::lookup(signs_, dmsa[pa]) >= 0))
179  ++pa;
180  // Find next sign
181  pb = min(dmsa.find_first_of(signs_, pa), end);
182  flag ind2 = NONE;
183  v += InternalDecode(dmsa.substr(p, pb - p), ind2);
184  if (ind1 == NONE)
185  ind1 = ind2;
186  else if (!(ind2 == NONE || ind1 == ind2))
187  throw GeographicErr("Incompatible hemisphere specifier in " +
188  dmsa.substr(beg, pb - beg));
189  }
190  if (i == 0)
191  throw GeographicErr("Empty or incomplete DMS string " +
192  dmsa.substr(beg, end - beg));
193  ind = ind1;
194  return v;
195  }
196 
197  Math::real DMS::InternalDecode(const string& dmsa, flag& ind) {
198  string errormsg;
199  do { // Executed once (provides the ability to break)
200  int sign = 1;
201  unsigned
202  beg = 0,
203  end = unsigned(dmsa.size());
204  flag ind1 = NONE;
205  int k = -1;
206  if (end > beg && (k = Utility::lookup(hemispheres_, dmsa[beg])) >= 0) {
207  ind1 = (k / 2) ? LONGITUDE : LATITUDE;
208  sign = k % 2 ? 1 : -1;
209  ++beg;
210  }
211  if (end > beg && (k = Utility::lookup(hemispheres_, dmsa[end-1])) >= 0) {
212  if (k >= 0) {
213  if (ind1 != NONE) {
214  if (toupper(dmsa[beg - 1]) == toupper(dmsa[end - 1]))
215  errormsg = "Repeated hemisphere indicators "
216  + Utility::str(dmsa[beg - 1])
217  + " in " + dmsa.substr(beg - 1, end - beg + 1);
218  else
219  errormsg = "Contradictory hemisphere indicators "
220  + Utility::str(dmsa[beg - 1]) + " and "
221  + Utility::str(dmsa[end - 1]) + " in "
222  + dmsa.substr(beg - 1, end - beg + 1);
223  break;
224  }
225  ind1 = (k / 2) ? LONGITUDE : LATITUDE;
226  sign = k % 2 ? 1 : -1;
227  --end;
228  }
229  }
230  if (end > beg && (k = Utility::lookup(signs_, dmsa[beg])) >= 0) {
231  if (k >= 0) {
232  sign *= k ? 1 : -1;
233  ++beg;
234  }
235  }
236  if (end == beg) {
237  errormsg = "Empty or incomplete DMS string " + dmsa;
238  break;
239  }
240  real ipieces[] = {0, 0, 0};
241  real fpieces[] = {0, 0, 0};
242  unsigned npiece = 0;
243  real icurrent = 0;
244  real fcurrent = 0;
245  unsigned ncurrent = 0, p = beg;
246  bool pointseen = false;
247  unsigned digcount = 0, intcount = 0;
248  while (p < end) {
249  char x = dmsa[p++];
250  if ((k = Utility::lookup(digits_, x)) >= 0) {
251  ++ncurrent;
252  if (digcount > 0)
253  ++digcount; // Count of decimal digits
254  else {
255  icurrent = 10 * icurrent + k;
256  ++intcount;
257  }
258  } else if (x == '.') {
259  if (pointseen) {
260  errormsg = "Multiple decimal points in "
261  + dmsa.substr(beg, end - beg);
262  break;
263  }
264  pointseen = true;
265  digcount = 1;
266  } else if ((k = Utility::lookup(dmsindicators_, x)) >= 0) {
267  if (k >= 3) {
268  if (p == end) {
269  errormsg = "Illegal for : to appear at the end of " +
270  dmsa.substr(beg, end - beg);
271  break;
272  }
273  k = npiece;
274  }
275  if (unsigned(k) == npiece - 1) {
276  errormsg = "Repeated " + string(components_[k]) +
277  " component in " + dmsa.substr(beg, end - beg);
278  break;
279  } else if (unsigned(k) < npiece) {
280  errormsg = string(components_[k]) + " component follows "
281  + string(components_[npiece - 1]) + " component in "
282  + dmsa.substr(beg, end - beg);
283  break;
284  }
285  if (ncurrent == 0) {
286  errormsg = "Missing numbers in " + string(components_[k]) +
287  " component of " + dmsa.substr(beg, end - beg);
288  break;
289  }
290  if (digcount > 0) {
291  istringstream s(dmsa.substr(p - intcount - digcount - 1,
292  intcount + digcount));
293  s >> fcurrent;
294  icurrent = 0;
295  }
296  ipieces[k] = icurrent;
297  fpieces[k] = icurrent + fcurrent;
298  if (p < end) {
299  npiece = k + 1;
300  icurrent = fcurrent = 0;
301  ncurrent = digcount = intcount = 0;
302  }
303  } else if (Utility::lookup(signs_, x) >= 0) {
304  errormsg = "Internal sign in DMS string "
305  + dmsa.substr(beg, end - beg);
306  break;
307  } else {
308  errormsg = "Illegal character " + Utility::str(x) + " in DMS string "
309  + dmsa.substr(beg, end - beg);
310  break;
311  }
312  }
313  if (!errormsg.empty())
314  break;
315  if (Utility::lookup(dmsindicators_, dmsa[p - 1]) < 0) {
316  if (npiece >= 3) {
317  errormsg = "Extra text following seconds in DMS string "
318  + dmsa.substr(beg, end - beg);
319  break;
320  }
321  if (ncurrent == 0) {
322  errormsg = "Missing numbers in trailing component of "
323  + dmsa.substr(beg, end - beg);
324  break;
325  }
326  if (digcount > 0) {
327  istringstream s(dmsa.substr(p - intcount - digcount,
328  intcount + digcount));
329  s >> fcurrent;
330  icurrent = 0;
331  }
332  ipieces[npiece] = icurrent;
333  fpieces[npiece] = icurrent + fcurrent;
334  }
335  if (pointseen && digcount == 0) {
336  errormsg = "Decimal point in non-terminal component of "
337  + dmsa.substr(beg, end - beg);
338  break;
339  }
340  // Note that we accept 59.999999... even though it rounds to 60.
341  if (ipieces[1] >= Math::dm || fpieces[1] > Math::dm ) {
342  errormsg = "Minutes " + Utility::str(fpieces[1])
343  + " not in range [0, " + to_string(Math::dm) + ")";
344  break;
345  }
346  if (ipieces[2] >= Math::ms || fpieces[2] > Math::ms) {
347  errormsg = "Seconds " + Utility::str(fpieces[2])
348  + " not in range [0, " + to_string(Math::ms) + ")";
349  break;
350  }
351  ind = ind1;
352  // Assume check on range of result is made by calling routine (which
353  // might be able to offer a better diagnostic).
354  return real(sign) *
355  ( fpieces[2] != 0 ?
356  (Math::ms*(Math::dm*fpieces[0] + fpieces[1]) + fpieces[2])/Math::ds :
357  ( fpieces[1] != 0 ?
358  (Math::dm*fpieces[0] + fpieces[1]) / Math::dm : fpieces[0] ) );
359  } while (false);
360  real val = Utility::nummatch<real>(dmsa);
361  if (val == 0)
362  throw GeographicErr(errormsg);
363  else
364  ind = NONE;
365  return val;
366  }
367 
368  void DMS::DecodeLatLon(const string& stra, const string& strb,
369  real& lat, real& lon,
370  bool longfirst) {
371  real a, b;
372  flag ia, ib;
373  a = Decode(stra, ia);
374  b = Decode(strb, ib);
375  if (ia == NONE && ib == NONE) {
376  // Default to lat, long unless longfirst
377  ia = longfirst ? LONGITUDE : LATITUDE;
378  ib = longfirst ? LATITUDE : LONGITUDE;
379  } else if (ia == NONE)
380  ia = flag(LATITUDE + LONGITUDE - ib);
381  else if (ib == NONE)
382  ib = flag(LATITUDE + LONGITUDE - ia);
383  if (ia == ib)
384  throw GeographicErr("Both " + stra + " and "
385  + strb + " interpreted as "
386  + (ia == LATITUDE ? "latitudes" : "longitudes"));
387  real
388  lat1 = ia == LATITUDE ? a : b,
389  lon1 = ia == LATITUDE ? b : a;
390  if (fabs(lat1) > Math::qd)
391  throw GeographicErr("Latitude " + Utility::str(lat1)
392  + "d not in [-" + to_string(Math::qd)
393  + "d, " + to_string(Math::qd) + "d]");
394  lat = lat1;
395  lon = lon1;
396  }
397 
398  Math::real DMS::DecodeAngle(const string& angstr) {
399  flag ind;
400  real ang = Decode(angstr, ind);
401  if (ind != NONE)
402  throw GeographicErr("Arc angle " + angstr
403  + " includes a hemisphere, N/E/W/S");
404  return ang;
405  }
406 
407  Math::real DMS::DecodeAzimuth(const string& azistr) {
408  flag ind;
409  real azi = Decode(azistr, ind);
410  if (ind == LATITUDE)
411  throw GeographicErr("Azimuth " + azistr
412  + " has a latitude hemisphere, N/S");
413  return Math::AngNormalize(azi);
414  }
415 
416  string DMS::Encode(real angle, component trailing, unsigned prec, flag ind,
417  char dmssep) {
418  // Assume check on range of input angle has been made by calling
419  // routine (which might be able to offer a better diagnostic).
420  if (!isfinite(angle))
421  return angle < 0 ? string("-inf") :
422  (angle > 0 ? string("inf") : string("nan"));
423 
424  // 15 - 2 * trailing = ceiling(log10(2^53/90/60^trailing)).
425  // This suffices to give full real precision for numbers in [-90,90]
426  prec = min(15 + Math::extra_digits() - 2 * unsigned(trailing), prec);
427  real scale = trailing == MINUTE ? Math::dm :
428  (trailing == SECOND ? Math::ds : 1);
429  if (ind == AZIMUTH) {
430  angle = Math::AngNormalize(angle);
431  // Only angles strictly less than 0 can become 360; since +/-180 are
432  // folded together, we convert -0 to +0 (instead of 360).
433  if (angle < 0)
434  angle += Math::td;
435  else
436  angle = Math::real(0) + angle;
437  }
438  int sign = signbit(angle) ? -1 : 1;
439  angle *= sign;
440 
441  // Break off integer part to preserve precision and avoid overflow in
442  // manipulation of fractional part for MINUTE and SECOND
443  real
444  idegree = trailing == DEGREE ? 0 : floor(angle),
445  fdegree = (angle - idegree) * scale;
446  string s = Utility::str(fdegree, prec), degree, minute, second;
447  switch (trailing) {
448  case DEGREE:
449  degree = s;
450  break;
451  default: // case MINUTE: case SECOND:
452  string::size_type p = s.find_first_of('.');
453  long long i;
454  if (p == 0)
455  i = 0;
456  else {
457  i = stoll(s);
458  if (p == string::npos)
459  s.clear();
460  else
461  s = s.substr(p);
462  }
463  // Now i in [0,Math::dm] or [0,Math::ds] for MINUTE/DEGREE
464  switch (trailing) {
465  case MINUTE:
466  minute = to_string(i % Math::dm) + s; i /= Math::dm;
467  degree = Utility::str(i + idegree, 0); // no overflow since i in [0,1]
468  break;
469  default: // case SECOND:
470  second = to_string(i % Math::ms) + s; i /= Math::ms;
471  minute = to_string(i % Math::dm) ; i /= Math::dm;
472  degree = Utility::str(i + idegree, 0); // no overflow since i in [0,1]
473  break;
474  }
475  break;
476  }
477  // No glue together degree+minute+second with
478  // sign + zero-fill + delimiters + hemisphere
479  ostringstream str;
480  if (prec) ++prec; // Extra width for decimal point
481  if (ind == NONE && sign < 0)
482  str << '-';
483  str << setfill('0');
484  switch (trailing) {
485  case DEGREE:
486  if (ind != NONE)
487  str << setw(1 + min(int(ind), 2) + prec);
488  str << degree;
489  // Don't include degree designator (d) if it is the trailing component.
490  break;
491  case MINUTE:
492  if (ind != NONE)
493  str << setw(1 + min(int(ind), 2));
494  str << degree << (dmssep ? dmssep : char(tolower(dmsindicators_[0])))
495  << setw(2 + prec) << minute;
496  if (!dmssep)
497  str << char(tolower(dmsindicators_[1]));
498  break;
499  default: // case SECOND:
500  if (ind != NONE)
501  str << setw(1 + min(int(ind), 2));
502  str << degree << (dmssep ? dmssep : char(tolower(dmsindicators_[0])))
503  << setw(2)
504  << minute << (dmssep ? dmssep : char(tolower(dmsindicators_[1])))
505  << setw(2 + prec) << second;
506  if (!dmssep)
507  str << char(tolower(dmsindicators_[2]));
508  break;
509  }
510  if (ind != NONE && ind != AZIMUTH)
511  str << hemispheres_[(ind == LATITUDE ? 0 : 2) + (sign < 0 ? 0 : 1)];
512  return str.str();
513  }
514 
515 } // namespace GeographicLib
Header for GeographicLib::DMS class.
GeographicLib::Math::real real
Definition: GeodSolve.cpp:31
Header for GeographicLib::Utility class.
static Math::real DecodeAzimuth(const std::string &azistr)
Definition: DMS.cpp:407
static Math::real DecodeAngle(const std::string &angstr)
Definition: DMS.cpp:398
static std::string Encode(real angle, component trailing, unsigned prec, flag ind=NONE, char dmssep=char(0))
Definition: DMS.cpp:416
static void DecodeLatLon(const std::string &dmsa, const std::string &dmsb, real &lat, real &lon, bool longfirst=false)
Definition: DMS.cpp:368
static Math::real Decode(const std::string &dms, flag &ind)
Definition: DMS.cpp:40
Exception handling for GeographicLib.
Definition: Constants.hpp:316
static T AngNormalize(T x)
Definition: Math.cpp:71
@ dm
minutes per degree
Definition: Math.hpp:142
@ td
degrees per turn
Definition: Math.hpp:145
@ ms
seconds per minute
Definition: Math.hpp:143
@ ds
seconds per degree
Definition: Math.hpp:146
@ qd
degrees per quarter turn
Definition: Math.hpp:141
static int extra_digits()
Definition: Math.cpp:51
static int lookup(const std::string &s, char c)
Definition: Utility.cpp:160
static std::string str(T x, int p=-1)
Definition: Utility.hpp:161
Namespace for GeographicLib.
Definition: Accumulator.cpp:12