Geodesic.h

#include <QString>
#include <QStringView>
 
#include <cmath>
#include <utility>
 
namespace Geodesic {
// Azimuth class, describes an azimuth in degrees. Created via
// interpolation of Maidenhead grid coordinates, and as such
// will be invalid if interpolation failed, typically due to
// bad coordinates.
 
class Azimuth {
    // Data members
 
    float m_value = NAN;
 
    // Constructors
 
    Azimuth() = default;
    Azimuth(float const value) : m_value{value} {}
 
    // Allow construction only by Vector.
 
    friend class Vector;
 
  public:
    // Allow copying, moving, and assignment by anyone.
 
    Azimuth(Azimuth const &) = default;
    Azimuth &operator=(Azimuth const &) = default;
    Azimuth(Azimuth &&) noexcept = default;
    Azimuth &operator=(Azimuth &&) noexcept = default;
 
    // Inline Accessors
 
    auto isValid() const { return !std::isnan(m_value); }
 
    // Conversion operators; return validity and value. These
    // are all we need to implement an ordering relation, but
    // we do so elsewhere.
 
    explicit operator bool() const noexcept { return isValid(); }
    operator float() const noexcept { return m_value; }
 
    // Return as a directional arrow and cardinal direction, if
    // valid, an empty string if invalid.
 
    QStringView compass() const;
 
    // String conversion, to the nearest whole degree; always
    // succeeds, returning an empty string if invalid. Caller
    // must specify if they want units or just a bare value.
 
    QString toString(bool units) const;
};
 
// Distance class, describes a distance in kilometers. Created via
// interpolation of Maidenhead grid coordinates, and as such will
// be invalid if interpolation failed, typically due to bad coordinates.
//
// May additionally be defined as 'close', meaning that either of the
// grids provided was only 4 characters and the computed distance was
// short, so we know it's close, but not just how close. In this case,
// the value will be a non-zero minimum constant, and string conversion
// will prepend a '<'.
//
// While distances are stored internally only in kilometers, caller may
// request string conversion in terms of statute miles.
 
class Distance {
    // Value, in kilometers, that we consider to be the close limit, so
    // if we're informed that we should consider the value for closeness,
    // i.e., one of the grids that gave rise to use is of at best square
    // magnitude, we'd consider any value at or under the limit to be of
    // only the limit in terms of precision.
 
    static constexpr float CLOSE = 120.0f;
 
    // Data members
 
    float m_value = NAN;
 
    // Constructors
 
    Distance() = default;
    Distance(float const value, bool const close)
        : m_value{close && CLOSE > value ? INFINITY : value} {}
 
    // Allow construction only by Vector.
 
    friend class Vector;
 
  public:
    // Allow copying, moving, and assignment by anyone.
 
    Distance(Distance const &) = default;
    Distance &operator=(Distance const &) = default;
    Distance(Distance &&) noexcept = default;
    Distance &operator=(Distance &&) noexcept = default;
 
    // Inline Accessors
 
    auto isValid() const { return !std::isnan(m_value); }
    auto isClose() const { return std::isinf(m_value); }
 
    // Conversion operators; return validity and value. These
    // are all we need to implement an ordering relation, but
    // we do so elsewhere.
 
    explicit operator bool() const noexcept { return isValid(); }
    operator float() const noexcept { return isClose() ? CLOSE : m_value; }
 
    // String conversion, to the nearest whole kilometer or mile,
    // always succeeds, returning an empty string if invalid. Caller
    // must specify if they want units or just the bare value.
 
    QString toString(bool miles, bool units) const;
};
 
// Vector class, aggregate of azimuth and distance from an
// origin grid to a remote grid.
 
class Vector {
    // Data members
 
    Azimuth m_azimuth;
    Distance m_distance;
 
    // Constructors; disallow creation without going through
    // the vector() function.
 
    Vector() = default;
    Vector(std::pair<float, float> const &azdist, bool const square)
        : m_azimuth{azdist.first}, m_distance{azdist.second, square} {}
 
    friend Vector vector(QStringView, QStringView);
 
  public:
    // Allow copying, moving, and assignment by anyone.
 
    Vector(Vector const &) = default;
    Vector &operator=(Vector const &) = default;
    Vector(Vector &&) noexcept = default;
    Vector &operator=(Vector &&) noexcept = default;
 
    // Inline accessors
 
    Azimuth const &azimuth() const { return m_azimuth; }
    Distance const &distance() const { return m_distance; }
};
 
// Creation method; manages a cache, returning cached data
// if possible. This gets called just a lot; performing the
// calculations needed to make a vector are not cheap, so
// we want to reuse results as much as possible.
 
Vector vector(QStringView origin, QStringView remote);
} // namespace Geodesic