EBGeometry_PointCloudBVH.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_POINTCLOUDBVH_HPP
#define EBGEOMETRY_POINTCLOUDBVH_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_PointSoA.hpp"
#include "EBGeometry_Pool.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
template <class T, size_t K = BVH::DefaultBranchingRatio<T>(), size_t W = PointSoA::DefaultWidth<T>()>
class PointCloudBVH : public PoolHandle
{
public:
  using PointGroup = PointAoSoA<T, W>;
 
  using Packed = BVH::PackedBVH<T, PointGroup, K>;
 
  using Node = typename Packed::Node;
 
  using AABB = BoundingVolumes::AABBT<T>;
 
  using Hit = PointCloud::Hit<T>;
 
  PointCloudBVH() = delete;
 
  EBGEOMETRY_HOST
  inline PointCloudBVH(Pool& a_pool, const std::vector<Vec3T<T>>& a_positions, std::size_t a_targetLeafSize = 16 * W);
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Hit
  closestPoint(const Vec3T<T>& a_query) const noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline std::size_t
  closestPoints(const Vec3T<T>& a_query, std::size_t a_k, Hit* a_out) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Hit
  nearestNeighbor(uint32_t a_point) const noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline std::size_t
  nearestNeighbors(uint32_t a_point, std::size_t a_k, Hit* a_out) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline std::vector<Hit>
  allNearestNeighbors(std::size_t a_k = 1) const;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline std::size_t
  numPoints() const noexcept
  {
    return m_positions.size();
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline const Vec3T<T>&
  position(uint32_t a_index) const noexcept
  {
    EBGEOMETRY_EXPECT(a_index < m_positions.size());
 
    return m_positions.at(this->base(), a_index);
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Packed
  getBVH() const noexcept
  {
    return Packed(m_bvhLayout, this->location());
  }
 
  using PoolHandle::base;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline PointCloudBVH
  rebasedView(const Pool& a_pool) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline PointCloudBVH
  deepCopy(Pool& a_dstPool) const;
 
private:
  struct BuildResult
  {
    std::vector<Node>          nodes;      
    std::vector<AABB>          boxes;      
    std::vector<PointGroup>    primitives; 
    std::vector<std::uint32_t> leafOff;    
    std::vector<std::uint32_t> leafCnt;    
    std::vector<std::uint32_t> order;      
  };
 
  EBGEOMETRY_HOST
  inline PointCloudBVH(Pool& a_pool, const BuildResult& a_build, const std::vector<Vec3T<T>>& a_positions);
 
  EBGEOMETRY_HOST
  inline void
  storeCloud(Pool&                             a_pool,
             const std::vector<Vec3T<T>>&      a_positions,
             const std::vector<std::uint32_t>& a_leafOff,
             const std::vector<std::uint32_t>& a_leafCnt,
             const std::vector<std::uint32_t>& a_order);
 
  template <class U>
  [[nodiscard]] EBGEOMETRY_HOST
  static inline std::vector<U>
  toHost(const PODVector<U>& a_array, const void* a_base);
 
  EBGEOMETRY_HOST
  static inline BuildResult
  buildTree(const std::vector<Vec3T<T>>& a_positions, std::size_t a_leafSize);
 
  EBGEOMETRY_HOST_DEVICE
  inline std::size_t
  query(const Vec3T<T>& a_query,
        std::size_t     a_k,
        Hit*            a_out,
        uint32_t        a_exclude,
        std::uint32_t   a_seedOff,
        std::uint32_t   a_seedCnt) const noexcept;
 
  typename Packed::Layout m_bvhLayout;
 
  PODVector<Vec3T<T>> m_positions;
 
  PODVector<std::uint32_t> m_leafOff;
 
  PODVector<std::uint32_t> m_leafCnt;
 
  PODVector<std::uint32_t> m_order;
};
 
static_assert(std::is_trivially_copyable_v<PointCloudBVH<float>>, "PointCloudBVH<float> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<PointCloudBVH<double>>, "PointCloudBVH<double> must be trivially copyable");
 
} // namespace EBGeometry
 
#include "EBGeometry_PointCloudBVHImplem.hpp"
 
#endif