EBGeometry_PointCloudHashGrid.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_POINTCLOUDHASHGRID_HPP
#define EBGEOMETRY_POINTCLOUDHASHGRID_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <vector>
 
// Our includes
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Math.hpp"
#include "EBGeometry_PODVector.hpp"
#include "EBGeometry_PointCloud.hpp"
#include "EBGeometry_Pool.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
template <class T>
class PointCloudHashGrid : public PoolHandle
{
public:
  using Hit = PointCloud::Hit<T>;
 
  PointCloudHashGrid() = delete;
 
  EBGEOMETRY_HOST
  inline PointCloudHashGrid(Pool& a_pool, const std::vector<Vec3T<T>>& a_positions, T a_targetPerCell = T(1));
 
  [[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);
  }
 
  using PoolHandle::base;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline PointCloudHashGrid
  rebasedView(const Pool& a_pool) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline PointCloudHashGrid
  deepCopy(Pool& a_dstPool) const;
 
private:
  EBGEOMETRY_HOST
  inline void
  storeArrays(Pool&                             a_pool,
              const std::vector<Vec3T<T>>&      a_positions,
              const std::vector<std::uint32_t>& a_cellStart,
              const std::vector<std::uint32_t>& a_cellPoints);
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline int
  cellCoord(T a_x, T a_lo, int a_n) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline std::size_t
  cellIndex(int a_ix, int a_iy, int a_iz) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline std::size_t
  cellIndexOf(const Vec3T<T>& a_p) const noexcept;
 
  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) const noexcept;
 
  PODVector<Vec3T<T>> m_positions;
 
  PODVector<std::uint32_t> m_cellStart;
 
  PODVector<std::uint32_t> m_cellPoints;
 
  Vec3T<T> m_lo;
 
  T m_h = T(1);
 
  T m_invH = T(1);
 
  int m_nx = 1, m_ny = 1, m_nz = 1;
};
 
static_assert(std::is_trivially_copyable_v<PointCloudHashGrid<float>>,
              "PointCloudHashGrid<float> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<PointCloudHashGrid<double>>,
              "PointCloudHashGrid<double> must be trivially copyable");
 
} // namespace EBGeometry
 
#include "EBGeometry_PointCloudHashGridImplem.hpp"
 
#endif