iss_keypoints.hpp

Go to the documentation of this file.

#pragma once
 
#include <cpp-toolbox/cpp-toolbox_export.hpp>
#include <cpp-toolbox/pcl/features/base_feature_extractor.hpp>
#include <cpp-toolbox/pcl/knn/kdtree.hpp>
#include <cpp-toolbox/pcl/knn/bfknn_parallel.hpp>
#include <cpp-toolbox/metrics/vector_metrics.hpp>
 
namespace toolbox::pcl
{
 
template<typename DataType, typename KNN = kdtree_generic_t<point_t<DataType>, toolbox::metrics::L2Metric<DataType>>>
class CPP_TOOLBOX_EXPORT iss_keypoint_extractor_t
    : public base_keypoint_extractor_t<iss_keypoint_extractor_t<DataType, KNN>,
                                       DataType,
                                       KNN>
{
public:
  using base_type = base_keypoint_extractor_t<iss_keypoint_extractor_t<DataType, KNN>,
                                              DataType,
                                              KNN>;
  using data_type = typename base_type::data_type;
  using knn_type = typename base_type::knn_type;
  using point_cloud = typename base_type::point_cloud;
  using point_cloud_ptr = typename base_type::point_cloud_ptr;
  using indices_vector = typename base_type::indices_vector;
 
  iss_keypoint_extractor_t() = default;
 
  std::size_t set_input_impl(const point_cloud& cloud);
  std::size_t set_input_impl(const point_cloud_ptr& cloud);
  
  std::size_t set_knn_impl(const knn_type& knn);
  
  std::size_t set_search_radius_impl(data_type radius);
  
  void enable_parallel_impl(bool enable);
 
  indices_vector extract_impl();
  void extract_impl(indices_vector& keypoint_indices);
  point_cloud extract_keypoints_impl();
  void extract_keypoints_impl(point_cloud_ptr output);
 
  void set_salient_radius(data_type radius) { m_salient_radius = radius; }
  
  void set_non_maxima_radius(data_type radius) { m_non_maxima_radius = radius; }
  
  void set_threshold21(data_type threshold) { m_threshold21 = threshold; }
  
  void set_threshold32(data_type threshold) { m_threshold32 = threshold; }
  
  void set_min_neighbors(std::size_t min_neighbors) { m_min_neighbors = min_neighbors; }
 
  [[nodiscard]] data_type get_salient_radius() const { return m_salient_radius; }
  
  [[nodiscard]] data_type get_non_maxima_radius() const { return m_non_maxima_radius; }
  
  [[nodiscard]] data_type get_threshold21() const { return m_threshold21; }
  
  [[nodiscard]] data_type get_threshold32() const { return m_threshold32; }
  
  [[nodiscard]] std::size_t get_min_neighbors() const { return m_min_neighbors; }
 
private:
  struct ISSInfo
  {
    data_type eigenvalue1;  
    data_type eigenvalue2;  
    data_type eigenvalue3;  
    data_type saliency;     
    bool is_valid;          
  };
 
  ISSInfo compute_iss_response(std::size_t point_idx);
  
  std::vector<ISSInfo> compute_all_iss_responses();
  
  indices_vector apply_non_maxima_suppression(const std::vector<ISSInfo>& iss_responses);
  
  void compute_iss_range(std::vector<ISSInfo>& iss_responses, 
                        std::size_t start_idx, 
                        std::size_t end_idx);
 
  // 成员变量 / Member variables
  bool m_enable_parallel = false;                               
  data_type m_salient_radius = static_cast<data_type>(1.0);    
  data_type m_non_maxima_radius = static_cast<data_type>(0.5); 
  data_type m_threshold21 = static_cast<data_type>(0.975);     
  data_type m_threshold32 = static_cast<data_type>(0.975);     
  std::size_t m_min_neighbors = 5;                             
  
  point_cloud_ptr m_cloud;                                      
  knn_type* m_knn = nullptr;                                    
 
  static constexpr std::size_t k_parallel_threshold = 1000;
};  // class iss_keypoint_extractor_t
 
}  // namespace toolbox::pcl
 
#include <cpp-toolbox/pcl/features/impl/iss_keypoints_impl.hpp>