apollo::perception::algorithm::VoxelGridXY< T > 模板类 参考

#include <i_struct_s.h>

apollo::perception::algorithm::VoxelGridXY< T > 的协作图:

Public 成员函数
	VoxelGridXY ()
	VoxelGridXY (unsigned int nr_voxel_x, unsigned int nr_voxel_y, T spatial_bound_x_min, T spatial_bound_x_max, T spatial_bound_y_min, T spatial_bound_y_max, T spatial_bound_z_min, T spatial_bound_z_max)
VoxelGridXY &	operator= (const VoxelGridXY< T > &vg)
void	CleanUp ()
	~VoxelGridXY ()
bool	Alloc (unsigned int nr_voxel_x, unsigned int nr_voxel_y, T spatial_bound_x_min, T spatial_bound_x_max, T spatial_bound_y_min, T spatial_bound_y_max, T spatial_bound_z_min, T spatial_bound_z_max)
bool	Set (const T *data, unsigned int nr_points, unsigned int nr_point_element)
bool	SetS (const float *data, unsigned int nr_points, unsigned int nr_point_element)
bool	Set (const T *data, unsigned int nr_points, unsigned int nr_point_element, unsigned int nr_voxel_x, unsigned int nr_voxel_y, T spatial_bound_x_min, T spatial_bound_x_max, T spatial_bound_y_min, T spatial_bound_y_max, T spatial_bound_z_min, T spatial_bound_z_max, bool force_bound=true)
bool	Initialized () const
unsigned int	NrVoxel () const
unsigned int	NrVoxelX () const
unsigned int	NrVoxelY () const
unsigned int	NrVoxelZ () const
unsigned int	NrPoints () const
unsigned int	NrPointElement () const
unsigned int	NrIndexedPoints () const
std::vector< Voxel< T > > &	GetVoxels ()
const std::vector< Voxel< T > > &	GetConstVoxels () const
void	SetVoxels (const std::vector< Voxel< T > > &voxels)
bool	GetGridDimension (T *dim_min_x, T *dim_max_x, T *dim_min_y, T *dim_max_y, T *dim_min_z, T *dim_max_z) const
void	SetGridDimension (T dim_min_x, T dim_max_x, T dim_min_y, T dim_max_y, T dim_min_z, T dim_max_z)
bool	GetVoxelDimension (T *voxel_width_x, T *voxel_width_y, T *voxel_width_z) const
void	SetVoxelDimension (T voxel_width_x, T voxel_width_y, T voxel_width_z)
void	SetNrPoints (unsigned int nr_points)
void	SetNrPointElement (unsigned int nr_point_element)
void	SetNrVoxel (unsigned int nr_voxel_x, unsigned int nr_voxel_y, unsigned int nr_voxel_z)
void	SetPointCloudsData (const T *data)
void	SetInitialized (bool initialized)
int	WhichVoxel (T x, T y, T z) const
bool	GetVoxelCoordinateXY (T x, T y, int *row, int *col) const
Voxel< T > &	operator[] (unsigned int i)
const Voxel< T > &	operator[] (unsigned int i) const
Voxel< T > &	operator[] (int i)
const Voxel< T > &	operator[] (int i) const
Voxel< T > &	operator() (unsigned int iy, unsigned int ix)
const Voxel< T > &	operator() (unsigned int iy, unsigned int ix) const
T *	Data ()
const T *	const_data () const

详细描述

template<typename T>
class apollo::perception::algorithm::VoxelGridXY< T >

在文件 i_struct_s.h 第 294 行定义.

构造及析构函数说明

VoxelGridXY() [1/2]

template<typename T >

apollo::perception::algorithm::VoxelGridXY< T >::VoxelGridXY

(

)

在文件 i_struct_s.h 第 500 行定义.

    : nr_points_(0),
      nr_point_element_(0),
      nr_voxel_x_(0),
      nr_voxel_y_(0),
      nr_voxel_z_(1),
      data_(nullptr),
      initialized_(false),
      mem_aligned16_f32_(nullptr),
      mem_aligned16_i32_(nullptr) {
  IZero2(dim_x_);
  IZero2(dim_y_);
  IZero2(dim_z_);
  IZero3(voxel_dim_);
  AllocAlignedMemory();
}

VoxelGridXY() [2/2]

template<typename T >

apollo::perception::algorithm::VoxelGridXY< T >::VoxelGridXY	(	unsigned int	nr_voxel_x,
		unsigned int	nr_voxel_y,
		T	spatial_bound_x_min,
		T	spatial_bound_x_max,
		T	spatial_bound_y_min,
		T	spatial_bound_y_max,
		T	spatial_bound_z_min,
		T	spatial_bound_z_max
	)

在文件 i_struct_s.h 第 531 行定义.

                                                                          {
  Alloc(nr_voxel_x, nr_voxel_y, spatial_bound_x_min, spatial_bound_x_max,
        spatial_bound_y_min, spatial_bound_y_max, spatial_bound_z_min,
        spatial_bound_z_max);
  AllocAlignedMemory();
  initialized_ = false;
}

~VoxelGridXY()

template<typename T >

apollo::perception::algorithm::VoxelGridXY< T >::~VoxelGridXY ( )

inline

在文件 i_struct_s.h 第 328 行定义.

                 {
    IFreeAligned<float>(&mem_aligned16_f32_);
    IFreeAligned<int>(&mem_aligned16_i32_);
    CleanUp();
  }

成员函数说明

Alloc()

template<typename T >

bool apollo::perception::algorithm::VoxelGridXY< T >::Alloc	(	unsigned int	nr_voxel_x,
		unsigned int	nr_voxel_y,
		T	spatial_bound_x_min,
		T	spatial_bound_x_max,
		T	spatial_bound_y_min,
		T	spatial_bound_y_max,
		T	spatial_bound_z_min,
		T	spatial_bound_z_max
	)

在文件 i_struct_s.h 第 634 行定义.

                                                                         {
  if (!nr_voxel_x || !nr_voxel_y) {
    initialized_ = false;
    return initialized_;
  }
  nr_voxel_x_ = nr_voxel_x;
  nr_voxel_y_ = nr_voxel_y;
 
  unsigned int i, j, k, n = 0;
  unsigned int nr_voxel_xy = (nr_voxel_x_ * nr_voxel_y_);
  unsigned int nr_voxel = nr_voxel_xy;
 
  T vx, vy, vz, voxel_width_x, voxel_width_y, voxel_width_z;
 
  voxels_.clear();
  voxels_.resize(nr_voxel);
 
  // voxel grid dimesion is forced to be the manual input
  dim_x_[0] = spatial_bound_x_min;
  dim_x_[1] = spatial_bound_x_max;
 
  dim_y_[0] = spatial_bound_y_min;
  dim_y_[1] = spatial_bound_y_max;
 
  dim_z_[0] = spatial_bound_z_min;
  dim_z_[1] = spatial_bound_z_max;
 
  T span_x = (dim_x_[1] - dim_x_[0]);
  T span_y = (dim_y_[1] - dim_y_[0]);
  T span_z = (dim_z_[1] - dim_z_[0]);
 
  assert(span_x > 0 && span_y > 0 && span_z > 0);
 
  voxel_dim_[0] = voxel_width_x = IDiv(span_x, static_cast<int>(nr_voxel_x_));
  voxel_dim_[1] = voxel_width_y = IDiv(span_y, static_cast<int>(nr_voxel_y_));
  voxel_dim_[2] = voxel_width_z = span_z;
 
  std::vector<T> vxs(nr_voxel_x_);
 
  vxs[0] = dim_x_[0];
  for (i = 1; i < nr_voxel_x_; i++) {
    vxs[i] = vxs[i - 1] + voxel_width_x;
  }
 
  vy = dim_y_[0];
  vz = dim_z_[0];
 
  for (j = 0; j < nr_voxel_y_; j++) {
    for (k = 0; k < nr_voxel_x_; k++) {
      vx = vxs[k];
      voxels_[n++].Init(vx, vy, vz, voxel_width_x, voxel_width_y, voxel_width_z,
                        static_cast<int>(k), static_cast<int>(j), 0);
    }
    vy += voxel_width_y;
  }
 
  // pre-Alloc capacaity for indices_ vector - speed-up the code slightly
  Reserve();
  return (true);
}

CleanUp()

template<typename T >

void apollo::perception::algorithm::VoxelGridXY< T >::CleanUp

(

)

在文件 i_struct_s.h 第 518 行定义.

                             {
  initialized_ = false;
  data_ = nullptr;
  nr_points_ = nr_point_element_ = nr_voxel_x_ = nr_voxel_y_ = 0;
  nr_voxel_z_ = 1;
  IZero2(dim_x_);
  IZero2(dim_y_);
  IZero2(dim_z_);
  IZero3(voxel_dim_);
  voxels_.clear();
}

const_data()

template<typename T >

const T * apollo::perception::algorithm::VoxelGridXY< T >::const_data ( ) const

inline

在文件 i_struct_s.h 第 479 行定义.

{ return (data_); }

Data()

template<typename T >

T * apollo::perception::algorithm::VoxelGridXY< T >::Data ( )

inline

在文件 i_struct_s.h 第 477 行定义.

{ return (data_); }

GetConstVoxels()

template<typename T >

const std::vector< Voxel< T > > & apollo::perception::algorithm::VoxelGridXY< T >::GetConstVoxels ( ) const

inline

在文件 i_struct_s.h 第 370 行定义.

{ return voxels_; }

GetGridDimension()

template<typename T >

bool apollo::perception::algorithm::VoxelGridXY< T >::GetGridDimension ( T *  dim_min_x, T *  dim_max_x, T *  dim_min_y, T *  dim_max_y, T *  dim_min_z, T *  dim_max_z  ) const

inline

在文件 i_struct_s.h 第 376 行定义.

                                                          {
    if (!initialized_) {
      dim_min_x = dim_max_x = dim_min_y = dim_max_y = dim_min_z = dim_max_z =
          static_cast<T>(0);
      return (false);
    }
    *dim_min_x = dim_x_[0];
    *dim_max_x = dim_x_[1];
    *dim_min_y = dim_y_[0];
    *dim_max_y = dim_y_[1];
    *dim_min_z = dim_z_[0];
    *dim_max_z = dim_z_[1];
    return (true);
  }

GetVoxelCoordinateXY()

template<typename T >

bool apollo::perception::algorithm::VoxelGridXY< T >::GetVoxelCoordinateXY	(	T	x,
		T	y,
		int *	row,
		int *	col
	)		const

在文件 i_struct_s.h 第 623 行定义.

                                                                            {
  if (x < dim_x_[0] || x > dim_x_[1] || y < dim_y_[0] || y > dim_y_[1]) {
    return false;  // points that are outside the defined BBOX are ignored
  }
 
  *col = static_cast<int>((x - dim_x_[0]) / voxel_dim_[0]);
  *row = static_cast<int>((y - dim_y_[0]) / voxel_dim_[1]);
  return true;
}

GetVoxelDimension()

template<typename T >

bool apollo::perception::algorithm::VoxelGridXY< T >::GetVoxelDimension ( T *  voxel_width_x, T *  voxel_width_y, T *  voxel_width_z  ) const

inline

在文件 i_struct_s.h 第 402 行定义.

                                                 {
    if (!initialized_) {
      *voxel_width_x = *voxel_width_y = *voxel_width_z = static_cast<T>(0);
      return (false);
    }
    *voxel_width_x = voxel_dim_[0];
    *voxel_width_y = voxel_dim_[1];
    *voxel_width_z = voxel_dim_[2];
    return (true);
  }

GetVoxels()

template<typename T >

std::vector< Voxel< T > > & apollo::perception::algorithm::VoxelGridXY< T >::GetVoxels ( )

inline

在文件 i_struct_s.h 第 368 行定义.

{ return voxels_; }

Initialized()

template<typename T >

bool apollo::perception::algorithm::VoxelGridXY< T >::Initialized ( ) const

inline

在文件 i_struct_s.h 第 352 行定义.

{ return initialized_; }

NrIndexedPoints()

template<typename T >

unsigned int apollo::perception::algorithm::VoxelGridXY< T >::NrIndexedPoints

(

)

const

在文件 i_struct_s.h 第 1036 行定义.

                                                   {
  if (!initialized_) {
    return 0;
  }
  unsigned int i, n = 0;
  for (i = 0; i < voxels_.size(); ++i) {
    n += voxels_[i].indices_.size();
  }
  return n;
}

NrPointElement()

template<typename T >

unsigned int apollo::perception::algorithm::VoxelGridXY< T >::NrPointElement ( ) const

inline

在文件 i_struct_s.h 第 364 行定义.

{ return nr_point_element_; }

NrPoints()

template<typename T >

unsigned int apollo::perception::algorithm::VoxelGridXY< T >::NrPoints ( ) const

inline

在文件 i_struct_s.h 第 362 行定义.

{ return nr_points_; }

NrVoxel()

template<typename T >

unsigned int apollo::perception::algorithm::VoxelGridXY< T >::NrVoxel ( ) const

inline

在文件 i_struct_s.h 第 354 行定义.

{ return (unsigned int)voxels_.size(); }

NrVoxelX()

template<typename T >

unsigned int apollo::perception::algorithm::VoxelGridXY< T >::NrVoxelX ( ) const

inline

在文件 i_struct_s.h 第 356 行定义.

{ return nr_voxel_x_; }

NrVoxelY()

template<typename T >

unsigned int apollo::perception::algorithm::VoxelGridXY< T >::NrVoxelY ( ) const

inline

在文件 i_struct_s.h 第 358 行定义.

{ return nr_voxel_y_; }

NrVoxelZ()

template<typename T >

unsigned int apollo::perception::algorithm::VoxelGridXY< T >::NrVoxelZ ( ) const

inline

在文件 i_struct_s.h 第 360 行定义.

{ return (1); }

operator()() [1/2]

template<typename T >

Voxel< T > & apollo::perception::algorithm::VoxelGridXY< T >::operator() ( unsigned int  iy, unsigned int  ix  )

inline

在文件 i_struct_s.h 第 463 行定义.

                                                         {
    assert(iy < nr_voxel_y_ && ix < nr_voxel_x_);
    unsigned int i = nr_voxel_x_ * iy + ix;
    assert(i < voxels_.size());
    return (voxels_[i]);
  }

operator()() [2/2]

template<typename T >

const Voxel< T > & apollo::perception::algorithm::VoxelGridXY< T >::operator() ( unsigned int  iy, unsigned int  ix  ) const

inline

在文件 i_struct_s.h 第 470 行定义.

                                                                     {
    assert(iy < nr_voxel_y_ && ix < nr_voxel_x_);
    unsigned int i = nr_voxel_x_ * iy + ix;
    assert(i < voxels_.size());
    return (voxels_[i]);
  }

operator=()

template<typename T >

VoxelGridXY & apollo::perception::algorithm::VoxelGridXY< T >::operator= ( const VoxelGridXY< T > &  vg )

inline

在文件 i_struct_s.h 第 305 行定义.

                                                   {
    if (this != &vg) {
      this->initialized_ = vg.Initialized();
      this->nr_points_ = vg.NrPoints();
      this->nr_point_element_ = vg.NrPointElement();
      this->nr_voxel_x_ = vg.NrVoxelX();
      this->nr_voxel_y_ = vg.NrVoxelY();
      this->nr_voxel_z_ = vg.NrVoxelZ();
      this->data_ = vg.const_data();
      vg.GetGridDimension(&this->dim_x_[0], &this->dim_x_[1], &this->dim_y_[0],
                          &this->dim_y_[1], &this->dim_z_[0], &this->dim_z_[1]);
      this->voxels_.resize(vg.NrVoxel());
      for (unsigned int i = 0; i < vg.NrVoxel(); ++i) {
        this->voxels_[i] = vg[i];
      }
 
      this->AllocAlignedMemory();
    }
    return (*this);
  }

operator[]() [1/4]

template<typename T >

Voxel< T > & apollo::perception::algorithm::VoxelGridXY< T >::operator[] ( int  i )

inline

在文件 i_struct_s.h 第 454 行定义.

                              {
    assert(i >= 0 && i < static_cast<int>(voxels_.size()));
    return (voxels_[i]);
  }

operator[]() [2/4]

template<typename T >

const Voxel< T > & apollo::perception::algorithm::VoxelGridXY< T >::operator[] ( int  i ) const

inline

在文件 i_struct_s.h 第 458 行定义.

                                          {
    assert(i >= 0 && i < static_cast<int>(voxels_.size()));
    return (voxels_[i]);
  }

operator[]() [3/4]

template<typename T >

Voxel< T > & apollo::perception::algorithm::VoxelGridXY< T >::operator[] ( unsigned int  i )

inline

在文件 i_struct_s.h 第 444 行定义.

                                       {
    assert(i >= 0 && i < voxels_.size());
    return (voxels_[i]);
  }

operator[]() [4/4]

template<typename T >

const Voxel< T > & apollo::perception::algorithm::VoxelGridXY< T >::operator[] ( unsigned int  i ) const

inline

在文件 i_struct_s.h 第 449 行定义.

                                                   {
    assert(i >= 0 && i < voxels_.size());
    return (voxels_[i]);
  }

Set() [1/2]

template<typename T >

bool apollo::perception::algorithm::VoxelGridXY< T >::Set	(	const T *	data,
		unsigned int	nr_points,
		unsigned int	nr_point_element
	)

在文件 i_struct_s.h 第 699 行定义.

                                                        {
  if (!data || !nr_points || !nr_point_element || !nr_voxel_x_ ||
      !nr_voxel_y_ || nr_voxel_z_ != 1) {
    initialized_ = false;
    return initialized_;
  }
 
  data_ = data;
  nr_points_ = nr_points;
  nr_point_element_ = nr_point_element;
 
  unsigned int nr_voxel = (nr_voxel_x_ * nr_voxel_y_);
  unsigned int i, nd = 0;
  int id, n = 0;
 
  T voxel_width_x_rec = IRec(voxel_dim_[0]);
  T voxel_width_y_rec = IRec(voxel_dim_[1]);
 
  T bound_x_min = dim_x_[0];
  T bound_x_max = dim_x_[1];
  T bound_y_min = dim_y_[0];
  T bound_y_max = dim_y_[1];
  T bound_z_min = dim_z_[0];
  T bound_z_max = dim_z_[1];
 
  // clear the old index buffer
  for (i = 0; i < nr_voxel; ++i) {
    voxels_[i].indices_.clear();
  }
 
  // Assign point indices
  for (; n < static_cast<int>(nr_points_); n++, nd += nr_point_element_) {
    id = IAssignPointToVoxel(
        data_ + nd, bound_x_min, bound_x_max, bound_y_min, bound_y_max,
        bound_z_min, bound_z_max, voxel_width_x_rec, voxel_width_y_rec,
        static_cast<int>(nr_voxel_x_), static_cast<int>(nr_voxel_y_));
 
    if (id >= 0) {
      voxels_[id].indices_.push_back(n);
    }
  }
 
  initialized_ = true;
  return (initialized_);
}

Set() [2/2]

template<typename T >

bool apollo::perception::algorithm::VoxelGridXY< T >::Set	(	const T *	data,
		unsigned int	nr_points,
		unsigned int	nr_point_element,
		unsigned int	nr_voxel_x,
		unsigned int	nr_voxel_y,
		T	spatial_bound_x_min,
		T	spatial_bound_x_max,
		T	spatial_bound_y_min,
		T	spatial_bound_y_max,
		T	spatial_bound_z_min,
		T	spatial_bound_z_max,
		bool	force_bound = true
	)

在文件 i_struct_s.h 第 902 行定义.

                                                                  {
  if (!data || !nr_points || !nr_point_element || !nr_voxel_x || !nr_voxel_y) {
    initialized_ = false;
    return initialized_;
  }
 
  data_ = data;
  nr_points_ = nr_points;
  nr_point_element_ = nr_point_element;
  nr_voxel_x_ = nr_voxel_x;
  nr_voxel_y_ = nr_voxel_y;
  nr_voxel_z_ = 1;
 
  unsigned int i, j, k, n = 0, nd = 0;
  unsigned int nr_voxel_xy = (nr_voxel_x_ * nr_voxel_y_);
  unsigned int nr_voxel = nr_voxel_xy;
  unsigned int nr_voxel_xm1 = nr_voxel_x - 1;
  unsigned int nr_voxel_ym1 = nr_voxel_y - 1;
  T vx, vy, vz, x, y, z;
  T voxel_width_x, voxel_width_y, voxel_width_z;
 
  voxels_.clear();
  voxels_.resize(nr_voxel);
 
  // if force_bound then the voxel grid dimesion is forced to be the manual
  //  * input
  if (force_bound) {
    dim_x_[0] = spatial_bound_x_min;
    dim_x_[1] = spatial_bound_x_max;
 
    dim_y_[0] = spatial_bound_y_min;
    dim_y_[1] = spatial_bound_y_max;
 
    dim_z_[0] = spatial_bound_z_min;
    dim_z_[1] = spatial_bound_z_max;
  } else {
    IGetPointcloudsDimWBound(
        data_, nr_points_, 0, nr_point_element_, &dim_x_[0], &dim_x_[1],
        &dim_y_[0], &dim_y_[1], &dim_z_[0], &dim_z_[1], spatial_bound_x_min,
        spatial_bound_x_max, spatial_bound_y_min, spatial_bound_y_max,
        spatial_bound_z_min, spatial_bound_z_max);
  }
 
  T dim_x_min = dim_x_[0];
  T dim_x_max = dim_x_[1];
 
  T dim_y_min = dim_y_[0];
  T dim_y_max = dim_y_[1];
 
  T dim_z_min = dim_z_[0];
  T dim_z_max = dim_z_[1];
 
  T span_x = (dim_x_max - dim_x_min);
  T span_y = (dim_y_max - dim_y_min);
  T span_z = (dim_z_max - dim_z_min);
 
  assert(span_x > 0 && span_y > 0 && span_z > 0);
 
  voxel_dim_[0] = voxel_width_x = IDiv(span_x, static_cast<int>(nr_voxel_x_));
  voxel_dim_[1] = voxel_width_y = IDiv(span_y, static_cast<int>(nr_voxel_y_));
  voxel_dim_[2] = voxel_width_z = span_z;
 
  T voxel_width_x_rec = IRec(voxel_dim_[0]);
  T voxel_width_y_rec = IRec(voxel_dim_[1]);
 
  std::vector<T> vxs(nr_voxel_x_);
  vxs[0] = dim_x_[0];
 
  for (i = 1; i < nr_voxel_x_; i++) {
    vxs[i] = vxs[i - 1] + voxel_width_x;
  }
 
  vy = dim_y_[0];
  vz = dim_z_[0];
 
  for (j = 0; j < nr_voxel_y_; j++) {
    for (k = 0; k < nr_voxel_x_; k++) {
      vx = vxs[k];
      voxels_[n++].init(vx, vy, vz, voxel_width_x, voxel_width_y, voxel_width_z,
                        static_cast<int>(k), static_cast<int>(j), 0);
    }
    vy += voxel_width_y;
  }
 
  // Assign point indices
  for (; n < nr_points_; n++, nd += nr_point_element_) {
    x = data_[nd];
    y = data_[nd + 1];
    z = data_[nd + 2];
 
    if (x < dim_x_min || x > dim_x_max || y < dim_y_min || y > dim_y_max ||
        z < dim_z_min || z > dim_z_max) {
      // points that are outside the defined BBOX are ignored
      continue;
    }
 
    k = IMax((unsigned int)0,
             IMin(nr_voxel_xm1,
                  (unsigned int)((x - dim_x_min) * voxel_width_x_rec)));
    j = IMax((unsigned int)0,
             IMin(nr_voxel_ym1,
                  (unsigned int)((y - dim_y_min) * voxel_width_y_rec)));
    i = nr_voxel_x * j + k;
 
    assert(i < nr_voxel);
    voxels_[i].indices_.push_back(n);
  }
  initialized_ = true;
  return initialized_;
}

SetGridDimension()

template<typename T >

void apollo::perception::algorithm::VoxelGridXY< T >::SetGridDimension ( T  dim_min_x, T  dim_max_x, T  dim_min_y, T  dim_max_y, T  dim_min_z, T  dim_max_z  )

inline

在文件 i_struct_s.h 第 392 行定义.

                                                  {
    dim_x_[0] = dim_min_x;
    dim_x_[1] = dim_max_x;
    dim_y_[0] = dim_min_y;
    dim_y_[1] = dim_max_y;
    dim_z_[0] = dim_min_z;
    dim_z_[1] = dim_max_z;
  }

SetInitialized()

template<typename T >

void apollo::perception::algorithm::VoxelGridXY< T >::SetInitialized ( bool  initialized )

inline

在文件 i_struct_s.h 第 435 行定义.

{ initialized_ = initialized; }

SetNrPointElement()

template<typename T >

void apollo::perception::algorithm::VoxelGridXY< T >::SetNrPointElement ( unsigned int  nr_point_element )

inline

在文件 i_struct_s.h 第 422 行定义.

                                                        {
    nr_point_element_ = nr_point_element;
  }

SetNrPoints()

template<typename T >

void apollo::perception::algorithm::VoxelGridXY< T >::SetNrPoints ( unsigned int  nr_points )

inline

在文件 i_struct_s.h 第 420 行定义.

{ nr_points_ = nr_points; }

SetNrVoxel()

template<typename T >

void apollo::perception::algorithm::VoxelGridXY< T >::SetNrVoxel ( unsigned int  nr_voxel_x, unsigned int  nr_voxel_y, unsigned int  nr_voxel_z  )

inline

在文件 i_struct_s.h 第 426 行定义.

                                           {
    nr_voxel_x_ = nr_voxel_x;
    nr_voxel_y_ = nr_voxel_y;
    nr_voxel_z_ = nr_voxel_z;
  }

SetPointCloudsData()

template<typename T >

void apollo::perception::algorithm::VoxelGridXY< T >::SetPointCloudsData ( const T *  data )

inline

在文件 i_struct_s.h 第 433 行定义.

{ data_ = data; }

SetS()

template<typename T >

bool apollo::perception::algorithm::VoxelGridXY< T >::SetS	(	const float *	data,
		unsigned int	nr_points,
		unsigned int	nr_point_element
	)

在文件 i_struct_s.h 第 747 行定义.

                                                         {
  if (!data || !nr_points || !nr_point_element || !nr_voxel_x_ ||
      !nr_voxel_y_ || nr_voxel_z_ != 1) {
    initialized_ = false;
    return initialized_;
  }
 
  data_ = data;
  nr_points_ = nr_points;
  nr_point_element_ = nr_point_element;
 
  unsigned int nr_voxel = (nr_voxel_x_ * nr_voxel_y_);
  unsigned int i, n = 0;
  int id;
 
  float voxel_width_x_rec = IRec(static_cast<float>(voxel_dim_[0]));
  float voxel_width_y_rec = IRec(static_cast<float>(voxel_dim_[1]));
 
  __m128i iv_nr_voxel_x = _mm_setr_epi32(static_cast<int>(nr_voxel_x_), 0,
                                         static_cast<int>(nr_voxel_x_), 0);
  __m128i iv_nr_voxel_x_m1 = _mm_set1_epi32(static_cast<int>(nr_voxel_x_ - 1));
  __m128i iv_nr_voxel_y_m1 = _mm_set1_epi32(static_cast<int>(nr_voxel_y_ - 1));
 
  __m128 v_width_x_rec = _mm_set_ps1(voxel_width_x_rec);
  __m128 v_width_y_rec = _mm_set_ps1(voxel_width_y_rec);
 
  __m128 v_x_min = _mm_set_ps1(dim_x_[0]);
  __m128 v_x_max = _mm_set_ps1(dim_x_[1]);
  __m128 v_y_min = _mm_set_ps1(dim_y_[0]);
  __m128 v_y_max = _mm_set_ps1(dim_y_[1]);
  __m128 v_z_min = _mm_set_ps1(dim_z_[0]);
  __m128 v_z_max = _mm_set_ps1(dim_z_[1]);
 
  __m128 v_cmp_x, v_cmp_y, v_cmp_z, v_in_roi;
  v_in_roi = _mm_setr_ps(1.0, 1.0, 1.0, 1.0);
 
  __m128 v_xs, v_ys, v_zs;
  __m128i iv_indices, iv_x_indices, iv_y_indices, iv_v_indices_02,
      iv_v_indices_13;
 
  for (i = 0; i < nr_voxel; ++i) {
    voxels_[i].indices_.clear();
  }
 
  unsigned int nr_loops = (nr_points >> 2);
  unsigned int nr_fast_processed = (nr_loops << 2);
  unsigned int remainder = nr_points - nr_fast_processed;
 
  unsigned int d1 = nr_point_element;
  unsigned int d2 = (nr_point_element << 1);
  unsigned int d3 = d1 + d2;
  unsigned int d4 = (nr_point_element << 2);
 
  // xyz are required to be stored in continuous memory
  const float *cptr_x = data;
  const float *cptr_y = data + 1;
  const float *cptr_z = data + 2;
  const float *cptr_remainder = data + (nr_fast_processed * nr_point_element);
 
  for (i = 0; i < nr_loops; ++i, n += 4) {
    // Set memory
    v_xs = _mm_setr_ps(cptr_x[0], cptr_x[d1], cptr_x[d2], cptr_x[d3]);
    v_ys = _mm_setr_ps(cptr_y[0], cptr_y[d1], cptr_y[d2], cptr_y[d3]);
    v_zs = _mm_setr_ps(cptr_z[0], cptr_z[d1], cptr_z[d2], cptr_z[d3]);
 
    // compare range:
    v_cmp_x =
        _mm_and_ps(_mm_cmpge_ps(v_xs, v_x_min), _mm_cmple_ps(v_xs, v_x_max));
    v_cmp_y =
        _mm_and_ps(_mm_cmpge_ps(v_ys, v_y_min), _mm_cmple_ps(v_ys, v_y_max));
    v_cmp_z =
        _mm_and_ps(_mm_cmpge_ps(v_zs, v_z_min), _mm_cmple_ps(v_zs, v_z_max));
    v_in_roi = _mm_and_ps(_mm_and_ps(v_cmp_x, v_cmp_y), v_cmp_z);
 
    // vector operations, cast into signed integers
    v_xs = _mm_sub_ps(v_xs, v_x_min);
    v_xs = _mm_mul_ps(v_xs, v_width_x_rec);
    iv_x_indices = _mm_cvttps_epi32(v_xs);  // truncate towards zero
    iv_x_indices = _mm_min_epi32(iv_nr_voxel_x_m1, iv_x_indices);
 
    // vector operations, cast into signed integers
    v_ys = _mm_sub_ps(v_ys, v_y_min);
    v_ys = _mm_mul_ps(v_ys, v_width_y_rec);
    iv_y_indices = _mm_cvttps_epi32(v_ys);  // truncate towards zero
    iv_y_indices = _mm_min_epi32(iv_nr_voxel_y_m1, iv_y_indices);
 
    iv_v_indices_02 = _mm_mullo_epi32(iv_y_indices, iv_nr_voxel_x);
    iv_y_indices = _mm_shuffle_epi32(iv_y_indices, _MM_SHUFFLE(2, 3, 0, 1));
 
    iv_v_indices_13 = _mm_mullo_epi32(iv_y_indices, iv_nr_voxel_x);
    iv_v_indices_13 =
        _mm_shuffle_epi32(iv_v_indices_13, _MM_SHUFFLE(2, 3, 0, 1));
 
    iv_indices = _mm_add_epi32(iv_v_indices_02, iv_v_indices_13);
    iv_indices = _mm_add_epi32(iv_indices, iv_x_indices);
 
    // store values from registers to memory
    // address 16byte-aligned
    _mm_store_ps(mem_aligned16_f32_, v_in_roi);
    // address 16byte-aligned
    _mm_store_si128(reinterpret_cast<__m128i *>(mem_aligned16_i32_),
                    iv_indices);
 
    if (mem_aligned16_f32_[0] != 0) {
      voxels_[mem_aligned16_i32_[0]].indices_.push_back(n);
    }
    if (mem_aligned16_f32_[1] != 0) {
      voxels_[mem_aligned16_i32_[1]].indices_.push_back(n + 1);
    }
    if (mem_aligned16_f32_[2] != 0) {
      voxels_[mem_aligned16_i32_[2]].indices_.push_back(n + 2);
    }
    if (mem_aligned16_f32_[3] != 0) {
      voxels_[mem_aligned16_i32_[3]].indices_.push_back(n + 3);
    }
    cptr_x += d4;
    cptr_y += d4;
    cptr_z += d4;
  }
 
  // handling remaining points
  for (i = 0; i < remainder; i++, n++) {
    id = IAssignPointToVoxel(cptr_remainder, dim_x_[0], dim_x_[1], dim_y_[0],
                             dim_y_[1], dim_z_[0], dim_z_[1], voxel_width_x_rec,
                             voxel_width_y_rec, static_cast<int>(nr_voxel_x_),
                             static_cast<int>(nr_voxel_y_));
 
    if (id >= 0) {
      voxels_[id].indices_.push_back(n);
    }
 
    cptr_remainder += nr_point_element;
  }
 
  // for (i = 0; i < nr_voxel; ++i) {
  //     voxels_[i].indices_.clear();
  // }
  // for (i = 0; i < nr_points; i++, n++) {
  //     float x = data_[nr_point_element_ * i];
  //     float y = data_[nr_point_element_ * i + 1];
  //     float z = data_[nr_point_element_ * i + 2];
  //     id = AssignPointToVoxel(x, y, z, dim_x_[0], dim_x_[1], dim_y_[0], dim_y_[1], dim_z_[0], dim_z_[1], 
  //         voxel_width_x_rec, voxel_width_y_rec, static_cast<int>(nr_voxel_x_), static_cast<int>(nr_voxel_y_));
      
  //     if (id >= 0) {
  //         voxels_[id].indices_.push_back(i);
  //     }
  // }
 
  initialized_ = true;
  return (initialized_);
}

SetVoxelDimension()

template<typename T >

void apollo::perception::algorithm::VoxelGridXY< T >::SetVoxelDimension ( T  voxel_width_x, T  voxel_width_y, T  voxel_width_z  )

inline

在文件 i_struct_s.h 第 414 行定义.

                                                                            {
    voxel_dim_[0] = voxel_width_x;
    voxel_dim_[1] = voxel_width_y;
    voxel_dim_[2] = voxel_width_z;
  }

SetVoxels()

template<typename T >

void apollo::perception::algorithm::VoxelGridXY< T >::SetVoxels ( const std::vector< Voxel< T > > &  voxels )

inline

在文件 i_struct_s.h 第 372 行定义.

                                                    {
    voxels_.assign(voxels.begin(), voxels.end());
  }

WhichVoxel()

template<typename T >

int apollo::perception::algorithm::VoxelGridXY< T >::WhichVoxel	(	T	x,
		T	y,
		T	z
	)		const

在文件 i_struct_s.h 第 601 行定义.

                                                  {
  int j, k;
  if (!initialized_) {
    return (-1);
  }
 
  if (x < dim_x_[0] || x > dim_x_[1] || y < dim_y_[0] || y > dim_y_[1] ||
      z < dim_z_[0] || z > dim_z_[1]) {
    return (-1);  // points that are outside the defined BBOX are ignored
  }
 
  k = static_cast<int>(IMax(
      (unsigned int)0,
      IMin(nr_voxel_x_ - 1, (unsigned int)((x - dim_x_[0]) / voxel_dim_[0]))));
  j = static_cast<int>(IMax(
      (unsigned int)0,
      IMin(nr_voxel_y_ - 1, (unsigned int)((y - dim_y_[0]) / voxel_dim_[1]))));
  return (nr_voxel_x_ * j + k);
}

---

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

• modules/perception/common/algorithm/i_lib/pc/i_struct_s.h