NanoflannAdaptor.hpp

#ifndef FIBER_BASEOP_NANOFLANN_ADAPTOR_HPP
#define FIBER_BASEOP_NANOFLANN_ADAPTOR_HPP      20251027
 
#if __has_include(<nanoflann.hpp>)
# include <nanoflann.hpp>
# define HAVE_NANOFLANN NANOFLANN_VERSION
#else
# define HAVE_NANOFLANN 0
#endif
 
#include <vector>
#include <array>
 
#include <eagle/PhysicalSpace.hpp>
 
namespace  Fiber
{
 
struct  NanoFlannPointCloudAdaptor
{
        using   point3 = Eagle::point3;
 
        const std::vector<point3>& pts;
 
        NanoFlannPointCloudAdaptor(const std::vector<point3>& points)
        : pts(points) {}
 
        size_t  kdtree_get_point_count() const { return pts.size(); }
 
        inline double kdtree_get_pt(size_t idx, size_t dim) const
        {
                switch (dim)
                {
                case 0: return pts[idx][dim];
                case 1: return pts[idx][dim];
                case 2: return pts[idx][dim];
                default: return 0.0;
                }
        }
 
        template <class BBOX>
        bool    kdtree_get_bbox(BBOX&) const { return false; }
};
 
using   nanoflannKDTree = nanoflann::KDTreeSingleIndexAdaptor<
                           nanoflann::L2_Simple_Adaptor<double, NanoFlannPointCloudAdaptor>,
                           NanoFlannPointCloudAdaptor, 3
                        >;
 
 
template <size_t N>
size_t  findNClosestPoints(const Eagle::point3&QueryPoint,
                           const nanoflannKDTree&theTree,
                           std::array<uint32_t, N>&indices,
                           std::array<double  , N>&squared_distances)
{
const double*query_pt = QueryPoint.const_elements_as_fixed_array();
        return  theTree.knnSearch(query_pt, N, indices.data(), squared_distances.data());
}
 
 
}
 
 
#endif  // FIBER_BASEOP_NANOFLANN_ADAPTOR_HPP