spherical.hpp

Go to the documentation of this file.

#pragma once
 
#include "../centers.hpp"
#include "../frames.hpp"
#include "../time.hpp"
#include "geodetic.hpp"
 
#include <qtty/qtty.hpp>
 
#include <type_traits>
 
namespace siderust {
namespace spherical {
 
template <typename F>
struct Direction {
    static_assert(frames::is_frame_v<F>, "F must be a valid frame tag");
 
  private:
    qtty::Degree azimuth_; 
    qtty::Degree polar_;   
 
  public:
    Direction() : azimuth_(qtty::Degree(0)), polar_(qtty::Degree(0)) {}
 
    Direction(qtty::Degree azimuth, qtty::Degree polar)
        : azimuth_(azimuth), polar_(polar) {}
 
    Direction(double azimuth_deg, double polar_deg)
        : azimuth_(qtty::Degree(azimuth_deg)), polar_(qtty::Degree(polar_deg)) {}
 
    static constexpr siderust_frame_t frame_id() {
        return frames::FrameTraits<F>::ffi_id;
    }
    static constexpr const char* frame_name() {
        return frames::FrameTraits<F>::name();
    }
 
    template <typename F_ = F, std::enable_if_t<frames::has_ra_dec_v<F_>, int> = 0>
    qtty::Degree ra() const { return azimuth_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_ra_dec_v<F_>, int> = 0>
    qtty::Degree dec() const { return polar_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_az_alt_v<F_>, int> = 0>
    qtty::Degree az() const { return azimuth_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_az_alt_v<F_>, int> = 0>
    qtty::Degree al() const { return polar_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_az_alt_v<F_>, int> = 0>
    qtty::Degree alt() const { return polar_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_az_alt_v<F_>, int> = 0>
    qtty::Degree altitude() const { return polar_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_lon_lat_v<F_>, int> = 0>
    qtty::Degree lon() const { return azimuth_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_lon_lat_v<F_>, int> = 0>
    qtty::Degree lat() const { return polar_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_lon_lat_v<F_>, int> = 0>
    qtty::Degree longitude() const { return azimuth_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_lon_lat_v<F_>, int> = 0>
    qtty::Degree latitude() const { return polar_; }
 
    siderust_spherical_dir_t to_c() const {
        return {azimuth_.value(), polar_.value(), frame_id()};
    }
 
    static Direction from_c(const siderust_spherical_dir_t& c) {
        return Direction(c.lon_deg, c.lat_deg);
    }
 
    template <typename Target>
    std::enable_if_t<
        frames::has_frame_transform_v<F, Target>,
        Direction<Target>>
    to_frame(const JulianDate& jd) const {
        if constexpr (std::is_same_v<F, Target>) {
            return Direction<Target>(azimuth_.value(), polar_.value());
        } else {
            siderust_spherical_dir_t out;
            check_status(
                siderust_spherical_dir_transform_frame(
                    azimuth_.value(), polar_.value(),
                    frames::FrameTraits<F>::ffi_id,
                    frames::FrameTraits<Target>::ffi_id,
                    jd.value(), &out),
                "Direction::to_frame");
            return Direction<Target>::from_c(out);
        }
    }
 
    template <typename Target>
    auto to(const JulianDate& jd) const
        -> decltype(this->template to_frame<Target>(jd)) {
        return to_frame<Target>(jd);
    }
 
    template <typename F_ = F>
    std::enable_if_t<
        frames::has_horizontal_transform_v<F_>,
        Direction<frames::Horizontal>>
    to_horizontal(const JulianDate& jd, const Geodetic& observer) const {
        siderust_spherical_dir_t out;
        check_status(
            siderust_spherical_dir_to_horizontal(
                azimuth_.value(), polar_.value(),
                frames::FrameTraits<F>::ffi_id,
                jd.value(), observer.to_c(), &out),
            "Direction::to_horizontal");
        return Direction<frames::Horizontal>::from_c(out);
    }
};
 
template <typename C, typename F, typename U = qtty::Meter>
struct Position {
    static_assert(frames::is_frame_v<F>, "F must be a valid frame tag");
    static_assert(centers::is_center_v<C>, "C must be a valid center tag");
 
  private:
    qtty::Degree azimuth_;
    qtty::Degree polar_;
    U            dist_;
 
  public:
    Position()
        : azimuth_(qtty::Degree(0)), polar_(qtty::Degree(0)), dist_(U(0)) {}
 
    Position(qtty::Degree azimuth, qtty::Degree polar, U dist)
        : azimuth_(azimuth), polar_(polar), dist_(dist) {}
 
    Position(double azimuth_deg, double polar_deg, double dist_val)
        : azimuth_(qtty::Degree(azimuth_deg)),
          polar_(qtty::Degree(polar_deg)),
          dist_(U(dist_val)) {}
 
    Direction<F> direction() const {
        return Direction<F>(azimuth_, polar_);
    }
 
    template <typename F_ = F, std::enable_if_t<frames::has_ra_dec_v<F_>, int> = 0>
    qtty::Degree ra() const { return azimuth_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_ra_dec_v<F_>, int> = 0>
    qtty::Degree dec() const { return polar_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_az_alt_v<F_>, int> = 0>
    qtty::Degree az() const { return azimuth_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_az_alt_v<F_>, int> = 0>
    qtty::Degree al() const { return polar_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_az_alt_v<F_>, int> = 0>
    qtty::Degree alt() const { return polar_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_lon_lat_v<F_>, int> = 0>
    qtty::Degree lon() const { return azimuth_; }
 
    template <typename F_ = F, std::enable_if_t<frames::has_lon_lat_v<F_>, int> = 0>
    qtty::Degree lat() const { return polar_; }
 
    static constexpr siderust_frame_t  frame_id() { return frames::FrameTraits<F>::ffi_id; }
    static constexpr siderust_center_t center_id() { return centers::CenterTraits<C>::ffi_id; }
 
    U distance() const { return dist_; }
};
 
} // namespace spherical
} // namespace siderust