sky_grid.hpp

Go to the documentation of this file.

#pragma once
 
#include "coordinates/spherical.hpp"
#include "ffi_core.hpp"
#include <qtty/qtty.hpp>
#include <vector>
 
namespace siderust {
 
namespace detail {
 
struct SkyGridCellsGuard {
  SiderustSkyGridCell *ptr = nullptr;
  uintptr_t count = 0;
 
  ~SkyGridCellsGuard() { siderust_sky_grid_cells_free(ptr, count); }
 
  SkyGridCellsGuard() = default;
  SkyGridCellsGuard(const SkyGridCellsGuard &) = delete;
  SkyGridCellsGuard &operator=(const SkyGridCellsGuard &) = delete;
  SkyGridCellsGuard(SkyGridCellsGuard &&) = delete;
  SkyGridCellsGuard &operator=(SkyGridCellsGuard &&) = delete;
};
 
} // namespace detail
 
struct SkyGridCell {
  spherical::Direction<frames::Horizontal> direction; 
  qtty::Steradian solid_angle;                        
 
  static SkyGridCell from_c(const SiderustSkyGridCell &c) {
    return SkyGridCell{spherical::Direction<frames::Horizontal>(qtty::Degree(c.azimuth_deg),
                                                                qtty::Degree(c.altitude_deg)),
                       qtty::Steradian(c.solid_angle_sr)};
  }
};
 
class SkyGrid {
  double alt_min_;
  double alt_max_;
  double alt_step_;
  double az_step_;
  bool equal_area_;
 
  SkyGrid(double alt_min, double alt_max, double alt_step, double az_step, bool equal_area)
      : alt_min_(alt_min), alt_max_(alt_max), alt_step_(alt_step), az_step_(az_step),
        equal_area_(equal_area) {}
 
public:
  static SkyGrid uniform(qtty::Degree step) {
    return SkyGrid(0.0, 90.0, step.value(), step.value(), false);
  }
 
  static SkyGrid with_steps(qtty::Degree alt_step, qtty::Degree az_step) {
    return SkyGrid(0.0, 90.0, alt_step.value(), az_step.value(), false);
  }
 
  static SkyGrid equal_area(qtty::Degree alt_step, qtty::Degree az_step_at_horizon) {
    return SkyGrid(0.0, 90.0, alt_step.value(), az_step_at_horizon.value(), true);
  }
 
  SkyGrid &with_alt_range(qtty::Degree lo, qtty::Degree hi) {
    alt_min_ = lo.value();
    alt_max_ = hi.value();
    return *this;
  }
 
  std::vector<SkyGridCell> cells() const {
    SiderustSkyGridCell *ptr = nullptr;
    uintptr_t count = 0;
    check_status(
        siderust_sky_grid_cells(alt_min_, alt_max_, alt_step_, az_step_, equal_area_, &ptr, &count),
        "SkyGrid::cells");
 
    detail::SkyGridCellsGuard guard{};
    guard.ptr = ptr;
    guard.count = count;
 
    std::vector<SkyGridCell> result;
    result.reserve(count);
    for (uintptr_t i = 0; i < count; ++i) {
      result.push_back(SkyGridCell::from_c(ptr[i]));
    }
    return result;
  }
 
  std::size_t size() const { return cells().size(); }
};
 
} // namespace siderust