subject.hpp

Go to the documentation of this file.

#pragma once
 
#include "altitude.hpp"
#include "azimuth.hpp"
#include "bodies.hpp"
#include "body_target.hpp"
#include "coordinates.hpp"
#include "ffi_core.hpp"
#include "target.hpp"
#include "time.hpp"
#include <vector>
 
namespace siderust {
 
// ============================================================================
// SubjectKind enum
// ============================================================================
 
enum class SubjectKind : int32_t {
  Body = SIDERUST_SUBJECT_KIND_T_BODY,
  Star = SIDERUST_SUBJECT_KIND_T_STAR,
  Icrs = SIDERUST_SUBJECT_KIND_T_ICRS,
  GenericTarget = SIDERUST_SUBJECT_KIND_T_GENERIC_TARGET,
};
 
// ============================================================================
// Subject value type
// ============================================================================
 
class Subject {
public:
  // -- Factories --------------------------------------------------------
 
  static Subject body(Body b) {
    siderust_subject_t s{};
    s.kind = SIDERUST_SUBJECT_KIND_T_BODY;
    s.body = static_cast<SiderustBody>(b);
    return Subject(s);
  }
 
  static Subject star(const siderust::Star &star) {
    siderust_subject_t s{};
    s.kind = SIDERUST_SUBJECT_KIND_T_STAR;
    s.star_handle = star.c_handle();
    return Subject(s);
  }
 
  static Subject icrs(const spherical::Direction<frames::ICRS> &dir) {
    siderust_subject_t s{};
    s.kind = SIDERUST_SUBJECT_KIND_T_ICRS;
    s.icrs_dir = dir.to_c();
    return Subject(s);
  }
 
  template <typename C> static Subject target(const DirectionTarget<C> &tgt) {
    siderust_subject_t s{};
    s.kind = SIDERUST_SUBJECT_KIND_T_GENERIC_TARGET;
    s.generic_target_handle = tgt.c_handle();
    return Subject(s);
  }
 
  // -- Accessors --------------------------------------------------------
 
  SubjectKind kind() const { return static_cast<SubjectKind>(inner_.kind); }
  const siderust_subject_t &c_inner() const { return inner_; }
 
private:
  siderust_subject_t inner_{};
  explicit Subject(siderust_subject_t s) : inner_(s) {}
};
 
// ============================================================================
// Unified free functions
// ============================================================================
 
inline qtty::Radian altitude_at(const Subject &subj, const Geodetic &obs,
                                const Time<TT, MJD> &mjd) {
  double out;
  check_status(siderust_altitude_at(subj.c_inner(), obs.to_c(), mjd.value(), &out),
               "altitude_at(Subject)");
  return qtty::Radian(out);
}
 
inline std::vector<Period<TT, MJD>> above_threshold(const Subject &subj, const Geodetic &obs,
                                                    const Period<TT, MJD> &window,
                                                    qtty::Degree threshold,
                                                    const SearchOptions &opts = {}) {
  tempoch_period_mjd_t *ptr = nullptr;
  uintptr_t count = 0;
  check_status(siderust_above_threshold(subj.c_inner(), obs.to_c(), window.c_inner(),
                                        threshold.value(), opts.to_c(), &ptr, &count),
               "above_threshold(Subject)");
  return detail::periods_from_c(ptr, count);
}
 
inline std::vector<Period<TT, MJD>> below_threshold(const Subject &subj, const Geodetic &obs,
                                                    const Period<TT, MJD> &window,
                                                    qtty::Degree threshold,
                                                    const SearchOptions &opts = {}) {
  tempoch_period_mjd_t *ptr = nullptr;
  uintptr_t count = 0;
  check_status(siderust_below_threshold(subj.c_inner(), obs.to_c(), window.c_inner(),
                                        threshold.value(), opts.to_c(), &ptr, &count),
               "below_threshold(Subject)");
  return detail::periods_from_c(ptr, count);
}
 
inline std::vector<CrossingEvent> crossings(const Subject &subj, const Geodetic &obs,
                                            const Period<TT, MJD> &window, qtty::Degree threshold,
                                            const SearchOptions &opts = {}) {
  siderust_crossing_event_t *ptr = nullptr;
  uintptr_t count = 0;
  check_status(siderust_crossings(subj.c_inner(), obs.to_c(), window.c_inner(), threshold.value(),
                                  opts.to_c(), &ptr, &count),
               "crossings(Subject)");
  return detail::crossings_from_c(ptr, count);
}
 
inline std::vector<CulminationEvent> culminations(const Subject &subj, const Geodetic &obs,
                                                  const Period<TT, MJD> &window,
                                                  const SearchOptions &opts = {}) {
  siderust_culmination_event_t *ptr = nullptr;
  uintptr_t count = 0;
  check_status(siderust_culminations(subj.c_inner(), obs.to_c(), window.c_inner(), opts.to_c(),
                                     &ptr, &count),
               "culminations(Subject)");
  return detail::culminations_from_c(ptr, count);
}
 
inline std::vector<Period<TT, MJD>> altitude_ranges(const Subject &subj, const Geodetic &obs,
                                                    const Period<TT, MJD> &window,
                                                    qtty::Degree min_alt, qtty::Degree max_alt,
                                                    const SearchOptions &opts = {}) {
  tempoch_period_mjd_t *ptr = nullptr;
  uintptr_t count = 0;
  check_status(siderust_altitude_ranges(subj.c_inner(), obs.to_c(), window.c_inner(),
                                        min_alt.value(), max_alt.value(), opts.to_c(), &ptr,
                                        &count),
               "altitude_ranges(Subject)");
  return detail::periods_from_c(ptr, count);
}
 
inline qtty::Degree azimuth_at(const Subject &subj, const Geodetic &obs, const Time<TT, MJD> &mjd) {
  double out;
  check_status(siderust_azimuth_at(subj.c_inner(), obs.to_c(), mjd.value(), &out),
               "azimuth_at(Subject)");
  return qtty::Degree(out);
}
 
inline std::vector<AzimuthCrossingEvent> azimuth_crossings(const Subject &subj, const Geodetic &obs,
                                                           const Period<TT, MJD> &window,
                                                           qtty::Degree bearing,
                                                           const SearchOptions &opts = {}) {
  siderust_azimuth_crossing_event_t *ptr = nullptr;
  uintptr_t count = 0;
  check_status(siderust_azimuth_crossings(subj.c_inner(), obs.to_c(), window.c_inner(),
                                          bearing.value(), opts.to_c(), &ptr, &count),
               "azimuth_crossings(Subject)");
  return detail::az_crossings_from_c(ptr, count);
}
 
inline std::vector<AzimuthExtremum> azimuth_extrema(const Subject &subj, const Geodetic &obs,
                                                    const Period<TT, MJD> &window,
                                                    const SearchOptions &opts = {}) {
  siderust_azimuth_extremum_t *ptr = nullptr;
  uintptr_t count = 0;
  check_status(siderust_azimuth_extrema(subj.c_inner(), obs.to_c(), window.c_inner(), opts.to_c(),
                                        &ptr, &count),
               "azimuth_extrema(Subject)");
  return detail::az_extrema_from_c(ptr, count);
}
 
inline std::vector<Period<TT, MJD>> in_azimuth_range(const Subject &subj, const Geodetic &obs,
                                                     const Period<TT, MJD> &window,
                                                     qtty::Degree min_deg, qtty::Degree max_deg,
                                                     const SearchOptions &opts = {}) {
  tempoch_period_mjd_t *ptr = nullptr;
  uintptr_t count = 0;
  check_status(siderust_in_azimuth_range(subj.c_inner(), obs.to_c(), window.c_inner(),
                                         min_deg.value(), max_deg.value(), opts.to_c(), &ptr,
                                         &count),
               "in_azimuth_range(Subject)");
  return detail::periods_from_c(ptr, count);
}
 
} // namespace siderust