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 <limits>
#include <vector>
 
// Our includes
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
template <class T, class Meta = std::size_t>
class PointCloudHashGrid
{
public:
  struct Hit
  {
    std::size_t index           = 0;                             
    T           distanceSquared = std::numeric_limits<T>::max(); 
  };
 
  PointCloudHashGrid() = delete;
 
  inline PointCloudHashGrid(const std::vector<Vec3T<T>>& a_positions,
                            const std::vector<Meta>&     a_metadata,
                            T                            a_targetPerCell = T(1));
 
  [[nodiscard]] inline Hit
  closestPoint(const Vec3T<T>& a_query) const noexcept;
 
  inline std::size_t
  closestPoints(const Vec3T<T>& a_query, std::size_t a_k, Hit* a_out) const noexcept;
 
  [[nodiscard]] inline Hit
  nearestNeighbor(std::size_t a_point) const noexcept;
 
  inline std::size_t
  nearestNeighbors(std::size_t a_point, std::size_t a_k, Hit* a_out) const noexcept;
 
  [[nodiscard]] inline std::vector<Hit>
  allNearestNeighbors(std::size_t a_k = 1) const;
 
  [[nodiscard]] inline Hit
  closestPointBruteForce(const Vec3T<T>& a_query) const noexcept;
 
  inline std::size_t
  closestPointsBruteForce(const Vec3T<T>& a_query, std::size_t a_k, Hit* a_out) const;
 
  [[nodiscard]] inline Hit
  nearestNeighborBruteForce(std::size_t a_point) const noexcept;
 
  inline std::size_t
  nearestNeighborsBruteForce(std::size_t a_point, std::size_t a_k, Hit* a_out) const;
 
  [[nodiscard]] inline std::size_t
  numPoints() const noexcept
  {
    return m_positions.size();
  }
 
  [[nodiscard]] inline const Vec3T<T>&
  position(std::size_t a_index) const noexcept
  {
    return m_positions[a_index];
  }
 
  [[nodiscard]] inline const Meta&
  metadata(std::size_t a_index) const noexcept
  {
    return m_metadata[a_index];
  }
 
private:
  [[nodiscard]] inline int
  cellCoord(T a_x, T a_lo, int a_n) const noexcept;
 
  [[nodiscard]] inline std::size_t
  cellIndex(int a_ix, int a_iy, int a_iz) const noexcept;
 
  [[nodiscard]] inline std::size_t
  cellIndexOf(const Vec3T<T>& a_p) const noexcept;
 
  inline void
  query(
    const Vec3T<T>& a_query, std::size_t a_k, Hit* a_out, std::size_t& a_found, std::size_t a_exclude) const noexcept;
 
  [[nodiscard]] inline Hit
  bruteForceOne(const Vec3T<T>& a_query, std::size_t a_exclude) const noexcept;
 
  inline std::size_t
  bruteForceK(const Vec3T<T>& a_query, std::size_t a_k, Hit* a_out, std::size_t a_exclude) const;
 
  static constexpr std::size_t s_none = std::numeric_limits<std::size_t>::max();
 
  std::vector<Vec3T<T>> m_positions;
 
  std::vector<Meta> m_metadata;
 
  Vec3T<T> m_lo;
 
  T m_h = T(1);
 
  T m_invH = T(1);
 
  int m_nx = 1, m_ny = 1, m_nz = 1;
 
  std::vector<std::uint32_t> m_cellStart;
 
  std::vector<std::uint32_t> m_cellPoints;
};
 
} // namespace EBGeometry
 
#include "EBGeometry_PointCloudHashGridImplem.hpp"
 
#endif