EBGeometry_SphereCloud.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_SPHERECLOUD_HPP
#define EBGEOMETRY_SPHERECLOUD_HPP
 
// Std includes
#include <cstdint>
#include <type_traits>
 
// Our includes
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Macros.hpp"
#include "EBGeometry_Math.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace SphereCloud {
 
inline constexpr uint32_t InvalidIndex = Math::Limits<uint32_t>::max();
 
template <class T>
struct Sphere
{
  Vec3T<T> m_center; 
  T        m_radius; 
};
 
template <class T>
struct Hit
{
  uint32_t index    = InvalidIndex;           
  T        distance = Math::Limits<T>::max(); 
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  bool
  valid() const noexcept
  {
    return index != InvalidIndex;
  }
};
 
template <class T>
struct FromArray
{
  const Sphere<T>* m_spheres = nullptr;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  Sphere<T>
  operator()(const uint32_t a_index) const noexcept
  {
    return m_spheres[a_index];
  }
};
 
template <class T>
struct FromRadii
{
  const T* m_radii = nullptr;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T
  operator()(const uint32_t a_index) const noexcept
  {
    return m_radii[a_index];
  }
};
 
template <class T, class Centers, class Radii>
struct FromCentersAndRadii
{
  static_assert(std::is_trivially_copyable_v<Centers>,
                "SphereCloud::FromCentersAndRadii: Centers must be trivially copyable");
  static_assert(std::is_trivially_copyable_v<Radii>,
                "SphereCloud::FromCentersAndRadii: Radii must be trivially copyable");
 
  Centers m_centers;
 
  Radii m_radii;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  Sphere<T>
  operator()(const uint32_t a_index) const noexcept
  {
    return Sphere<T>{m_centers(a_index), m_radii(a_index)};
  }
};
 
} // namespace SphereCloud
 
} // namespace EBGeometry
 
#endif