body_target.hpp

Go to the documentation of this file.

#pragma once

 
#include "altitude.hpp"
#include "azimuth.hpp"
#include "ffi_core.hpp"
#include "trackable.hpp"
#include <string>
 
namespace siderust {
 
// ============================================================================
// Body enum
// ============================================================================

enum class Body : int32_t {
  Sun = SIDERUST_BODY_SUN,
  Moon = SIDERUST_BODY_MOON,
  Mercury = SIDERUST_BODY_MERCURY,
  Venus = SIDERUST_BODY_VENUS,
  Mars = SIDERUST_BODY_MARS,
  Jupiter = SIDERUST_BODY_JUPITER,
  Saturn = SIDERUST_BODY_SATURN,
  Uranus = SIDERUST_BODY_URANUS,
  Neptune = SIDERUST_BODY_NEPTUNE,
};
 
// ============================================================================
// Free functions in body:: namespace
// ============================================================================
 
namespace body {

inline qtty::Radian altitude_at(Body b, const Geodetic &obs, const Time<TT, MJD> &mjd) {
  double out;
  check_status(siderust_altitude_at(detail::make_body_subject(static_cast<SiderustBody>(b)),
                                    obs.to_c(), mjd.value(), &out),
               "body::altitude_at");
  return qtty::Radian(out);
}

inline std::vector<Period<TT, MJD>> above_threshold(Body b, 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(detail::make_body_subject(static_cast<SiderustBody>(b)),
                                        obs.to_c(), window.c_inner(), threshold.value(),
                                        opts.to_c(), &ptr, &count),
               "body::above_threshold");
  return detail::periods_from_c(ptr, count);
}

inline std::vector<Period<TT, MJD>> below_threshold(Body b, 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(detail::make_body_subject(static_cast<SiderustBody>(b)),
                                        obs.to_c(), window.c_inner(), threshold.value(),
                                        opts.to_c(), &ptr, &count),
               "body::below_threshold");
  return detail::periods_from_c(ptr, count);
}

inline std::vector<CrossingEvent> crossings(Body b, 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(detail::make_body_subject(static_cast<SiderustBody>(b)),
                                  obs.to_c(), window.c_inner(), threshold.value(), opts.to_c(),
                                  &ptr, &count),
               "body::crossings");
  return detail::crossings_from_c(ptr, count);
}

inline std::vector<CulminationEvent> culminations(Body b, 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(detail::make_body_subject(static_cast<SiderustBody>(b)),
                                     obs.to_c(), window.c_inner(), opts.to_c(), &ptr, &count),
               "body::culminations");
  return detail::culminations_from_c(ptr, count);
}

inline std::vector<Period<TT, MJD>> altitude_ranges(Body b, 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(detail::make_body_subject(static_cast<SiderustBody>(b)),
                                        obs.to_c(), window.c_inner(), min_alt.value(),
                                        max_alt.value(), opts.to_c(), &ptr, &count),
               "body::altitude_ranges");
  return detail::periods_from_c(ptr, count);
}
 
} // namespace body
 
namespace body {
 
// ── Azimuth free functions ──────────────────────────────────────────────

inline qtty::Radian azimuth_at(Body b, const Geodetic &obs, const Time<TT, MJD> &mjd) {
  double out;
  check_status(siderust_azimuth_at(detail::make_body_subject(static_cast<SiderustBody>(b)),
                                   obs.to_c(), mjd.value(), &out),
               "body::azimuth_at");
  return qtty::Radian(out);
}

inline std::vector<AzimuthCrossingEvent> azimuth_crossings(Body b, 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(detail::make_body_subject(static_cast<SiderustBody>(b)),
                                          obs.to_c(), window.c_inner(), bearing.value(),
                                          opts.to_c(), &ptr, &count),
               "body::azimuth_crossings");
  return detail::az_crossings_from_c(ptr, count);
}

inline std::vector<AzimuthExtremum> azimuth_extrema(Body b, 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(detail::make_body_subject(static_cast<SiderustBody>(b)),
                                        obs.to_c(), window.c_inner(), opts.to_c(), &ptr, &count),
               "body::azimuth_extrema");
  return detail::az_extrema_from_c(ptr, count);
}

inline std::vector<Period<TT, MJD>> in_azimuth_range(Body b, const Geodetic &obs,
                                                     const Period<TT, MJD> &window,
                                                     qtty::Degree min, qtty::Degree max,
                                                     const SearchOptions &opts = {}) {
  tempoch_period_mjd_t *ptr = nullptr;
  uintptr_t count = 0;
  check_status(siderust_in_azimuth_range(detail::make_body_subject(static_cast<SiderustBody>(b)),
                                         obs.to_c(), window.c_inner(), min.value(), max.value(),
                                         opts.to_c(), &ptr, &count),
               "body::in_azimuth_range");
  return detail::periods_from_c(ptr, count);
}
 
} // namespace body
 
// ============================================================================
// BodyTarget — Target implementation for solar-system bodies
// ============================================================================

class BodyTarget : public Target {
public:
  explicit BodyTarget(Body body) : body_(body) {}
 
  // ------------------------------------------------------------------
  // Identity (implements Target)
  // ------------------------------------------------------------------

  std::string name() const override {
    switch (body_) {
    case Body::Sun:
      return "Sun";
    case Body::Moon:
      return "Moon";
    case Body::Mercury:
      return "Mercury";
    case Body::Venus:
      return "Venus";
    case Body::Mars:
      return "Mars";
    case Body::Jupiter:
      return "Jupiter";
    case Body::Saturn:
      return "Saturn";
    case Body::Uranus:
      return "Uranus";
    case Body::Neptune:
      return "Neptune";
    default:
      return "Unknown Body";
    }
  }
 
  // ------------------------------------------------------------------
  // Altitude queries
  // ------------------------------------------------------------------
 
  qtty::Degree altitude_at(const Geodetic &obs, const Time<TT, MJD> &mjd) const override {
    auto rad = body::altitude_at(body_, obs, mjd);
    return qtty::Degree(rad.value() * 180.0 / 3.14159265358979323846);
  }
 
  std::vector<Period<TT, MJD>> above_threshold(const Geodetic &obs, const Period<TT, MJD> &window,
                                               qtty::Degree threshold,
                                               const SearchOptions &opts = {}) const override {
    return body::above_threshold(body_, obs, window, threshold, opts);
  }
 
  std::vector<Period<TT, MJD>> below_threshold(const Geodetic &obs, const Period<TT, MJD> &window,
                                               qtty::Degree threshold,
                                               const SearchOptions &opts = {}) const override {
    return body::below_threshold(body_, obs, window, threshold, opts);
  }
 
  std::vector<CrossingEvent> crossings(const Geodetic &obs, const Period<TT, MJD> &window,
                                       qtty::Degree threshold,
                                       const SearchOptions &opts = {}) const override {
    return body::crossings(body_, obs, window, threshold, opts);
  }
 
  std::vector<CulminationEvent> culminations(const Geodetic &obs, const Period<TT, MJD> &window,
                                             const SearchOptions &opts = {}) const override {
    return body::culminations(body_, obs, window, opts);
  }
 
  // ------------------------------------------------------------------
  // Azimuth queries
  // ------------------------------------------------------------------
 
  qtty::Degree azimuth_at(const Geodetic &obs, const Time<TT, MJD> &mjd) const override {
    auto rad = body::azimuth_at(body_, obs, mjd);
    return qtty::Degree(rad.value() * 180.0 / 3.14159265358979323846);
  }
 
  std::vector<AzimuthCrossingEvent>
  azimuth_crossings(const Geodetic &obs, const Period<TT, MJD> &window, qtty::Degree bearing,
                    const SearchOptions &opts = {}) const override {
    return body::azimuth_crossings(body_, obs, window, bearing, opts);
  }

  Body body() const { return body_; }
 
private:
  Body body_;
};
 
} // namespace siderust