apollo::perception::lidar::NCutSegmentation类 参考

#include <ncut_segmentation.h>

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

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

Public 成员函数
	NCutSegmentation ()=default
virtual	~NCutSegmentation ()
bool	Init (const LidarDetectorInitOptions &options=LidarDetectorInitOptions()) override
	Init ncut segmentation
bool	Detect (const LidarDetectorOptions &options, LidarFrame *frame) override
	Detection function of ncut
std::string	Name () const override
	Get class name
void	ByPassROIService ()
	Reset roi and ground flag false
Public 成员函数 继承自 apollo::perception::lidar::BaseLidarDetector
	BaseLidarDetector ()=default
	Construct a new Base Lidar Detector object
virtual	~BaseLidarDetector ()=default
	Destroy the Base Lidar Detector object

详细描述

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

构造及析构函数说明

NCutSegmentation()

apollo::perception::lidar::NCutSegmentation::NCutSegmentation ( )

default

~NCutSegmentation()

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

inlinevirtual

在文件 ncut_segmentation.h 第 40 行定义.

{};

成员函数说明

ByPassROIService()

void apollo::perception::lidar::NCutSegmentation::ByPassROIService ( )

inline

Reset roi and ground flag false

在文件 ncut_segmentation.h 第 70 行定义.

                            {
        remove_roi_ = false;
        remove_ground_ = false;
    }

Detect()

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

overridevirtual

Detection function of ncut

参数

options
frame	location to save segment objects

返回

true

false

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

在文件 ncut_segmentation.cc 第 101 行定义.

                                                                                    {
    // 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;
 
    std::vector<base::ObjectPtr>* segments = &(frame->segmented_objects);
    double start_t = omp_get_wtime();
 
    AINFO << "input point cloud: " << original_cloud_->size() << " points";
#ifdef DEBUG_NCUT
    VisualizePointCloud(original_cloud_);
#endif
 
    base::PointFCloudPtr cloud_above_ground(new base::PointFCloud);
    if (remove_ground_) {
        AINFO << "remove ground";
        CloudMask mask;
        mask.Set(original_cloud_->size(), 0);
        mask.AddIndicesOfIndices(lidar_frame_ref_->roi_indices, lidar_frame_ref_->non_ground_indices, 1);
        mask.GetValidIndices(&lidar_frame_ref_->secondary_indices);
    }
 
    // if used as secondary segmentor, got from cloud directly
    cloud_above_ground->CopyPointCloud(*lidar_frame_ref_->cloud, lidar_frame_ref_->secondary_indices);
 
#ifdef DEBUG_NCUT
    AINFO << "filter ground, elapsed time: " << omp_get_wtime() - start_t << cloud_above_ground->size()
          << " points left";
    start_t = omp_get_wtime();
    VisualizePointCloud(cloud_above_ground);
#endif
 
    // .3 filter vehicle
    base::PointFCloudPtr cloud_after_car_filter = cloud_above_ground;
    if (filter_vehicle_) {
        ObstacleFilter(cloud_above_ground, vehicle_filter_cell_size_, false, &cloud_after_car_filter, segments);
    }
#ifdef DEBUG_NCUT
    AINFO << "filter vehicle, elapsed time: " << omp_get_wtime() - start_t
          << "filter vehicle: " << cloud_after_car_filter->size() << " points left";
    start_t = omp_get_wtime();
    VisualizePointCloud(cloud_after_car_filter);
#endif
 
    // .4 filter pedestrian
    base::PointFCloudPtr cloud_after_people_filter = cloud_after_car_filter;
    if (filter_pedestrian_) {
        ObstacleFilter(
                cloud_after_car_filter, pedestrian_filter_cell_size_, true, &cloud_after_people_filter, segments);
    }
 
#ifdef DEBUG_NCUT
    AINFO << "filter pedestrian, elapsed time: " << omp_get_wtime() - start_t;
    start_t = omp_get_wtime();
    AINFO << "filter pedestrian: " << cloud_after_people_filter->size() << " points left";
    VisualizePointCloud(cloud_after_people_filter);
    AINFO << "after filter car/pedestrian #segments " << segments->size();
// VisualizeSegments(*segments);
#endif
 
    // .5 partition into small regions
    std::vector<base::PointFCloudPtr> cloud_components;
    PartitionConnectedComponents(cloud_after_people_filter, partition_cell_size_, &cloud_components);
 
#ifdef DEBUG_NCUT
    AINFO << "partition small regions, elapsed time: " << omp_get_wtime() - start_t;
    start_t = omp_get_wtime();
    AINFO << "partition " << cloud_components.size() << " components";
#endif
 
    std::vector<bool> cloud_outlier_flag(cloud_components.size());
 
#pragma omp parallel
    {
#pragma omp for
        for (size_t i = 0; i < cloud_components.size(); ++i) {
            cloud_outlier_flag[i] = IsOutlier(cloud_components[i]);
        }
    }
 
    std::vector<int> cloud_outlier;
    std::vector<int> cloud_tbd;
    for (int i = 0; i < static_cast<int>(cloud_components.size()); ++i) {
        if (cloud_outlier_flag[i]) {
            cloud_outlier.push_back(i);
        } else {
            cloud_tbd.push_back(i);
        }
    }
 
    // .5.1 outlier
    for (size_t i = 0; i < cloud_outlier.size(); ++i) {
        base::PointFCloudPtr pc = cloud_components[cloud_outlier[i]];
        base::ObjectPtr obj(new base::Object);
        obj->lidar_supplement.cloud = *pc;
        _outliers->push_back(obj);
    }
#ifdef DEBUG_NCUT
    AINFO << "filter outlier, elapsed time: " << omp_get_wtime() - start_t;
    start_t = omp_get_wtime();
#endif
    // .6 graph cut each
    std::vector<std::vector<base::PointFCloudPtr>> threads_segment_pcs(num_threads_);
    std::vector<std::vector<std::string>> threads_segment_labels(num_threads_);
    std::vector<std::vector<base::PointFCloudPtr>> threads_outlier_pcs(num_threads_);
    // .6.1 process each component in parallel
    omp_set_num_threads(num_threads_);
#pragma omp parallel
    {
        int tid = omp_get_thread_num();
        std::shared_ptr<NCut> my_ncut = _segmentors[tid];
        std::vector<base::PointFCloudPtr>& my_segment_pcs = threads_segment_pcs[tid];
        std::vector<std::string>& my_segment_labels = threads_segment_labels[tid];
        std::vector<base::PointFCloudPtr>& my_outlier_pcs = threads_outlier_pcs[tid];
 
#pragma omp for schedule(guided)
        for (size_t i = 0; i < cloud_tbd.size(); ++i) {
            my_ncut->Segment(cloud_components[cloud_tbd[i]]);
            ADEBUG << "after segment with num segments" << my_ncut->NumSegments();
            for (int j = 0; j < my_ncut->NumSegments(); ++j) {
                base::PointFCloudPtr pc = my_ncut->GetSegmentPointCloud(j);
                std::string label = my_ncut->GetSegmentLabel(j);
                if (IsOutlier(pc)) {
                    my_outlier_pcs.push_back(pc);
                } else {
                    my_segment_pcs.push_back(pc);
                    my_segment_labels.push_back(label);
                }
            }
        }
    }
#ifdef DEBUG_NCUT
    ADEBUG << "parallel normalized cut, elapsed time: " << omp_get_wtime() - start_t;
    start_t = omp_get_wtime();
#endif
    // .6.2 aggregate results
    std::vector<int> segment_offset(num_threads_, static_cast<int>(segments->size()));
    for (int i = 1; i < num_threads_; ++i) {
        segment_offset[i] = segment_offset[i - 1] + static_cast<int>(threads_segment_pcs[i - 1].size());
    }
    int new_num_segments
            = static_cast<int>(threads_segment_pcs[num_threads_ - 1].size()) + segment_offset[num_threads_ - 1];
    segments->resize(new_num_segments);
#pragma omp parallel for
    for (int i = 0; i < num_threads_; ++i) {
        int offset = segment_offset[i];
        for (size_t j = 0; j < threads_segment_pcs[i].size(); ++j) {
            base::ObjectPtr& obj_ptr = (*segments)[offset + j];
            obj_ptr.reset(new base::Object());
            obj_ptr->lidar_supplement.cloud = *threads_segment_pcs[i][j];
 
            if (do_classification_) {
                obj_ptr->type = Label2Type(threads_segment_labels[i][j]);
            }
        }
    }
    std::vector<int> outlier_offset(num_threads_, static_cast<int>(_outliers->size()));
    for (int i = 1; i < num_threads_; ++i) {
        outlier_offset[i] = outlier_offset[i - 1] + static_cast<int>(threads_outlier_pcs[i - 1].size());
    }
    int new_num_outliers
            = static_cast<int>(threads_outlier_pcs[num_threads_ - 1].size()) + outlier_offset[num_threads_ - 1];
    _outliers->resize(new_num_outliers);
#pragma omp parallel for
    for (int i = 0; i < num_threads_; ++i) {
        int offset = outlier_offset[i];
        for (size_t j = 0; j < threads_outlier_pcs[i].size(); ++j) {
            base::ObjectPtr& obj_ptr = (*_outliers)[offset + j];
            obj_ptr.reset(new base::Object);
            obj_ptr->lidar_supplement.cloud = *threads_outlier_pcs[i][j];
        }
    }
    AINFO << "aggregate results, elapsed time: " << omp_get_wtime() - start_t;
    AINFO << "final #segments " << segments->size();
    AINFO << "final #outliers " << _outliers->size();
 
#ifdef DEBUG_NCUT
    VisualizeSegments(*segments);
    VisualizeSegments(*_outliers);
#endif
 
    return true;
}

Init()

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

overridevirtual

Init ncut segmentation

参数

options

返回

true

false

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

在文件 ncut_segmentation.cc 第 37 行定义.

                                                                   {
    std::string param_file = GetConfigFile(options.config_path, options.config_file);
    AINFO << "--    param_file: " << param_file;
 
    if (!Configure(param_file)) {
        AERROR << "failed to load ncut config.";
        return false;
    }
 
    _outliers.reset(new std::vector<ObjectPtr>);
    if (!_outliers) {
        AERROR << "Failed to reset outliers.";
        return false;
    }
#pragma omp parallel
    { num_threads_ = omp_get_num_threads(); }
 
    AINFO << "number threads " << num_threads_;
    _segmentors.resize(num_threads_);
    for (int i = 0; i < num_threads_; ++i) {
        _segmentors[i].reset(new NCut);
        if (!(_segmentors[i]->Init(ncut_param_))) {
            AERROR << "failed to init NormalizedCut " << i << ".";
            return false;
        }
    }
 
    roi_cloud_ = base::PointFCloudPool::Instance().Get();
    roi_world_cloud_ = base::PointDCloudPool::Instance().Get();
 
#ifdef DEBUG_NCUT
    _viewer = pcl::visualization::PCLVisualizer::Ptr(new pcl::visualization::PCLVisualizer("3D Viewer"));
    _viewer->setBackgroundColor(0, 0, 0);
    _viewer->addCoordinateSystem(1.0);
    _viewer->initCameraParameters();
    _viewer_count = 0;
    _rgb_cloud = CPointCloudPtr(new CPointCloud);
#endif
 
    AINFO << "NCutSegmentation init success, num_threads: " << num_threads_;
    return true;
}

Name()

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

inlineoverridevirtual

Get class name

返回

std::string

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

在文件 ncut_segmentation.h 第 63 行定义.

                                    {
        return "NCutSegmentation";
    }

---

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

• modules/perception/lidar_segmentation/segmentor/ncut_segmentation/ncut_segmentation.h
• modules/perception/lidar_segmentation/segmentor/ncut_segmentation/ncut_segmentation.cc