cloud_preprocessor.hpp

#pragma once
 
#include <random>
#include <vector>
#include <Eigen/Core>
#include <Eigen/Geometry>
 
#include <glim/preprocess/preprocessed_frame.hpp>
 
namespace glim {
 
struct CloudPreprocessorParams {
public:
  CloudPreprocessorParams();
  ~CloudPreprocessorParams();
 
public:
  double distance_near_thresh;        
  double distance_far_thresh;         
  bool global_shutter;                
  bool use_random_grid_downsampling;  
  double downsample_resolution;       
  int downsample_target;              
  double downsample_rate;             
  bool enable_outlier_removal;        
  int outlier_removal_k;              
  double outlier_std_mul_factor;      
  bool enable_cropbox_filter;         
  std::string crop_bbox_frame;        
  Eigen::Vector3d crop_bbox_min;      
  Eigen::Vector3d crop_bbox_max;      
  Eigen::Isometry3d T_imu_lidar;      
  int k_correspondences;              
 
  int num_threads;                    
};
 
class CloudPreprocessor {
public:
  using Points = std::vector<Eigen::Vector4d>;
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
  CloudPreprocessor(const CloudPreprocessorParams& params = CloudPreprocessorParams());
  virtual ~CloudPreprocessor();
 
  virtual PreprocessedFrame::Ptr preprocess(const RawPoints::ConstPtr& raw_points);
 
private:
  PreprocessedFrame::Ptr preprocess_impl(const RawPoints::ConstPtr& raw_points);
  std::vector<int> find_neighbors(const Eigen::Vector4d* points, const int num_points, const int k) const;
 
private:
  using Params = CloudPreprocessorParams;
  Params params;
 
  mutable std::mt19937 mt;
 
  std::shared_ptr<void> tbb_task_arena;
};
 
}  // namespace glim