target.hpp

Go to the documentation of this file.

#pragma once
 
#include "altitude.hpp"
#include "azimuth.hpp"
#include "coordinates.hpp"
#include "ffi_core.hpp"
#include "time.hpp"
#include "trackable.hpp"
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace siderust {
 
// ============================================================================
// Internal type traits
// ============================================================================
 
namespace detail {
 
 
template <typename T> struct is_spherical_direction : std::false_type {};
 
template <typename F> struct is_spherical_direction<spherical::Direction<F>> : std::true_type {};
 
template <typename T>
inline constexpr bool is_spherical_direction_v = is_spherical_direction<T>::value;
 
template <typename T> struct spherical_direction_frame; // undefined primary
 
template <typename F> struct spherical_direction_frame<spherical::Direction<F>> {
  using type = F;
};
 
template <typename T>
using spherical_direction_frame_t = typename spherical_direction_frame<T>::type;
 
 
} // namespace detail
 
// ============================================================================
// Target<C>
// ============================================================================
 
template <typename C> class DirectionTarget : public Target {
 
  static_assert(detail::is_spherical_direction_v<C>, "Target<C>: C must be a specialisation of "
                                                     "siderust::spherical::Direction<F>");
 
  using Frame = detail::spherical_direction_frame_t<C>;
 
  static_assert(frames::has_frame_transform_v<Frame, frames::ICRS>,
                "Target<C>: frame F must support a transform to ICRS "
                "(frames::has_frame_transform_v<F, frames::ICRS> must be true). "
                "Supported frames: ICRS, ICRF, EquatorialMeanJ2000, "
                "EquatorialMeanOfDate, EquatorialTrueOfDate, EclipticMeanJ2000.");
 
public:
  // ------------------------------------------------------------------
  // Construction / destruction
  // ------------------------------------------------------------------
 
  explicit DirectionTarget(C dir, Time<TT, JD> epoch = Time<TT, JD>::J2000(),
                           std::string label = "")
      : m_dir_(dir), m_epoch_(epoch), label_(std::move(label)) {
    // Convert to ICRS for the FFI; identity transform when already ICRS.
    if constexpr (std::is_same_v<Frame, frames::ICRS>) {
      m_icrs_ = dir;
    } else {
      m_icrs_ = dir.template to_frame<frames::ICRS>(epoch);
    }
    SiderustGenericTarget *h = nullptr;
    check_status(siderust_generic_target_create_icrs(m_icrs_.ra().value(), m_icrs_.dec().value(),
                                                     epoch.value(), &h),
                 "Target::Target");
    handle_ = h;
  }
 
  ~DirectionTarget() {
    if (handle_) {
      siderust_generic_target_free(handle_);
      handle_ = nullptr;
    }
  }
 
  DirectionTarget(DirectionTarget &&other) noexcept
      : m_dir_(std::move(other.m_dir_)), m_epoch_(other.m_epoch_), m_icrs_(other.m_icrs_),
        label_(std::move(other.label_)), handle_(other.handle_) {
    other.handle_ = nullptr;
  }
 
  DirectionTarget &operator=(DirectionTarget &&other) noexcept {
    if (this != &other) {
      if (handle_) {
        siderust_generic_target_free(handle_);
      }
      m_dir_ = std::move(other.m_dir_);
      m_epoch_ = other.m_epoch_;
      m_icrs_ = other.m_icrs_;
      label_ = std::move(other.label_);
      handle_ = other.handle_;
      other.handle_ = nullptr;
    }
    return *this;
  }
 
  // Prevent copying (the handle has unique ownership).
  DirectionTarget(const DirectionTarget &) = delete;
  DirectionTarget &operator=(const DirectionTarget &) = delete;
 
  // ------------------------------------------------------------------
  // Identity (implements Target)
  // ------------------------------------------------------------------
 
  std::string name() const override {
    if (!label_.empty())
      return label_;
    std::ostringstream ss;
    ss << "Direction(" << m_icrs_.ra().value() << "\xc2\xb0, " << m_icrs_.dec().value()
       << "\xc2\xb0)";
    return ss.str();
  }
 
  // ------------------------------------------------------------------
  // Coordinate accessors
  // ------------------------------------------------------------------
 
  const C &direction() const { return m_dir_; }
 
  Time<TT, JD> epoch() const { return m_epoch_; }
 
  const spherical::direction::ICRS &icrs_direction() const { return m_icrs_; }
 
  template <typename F_ = Frame, std::enable_if_t<frames::has_ra_dec_v<F_>, int> = 0>
  qtty::Degree ra() const {
    return m_dir_.ra();
  }
 
  template <typename F_ = Frame, std::enable_if_t<frames::has_ra_dec_v<F_>, int> = 0>
  qtty::Degree dec() const {
    return m_dir_.dec();
  }
 
  // ------------------------------------------------------------------
  // Altitude queries (implements Trackable)
  // ------------------------------------------------------------------
 
  qtty::Degree altitude_at(const Geodetic &obs, const Time<TT, MJD> &mjd) const override {
    double out{};
    check_status(siderust_altitude_at(detail::make_generic_target_subject(handle_), obs.to_c(),
                                      mjd.value(), &out),
                 "Target::altitude_at");
    return qtty::Radian(out).to<qtty::Degree>();
  }
 
  std::vector<Period<TT, MJD>> above_threshold(const Geodetic &obs, const Period<TT, MJD> &window,
                                               qtty::Degree threshold,
                                               const SearchOptions &opts = {}) const override {
    tempoch_period_mjd_t *ptr = nullptr;
    uintptr_t count = 0;
    check_status(siderust_above_threshold(detail::make_generic_target_subject(handle_), obs.to_c(),
                                          window.c_inner(), threshold.value(), opts.to_c(), &ptr,
                                          &count),
                 "Target::above_threshold");
    return detail_periods_from_c(ptr, count);
  }
 
  std::vector<Period<TT, MJD>> below_threshold(const Geodetic &obs, const Period<TT, MJD> &window,
                                               qtty::Degree threshold,
                                               const SearchOptions &opts = {}) const override {
    tempoch_period_mjd_t *ptr = nullptr;
    uintptr_t count = 0;
    check_status(siderust_below_threshold(detail::make_generic_target_subject(handle_), obs.to_c(),
                                          window.c_inner(), threshold.value(), opts.to_c(), &ptr,
                                          &count),
                 "Target::below_threshold");
    return detail_periods_from_c(ptr, count);
  }
 
  std::vector<CrossingEvent> crossings(const Geodetic &obs, const Period<TT, MJD> &window,
                                       qtty::Degree threshold,
                                       const SearchOptions &opts = {}) const override {
    siderust_crossing_event_t *ptr = nullptr;
    uintptr_t count = 0;
    check_status(siderust_crossings(detail::make_generic_target_subject(handle_), obs.to_c(),
                                    window.c_inner(), threshold.value(), opts.to_c(), &ptr, &count),
                 "Target::crossings");
    return detail::crossings_from_c(ptr, count);
  }
 
  std::vector<CulminationEvent> culminations(const Geodetic &obs, const Period<TT, MJD> &window,
                                             const SearchOptions &opts = {}) const override {
    siderust_culmination_event_t *ptr = nullptr;
    uintptr_t count = 0;
    check_status(siderust_culminations(detail::make_generic_target_subject(handle_), obs.to_c(),
                                       window.c_inner(), opts.to_c(), &ptr, &count),
                 "Target::culminations");
    return detail::culminations_from_c(ptr, count);
  }
 
  // ------------------------------------------------------------------
  // Azimuth queries (implements Trackable)
  // ------------------------------------------------------------------
 
  qtty::Degree azimuth_at(const Geodetic &obs, const Time<TT, MJD> &mjd) const override {
    double out{};
    check_status(siderust_azimuth_at(detail::make_generic_target_subject(handle_), obs.to_c(),
                                     mjd.value(), &out),
                 "Target::azimuth_at");
    return qtty::Degree(out);
  }
 
  std::vector<AzimuthCrossingEvent>
  azimuth_crossings(const Geodetic &obs, const Period<TT, MJD> &window, qtty::Degree bearing,
                    const SearchOptions &opts = {}) const override {
    siderust_azimuth_crossing_event_t *ptr = nullptr;
    uintptr_t count = 0;
    check_status(siderust_azimuth_crossings(detail::make_generic_target_subject(handle_),
                                            obs.to_c(), window.c_inner(), bearing.value(),
                                            opts.to_c(), &ptr, &count),
                 "Target::azimuth_crossings");
    return detail::az_crossings_from_c(ptr, count);
  }
 
  const SiderustGenericTarget *c_handle() const { return handle_; }
 
  SiderustGenericTargetData data() const {
    SiderustGenericTargetData out{};
    check_status(siderust_generic_target_get_data(handle_, &out), "DirectionTarget::data");
    return out;
  }
 
private:
  C m_dir_;
  Time<TT, JD> m_epoch_;
  spherical::direction::ICRS m_icrs_;
  std::string label_;
  SiderustGenericTarget *handle_ = nullptr;
 
  static std::vector<Period<TT, MJD>> detail_periods_from_c(tempoch_period_mjd_t *ptr,
                                                            uintptr_t count) {
    std::vector<Period<TT, MJD>> result;
    result.reserve(count);
    for (uintptr_t i = 0; i < count; ++i) {
      result.push_back(
          Period<TT, MJD>(Time<TT, MJD>(ptr[i].start_mjd), Time<TT, MJD>(ptr[i].end_mjd)));
    }
    siderust_periods_free(ptr, count);
    return result;
  }
};
 
// ============================================================================
// Convenience type aliases
// ============================================================================
 
using ICRSTarget = DirectionTarget<spherical::direction::ICRS>;
 
using ICRFTarget = DirectionTarget<spherical::direction::ICRF>;
 
using EquatorialMeanJ2000Target = DirectionTarget<spherical::direction::EquatorialMeanJ2000>;
 
using EquatorialMeanOfDateTarget = DirectionTarget<spherical::direction::EquatorialMeanOfDate>;
 
using EquatorialTrueOfDateTarget = DirectionTarget<spherical::direction::EquatorialTrueOfDate>;
 
using EclipticMeanJ2000Target = DirectionTarget<spherical::direction::EclipticMeanJ2000>;
 
// ============================================================================
// ProperMotionTarget
// ============================================================================
 
class ProperMotionTarget : public Target {
public:
  ProperMotionTarget(spherical::direction::ICRS position, Time<TT, JD> epoch,
                     ProperMotion proper_motion, std::string label = "")
      : position_(position), epoch_(epoch), proper_motion_(proper_motion),
        label_(std::move(label)) {
    SiderustGenericTarget *h = nullptr;
    const auto pm = proper_motion_.to_c();
    check_status(siderust_generic_target_create_icrs_with_pm(
                     position_.ra().value(), position_.dec().value(), epoch.value(),
                     pm.pm_ra_deg_yr, pm.pm_dec_deg_yr, pm.ra_convention, &h),
                 "ProperMotionTarget::ProperMotionTarget");
    handle_ = h;
  }
 
  ~ProperMotionTarget() {
    if (handle_) {
      siderust_generic_target_free(handle_);
      handle_ = nullptr;
    }
  }
 
  ProperMotionTarget(ProperMotionTarget &&other) noexcept
      : position_(other.position_), epoch_(other.epoch_), proper_motion_(other.proper_motion_),
        label_(std::move(other.label_)), handle_(other.handle_) {
    other.handle_ = nullptr;
  }
 
  ProperMotionTarget &operator=(ProperMotionTarget &&other) noexcept {
    if (this != &other) {
      if (handle_)
        siderust_generic_target_free(handle_);
      position_ = other.position_;
      epoch_ = other.epoch_;
      proper_motion_ = other.proper_motion_;
      label_ = std::move(other.label_);
      handle_ = other.handle_;
      other.handle_ = nullptr;
    }
    return *this;
  }
 
  ProperMotionTarget(const ProperMotionTarget &) = delete;
  ProperMotionTarget &operator=(const ProperMotionTarget &) = delete;
 
  // -- Target identity -------------------------------------------------------
 
  std::string name() const override {
    if (!label_.empty())
      return label_;
    SiderustGenericTargetData d{};
    siderust_generic_target_get_data(handle_, &d);
    std::ostringstream ss;
    ss << "ProperMotion(" << d.coord.spherical_dir.azimuth_deg << "\xc2\xb0, "
       << d.coord.spherical_dir.polar_deg << "\xc2\xb0)";
    return ss.str();
  }
 
  // -- Accessors -------------------------------------------------------------
 
  Time<TT, JD> epoch() const { return epoch_; }
 
  const spherical::direction::ICRS &position() const { return position_; }
 
  const ProperMotion &proper_motion() const { return proper_motion_; }
 
  SiderustGenericTargetData data() const {
    SiderustGenericTargetData out{};
    check_status(siderust_generic_target_get_data(handle_, &out), "ProperMotionTarget::data");
    return out;
  }
 
  // -- Altitude tracking (implements Trackable) ------------------------------
 
  qtty::Degree altitude_at(const Geodetic &obs, const Time<TT, MJD> &mjd) const override {
    double out{};
    check_status(siderust_altitude_at(detail::make_generic_target_subject(handle_), obs.to_c(),
                                      mjd.value(), &out),
                 "ProperMotionTarget::altitude_at");
    return qtty::Radian(out).to<qtty::Degree>();
  }
 
  std::vector<Period<TT, MJD>> above_threshold(const Geodetic &obs, const Period<TT, MJD> &window,
                                               qtty::Degree threshold,
                                               const SearchOptions &opts = {}) const override {
    tempoch_period_mjd_t *ptr = nullptr;
    uintptr_t count = 0;
    check_status(siderust_above_threshold(detail::make_generic_target_subject(handle_), obs.to_c(),
                                          window.c_inner(), threshold.value(), opts.to_c(), &ptr,
                                          &count),
                 "ProperMotionTarget::above_threshold");
    return detail_periods_from_c(ptr, count);
  }
 
  std::vector<Period<TT, MJD>> below_threshold(const Geodetic &obs, const Period<TT, MJD> &window,
                                               qtty::Degree threshold,
                                               const SearchOptions &opts = {}) const override {
    tempoch_period_mjd_t *ptr = nullptr;
    uintptr_t count = 0;
    check_status(siderust_below_threshold(detail::make_generic_target_subject(handle_), obs.to_c(),
                                          window.c_inner(), threshold.value(), opts.to_c(), &ptr,
                                          &count),
                 "ProperMotionTarget::below_threshold");
    return detail_periods_from_c(ptr, count);
  }
 
  std::vector<CrossingEvent> crossings(const Geodetic &obs, const Period<TT, MJD> &window,
                                       qtty::Degree threshold,
                                       const SearchOptions &opts = {}) const override {
    siderust_crossing_event_t *ptr = nullptr;
    uintptr_t count = 0;
    check_status(siderust_crossings(detail::make_generic_target_subject(handle_), obs.to_c(),
                                    window.c_inner(), threshold.value(), opts.to_c(), &ptr, &count),
                 "ProperMotionTarget::crossings");
    return detail::crossings_from_c(ptr, count);
  }
 
  std::vector<CulminationEvent> culminations(const Geodetic &obs, const Period<TT, MJD> &window,
                                             const SearchOptions &opts = {}) const override {
    siderust_culmination_event_t *ptr = nullptr;
    uintptr_t count = 0;
    check_status(siderust_culminations(detail::make_generic_target_subject(handle_), obs.to_c(),
                                       window.c_inner(), opts.to_c(), &ptr, &count),
                 "ProperMotionTarget::culminations");
    return detail::culminations_from_c(ptr, count);
  }
 
  // -- Azimuth tracking (implements Trackable) -------------------------------
 
  qtty::Degree azimuth_at(const Geodetic &obs, const Time<TT, MJD> &mjd) const override {
    double out{};
    check_status(siderust_azimuth_at(detail::make_generic_target_subject(handle_), obs.to_c(),
                                     mjd.value(), &out),
                 "ProperMotionTarget::azimuth_at");
    return qtty::Degree(out);
  }
 
  std::vector<AzimuthCrossingEvent>
  azimuth_crossings(const Geodetic &obs, const Period<TT, MJD> &window, qtty::Degree bearing,
                    const SearchOptions &opts = {}) const override {
    siderust_azimuth_crossing_event_t *ptr = nullptr;
    uintptr_t count = 0;
    check_status(siderust_azimuth_crossings(detail::make_generic_target_subject(handle_),
                                            obs.to_c(), window.c_inner(), bearing.value(),
                                            opts.to_c(), &ptr, &count),
                 "ProperMotionTarget::azimuth_crossings");
    return detail::az_crossings_from_c(ptr, count);
  }
 
private:
  spherical::direction::ICRS position_;
  Time<TT, JD> epoch_;
  ProperMotion proper_motion_;
  std::string label_;
  SiderustGenericTarget *handle_ = nullptr;
 
  static std::vector<Period<TT, MJD>> detail_periods_from_c(tempoch_period_mjd_t *ptr,
                                                            uintptr_t count) {
    std::vector<Period<TT, MJD>> result;
    result.reserve(count);
    for (uintptr_t i = 0; i < count; ++i) {
      result.push_back(
          Period<TT, MJD>(Time<TT, MJD>(ptr[i].start_mjd), Time<TT, MJD>(ptr[i].end_mjd)));
    }
    siderust_periods_free(ptr, count);
    return result;
  }
};
 
} // namespace siderust