EBGeometry_SphereCloudBVH.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_SPHERECLOUDBVH_HPP
#define EBGEOMETRY_SPHERECLOUDBVH_HPP
 
// Std includes
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <vector>
 
// Our includes
#include "EBGeometry_BoundingVolumes.hpp"
#include "EBGeometry_CloudBVH.hpp"
#include "EBGeometry_GPUAlgorithms.hpp"
#include "EBGeometry_PackedBVH.hpp"
#include "EBGeometry_Pool.hpp"
#include "EBGeometry_SphereAoSoA.hpp"
#include "EBGeometry_SphereCloud.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace PointCloudDetail {
 
template <class T, class Source>
struct RadiiAsPoints
{
  Source m_source;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  Vec3T<T>
  operator()(const uint32_t a_index) const noexcept
  {
    const T radius = m_source(a_index).m_radius;
 
    return Vec3T<T>(radius, radius, radius);
  }
};
 
template <class T, size_t W>
struct SpherePrimitive
{
  using Item = SphereCloud::Sphere<T>;
 
  using Group = SphereAoSoA<T, W>;
 
  using FromArray = SphereCloud::FromArray<T>;
 
  static constexpr const char* ClassName = "SphereCloudBVH";
 
  static constexpr const char* Singular = "sphere";
 
  static constexpr const char* Plural = "spheres";
 
  static constexpr const char* MaxParameter = "a_maxSpheres";
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  static inline const Vec3T<T>&
  center(const Item& a_item) noexcept
  {
    return a_item.m_center;
  }
 
  EBGEOMETRY_HOST_DEVICE
  static inline void
  grow(Vec3T<T>& a_lo, Vec3T<T>& a_hi, const Item& a_item) noexcept
  {
    const Vec3T<T> radius = a_item.m_radius * Vec3T<T>::ones();
 
    a_lo = min(a_lo, a_item.m_center - radius);
    a_hi = max(a_hi, a_item.m_center + radius);
  }
 
  EBGEOMETRY_HOST
  static inline void
  requireValid(const char* a_who, const std::vector<Item>& a_items) noexcept
  {
    for (std::size_t i = 0; i < a_items.size(); i++) {
      const Item& sphere = a_items[i];
 
      EBGEOMETRY_REQUIRE(std::isfinite(sphere.m_center[0]) && std::isfinite(sphere.m_center[1]) &&
                           std::isfinite(sphere.m_center[2]),
                         "%s: sphere %zu of %zu has a non-finite coordinate",
                         a_who,
                         i,
                         a_items.size());
      EBGEOMETRY_REQUIRE(std::isfinite(sphere.m_radius) && sphere.m_radius >= T(0),
                         "%s: sphere %zu of %zu has a non-finite or negative radius",
                         a_who,
                         i,
                         a_items.size());
    }
  }
 
  template <class Source>
  EBGEOMETRY_HOST
  static inline void
  requireValidWhereBuilt(const Source&  a_source,
                         const uint32_t a_numItems,
                         const bool     a_parallel,
                         Vec3T<T>*      a_scratch,
                         const char*    a_who) noexcept
  {
    if (a_numItems == 0) {
      return;
    }
 
    if (a_parallel) {
      const BoundingVolumes::AABBT<T> box =
        GPU::boundingBoxOf<T>(RadiiAsPoints<T, Source>{a_source}, a_numItems, a_scratch);
 
      const T smallest = box.getLowCorner()[0];
      const T largest  = box.getHighCorner()[0];
 
      EBGEOMETRY_REQUIRE(std::isfinite(smallest) && std::isfinite(largest) && smallest >= T(0),
                         "%s: a sphere has a non-finite or negative radius",
                         a_who);
 
      return;
    }
 
    for (uint32_t i = 0; i < a_numItems; i++) {
      const T radius = a_source(i).m_radius;
 
      EBGEOMETRY_REQUIRE(std::isfinite(radius) && radius >= T(0),
                         "%s: sphere %u of %u has a non-finite or negative radius",
                         a_who,
                         unsigned(i),
                         unsigned(a_numItems));
    }
  }
};
 
} // namespace PointCloudDetail
 
template <class T, size_t K = BVH::DefaultBranchingRatio<T>(), size_t W = PointSoA::DefaultWidth<T>()>
class SphereCloudBVH : public PointCloudDetail::CloudBVH<T, K, W, PointCloudDetail::SpherePrimitive<T, W>>
{
public:
  using Sphere = SphereCloud::Sphere<T>;
 
  using Hit = SphereCloud::Hit<T>;
 
  using SphereGroup = SphereAoSoA<T, W>;
 
  using Packed = BVH::PackedBVH<T, SphereGroup, K>;
 
  using AABB = BoundingVolumes::AABBT<T>;
 
  EBGEOMETRY_HOST
  inline SphereCloudBVH(Pool& a_pool, const std::vector<Sphere>& a_spheres, std::size_t a_targetLeafSize = 16 * W);
 
  EBGEOMETRY_HOST
  inline SphereCloudBVH(Pool&                        a_pool,
                        const std::vector<Vec3T<T>>& a_centers,
                        const std::vector<T>&        a_radii,
                        std::size_t                  a_targetLeafSize = 16 * W);
 
  template <class Source>
  [[nodiscard]] EBGEOMETRY_HOST
  static inline SphereCloudBVH
  build(Pool&         a_pool,
        const Source& a_source,
        uint32_t      a_numSpheres,
        std::size_t   a_targetLeafSize = 16 * W,
        uint32_t      a_maxSpheres     = 0);
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline SphereCloudBVH
  build(Pool&                      a_pool,
        const std::vector<Sphere>& a_spheres,
        std::size_t                a_targetLeafSize = 16 * W,
        uint32_t                   a_maxSpheres     = 0);
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline SphereCloudBVH
  build(Pool&                        a_pool,
        const std::vector<Vec3T<T>>& a_centers,
        const std::vector<T>&        a_radii,
        std::size_t                  a_targetLeafSize = 16 * W,
        uint32_t                     a_maxSpheres     = 0);
 
  template <class Source>
  EBGEOMETRY_HOST
  inline void
  rebuild(const Source& a_source, uint32_t a_numSpheres);
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline uint32_t
  maxSpheres() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  signedDistance(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Hit
  closestSphere(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline AABB
  computeBoundingVolume() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline uint32_t
  numSpheres() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Sphere
  sphere(uint32_t a_index) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Packed
  getBVH() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline SphereCloudBVH
  rebasedView(const Pool& a_pool) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline SphereCloudBVH
  deepCopy(Pool& a_dstPool) const;
 
  using PoolHandle::base;
 
private:
  using Base = PointCloudDetail::CloudBVH<T, K, W, PointCloudDetail::SpherePrimitive<T, W>>;
 
  using Base::m_bvhLayout;
  using Base::m_items;
  using Base::m_maxItems;
 
  SphereCloudBVH() noexcept = default;
};
 
static_assert(std::is_trivially_copyable_v<SphereCloudBVH<float>>, "SphereCloudBVH<float> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<SphereCloudBVH<double>>,
              "SphereCloudBVH<double> must be trivially copyable");
 
} // namespace EBGeometry
 
#include "EBGeometry_SphereCloudBVHImplem.hpp"
 
#endif