bodycentric_transforms.hpp

Go to the documentation of this file.

#pragma once
 
#include "../ffi_core.hpp"
#include "../orbital_center.hpp"
#include "../time.hpp"
#include "cartesian.hpp"
 
#include <cstdint>
 
namespace siderust {
 
// ============================================================================
// BodycentricPos<F, U>
// ============================================================================
 
template <typename F, typename U = qtty::AstronomicalUnit> struct BodycentricPos {
  static_assert(frames::is_frame_v<F>, "F must be a valid frame tag");
 
  cartesian::Position<centers::Bodycentric, F, U> pos;
 
  BodycentricParams params;
 
  // -- Accessors --
 
  U x() const { return pos.x(); }
  U y() const { return pos.y(); }
  U z() const { return pos.z(); }
 
  U distance() const { return pos.distance(); }
 
  U distance_to(const BodycentricPos &other) const { return pos.distance_to(other.pos); }
 
  const BodycentricParams &center_params() const { return params; }
 
  // ── Inverse transform ─────────────────────────────────────────────────────
 
  cartesian::Position<centers::Geocentric, F, U> to_geocentric(const Time<TT, JD> &jd) const;
};
 
// ============================================================================
// to_bodycentric() — free function template
// ============================================================================
 
template <typename C, typename F, typename U>
inline BodycentricPos<F, U> to_bodycentric(const cartesian::Position<C, F, U> &pos,
                                           const BodycentricParams &params,
                                           const Time<TT, JD> &jd) {
  static_assert(centers::is_center_v<C>, "C must be a valid center tag");
 
  siderust_cartesian_pos_t c_pos = pos.to_c();
  SiderustBodycentricParams c_params = params.to_c();
  siderust_cartesian_pos_t c_out{};
 
  check_status(siderust_to_bodycentric(c_pos, c_params, jd.value(), &c_out), "to_bodycentric");
 
  cartesian::Position<centers::Bodycentric, F, U> result_pos(U(c_out.x), U(c_out.y), U(c_out.z));
  return BodycentricPos<F, U>{result_pos, params};
}
 
// ============================================================================
// BodycentricPos::to_geocentric() — out-of-line member implementation
// ============================================================================
 
template <typename F, typename U>
inline cartesian::Position<centers::Geocentric, F, U>
BodycentricPos<F, U>::to_geocentric(const Time<TT, JD> &jd) const {
  siderust_cartesian_pos_t c_pos = pos.to_c();
  SiderustBodycentricParams c_params = params.to_c();
  siderust_cartesian_pos_t c_out{};
 
  check_status(siderust_from_bodycentric(c_pos, c_params, jd.value(), &c_out), "from_bodycentric");
 
  return cartesian::Position<centers::Geocentric, F, U>(U(c_out.x), U(c_out.y), U(c_out.z));
}
 
} // namespace siderust