src/marnav/geo/angle.cpp

   1 #include "angle.hpp"
   2 #include <algorithm>
   3 #include <stdexcept>
   4 #include <cmath>
   5 #include <marnav/math/floatingpoint.hpp>
   6
   7 namespace marnav
   8 {
   9 namespace geo
  10 {
  11 /// Returns the degrees of this angle. This value is always positive.
  12 uint32_t angle::degrees() const noexcept
  13 {
  14         auto a = std::abs(get());
  15         a = std::floor(a);
  16         return static_cast<uint32_t>(a);
  17 }
  18
  19 /// Returns the minutes of this angle. This value is always positive
  20 /// and is between 0 and 59.
  21 uint32_t angle::minutes() const noexcept
  22 {
  23         auto a = std::abs(get());
  24         a -= std::floor(a);
  25         a *= 60.0;
  26         a += epsilon;
  27         return static_cast<uint32_t>(a);
  28 }
  29
  30 /// Returns the seconds of this angle.
  31 double angle::seconds() const noexcept
  32 {
  33         auto a = std::abs(get());
  34         a -= std::floor(a);
  35         a *= 60.0;
  36         a += epsilon;
  37         a -= std::floor(a);
  38         a *= 60.0;
  39         return a;
  40 }
  41
  42 void swap(angle & a, angle & b) noexcept { std::swap(a.value, b.value); }
  43
  44 bool operator==(const angle & a, const angle & b) noexcept
  45 {
  46         return (&a == &b) || math::is_same(a.value, b.value, angle::epsilon);
  47 }
  48
  49 bool operator!=(const angle & a, const angle & b) noexcept { return !(a == b); }
  50
  51 /// Constructs a latitude with the specified angle in degrees.
  52 latitude::latitude(double deg)
  53         : angle(deg)
  54 {
  55         check(get());
  56 }
  57
  58 /// Initializes the object with the specified angle.
  59 /// Corrects the stored value according to the specified hemisphere.
  60 ///
  61 /// @param[in] degrees Angle in degrees.
  62 /// @param[in] h Hemisphere
  63 latitude::latitude(double degrees, hemisphere h)
  64         : angle(degrees)
  65 {
  66         check(get());
  67
  68         switch (h) {
  69                 case hemisphere::north:
  70                         if (hem() == hemisphere::south)
  71                                 set(-get());
  72                         break;
  73                 case hemisphere::south:
  74                         if (hem() == hemisphere::north)
  75                                 set(-get());
  76                         break;
  77         }
  78 }
  79
  80 latitude::latitude(uint32_t d, uint32_t m, uint32_t s, hemisphere h)
  81         : angle((static_cast<double>(d) + static_cast<double>(m) / 60.0
  82                                 + static_cast<double>(s) / 3600.0)
  83                   * ((h == hemisphere::south) ? -1.0 : 1.0))
  84 {
  85         check(get());
  86 }
  87
  88 bool operator==(const latitude & a, const latitude & b) noexcept
  89 {
  90         return (&a == &b) || math::is_same(a.get(), b.get(), angle::epsilon);
  91 }
  92
  93 bool operator!=(const latitude & a, const latitude & b) noexcept { return !(a == b); }
  94
  95 void latitude::check(double a)
  96 {
  97         if ((a < min) || (a > max))
  98                 throw std::invalid_argument{"invalid value for nmea::latitude"};
  99 }
 100
 101 std::string to_string(latitude::hemisphere h)
 102 {
 103         switch (h) {
 104                 case latitude::hemisphere::north:
 105                         return "N";
 106                 case latitude::hemisphere::south:
 107                         return "S";
 108         }
 109         return "?";
 110 }
 111
 112 /// Constructs a longitude with the specified angle in degrees.
 113 longitude::longitude(double deg)
 114         : angle(deg)
 115 {
 116         check(get());
 117 }
 118
 119 /// Initializes the object with the specified angle.
 120 /// Corrects the stored value according to the specified hemisphere.
 121 ///
 122 /// @param[in] degrees Angle in degrees.
 123 /// @param[in] h Hemisphere
 124 longitude::longitude(double degrees, hemisphere h)
 125         : angle(degrees)
 126 {
 127         check(get());
 128
 129         switch (h) {
 130                 case hemisphere::east:
 131                         if (hem() == hemisphere::west)
 132                                 set(-get());
 133                         break;
 134                 case hemisphere::west:
 135                         if (hem() == hemisphere::east)
 136                                 set(-get());
 137                         break;
 138         }
 139 }
 140
 141 longitude::longitude(uint32_t d, uint32_t m, uint32_t s, hemisphere h)
 142         : angle((static_cast<double>(d) + static_cast<double>(m) / 60.0
 143                                 + static_cast<double>(s) / 3600.0)
 144                   * ((h == hemisphere::east) ? +1.0 : -1.0))
 145 {
 146         check(get());
 147 }
 148
 149 bool operator==(const longitude & a, const longitude & b) noexcept
 150 {
 151         return (&a == &b) || math::is_same(a.get(), b.get(), angle::epsilon);
 152 }
 153
 154 bool operator!=(const longitude & a, const longitude & b) noexcept { return !(a == b); }
 155
 156 void longitude::check(double a)
 157 {
 158         if ((a < min) || (a > max))
 159                 throw std::invalid_argument{"invalid value for nmea::longitude"};
 160 }
 161
 162 std::string to_string(longitude::hemisphere h)
 163 {
 164         switch (h) {
 165                 case longitude::hemisphere::east:
 166                         return "E";
 167                 case longitude::hemisphere::west:
 168                         return "W";
 169         }
 170         return "?";
 171 }
 172
 173 }
 174 }