EBGeometry_CloudBVH.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_CLOUDBVH_HPP
#define EBGEOMETRY_CLOUDBVH_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <vector>
 
// Our includes
#include "EBGeometry_BoundingVolumes.hpp"
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Math.hpp"
#include "EBGeometry_PODVector.hpp"
#include "EBGeometry_PackedBVH.hpp"
#include "EBGeometry_PointAoSoA.hpp"
#include "EBGeometry_PointCloud.hpp"
#include "EBGeometry_PointCloudDetail.hpp"
#include "EBGeometry_Pool.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace PointCloudDetail {
 
struct MortonKey
{
  uint64_t m_code;
 
  uint32_t m_index;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline bool
  operator<(const MortonKey& a_other) const noexcept
  {
    return m_code < a_other.m_code || (m_code == a_other.m_code && m_index < a_other.m_index);
  }
};
 
struct BuildNode
{
  uint32_t m_lo;
 
  uint32_t m_hi;
 
  uint32_t m_parent;
 
  uint32_t m_slot;
 
  uint32_t m_firstChild;
 
  uint32_t m_subtree;
 
  uint32_t m_depthFirst;
};
 
template <class T, size_t W>
struct PointPrimitive
{
  using Item = Vec3T<T>;
 
  using Group = PointAoSoA<T, W>;
 
  using FromArray = PointCloud::FromArray<T>;
 
  static constexpr const char* ClassName = "PointCloudBVH";
 
  static constexpr const char* Singular = "point";
 
  static constexpr const char* Plural = "points";
 
  static constexpr const char* MaxParameter = "a_maxPoints";
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  static inline const Vec3T<T>&
  center(const Item& a_item) noexcept
  {
    return a_item;
  }
 
  EBGEOMETRY_HOST_DEVICE
  static inline void
  grow(Vec3T<T>& a_lo, Vec3T<T>& a_hi, const Item& a_item) noexcept
  {
    a_lo = min(a_lo, a_item);
    a_hi = max(a_hi, a_item);
  }
 
  EBGEOMETRY_HOST
  static inline void
  requireValid(const char* a_who, const std::vector<Item>& a_items) noexcept
  {
    requireValidCloud(a_who, a_items);
  }
 
  template <class Source>
  EBGEOMETRY_HOST
  static inline void
  requireValidWhereBuilt(const Source&, uint32_t, bool, Vec3T<T>*, const char*) noexcept
  {}
};
 
template <class Prim, class Source>
struct Centers
{
  Source m_source;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  auto
  operator()(const uint32_t a_index) const noexcept
  {
    return Prim::center(m_source(a_index));
  }
};
 
template <class T, size_t K, size_t W, class Prim>
class CloudBVH : public PoolHandle
{
public:
  using Item = typename Prim::Item;
 
  using Group = typename Prim::Group;
 
  using Packed = BVH::PackedBVH<T, Group, K>;
 
  using Node = typename Packed::Node;
 
  using AABB = BoundingVolumes::AABBT<T>;
 
protected:
  CloudBVH() noexcept = default;
 
  struct Scratch
  {
    PODVector<MortonKey> m_keys;
 
    PODVector<Vec3T<T>> m_box;
 
    PODVector<BuildNode> m_nodes;
 
    PODVector<AABB> m_boxes;
 
    PODVector<std::uint32_t> m_rows;
 
    PODVector<std::uint32_t> m_groups;
 
    PODVector<std::uint32_t> m_scan;
  };
 
  struct Sizes
  {
    std::uint32_t m_nodes;
 
    std::uint32_t m_interior;
 
    std::uint32_t m_groups;
  };
 
  template <class Source>
  EBGEOMETRY_HOST
  inline void
  initialize(Pool&         a_pool,
             const Source& a_source,
             uint32_t      a_numItems,
             std::size_t   a_targetLeafSize,
             uint32_t      a_maxItems,
             const char*   a_who);
 
  EBGEOMETRY_HOST
  inline void
  initialize(Pool&                    a_pool,
             const std::vector<Item>& a_items,
             std::size_t              a_targetLeafSize,
             uint32_t                 a_maxItems,
             const char*              a_who);
 
  template <class Source>
  EBGEOMETRY_HOST
  inline void
  reinitialize(const Source& a_source, uint32_t a_numItems, const char* a_who);
 
  EBGEOMETRY_HOST
  inline void
  rebase(const Pool& a_pool) noexcept;
 
  EBGEOMETRY_HOST
  inline void
  copyInto(CloudBVH& a_copy, Pool& a_dstPool) const;
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline Sizes
  sizesFor(uint32_t a_numItems, uint32_t a_leafSize, const char* a_who) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline Scratch
  reserveScratch(Pool& a_pool, uint32_t a_numItems, uint32_t a_leafSize, const char* a_who);
 
  EBGEOMETRY_HOST
  inline void
  reserveArrays(Pool& a_pool, const Sizes& a_sizes, uint32_t a_numItems);
 
  template <class Source>
  EBGEOMETRY_HOST
  inline Sizes
  shape(const Scratch& a_scratch, void* a_base, const Source& a_source, uint32_t a_numItems, const char* a_who);
 
  template <class Source>
  EBGEOMETRY_HOST
  inline void
  write(const Scratch& a_scratch, void* a_base, const Sizes& a_sizes, const Source& a_source, uint32_t a_numItems);
 
  template <class F>
  EBGEOMETRY_HOST
  inline void
  run(std::size_t a_count, const F& a_f) const;
 
  EBGEOMETRY_HOST
  inline std::uint32_t
  scan(std::uint32_t* a_values, std::uint32_t a_count, std::uint32_t* a_scratch) const;
 
  template <class U>
  [[nodiscard]] EBGEOMETRY_HOST
  static inline std::vector<U>
  toHost(const PODVector<U>& a_array, const void* a_base);
 
  typename Packed::Layout m_bvhLayout;
 
  PODVector<Item> m_items;
 
  PODVector<std::uint32_t> m_leafOff;
 
  PODVector<std::uint32_t> m_leafCnt;
 
  PODVector<std::uint32_t> m_order;
 
  Scratch m_scratch;
 
  std::uint32_t m_maxItems = 0;
 
  std::uint32_t m_leafSize = 0;
 
  std::uint32_t m_depth = 0;
 
  bool m_parallel = false;
};
 
} // namespace PointCloudDetail
 
} // namespace EBGeometry
 
#include "EBGeometry_CloudBVHImplem.hpp"
 
#endif