apollo::perception::lidar::CNNSegmentation类 参考

#include <cnn_segmentation.h>

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

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

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

详细描述

在文件 cnn_segmentation.h 第 37 行定义.

构造及析构函数说明

CNNSegmentation()

apollo::perception::lidar::CNNSegmentation::CNNSegmentation ( )

default

Construct a new CNNSegmentation object

~CNNSegmentation()

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

virtualdefault

Destroy the CNNSegmentation object

成员函数说明

Detect()

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

overridevirtual

Detect foreground objects using CNNSegmentation

参数

options	lidar detection options
frame	lidar frame

返回

true

false

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

在文件 cnn_segmentation.cc 第 184 行定义.

                                                {
  // 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->world_cloud == nullptr) {
    AERROR << "Input null frame world cloud.";
    return false;
  }
  if (frame->cloud->size() == 0) {
    AERROR << "Input none points.";
    return false;
  }
  if (frame->cloud->size() != frame->world_cloud->size()) {
    AERROR << "Cloud size and world cloud size not consistent.";
    return false;
  }
  // record input cloud and lidar frame
  original_cloud_ = frame->cloud;
  original_world_cloud_ = frame->world_cloud;
  lidar_frame_ref_ = frame;
 
  // roi cloud
  roi_cloud_->CopyPointCloud(*lidar_frame_ref_->cloud,
                             lidar_frame_ref_->roi_indices);
  roi_world_cloud_->CopyPointCloud(*lidar_frame_ref_->world_cloud,
                                   lidar_frame_ref_->roi_indices);
 
  // check output
  frame->segmented_objects.clear();
 
  // note we should use origninal cloud here, frame->cloud may be exchanged
  Timer timer;
  // map 3d points to 2d image grids
  MapPointToGrid(original_cloud_);
  mapping_time_ = timer.toc(true);
 
  if (cudaSetDevice(gpu_id_) != cudaSuccess) {
    AERROR << "Failed to set device to " << gpu_id_;
    return false;
  }
 
  // generate features
  feature_generator_->Generate(original_cloud_, point2grid_);
  feature_time_ = timer.toc(true);
 
  // model inference
  inference_->Infer();
  infer_time_ = timer.toc(true);
 
  // processing clustering
  GetObjectsFromSppEngine(&frame->segmented_objects);
 
  AINFO << "CNNSEG: mapping: " << mapping_time_ << "\t"
        << " feature: " << feature_time_ << "\t"
        << " infer: " << infer_time_ << "\t"
        << " fg-seg: " << fg_seg_time_ << "\t"
        << " collect: " << collect_time_;
  return true;
}

Init()

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

overridevirtual

Init of CNNSegmentation object

参数

options

lidar detection init options

返回

true

false

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

在文件 cnn_segmentation.cc 第 41 行定义.

                                                                  {
  sensor_name_ = options.sensor_name;
  std::string config_file =
      GetConfigFile(options.config_path, options.config_file);
  ACHECK(apollo::cyber::common::GetProtoFromFile(config_file, &model_param_));
 
  // init feature parameters
  const cnnseg::FeatureParam& feature_param = model_param_.feature_param();
  range_ = feature_param.point_cloud_range();
  width_ = feature_param.width();
  height_ = feature_param.height();
  min_height_ = feature_param.min_height();
  max_height_ = feature_param.max_height();
 
  const auto& model_info = model_param_.info();
  std::string model_path = GetModelPath(model_info.name());
  std::string proto_file =
      GetModelFile(model_path, model_info.proto_file().file());
  std::string weight_file =
      GetModelFile(model_path, model_info.weight_file().file());
 
  // init inference model
  std::vector<std::string> input_names =
      inference::GetBlobNames(model_info.inputs());
  std::vector<std::string> output_names =
      inference::GetBlobNames(model_info.outputs());
 
  inference_.reset(inference::CreateInferenceByName(
      model_param_.info().framework(), proto_file, weight_file, output_names,
      input_names));
  CHECK_NOTNULL(inference_.get());
 
  gpu_id_ = model_param_.preprocess().has_gpu_id()
                ? model_param_.preprocess().gpu_id()
                : -1;
  BASE_GPU_CHECK(cudaSetDevice(gpu_id_));
  inference_->set_gpu_id(gpu_id_);  // inference sets CPU mode when -1
 
  std::map<std::string, std::vector<int>> input_shapes;
  inference::AddShape(&input_shapes, model_info.inputs());
  auto& input_shape = input_shapes[input_names.at(0)];
  if (!feature_param.use_intensity_feature()) {
    input_shape[1] -= 2;
  }
  if (!feature_param.use_constant_feature()) {
    input_shape[1] -= 2;
  }
  ACHECK(inference_->Init(input_shapes)) << "Failed to init inference.";
 
  // init blobs
  instance_pt_blob_ = inference_->get_blob(output_names.at(0));
  CHECK_NOTNULL(instance_pt_blob_.get());
  category_pt_blob_ = inference_->get_blob(output_names.at(1));
  CHECK_NOTNULL(category_pt_blob_.get());
  confidence_pt_blob_ = inference_->get_blob(output_names.at(2));
  CHECK_NOTNULL(confidence_pt_blob_.get());
  height_pt_blob_ = inference_->get_blob(output_names.at(3));
  CHECK_NOTNULL(height_pt_blob_.get());
  feature_blob_ = inference_->get_blob(input_names.at(0));
  CHECK_NOTNULL(feature_blob_.get());
  if (model_param_.do_classification()) {
    classify_pt_blob_ = inference_->get_blob(output_names.at(5));
    CHECK_NOTNULL(classify_pt_blob_.get());
  }
  if (model_param_.do_heading()) {
    heading_pt_blob_ = inference_->get_blob(output_names.at(4));
    CHECK_NOTNULL(heading_pt_blob_.get());
  }
 
  // init feature generator
  feature_generator_.reset(new FeatureGenerator);
  ACHECK(feature_generator_->Init(feature_param, feature_blob_.get()))
      << "Failed to init feature generator.";
 
  point2grid_.reserve(kDefaultPointCloudSize);
 
  // init cluster and background segmentation methods
  ACHECK(InitClusterAndBackgroundSegmentation());
 
  return true;
}

Name()

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

inlineoverridevirtual

Name of CNNSegmentation module

返回

std::string

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

在文件 cnn_segmentation.h 第 76 行定义.

{ return "CNNSegmentation"; }

---

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

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