apollo::perception::lidar::MaskPillarsDetection类 参考

#include <mask_pillars_detection.h>

类 apollo::perception::lidar::MaskPillarsDetection 继承关系图:

apollo::perception::lidar::MaskPillarsDetection 的协作图:

Public 成员函数
	MaskPillarsDetection ()
	Construct a new Mask Pillars Detection object
virtual	~MaskPillarsDetection ()=default
	Destroy the Mask Pillars Detection object
bool	Init (const LidarDetectorInitOptions &options=LidarDetectorInitOptions()) override
	Init of Mask Pillars Detection object
bool	Detect (const LidarDetectorOptions &options, LidarFrame *frame) override
	Detect foregorund objects using maskpillars
std::string	Name () const override
	Name of Mask Pillars Detection module
Public 成员函数 继承自 apollo::perception::lidar::BaseLidarDetector
	BaseLidarDetector ()=default
	Construct a new Base Lidar Detector object
virtual	~BaseLidarDetector ()=default
	Destroy the Base Lidar Detector object

详细描述

在文件 mask_pillars_detection.h 第 38 行定义.

构造及析构函数说明

MaskPillarsDetection()

apollo::perception::lidar::MaskPillarsDetection::MaskPillarsDetection

(

)

Construct a new Mask Pillars Detection object

在文件 mask_pillars_detection.cc 第 40 行定义.

    : x_min_(Params::kMinXRange),
      x_max_(Params::kMaxXRange),
      y_min_(Params::kMinYRange),
      y_max_(Params::kMaxYRange),
      z_min_(Params::kMinZRange),
      z_max_(Params::kMaxZRange) {}

~MaskPillarsDetection()

virtual apollo::perception::lidar::MaskPillarsDetection::~MaskPillarsDetection ( )

virtualdefault

Destroy the Mask Pillars Detection object

成员函数说明

Detect()

bool apollo::perception::lidar::MaskPillarsDetection::Detect ( const LidarDetectorOptions &  options, LidarFrame *  frame  )

overridevirtual

Detect foregorund objects using maskpillars

参数

options	lidar detector options
frame	lidar frame

返回

true

false

实现了 apollo::perception::lidar::BaseLidarDetector.

在文件 mask_pillars_detection.cc 第 94 行定义.

                                                      {
  // check input
  if (frame == nullptr) {
    AERROR << "Input null frame ptr.";
    return false;
  }
  if (frame->cloud == nullptr) {
    AERROR << "Input null frame cloud.";
    return false;
  }
  if (frame->cloud->size() == 0) {
    AERROR << "Input none points.";
    return false;
  }
 
  // record input cloud and lidar frame
  original_cloud_ = frame->cloud;
  original_world_cloud_ = frame->world_cloud;
  lidar_frame_ref_ = frame;
 
  // check output
  frame->segmented_objects.clear();
 
  if (cudaSetDevice(param_.preprocess().gpu_id()) != cudaSuccess) {
    AERROR << "Failed to set device to gpu " << param_.preprocess().gpu_id();
    return false;
  }
 
  Timer timer;
 
  int num_points;
  cur_cloud_ptr_ = std::shared_ptr<base::PointFCloud>(
      new base::PointFCloud(*original_cloud_));
 
  // down sample the point cloud through filtering beams
  if (param_.preprocess().enable_downsample_beams()) {
    base::PointFCloudPtr downsample_beams_cloud_ptr(new base::PointFCloud());
    if (DownSamplePointCloudBeams(
          original_cloud_, downsample_beams_cloud_ptr,
          param_.preprocess().downsample_beams_factor())) {
      cur_cloud_ptr_ = downsample_beams_cloud_ptr;
    } else {
      AWARN << "Down-sample beams factor must be >= 1. Cancel down-sampling."
               " Current factor: "
            << param_.preprocess().downsample_beams_factor();
    }
  }
 
  // down sample the point cloud through filtering voxel grid
  if (param_.preprocess().enable_downsample_pointcloud()) {
    DownSampleOptions down_sample_options;
    ACHECK(down_sample_ != nullptr);
    down_sample_->Process(down_sample_options, cur_cloud_ptr_);
  }
  downsample_time_ = timer.toc(true);
 
  num_points = cur_cloud_ptr_->size();
  AINFO << "num points before fusing: " << num_points;
 
  // fuse clouds of preceding frames with current cloud
  cur_cloud_ptr_->mutable_points_timestamp()->assign(cur_cloud_ptr_->size(),
                                                     0.0);
  if (param_.preprocess().enable_fuse_frames() &&
      param_.preprocess().num_fuse_frames() > 1) {
    // before fusing
    while (!prev_world_clouds_.empty() &&
           frame->timestamp - prev_world_clouds_.front()->get_timestamp() >
               param_.preprocess().fuse_time_interval()) {
      prev_world_clouds_.pop_front();
    }
    // transform current cloud to world coordinate and save to a new ptr
    base::PointDCloudPtr cur_world_cloud_ptr =
        std::make_shared<base::PointDCloud>();
    for (size_t i = 0; i < cur_cloud_ptr_->size(); ++i) {
      auto& pt = cur_cloud_ptr_->at(i);
      Eigen::Vector3d trans_point(pt.x, pt.y, pt.z);
      trans_point = lidar_frame_ref_->lidar2world_pose * trans_point;
      PointD world_point;
      world_point.x = trans_point(0);
      world_point.y = trans_point(1);
      world_point.z = trans_point(2);
      world_point.intensity = pt.intensity;
      cur_world_cloud_ptr->push_back(world_point);
    }
    cur_world_cloud_ptr->set_timestamp(frame->timestamp);
 
    // fusing clouds
    for (auto& prev_world_cloud_ptr : prev_world_clouds_) {
      num_points += prev_world_cloud_ptr->size();
    }
    FuseCloud(cur_cloud_ptr_, prev_world_clouds_);
 
    // after fusing
    while (static_cast<int>(prev_world_clouds_.size()) >=
           param_.preprocess().num_fuse_frames() - 1) {
      prev_world_clouds_.pop_front();
    }
    prev_world_clouds_.emplace_back(cur_world_cloud_ptr);
  }
  AINFO << "num points after fusing: " << num_points;
  fuse_time_ = timer.toc(true);
 
  // shuffle points and cut off
  if (param_.preprocess().enable_shuffle_points()) {
    num_points = std::min(num_points, param_.preprocess().max_num_points());
    std::vector<int> point_indices = GenerateIndices(0, num_points, true);
    base::PointFCloudPtr shuffle_cloud_ptr(
        new base::PointFCloud(*cur_cloud_ptr_, point_indices));
    cur_cloud_ptr_ = shuffle_cloud_ptr;
  }
  shuffle_time_ = timer.toc(true);
 
  // point cloud to array
  float* points_array =
    new float[num_points * param_.preprocess().num_point_feature()]();
  CloudToArray(cur_cloud_ptr_, points_array,
               param_.preprocess().normalizing_factor());
  cloud_to_array_time_ = timer.toc(true);
 
  // inference
  std::vector<float> out_detections;
  std::vector<int> out_labels;
  point_pillars_ptr_->DoInference(points_array, num_points, &out_detections,
                                  &out_labels);
  inference_time_ = timer.toc(true);
 
  // transfer output bounding boxes to objects
  GetObjects(&frame->segmented_objects, frame->lidar2world_pose,
             &out_detections, &out_labels);
  collect_time_ = timer.toc(true);
 
  AINFO << "PointPillars: "
        << "\n"
        << "down sample: " << downsample_time_ << "\t"
        << "fuse: " << fuse_time_ << "\t"
        << "shuffle: " << shuffle_time_ << "\t"
        << "cloud_to_array: " << cloud_to_array_time_ << "\t"
        << "inference: " << inference_time_ << "\t"
        << "collect: " << collect_time_;
 
  delete[] points_array;
  return true;
}

Init()

bool apollo::perception::lidar::MaskPillarsDetection::Init ( const LidarDetectorInitOptions &  options = LidarDetectorInitOptions() )

overridevirtual

Init of Mask Pillars Detection object

参数

options

lidar detection init options

返回

true

false

实现了 apollo::perception::lidar::BaseLidarDetector.

在文件 mask_pillars_detection.cc 第 50 行定义.

                                                                       {
  std::string config_file =
      GetConfigFile(options.config_path, options.config_file);
  ACHECK(apollo::cyber::common::GetProtoFromFile(config_file, &param_));
 
  const auto &model_info = param_.info();
  std::string model_path = GetModelPath(model_info.name());
  std::string weight_file =
      GetModelFile(model_path, model_info.weight_file().file());
 
  point_pillars_ptr_.reset(
      new PointPillars(param_.preprocess().reproduce_result_mode(),
                       param_.postprocess().score_threshold(),
                       param_.postprocess().nms_overlap_threshold(),
                       model_info.framework(),
                       weight_file));
  if (param_.preprocess().enable_ground_removal()) {
    z_min_ = std::max(z_min_,
                      static_cast<float>(
                        param_.preprocess().ground_removal_height()));
  }
 
  if (param_.has_plugins()) {
    const auto &plugin = param_.plugins();
    const auto &name = plugin.name();
    down_sample_ = apollo::cyber::plugin_manager::PluginManager::Instance()
                       ->CreateInstance<BaseDownSample>(
                           ConfigUtil::GetFullClassName(name));
    if (!down_sample_) {
      AINFO << "Failed to find down_sample plugin: " << name << ", skipped";
      return false;
    }
    DownSampleInitOptions option;
    option.config_path = plugin.config_path();
    option.config_file = plugin.config_file();
    if (!down_sample_->Init(option)) {
      AINFO << "Failed to init down_sample plugin: " << name << ", skipped";
      return false;
    }
  }
 
  return true;
}

Name()

std::string apollo::perception::lidar::MaskPillarsDetection::Name ( ) const

inlineoverridevirtual

Name of Mask Pillars Detection module

返回

std::string

实现了 apollo::perception::lidar::BaseLidarDetector.

在文件 mask_pillars_detection.h 第 77 行定义.

{ return "MaskPillarsDetection"; }

---

该类的文档由以下文件生成:

• modules/perception/lidar_detection/detector/mask_pillars_detection/mask_pillars_detection.h
• modules/perception/lidar_detection/detector/mask_pillars_detection/mask_pillars_detection.cc