apollo::perception::lidar::SppLabelImage类 参考

#include <spp_label_image.h>

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

Public 成员函数
	SppLabelImage ()
	~SppLabelImage ()
void	Init (size_t width, size_t height, const std::string &sensor_name="velodyne64")
void	InitRangeMask (float range, float boundary_distance)
void	CollectClusterFromSppLabelImage ()
void	ProjectClusterToSppLabelImage ()
void	FilterClusters (const float *confidence_map, float threshold)
void	FilterClusters (const float *confidence_map, const float *category_map, float confidence_threshold, float category_threshold)
void	CalculateClusterClass (const float *class_map, size_t class_num)
void	CalculateClusterHeading (const float *heading_map)
void	CalculateClusterTopZ (const float *top_z_map)
uint16_t **	GetSppLabelImage ()
const uint16_t *const *	GetSppLabelImage () const
std::vector< SppClusterPtr > &	GetClusters ()
const std::vector< SppClusterPtr > &	GetClusters () const
uint16_t *	operator[] (size_t id)
const uint16_t *	operator[] (size_t id) const
size_t	GetClusterNum () const
SppClusterPtr	GetCluster (size_t id)
SppClusterConstPtr	GetCluster (size_t id) const
void	AddPixelSample (size_t id, uint16_t x, uint16_t y)
void	AddPixelSample (size_t id, uint32_t pixel)
void	ClearClusters ()
void	ResizeClusters (size_t size)
void	ResetClusters (size_t size)

详细描述

在文件 spp_label_image.h 第 32 行定义.

构造及析构函数说明

SppLabelImage()

apollo::perception::lidar::SppLabelImage::SppLabelImage ( )

inline

在文件 spp_label_image.h 第 34 行定义.

{ clusters_.reserve(kDefaultReserveSize); }

~SppLabelImage()

apollo::perception::lidar::SppLabelImage::~SppLabelImage ( )

inline

在文件 spp_label_image.h 第 35 行定义.

                   {
    if (labels_) {
      algorithm::IFree2(&labels_);
    }
    if (range_mask_) {
      algorithm::IFree2(&range_mask_);
    }
  }

成员函数说明

AddPixelSample() [1/2]

void apollo::perception::lidar::SppLabelImage::AddPixelSample ( size_t  id, uint16_t  x, uint16_t  y  )

inline

在文件 spp_label_image.h 第 115 行定义.

                                                         {
    return AddPixelSample(id, y * static_cast<uint32_t>(width_) + x);
  }

AddPixelSample() [2/2]

void apollo::perception::lidar::SppLabelImage::AddPixelSample	(	size_t	id,
		uint32_t	pixel
	)

在文件 spp_label_image.cc 第 237 行定义.

                                                            {
  if (clusters_.size() <= id) {
    SppClusterPool::Instance(sensor_name_)
        .BatchGet(id + 1 - clusters_.size(), &clusters_);
  }
  clusters_[id]->pixels.push_back(pixel);
}

CalculateClusterClass()

void apollo::perception::lidar::SppLabelImage::CalculateClusterClass	(	const float *	class_map,
		size_t	class_num
	)

在文件 spp_label_image.cc 第 182 行定义.

                                                            {
  for (auto& cluster : clusters_) {
    cluster->class_prob.assign(class_num, 0.f);
  }
  size_t size = width_ * height_;
  for (size_t c = 0; c < class_num; ++c) {
    const float* class_map_ptr = class_map + c * size;
    for (auto& cluster : clusters_) {
      auto& probs = cluster->class_prob;
      for (auto& pixel : cluster->pixels) {
        probs[c] += class_map_ptr[pixel];
      }
    }
  }
  for (auto& cluster : clusters_) {
    auto& probs = cluster->class_prob;
    float sum = std::accumulate(probs.begin(), probs.end(), 0.f);
    if (sum > 1e-9) {
      for (auto& value : probs) {
        value /= sum;
      }
    }
    cluster->type = static_cast<SppClassType>(std::distance(
        probs.begin(), std::max_element(probs.begin(), probs.end())));
  }
}

CalculateClusterHeading()

void apollo::perception::lidar::SppLabelImage::CalculateClusterHeading

(

const float *

heading_map

)

在文件 spp_label_image.cc 第 210 行定义.

                                                                    {
  const float* heading_map_x_ptr = heading_map;
  const float* heading_map_y_ptr = heading_map + width_ * height_;
 
  for (size_t n = 0; n < clusters_.size(); ++n) {
    float heading_x = 0.f, heading_y = 0.f;
    for (auto pixel : clusters_[n]->pixels) {
      heading_x += heading_map_x_ptr[pixel];
      heading_y += heading_map_y_ptr[pixel];
    }
    clusters_[n]->yaw = std::atan2(heading_y, heading_x) * 0.5f;
  }
}

CalculateClusterTopZ()

void apollo::perception::lidar::SppLabelImage::CalculateClusterTopZ

(

const float *

top_z_map

)

在文件 spp_label_image.cc 第 224 行定义.

                                                               {
  for (auto& cluster : clusters_) {
    float sum = 0.f;
    for (auto& pixel : cluster->pixels) {
      sum += top_z_map[pixel];
    }
    sum = cluster->pixels.size() > 0
              ? sum / static_cast<float>(cluster->pixels.size())
              : sum;
    cluster->top_z = sum;
  }
}

ClearClusters()

void apollo::perception::lidar::SppLabelImage::ClearClusters ( )

inline

在文件 spp_label_image.h 第 123 行定义.

{ clusters_.clear(); }

CollectClusterFromSppLabelImage()

void apollo::perception::lidar::SppLabelImage::CollectClusterFromSppLabelImage

(

)

在文件 spp_label_image.cc 第 67 行定义.

                                                    {
  size_t size = width_ * height_;
  // find max label
  uint16_t max_label = *(std::max_element(labels_[0], labels_[0] + size));
  clusters_.clear();
  SppClusterPool::Instance(sensor_name_).BatchGet(max_label, &clusters_);
  for (size_t y = 0; y < height_; ++y) {
    for (size_t x = 0; x < width_; ++x) {
      uint16_t& label = labels_[y][x];
      // label 0 is invalid, will be ignored
      if (label) {
        clusters_[label - 1]->pixels.push_back(
            static_cast<unsigned int>(y * width_ + x));
      }
    }
  }
}

FilterClusters() [1/2]

void apollo::perception::lidar::SppLabelImage::FilterClusters	(	const float *	confidence_map,
		const float *	category_map,
		float	confidence_threshold,
		float	category_threshold
	)

在文件 spp_label_image.cc 第 126 行定义.

                                                             {
  std::vector<bool> is_valid;
  is_valid.reserve(clusters_.size());
  for (auto& cluster : clusters_) {
    char mask = 1;
    for (auto& pixel : cluster->pixels) {
      mask &= range_mask_[0][pixel];
    }
    float sum_confidence = 0.f;
    for (auto& pixel : cluster->pixels) {
      sum_confidence += confidence_map[pixel];
    }
    sum_confidence =
        cluster->pixels.size() > 0
            ? sum_confidence / static_cast<float>(cluster->pixels.size())
            : sum_confidence;
    cluster->confidence = sum_confidence;
    if (mask) {  // in range, use confidence estimation
      is_valid.push_back(cluster->confidence >= confidence_threshold);
    } else {  // out of range, use category estimation
      float sum_category = 0.f;
      for (auto& pixel : cluster->pixels) {
        sum_category += category_map[pixel];
      }
      sum_category =
          cluster->pixels.size() > 0
              ? sum_category / static_cast<float>(cluster->pixels.size())
              : sum_category;
      is_valid.push_back(sum_category >= category_threshold);
      // category is not stable, here we hack the confidence
      cluster->confidence =
          std::max(sum_confidence, confidence_threshold + 0.01f);
    }
  }
  size_t current = 0;
  for (size_t n = 0; n < clusters_.size(); ++n) {
    if (is_valid[n]) {
      if (current != n) {
        clusters_[current] = clusters_[n];
        for (auto& pixel : clusters_[current]->pixels) {
          labels_[0][pixel] = static_cast<uint16_t>(current + 1);
        }
      }
      ++current;
    } else {
      for (auto& pixel : clusters_[n]->pixels) {
        labels_[0][pixel] = 0;
      }
    }
  }
  clusters_.resize(current);
}

FilterClusters() [2/2]

void apollo::perception::lidar::SppLabelImage::FilterClusters	(	const float *	confidence_map,
		float	threshold
	)

在文件 spp_label_image.cc 第 95 行定义.

                                                    {
  for (auto& cluster : clusters_) {
    float sum = 0.f;
    for (auto& pixel : cluster->pixels) {
      sum += confidence_map[pixel];
    }
    sum = cluster->pixels.size() > 0
              ? sum / static_cast<float>(cluster->pixels.size())
              : sum;
    cluster->confidence = sum;
  }
  size_t current = 0;
  for (size_t n = 0; n < clusters_.size(); ++n) {
    if (clusters_[n]->confidence >= threshold) {
      if (current != n) {
        clusters_[current] = clusters_[n];
        for (auto& pixel : clusters_[current]->pixels) {
          labels_[0][pixel] = static_cast<uint16_t>(current + 1);
        }
      }
      ++current;
    } else {
      for (auto& pixel : clusters_[n]->pixels) {
        labels_[0][pixel] = 0;
      }
    }
  }
  clusters_.resize(current);
}

GetCluster() [1/2]

SppClusterPtr apollo::perception::lidar::SppLabelImage::GetCluster ( size_t  id )

inline

在文件 spp_label_image.h 第 106 行定义.

{ return clusters_[id]; }

GetCluster() [2/2]

SppClusterConstPtr apollo::perception::lidar::SppLabelImage::GetCluster ( size_t  id ) const

inline

在文件 spp_label_image.h 第 110 行定义.

{ return clusters_[id]; }

GetClusterNum()

size_t apollo::perception::lidar::SppLabelImage::GetClusterNum ( ) const

inline

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

{ return clusters_.size(); }

GetClusters() [1/2]

std::vector< SppClusterPtr > & apollo::perception::lidar::SppLabelImage::GetClusters ( )

inline

在文件 spp_label_image.h 第 86 行定义.

{ return clusters_; }

GetClusters() [2/2]

const std::vector< SppClusterPtr > & apollo::perception::lidar::SppLabelImage::GetClusters ( ) const

inline

在文件 spp_label_image.h 第 89 行定义.

                                                             {
    return clusters_;
  }

GetSppLabelImage() [1/2]

uint16_t ** apollo::perception::lidar::SppLabelImage::GetSppLabelImage ( )

inline

在文件 spp_label_image.h 第 80 行定义.

{ return labels_; }

GetSppLabelImage() [2/2]

const uint16_t *const * apollo::perception::lidar::SppLabelImage::GetSppLabelImage ( ) const

inline

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

{ return labels_; }

Init()

void apollo::perception::lidar::SppLabelImage::Init	(	size_t	width,
		size_t	height,
		const std::string &	sensor_name = "velodyne64"
	)

在文件 spp_label_image.cc 第 29 行定义.

                                                       {
  // simply release the last memory and allocate new one
  if (labels_) {
    algorithm::IFree2(&labels_);
  }
  width_ = width;
  height_ = height;
  sensor_name_ = sensor_name;
  labels_ = algorithm::IAlloc2<uint16_t>(static_cast<int>(height_),
                                      static_cast<int>(width_));
  memset(labels_[0], 0, sizeof(uint16_t) * width_ * height_);
  clusters_.clear();
}

InitRangeMask()

void apollo::perception::lidar::SppLabelImage::InitRangeMask	(	float	range,
		float	boundary_distance
	)

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

                                                                      {
  if (range_mask_) {
    algorithm::IFree2(&range_mask_);
  }
  range_mask_ = algorithm::IAlloc2<char>(static_cast<int>(height_),
                                      static_cast<int>(width_));
  memset(range_mask_[0], 0, sizeof(char) * width_ * height_);
  float meter_per_pixel = range * 2.0f / static_cast<float>(width_);
  size_t half_width = width_ / 2;
  size_t half_height = height_ / 2;
  for (size_t r = 0; r < height_; ++r) {
    for (size_t c = 0; c < width_; ++c) {
      float distance = sqrtf(
          powf((static_cast<float>(r) - static_cast<float>(half_height)), 2.f) +
          powf((static_cast<float>(c) - static_cast<float>(half_width)), 2.f));
      distance *= meter_per_pixel;
      if (distance <= boundary_distance) {
        range_mask_[r][c] = 1;
      }
    }
  }
}

operator[]() [1/2]

uint16_t * apollo::perception::lidar::SppLabelImage::operator[] ( size_t  id )

inline

在文件 spp_label_image.h 第 95 行定义.

{ return labels_[id]; }

operator[]() [2/2]

const uint16_t * apollo::perception::lidar::SppLabelImage::operator[] ( size_t  id ) const

inline

在文件 spp_label_image.h 第 99 行定义.

{ return labels_[id]; }

ProjectClusterToSppLabelImage()

void apollo::perception::lidar::SppLabelImage::ProjectClusterToSppLabelImage

(

)

在文件 spp_label_image.cc 第 85 行定义.

                                                  {
  memset(labels_[0], 0, sizeof(uint16_t) * width_ * height_);
  for (size_t n = 0; n < clusters_.size(); ++n) {
    auto& cluster = clusters_[n];
    for (auto& pixel : cluster->pixels) {
      labels_[0][pixel] = static_cast<uint16_t>(n + 1);
    }
  }
}

ResetClusters()

void apollo::perception::lidar::SppLabelImage::ResetClusters

(

size_t

size

)

在文件 spp_label_image.cc 第 254 行定义.

                                             {
  size_t reset_pos = std::min(clusters_.size(), size);
  ResizeClusters(size);
  for (size_t i = 0; i < reset_pos; ++i) {
    clusters_[i]->clear();
  }
}

ResizeClusters()

void apollo::perception::lidar::SppLabelImage::ResizeClusters

(

size_t

size

)

在文件 spp_label_image.cc 第 245 行定义.

                                              {
  if (size > clusters_.size()) {
    SppClusterPool::Instance(sensor_name_)
        .BatchGet(size - clusters_.size(), &clusters_);
  } else {
    clusters_.resize(size);
  }
}

---

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

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