apollo::perception::lidar::PreprocessPoints类 参考

#include <preprocess_points.h>

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

Public 成员函数
	PreprocessPoints (const int max_num_pillars, const int max_points_per_pillar, const int num_point_feature, const int grid_x_size, const int grid_y_size, const int grid_z_size, const float pillar_x_size, const float pillar_y_size, const float pillar_z_size, const float min_x_range, const float min_y_range, const float min_z_range, const int num_inds_for_scan)
	Constructor
void	Preprocess (const float *in_points_array, int in_num_points, int *x_coors, int *y_coors, float *num_points_per_pillar, float *pillar_point_feature, float *pillar_coors, float *sparse_pillar_map, int *host_pillar_count)
	CPU preprocessing for input pointcloud
void	InitializeVariables (int *coor_to_pillaridx, float *sparse_pillar_map, float *pillar_point_feature, float *pillar_coors)
	Initializing variables for preprocessing

友元
class	TestClass

详细描述

在文件 preprocess_points.h 第 46 行定义.

构造及析构函数说明

PreprocessPoints()

apollo::perception::lidar::PreprocessPoints::PreprocessPoints	(	const int	max_num_pillars,
		const int	max_points_per_pillar,
		const int	num_point_feature,
		const int	grid_x_size,
		const int	grid_y_size,
		const int	grid_z_size,
		const float	pillar_x_size,
		const float	pillar_y_size,
		const float	pillar_z_size,
		const float	min_x_range,
		const float	min_y_range,
		const float	min_z_range,
		const int	num_inds_for_scan
	)

Constructor

参数

[in]	max_num_pillars	Maximum number of pillars
[in]	max_points_per_pillar	Maximum number of points per pillar
[in]	num_point_feature	Number of features in a point
[in]	grid_x_size	Number of pillars in x-coordinate
[in]	grid_y_size	Number of pillars in y-coordinate
[in]	grid_z_size	Number of pillars in z-coordinate
[in]	pillar_x_size	Size of x-dimension for a pillar
[in]	pillar_y_size	Size of y-dimension for a pillar
[in]	pillar_z_size	Size of z-dimension for a pillar
[in]	min_x_range	Minimum x value for pointcloud
[in]	min_y_range	Minimum y value for pointcloud
[in]	min_z_range	Minimum z value for pointcloud
[in]	num_inds_for_scan	Number of indexes for scan(cumsum)

Captital variables never change after the compile

在文件 preprocess_points.cc 第 44 行定义.

    : max_num_pillars_(max_num_pillars),
      max_num_points_per_pillar_(max_points_per_pillar),
      num_point_feature_(num_point_feature),
      grid_x_size_(grid_x_size),
      grid_y_size_(grid_y_size),
      grid_z_size_(grid_z_size),
      pillar_x_size_(pillar_x_size),
      pillar_y_size_(pillar_y_size),
      pillar_z_size_(pillar_z_size),
      min_x_range_(min_x_range),
      min_y_range_(min_y_range),
      min_z_range_(min_z_range),
      num_inds_for_scan_(num_inds_for_scan) {}

成员函数说明

InitializeVariables()

void apollo::perception::lidar::PreprocessPoints::InitializeVariables	(	int *	coor_to_pillaridx,
		float *	sparse_pillar_map,
		float *	pillar_point_feature,
		float *	pillar_coors
	)

Initializing variables for preprocessing

参数

[in]	coor_to_pillaridx	Map for converting one set of coordinate to a pillar
[in]	sparse_pillar_map	Grid map representation for pillar-occupancy
[in]	pillar_point_feature	Values for features of points in each pillar
[in]	pillar_coors	Array for coors of pillars

Initializeing input arguments with certain values

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

                                                                {
  for (int i = 0; i < grid_y_size_; ++i) {
    for (int j = 0; j < grid_x_size_; ++j) {
      coor_to_pillaridx[i * grid_x_size_ + j] = -1;
    }
  }
 
  for (int i = 0; i < num_inds_for_scan_; ++i) {
    for (int j = 0; j < num_inds_for_scan_; ++j) {
      sparse_pillar_map[i * num_inds_for_scan_ + j] = 0;
    }
  }
 
  for (int i = 0;
       i < max_num_pillars_ * max_num_points_per_pillar_ * num_point_feature_;
       ++i) {
    pillar_point_feature[i] = 0;
  }
 
  for (int i = 0; i < max_num_pillars_ * 4; ++i) {
    pillar_coors[i] = 0;
  }
}

Preprocess()

void apollo::perception::lidar::PreprocessPoints::Preprocess	(	const float *	in_points_array,
		int	in_num_points,
		int *	x_coors,
		int *	y_coors,
		float *	num_points_per_pillar,
		float *	pillar_point_feature,
		float *	pillar_coors,
		float *	sparse_pillar_map,
		int *	host_pillar_count
	)

CPU preprocessing for input pointcloud

参数

[in]	in_points_array	Pointcloud array
[in]	in_num_points	The number of points
[in]	x_coors	X-coordinate indexes for corresponding pillars
[in]	y_coors	Y-coordinate indexes for corresponding pillars
[in]	num_points_per_pillar	Number of points in corresponding pillars
[in]	pillar_point_feature	Values for features of points in each pillar
[in]	pillar_coors	Array for coors of pillars
[in]	sparse_pillar_map	Grid map representation for pillar-occupancy
[in]	host_pillar_count	The numnber of valid pillars for the input pointcloud

Convert pointcloud to pillar representation

在文件 preprocess_points.cc 第 91 行定义.

                                                          {
  int pillar_count = 0;
  // init variables
  int* coor_to_pillaridx = new int[grid_y_size_ * grid_x_size_];
  InitializeVariables(coor_to_pillaridx, sparse_pillar_map,
                      pillar_point_feature, pillar_coors);
  for (int i = 0; i < in_num_points; ++i) {
    int x_coor = std::floor(
        (in_points_array[i * num_point_feature_ + 0] - min_x_range_) /
        pillar_x_size_);
    int y_coor = std::floor(
        (in_points_array[i * num_point_feature_ + 1] - min_y_range_) /
        pillar_y_size_);
    int z_coor = std::floor(
        (in_points_array[i * num_point_feature_ + 2] - min_z_range_) /
        pillar_z_size_);
    if (x_coor < 0 || x_coor >= grid_x_size_ || y_coor < 0 ||
        y_coor >= grid_y_size_ || z_coor < 0 || z_coor >= grid_z_size_) {
      continue;
    }
    // reverse index
    int pillar_index = coor_to_pillaridx[y_coor * grid_x_size_ + x_coor];
    if (pillar_index == -1) {
      pillar_index = pillar_count;
      if (pillar_count >= max_num_pillars_) {
        break;
      }
      pillar_count += 1;
      coor_to_pillaridx[y_coor * grid_x_size_ + x_coor] = pillar_index;
 
      y_coors[pillar_index] = std::floor(y_coor);
      x_coors[pillar_index] = std::floor(x_coor);
 
      sparse_pillar_map[y_coor * num_inds_for_scan_ + x_coor] = 1;
    }
    int num = num_points_per_pillar[pillar_index];
    if (num < max_num_points_per_pillar_) {
      for (int j = 0; j < num_point_feature_; ++j) {
        pillar_point_feature[pillar_index * max_num_points_per_pillar_ *
                                 num_point_feature_ +
                             num * num_point_feature_ + j] =
            in_points_array[i * num_point_feature_ + j];
      }
      num_points_per_pillar[pillar_index] += 1;
    }
  }
 
  for (int i = 0; i < max_num_pillars_; ++i) {
    float x = 0;
    float y = 0;
    if (i < pillar_count) {
      x = static_cast<float>(x_coors[i]);
      y = static_cast<float>(y_coors[i]);
    }
    pillar_coors[i * 4 + 0] = 0;  // batch idx, but currently it is useless
    pillar_coors[i * 4 + 1] = 0;  // z
    pillar_coors[i * 4 + 2] = y;
    pillar_coors[i * 4 + 3] = x;
  }
  host_pillar_count[0] = pillar_count;
 
  delete[] coor_to_pillaridx;
}

友元及相关函数文档

TestClass

friend class TestClass

friend

在文件 preprocess_points.h 第 48 行定义.

---

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

• modules/perception/lidar_detection/detector/point_pillars_detection/preprocess_points.h
• modules/perception/lidar_detection/detector/point_pillars_detection/preprocess_points.cc