include/marnav/geo/angle.hpp

   1 #ifndef MARNAV__GEO__ANGLE__HPP
   2 #define MARNAV__GEO__ANGLE__HPP
   3
   4 #include <cstdint>
   5 #include <string>
   6
   7 namespace marnav
   8 {
   9 namespace geo
  10 {
  11
  12 /// @brief A geographic angle. This is the base class for Latitudes and Longitudes.
  13 class angle
  14 {
  15 public:
  16         constexpr static double epsilon() noexcept { return 1.0e-8; }
  17
  18         angle(const angle &) = default;
  19         angle(angle &&) noexcept = default;
  20
  21         constexpr angle() noexcept
  22                 : value_(0.0)
  23         {
  24         }
  25
  26         /// Initializes the angle with the specified angle in degrees.
  27         ///
  28         /// @param[in] degrees Angle in degrees.
  29         constexpr angle(double degrees) noexcept
  30                 : value_(degrees)
  31         {
  32         }
  33
  34         uint32_t degrees() const noexcept;
  35         uint32_t minutes() const noexcept;
  36         double seconds() const noexcept;
  37
  38         /// Converts an angle to double, units: degrees.
  39         constexpr operator double() const noexcept { return value_; }
  40
  41         constexpr double get() const noexcept { return value_; }
  42
  43         angle & operator=(const angle &) = default;
  44         angle & operator=(angle &&) noexcept = default;
  45
  46         friend void swap(angle & a, angle & b) noexcept;
  47
  48 protected:
  49         /// Sets the angle in degrees.
  50         ///
  51         /// Not part of the public interface intentionally.
  52         void set(double degrees) noexcept { value_ = degrees; }
  53
  54 private:
  55         double value_; // angle in degrees
  56 };
  57
  58 void swap(angle & a, angle & b) noexcept;
  59 bool operator==(const angle & a, const angle & b) noexcept;
  60 bool operator!=(const angle & a, const angle & b) noexcept;
  61
  62 /// @brief Geographic Latitude
  63 ///
  64 /// Value ranges between +90.0 (north) to -90.0 (south).
  65 class latitude : public angle
  66 {
  67 public:
  68         enum class hemisphere { north, south };
  69
  70         constexpr static double min() noexcept { return -90.0; }
  71         constexpr static double max() noexcept { return +90.0; }
  72
  73         constexpr latitude() noexcept
  74                 : angle(0.0)
  75         {
  76         }
  77
  78         latitude(double degrees);
  79         latitude(double degrees, hemisphere h);
  80         latitude(uint32_t d, uint32_t m, uint32_t s, hemisphere h);
  81
  82         latitude(const latitude &) = default;
  83         latitude(latitude &&) noexcept = default;
  84
  85         latitude & operator=(const latitude &) = default;
  86         latitude & operator=(latitude &&) noexcept = default;
  87
  88         /// Deletion of this operator prevents comparison of apples and oranges.
  89         bool operator==(const angle &) const = delete;
  90
  91         /// Deletion of this operator prevents comparison of apples and oranges.
  92         bool operator!=(const angle &) const = delete;
  93
  94         /// Returns the corresponding hemisphere.
  95         constexpr hemisphere hem() const noexcept
  96         {
  97                 return get() >= 0.0 ? hemisphere::north : hemisphere::south;
  98         }
  99
 100 private:
 101         static void check(double a);
 102 };
 103
 104 bool operator==(const latitude & a, const latitude & b) noexcept;
 105 bool operator!=(const latitude & a, const latitude & b) noexcept;
 106 std::string to_string(latitude::hemisphere h);
 107
 108 /// @{
 109 /// User defined literal to construct latitudes.
 110
 111 inline latitude operator"" _lat(long double value)
 112 {
 113         return latitude{static_cast<double>(value)};
 114 }
 115
 116 inline latitude operator"" _north(long double value)
 117 {
 118         return latitude{static_cast<double>(value)};
 119 }
 120
 121 inline latitude operator"" _south(long double value)
 122 {
 123         return latitude{static_cast<double>(-value)};
 124 }
 125
 126 ///@}
 127
 128 /// @brief Geographic Longitude
 129 ///
 130 /// Value ranges between -180.0 (west) to +180.0 (east).
 131 class longitude : public angle
 132 {
 133 public:
 134         enum class hemisphere { east, west };
 135
 136         constexpr static double min() noexcept { return -180.0; }
 137         constexpr static double max() noexcept { return +180.0; }
 138
 139         constexpr longitude() noexcept
 140                 : angle(0.0)
 141         {
 142         }
 143
 144         longitude(double degrees);
 145         longitude(double degrees, hemisphere h);
 146         longitude(uint32_t d, uint32_t m, uint32_t s, hemisphere h);
 147
 148         longitude(const longitude &) = default;
 149         longitude(longitude &&) noexcept = default;
 150
 151         longitude & operator=(const longitude &) = default;
 152         longitude & operator=(longitude &&) noexcept = default;
 153
 154         /// Deletion of this operator prevents comparison of apples and oranges.
 155         bool operator==(const angle &) const = delete;
 156
 157         /// Deletion of this operator prevents comparison of apples and oranges.
 158         bool operator!=(const angle &) const = delete;
 159
 160         /// Returns the corresponding hemisphere.
 161         constexpr hemisphere hem() const noexcept
 162         {
 163                 return get() < 0.0 ? hemisphere::west : hemisphere::east;
 164         }
 165
 166 private:
 167         static void check(double a);
 168 };
 169
 170 bool operator==(const longitude & a, const longitude & b) noexcept;
 171 bool operator!=(const longitude & a, const longitude & b) noexcept;
 172 std::string to_string(longitude::hemisphere h);
 173
 174 /// @{
 175 /// User defined literal to construct latitudes.
 176
 177 inline longitude operator"" _lon(long double value)
 178 {
 179         return longitude{static_cast<double>(value)};
 180 }
 181
 182 inline longitude operator"" _east(long double value)
 183 {
 184         return longitude{static_cast<double>(value)};
 185 }
 186
 187 inline longitude operator"" _west(long double value)
 188 {
 189         return longitude{static_cast<double>(-value)};
 190 }
 191
 192 /// @}
 193 }
 194 }
 195
 196 #endif