apollo::perception::lidar::CPDetection类 参考

#include <cpdet.h>

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

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

Public 成员函数
	CPDetection ()
virtual	~CPDetection ()=default
bool	Init (const CPDetectorInitOptions &options=CPDetectorInitOptions()) override
	Init the Base Lidar Detector object
bool	Detect (const CPDetectorOptions &options, LidarFrame *frame) override
	Detect foreground objects
std::string	Name () const
	Name of Base Lidar Detector class
void	GeneratePfnFeature ()
void	GenerateBackboneFeature (const base::Blob< float > *pillar_feature_blob)
void	GetObjectsAndAssignPoints ()
Public 成员函数 继承自 apollo::perception::lidar::BaseCPDetector
	BaseCPDetector ()=default
	Construct a new Base Lidar Detector object
virtual	~BaseCPDetector ()=default
	Destroy the Base Lidar Detector object

详细描述

在文件 cpdet.h 第 72 行定义.

构造及析构函数说明

CPDetection()

apollo::perception::lidar::CPDetection::CPDetection

(

)

在文件 cpdet.cc 第 52 行定义.

    : x_min_range_(MIN_X_RANGE), x_max_range_(MAX_X_RANGE),
      y_min_range_(MIN_Y_RANGE), y_max_range_(MAX_Y_RANGE) {}

~CPDetection()

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

virtualdefault

成员函数说明

Detect()

bool apollo::perception::lidar::CPDetection::Detect ( const CPDetectorOptions &  options, LidarFrame *  frame  )

overridevirtual

Detect foreground objects

参数

options	lidar detector options
frame	lidar frame

返回

true

false

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

在文件 cpdet.cc 第 1551 行定义.

                       {
    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;
    }
    frame->segmented_objects.clear();
    original_cloud_ = frame->cloud;
    original_world_cloud_ = frame->world_cloud;
    lidar_frame_ref_ = frame;
    cur_cloud_ptr_ = std::shared_ptr<base::PointFCloud>(
        new base::PointFCloud(*original_cloud_));
 
    // BASE_GPU_CHECK(cudaStreamCreate(&stream_));
    if (cudaSetDevice(cpdet_config_.model_param().preprocess().gpu_id()) != cudaSuccess) {
        AERROR << "Failed to set device to "
               << cpdet_config_.model_param().preprocess().gpu_id();
        return false;
    }
 
    Timer timer;
    PointCloudPreprocess();
    AINFO << "Downsample PointCloud from " << original_cloud_->size() << " to " << cur_cloud_ptr_->size();
    double pointcloud_pre_time = timer.toc(true);
 
    model_cloud_size_ = static_cast<int>(cur_cloud_ptr_->size());
    total_cloud_size_ = static_cast<int>(original_cloud_->size());
    GeneratePfnFeature();
    double pfn_feature_generate_time = timer.toc(true);
 
    // pfn_output
    pfn_inference_->Infer();
    // cudaStreamSynchronize(stream_);
    double pfn_inference_time = timer.toc(true);
 
    // generate backbone feature
    GenerateBackboneFeature(pfn_pillar_feature_blob_.get());
    double backbone_feature_generate_time = timer.toc(true);
 
    // backbone output
    backbone_inference_->Infer();
    // cudaStreamSynchronize(stream_);
    double backbone_inference_time = timer.toc(true);
 
    GetObjectsAndAssignPoints();
    double get_objects_and_assign_time = timer.toc(true);
 
    GenerateObjects(frame);
    std::stringstream sstr;
    sstr << "[CPDetection 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();
    // filter
    if (num_tasks_ > 1 && inter_class_nms_) {
        FilterObjectsbyClassNMS(&frame->segmented_objects);
    }
    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();
 
    // filter semantic if it's not unknown
    SetPointsInROI(&frame->segmented_objects);
    if (filter_by_semantic_type_) {
        FilterObjectsbySemanticType(&frame->segmented_objects);
    }
    RemoveForePoints(&frame->segmented_objects);
 
    res_outputs_.clear();
    double post_process_time = timer.toc(true);
 
    double total_time = pointcloud_pre_time + pfn_feature_generate_time +
        pfn_inference_time + backbone_feature_generate_time +
        backbone_inference_time + get_objects_and_assign_time + post_process_time;
    AINFO << "[CpDetTime] " << std::to_string(frame->timestamp)
          << ", pointcloud preprocess: " << pointcloud_pre_time
          << ", pfn feature generate: " << pfn_feature_generate_time
          << ", pfn inference: " << pfn_inference_time
          << ", backbone feature generate: " << backbone_feature_generate_time
          << ", backbone inference: " << backbone_inference_time
          << ", getObjects and assignPoints: " << get_objects_and_assign_time
          << ", postProcess: " << post_process_time
          << ", Total: " << total_time;
    return true;
}

GenerateBackboneFeature()

void apollo::perception::lidar::CPDetection::GenerateBackboneFeature ( const base::Blob< float > *  pillar_feature_blob )

inline

在文件 cpdet.h 第 93 行定义.

                                                        {
            if (use_gpu_generate_feature_) {
                GenerateBackboneFeatureGPU(pillar_feature_blob);
            } else {
                GenerateBackboneFeatureCPU(pillar_feature_blob);
            }
        }

GeneratePfnFeature()

void apollo::perception::lidar::CPDetection::GeneratePfnFeature ( )

inline

在文件 cpdet.h 第 85 行定义.

                                  {
            if (use_gpu_generate_feature_) {
                GeneratePfnFeatureGPU();
            } else {
                GeneratePfnFeatureCPU();
            }
        }

GetObjectsAndAssignPoints()

void apollo::perception::lidar::CPDetection::GetObjectsAndAssignPoints ( )

inline

在文件 cpdet.h 第 102 行定义.

                                         {
            // all-gpu
            if (!use_cpu_get_objects_ && !use_cpu_assign_points_) {
                GetObjectsAndAssignPointsGPU();
                return;
            }
            if (use_cpu_get_objects_) {
                GetObjectsCPU();
            } else {
                GetObjectsGPU();
            }
            if (use_cpu_assign_points_) {
                AssignPointsCPU();
            } else {
                AERROR << "Error: Not Support AssignPoints is False when GetObjects is not False";
                return;
            }
        }

Init()

bool apollo::perception::lidar::CPDetection::Init ( const CPDetectorInitOptions &  options = CPDetectorInitOptions() )

overridevirtual

Init the Base Lidar Detector object

参数

options

lidar detector init options

返回

true

false

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

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

                                                           {
    std::string conf_file =
        GetConfigFile(options.config_path, options.config_file);
    ACHECK(apollo::cyber::common::GetProtoFromFile(conf_file, &cpdet_config_));
 
    LoadParams(cpdet_config_);
 
    if (!InitModel(cpdet_config_.model_param())) {
        AERROR << "Init CPDetection Model Failed";
        return false;
    }
 
    // create cuda stream
    cudaStreamCreate(&stream_);
    pfn_inference_->SetStream(stream_);
    backbone_inference_->SetStream(stream_);
    
    // set private feature blob
    point2grid_blob_.reset(new base::Blob<int>(std::vector<int>{max_voxel_num_}));
    grid2pointnum_blob_.reset(new base::Blob<int>(std::vector<int>{map_size_}));
    
    if (use_gpu_generate_feature_) {
        voxels_blob_->mutable_gpu_data();
        canvas_feature_blob_->mutable_gpu_data();
        point2grid_blob_->mutable_gpu_data();
        grid2pointnum_blob_->mutable_gpu_data();
    } else {
        voxels_blob_->mutable_cpu_data();
        canvas_feature_blob_->mutable_cpu_data();
        point2grid_blob_->mutable_cpu_data();
        grid2pointnum_blob_->mutable_cpu_data();
    }
 
    int channel_index = pillar_feature_dim_;
    feature_offset_["canvas_feature"] = canvas_feature_blob_->offset(0, 0);
    if (use_cnnseg_features_) {
        feature_offset_["max_height"] = canvas_feature_blob_->offset(0, channel_index++);
        feature_offset_["mean_height"] = canvas_feature_blob_->offset(0, channel_index++);
        feature_offset_["top_intensity"] = canvas_feature_blob_->offset(0, channel_index++);
        feature_offset_["mean_intensity"] = canvas_feature_blob_->offset(0, channel_index++);
        feature_offset_["count"] = canvas_feature_blob_->offset(0, channel_index++);
        feature_offset_["nonempty"] = canvas_feature_blob_->offset(0, channel_index++);
        feature_offset_["height_bin"] = canvas_feature_blob_->offset(0, channel_index);
    }
 
    max_candidate_num_ = num_tasks_ * nms_pre_max_size_;
    all_res_box_blob_.reset(new base::Blob<float>(std::vector<int>{max_candidate_num_, kBoxBlockSize}));
    all_res_conf_blob_.reset(new base::Blob<float>(std::vector<int>{max_candidate_num_}));
    all_res_cls_blob_.reset(new base::Blob<int>(std::vector<int>{max_candidate_num_}));
    
    res_box_num_blob_.reset(new base::Blob<int>(std::vector<int>{1}));
    res_box_blob_.reset(new base::Blob<float>(std::vector<int>{nms_pre_max_size_, kBoxBlockSize}));
    res_conf_blob_.reset(new base::Blob<float>(std::vector<int>{nms_pre_max_size_}));
    res_cls_blob_.reset(new base::Blob<int>(std::vector<int>{nms_pre_max_size_}));
    
    score_class_map_blob_.reset(new base::Blob<float>(std::vector<int>{num_classes_}));
 
    res_sorted_indices_blob_.reset(new base::Blob<int>(std::vector<int>{nms_pre_max_size_}));
    box_for_nms_blob_.reset(new base::Blob<float>(std::vector<int>{max_candidate_num_, 4}));
    box_corner_blob_.reset(new base::Blob<float>(std::vector<int>{max_candidate_num_, 8}));
    remain_conf_blob_.reset(new base::Blob<float>(std::vector<int>{nms_pre_max_size_}));
    rotate_overlapped_blob_.reset(new base::Blob<bool>(std::vector<int>{nms_pre_max_size_, nms_pre_max_size_}));
    kept_indices_blob_.reset(new base::Blob<int>(std::vector<int>{num_tasks_ * nms_post_max_size_}));
 
    box_corners_blob_.reset(new base::Blob<float>(std::vector<int>{max_candidate_num_, 8}));
    box_rects_blob_.reset(new base::Blob<float>(std::vector<int>{max_candidate_num_, 4}));
    valid_point_num_blob_.reset(new base::Blob<int>(std::vector<int>{1}));
    valid_point_indices_blob_.reset(new base::Blob<int>(std::vector<int>{max_valid_point_size_}));
    valid_point2boxid_blob_.reset(new base::Blob<int>(std::vector<int>{max_valid_point_size_}));
 
    res_box_num_blob_->mutable_gpu_data();
    res_box_blob_->mutable_gpu_data();
    res_conf_blob_->mutable_gpu_data();
    res_cls_blob_->mutable_gpu_data();
    all_res_box_blob_->mutable_gpu_data();
    all_res_conf_blob_->mutable_gpu_data();
    all_res_cls_blob_->mutable_gpu_data();
    score_class_map_blob_->mutable_gpu_data();
    remain_conf_blob_->mutable_gpu_data();
    rotate_overlapped_blob_->mutable_gpu_data();
    kept_indices_blob_->mutable_gpu_data();
    box_corners_blob_->mutable_gpu_data();
    box_rects_blob_->mutable_gpu_data();
    valid_point_num_blob_->mutable_gpu_data();
    valid_point_indices_blob_->mutable_gpu_data();
    valid_point2boxid_blob_->mutable_gpu_data();
 
    res_box_num_blob_->mutable_cpu_data();
    all_res_box_blob_->mutable_cpu_data();
    all_res_conf_blob_->mutable_cpu_data();
    all_res_cls_blob_->mutable_cpu_data();
    rotate_overlapped_blob_->mutable_cpu_data();
    box_corners_blob_->mutable_cpu_data();
    box_rects_blob_->mutable_cpu_data();
    valid_point_num_blob_->mutable_cpu_data();
    valid_point_indices_blob_->mutable_cpu_data();
    valid_point2boxid_blob_->mutable_cpu_data();
 
    if (cpdet_config_.has_plugins()) {
        const auto &plugin = cpdet_config_.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::CPDetection::Name ( ) const

inlinevirtual

Name of Base Lidar Detector class

返回

std::string

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

在文件 cpdet.h 第 83 行定义.

{ return "CPDetection"; }

---

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

• modules/perception/lidar_cpdet_detection/detector/cpdet/cpdet.h
• modules/perception/lidar_cpdet_detection/detector/cpdet/cpdet.cc