base_knn.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <type_traits>
 
#include <cpp-toolbox/cpp-toolbox_export.hpp>
#include <cpp-toolbox/types/point.hpp>
#include <cpp-toolbox/metrics/vector_metrics.hpp>
#include <cpp-toolbox/metrics/metric_factory.hpp>
 
namespace toolbox::pcl
{
 
using toolbox::types::point_t;
 
template<typename Element, typename Metric>
struct knn_traits
{
  using element_type = Element;     
  using metric_type = Metric;       
  using distance_type = typename Metric::result_type;  
};
 
template<typename Derived, typename Element, typename Metric = toolbox::metrics::L2Metric<typename Element::value_type>>
class CPP_TOOLBOX_EXPORT base_knn_generic_t
{
public:
  using traits_type = knn_traits<Element, Metric>;
  using element_type = typename traits_type::element_type;
  using metric_type = typename traits_type::metric_type;
  using distance_type = typename traits_type::distance_type;
  using container_type = std::vector<element_type>;
  using container_ptr = std::shared_ptr<container_type>;
 
  std::size_t set_input(const container_type& data)
  {
    return static_cast<Derived*>(this)->set_input_impl(data);
  }
 
  std::size_t set_input(const container_ptr& data)
  {
    return static_cast<Derived*>(this)->set_input_impl(data);
  }
  
  template<typename T = typename Element::value_type, 
           typename = std::enable_if_t<std::is_same_v<Element, point_t<T>>>>
  std::size_t set_input(const toolbox::types::point_cloud_t<T>& cloud)
  {
    return set_input(cloud.points);
  }
  
  template<typename T = typename Element::value_type,
           typename = std::enable_if_t<std::is_same_v<Element, point_t<T>>>>
  std::size_t set_input(const std::shared_ptr<toolbox::types::point_cloud_t<T>>& cloud)
  {
    if (!cloud) return 0;
    return set_input(cloud->points);
  }
 
  void set_metric(const metric_type& metric)
  {
    static_cast<Derived*>(this)->set_metric_impl(metric);
  }
 
  template<typename T = typename Element::value_type>
  void set_metric(std::shared_ptr<toolbox::metrics::IMetric<T>> metric)
  {
    static_cast<Derived*>(this)->set_metric_impl(metric);
  }
  
  template<typename T = typename Element::value_type>
  void set_metric(std::unique_ptr<toolbox::metrics::IMetric<T>> metric)
  {
    static_cast<Derived*>(this)->set_metric_impl(std::move(metric));
  }
 
  bool kneighbors(const element_type& query,
                  std::size_t num_neighbors,
                  std::vector<std::size_t>& indices,
                  std::vector<distance_type>& distances)
  {
    return static_cast<Derived*>(this)->kneighbors_impl(
        query, num_neighbors, indices, distances);
  }
 
  bool radius_neighbors(const element_type& query,
                        distance_type radius,
                        std::vector<std::size_t>& indices,
                        std::vector<distance_type>& distances)
  {
    return static_cast<Derived*>(this)->radius_neighbors_impl(
        query, radius, indices, distances);
  }
 
protected:
  base_knn_generic_t() = default;
  ~base_knn_generic_t() = default;
 
public:
  base_knn_generic_t(const base_knn_generic_t&) = delete;
  base_knn_generic_t& operator=(const base_knn_generic_t&) = delete;
  base_knn_generic_t(base_knn_generic_t&&) = delete;
  base_knn_generic_t& operator=(base_knn_generic_t&&) = delete;
};  // class base_knn_generic_t
 
}  // namespace toolbox::pcl