apollo::perception::lidar::CenterPointDetection类 参考

#include <center_point_detection.h>

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

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

Public 成员函数
	CenterPointDetection ()
	Construct a new Center Point Detection object
virtual	~CenterPointDetection ()=default
	Destroy the Center Point Detection object
bool	Init (const LidarDetectorInitOptions &options=LidarDetectorInitOptions()) override
	Init of Center Point Detection module
bool	Detect (const LidarDetectorOptions &options, LidarFrame *frame) override
	Detect foreground object using centerpoint
std::string	Name () const
	Name of Center Point 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

详细描述

在文件 center_point_detection.h 第 41 行定义.

构造及析构函数说明

CenterPointDetection()

apollo::perception::lidar::CenterPointDetection::CenterPointDetection

(

)

Construct a new Center Point Detection object

在文件 center_point_detection.cc 第 56 行定义.

    : x_min_range_(Params::kMinXRange),
      x_max_range_(Params::kMaxXRange),
      y_min_range_(Params::kMinYRange),
      y_max_range_(Params::kMaxYRange),
      z_min_range_(Params::kMinZRange),
      z_max_range_(Params::kMaxZRange) {}

~CenterPointDetection()

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

virtualdefault

Destroy the Center Point Detection object

成员函数说明

Detect()

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

overridevirtual

Detect foreground object using centerpoint

参数

options	lidar dectection options
frame	lidar frame

返回

true

false

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

在文件 center_point_detection.cc 第 180 行定义.

                                                     {
  // 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(model_param_.preprocess().gpu_id()) != cudaSuccess) {
    AERROR << "Failed to set device to gpu "
           << model_param_.preprocess().gpu_id();
    return false;
  }
 
  Timer timer;
 
  int num_points;
  cur_cloud_ptr_ = std::shared_ptr<base::PointFCloud>(
      new base::PointFCloud(*original_cloud_));
 
  if (model_param_.preprocess().enable_roi_outside_removal()) {
    cur_cloud_ptr_->CopyPointCloud(*original_cloud_, frame->roi_indices);
  }
 
  // down sample the point cloud through filtering beams
  if (model_param_.preprocess().enable_downsample_beams()) {
    base::PointFCloudPtr downsample_beams_cloud_ptr(new base::PointFCloud());
    if (DownSamplePointCloudBeams(
            cur_cloud_ptr_, downsample_beams_cloud_ptr,
            model_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: "
            << model_param_.preprocess().downsample_beams_factor();
    }
  }
 
  // down sample the point cloud through filtering voxel grid
  if (model_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 (model_param_.preprocess().enable_fuse_frames() &&
      model_param_.preprocess().num_fuse_frames() > 1) {
    // before fusing
    while (!prev_world_clouds_.empty() &&
           frame->timestamp - prev_world_clouds_.front()->get_timestamp() >
               model_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()) >=
           model_param_.preprocess().num_fuse_frames() - 1) {
      prev_world_clouds_.pop_front();
    }
    prev_world_clouds_.emplace_back(cur_world_cloud_ptr);
  }
  fuse_time_ = timer.toc(true);
 
  // shuffle points and cut off
  if (model_param_.preprocess().enable_shuffle_points()) {
    num_points =
        std::min(num_points, model_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);
 
  // points_array[x, y, z, i,timestampe, ......]
  std::vector<float> points_data(num_points *
                                 model_param_.preprocess().num_point_feature());
 
  CloudToArray(cur_cloud_ptr_, points_data.data(),
               model_param_.preprocess().normalizing_factor());
  cloud_to_array_time_ = timer.toc(true);
 
  auto input_data_blob = inference_->get_blob(input_blob_names_.at(0));
  auto output_bbox_blob = inference_->get_blob(output_blob_names_.at(0));
  auto output_score_blob = inference_->get_blob(output_blob_names_.at(1));
  auto output_label_blob = inference_->get_blob(output_blob_names_.at(2));
 
  std::vector<int> points_shape{num_points,
                                model_param_.preprocess().num_point_feature()};
  input_data_blob->Reshape(points_shape);
  float *data_ptr = input_data_blob->mutable_cpu_data();
  memcpy(data_ptr, points_data.data(), points_data.size() * sizeof(float));
 
  inference_->Infer();
 
  inference_time_ = timer.toc(true);
 
  // paddle inference
  std::vector<float> out_detections;
  std::vector<int64_t> out_labels;
  std::vector<float> out_scores;
 
  // FilterScore(output_bbox_blob, output_label_blob, output_score_blob,
  //           model_param_.postprocess().score_threshold(), &out_detections,
  //           &out_labels, &out_scores);
 
  FilterDiffScore(output_bbox_blob, output_label_blob, output_score_blob,
              &out_detections, &out_labels, &out_scores);
 
  GetObjects(frame->lidar2world_pose, out_detections,
             out_labels, out_scores, &frame->segmented_objects);
 
  std::stringstream sstr;
  sstr << "[CenterPointDetection BeforeNMS] "
       << std::to_string(frame->timestamp)
       << " objs: " << frame->segmented_objects.size() << std::endl;
  for (auto obj : frame->segmented_objects) {
      sstr << "id = " << obj->id << ": " << obj->center(0) << ", "
           << obj->center(1) << ", " << obj->center(2) << ", "
           << obj->size(0) << ", " << obj->size(1) << ", "
           << obj->size(2) << ", " << obj->theta << ", "
           << static_cast<int>(obj->type) << ", "
           << obj->confidence << std::endl;
  }
  ADEBUG << sstr.str();
 
  if (model_param_.filter_by_points()) {
    FilterObjectsbyPoints(&frame->segmented_objects);
  }
 
  PERF_BLOCK("class_nms")
  if (diff_class_nms_) {
    FilterObjectsbyClassNMS(&frame->segmented_objects);
  }
  PERF_BLOCK_END
  nms_time_ = timer.toc(true);
 
  // filter semantic if it's not unknown
  if (model_param_.filter_by_semantic_type()) {
    FilterObjectsbySemanticType(&frame->segmented_objects);
  }
 
  FilterForegroundPoints(&frame->segmented_objects);
 
  SetPointsInROI(&frame->segmented_objects);
 
  postprocess_time_ = timer.toc(true);
 
  AINFO << "CenterPoint: "
        << "\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"
        << "postprocess: " << postprocess_time_ << "\t"
        << "nms: " << nms_time_ << "\t";
 
  std::stringstream ssstr;
  ssstr << "[CenterPointDetection AfterNMS] "
        << std::to_string(frame->timestamp)
        << " objs: " << frame->segmented_objects.size() << std::endl;
  for (auto obj : frame->segmented_objects) {
      ssstr << "id = " << obj->id << ": " << obj->center(0) << ", "
            << obj->center(1) << ", " << obj->center(2) << ", "
            << obj->size(0) << ", " << obj->size(1) << ", "
            << obj->size(2) << ", " << obj->theta << ", "
            << static_cast<int>(obj->type) << std::endl;
  }
  ADEBUG << ssstr.str();
 
  return true;
}

Init()

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

overridevirtual

Init of Center Point Detection module

参数

options

lidar detection init options

返回

true

false

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

在文件 center_point_detection.cc 第 64 行定义.

                                                                       {
  std::string config_file =
      GetConfigFile(options.config_path, options.config_file);
  ACHECK(apollo::cyber::common::GetProtoFromFile(config_file, &model_param_));
 
  const auto &model_info = model_param_.info();
  std::string model_path = GetModelPath(model_info.name());
  // Network files
  std::string proto_file =
      GetModelFile(model_path, model_info.proto_file().file());
  std::string weight_file =
      GetModelFile(model_path, model_info.weight_file().file());
  // Network input and output names
  input_blob_names_ = inference::GetBlobNames(model_info.inputs());
  output_blob_names_ = inference::GetBlobNames(model_info.outputs());
 
  inference_.reset(inference::CreateInferenceByName(
      model_info.framework(), proto_file, weight_file, output_blob_names_,
      input_blob_names_));
 
  std::map<std::string, std::vector<int>> shape_map;
  inference::AddShape(&shape_map, model_info.inputs());
  inference::AddShape(&shape_map, model_info.outputs());
 
  if (!inference_->Init(shape_map)) {
    return false;
  }
 
  if (model_param_.preprocess().enable_ground_removal()) {
    z_min_range_ = std::max(
        z_min_range_,
        static_cast<float>(model_param_.preprocess().ground_removal_height()));
  }
  nms_strategy_ = model_param_.nms_strategy();
  diff_class_iou_ = model_param_.diff_class_iou();
  diff_class_nms_ = model_param_.diff_class_nms();
 
  cone_score_threshold_ = model_param_.postprocess().cone_score_threshold();
  ped_score_threshold_ = model_param_.postprocess().ped_score_threshold();
  cyc_score_threshold_ = model_param_.postprocess().cyc_score_threshold();
  small_mot_score_threshold_ =
      model_param_.postprocess().small_mot_score_threshold();
  big_mot_score_threshold_ =
      model_param_.postprocess().big_mot_score_threshold();
 
  if (model_param_.has_plugins()) {
    const auto &plugin = model_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;
    }
  }
  // if (diff_class_nms_) {
  //   nms_strategy_table_ = {
  //     {base::ObjectType::BICYCLE, {base::ObjectType::PEDESTRIAN,
  //      base::ObjectType::UNKNOWN}},
  //     {base::ObjectType::PEDESTRIAN, {base::ObjectType::UNKNOWN}},
  //     {base::ObjectType::VEHICLE, {base::ObjectType::BICYCLE,
  //      base::ObjectType::PEDESTRIAN, base::ObjectType::UNKNOWN}}
  //   };
  // }
  return true;
}

Name()

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

inlinevirtual

Name of Center Point Detection module

返回

std::string

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

在文件 center_point_detection.h 第 80 行定义.

{ return "CenterPointDetection"; }

---

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

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