apollo::perception::algorithm::HoughTransfer类 参考

#include <hough_transfer.h>

apollo::perception::algorithm::HoughTransfer 的协作图:

Public 成员函数
	HoughTransfer ()
	~HoughTransfer ()=default
bool	Init (int img_w, int img_h, float d_r, float d_theta)
bool	ImageVote (const std::vector< int > &image, bool with_distribute)
void	PointVote (int x, int y, bool with_distribute)
void	PointVote (int pos, bool with_distribute)
bool	GetLines (int min_pt_num, int r_neibor, int theta_neibor, bool with_distribute, std::vector< HoughLine > *lines) const
unsigned int	MemoryConsume () const
void	FreeCache ()
void	ResetMaps (bool with_distribute)
std::string	name () const
bool	is_prepared () const
const std::vector< int > &	get_vote_map () const
const std::vector< std::vector< int > > &	get_distribute_map () const
float	get_d_r () const
float	get_d_theta () const
int	get_img_w () const
int	get_img_h () const
int	get_r_size () const
int	get_theta_size () const
void	ClearWithShrink ()

详细描述

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

构造及析构函数说明

HoughTransfer()

apollo::perception::algorithm::HoughTransfer::HoughTransfer

(

)

在文件 hough_transfer.cc 第 22 行定义.

    : prepared_(false),
      d_r_(0.0),
      d_theta_(0.0),
      img_w_(0),
      img_h_(0),
      r_size_(0),
      theta_size_(0),
      vote_reserve_size_(10),
      vote_map_(),
      query_map_(),
      distribute_map_() {}

~HoughTransfer()

apollo::perception::algorithm::HoughTransfer::~HoughTransfer ( )

default

成员函数说明

ClearWithShrink()

void apollo::perception::algorithm::HoughTransfer::ClearWithShrink

(

)

在文件 hough_transfer.cc 第 195 行定义.

                                    {
  vote_map_.clear();
  vote_map_.shrink_to_fit();
  query_map_.clear();
  query_map_.shrink_to_fit();
  distribute_map_.clear();
  distribute_map_.shrink_to_fit();
  prepared_ = false;
}

FreeCache()

void apollo::perception::algorithm::HoughTransfer::FreeCache

(

)

在文件 hough_transfer.cc 第 180 行定义.

                              {
  for (auto& distribute : distribute_map_) {
    distribute.shrink_to_fit();
  }
}

get_d_r()

float apollo::perception::algorithm::HoughTransfer::get_d_r ( ) const

inline

在文件 hough_transfer.h 第 92 行定义.

{ return d_r_; }

get_d_theta()

float apollo::perception::algorithm::HoughTransfer::get_d_theta ( ) const

inline

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

{ return d_theta_; }

get_distribute_map()

const std::vector< std::vector< int > > & apollo::perception::algorithm::HoughTransfer::get_distribute_map ( ) const

inline

在文件 hough_transfer.h 第 88 行定义.

                                                                     {
    return distribute_map_;
  }

get_img_h()

int apollo::perception::algorithm::HoughTransfer::get_img_h ( ) const

inline

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

{ return img_h_; }

get_img_w()

int apollo::perception::algorithm::HoughTransfer::get_img_w ( ) const

inline

在文件 hough_transfer.h 第 94 行定义.

{ return img_w_; }

get_r_size()

int apollo::perception::algorithm::HoughTransfer::get_r_size ( ) const

inline

在文件 hough_transfer.h 第 96 行定义.

{ return r_size_; }

get_theta_size()

int apollo::perception::algorithm::HoughTransfer::get_theta_size ( ) const

inline

在文件 hough_transfer.h 第 97 行定义.

{ return theta_size_; }

get_vote_map()

const std::vector< int > & apollo::perception::algorithm::HoughTransfer::get_vote_map ( ) const

inline

在文件 hough_transfer.h 第 87 行定义.

{ return vote_map_; }

GetLines()

bool apollo::perception::algorithm::HoughTransfer::GetLines	(	int	min_pt_num,
		int	r_neibor,
		int	theta_neibor,
		bool	with_distribute,
		std::vector< HoughLine > *	lines
	)		const

在文件 hough_transfer.cc 第 133 行定义.

                                                                {
  if (!lines) {
    return false;
  }
  int r_step = 2 * r_neibor + 1;
  int theta_step = 2 * theta_neibor + 1;
 
  // search one vote neighbor for max_vote position in the region
  std::set<int> max_vote_lines;
  GetMaxVotes(min_pt_num, r_neibor, theta_neibor, r_step, theta_step,
              &max_vote_lines);
 
  // from max vote pos to get line params
  lines->resize(max_vote_lines.size());
  int idx = 0;
  for (auto i = max_vote_lines.begin(); i != max_vote_lines.end(); ++i) {
    if (!VotePosToHoughLine(*i, with_distribute, &(*lines)[idx++])) {
      return false;
    }
  }
  return true;
}

ImageVote()

bool apollo::perception::algorithm::HoughTransfer::ImageVote	(	const std::vector< int > &	image,
		bool	with_distribute
	)

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

                                                    {
  if (image.size() != query_map_.size()) {
    return false;
  }
  ResetMaps(with_distribute);
  for (size_t i = 0; i < image.size(); ++i) {
    if (image[i] > 0) {
      int x = static_cast<int>(i) % img_w_;
      int y = static_cast<int>(i) / img_w_;
      PointVote(x, y, with_distribute);
    }
  }
  return true;
}

Init()

bool apollo::perception::algorithm::HoughTransfer::Init	(	int	img_w,
		int	img_h,
		float	d_r,
		float	d_theta
	)

在文件 hough_transfer.cc 第 40 行定义.

                                                                       {
  img_w_ = img_w;
  img_h_ = img_h;
  d_r_ = d_r;
  d_theta_ = static_cast<float>(M_PI) * d_theta / 180.0f;
  r_size_ = static_cast<int>(
      2 * sqrtf(static_cast<float>(img_w_ * img_w_ + img_h_ * img_h_)) / d_r_);
  theta_size_ = static_cast<int>(M_PI / d_theta_);
 
  ClearWithShrink();
  // init vote map
  vote_map_.resize(r_size_ * theta_size_, 0);
  // init query map
  query_map_.resize(img_w_ * img_h_);
  for (auto& query : query_map_) {
    query.resize(theta_size_, 0);
  }
 
  for (int theta_idx = 0; theta_idx < theta_size_; ++theta_idx) {
    float cur_theta = d_theta_ * static_cast<float>(theta_idx);
    for (int img_pos = 0; img_pos < img_w_ * img_h_; ++img_pos) {
      int w = img_pos % img_w_;
      int h = img_pos / img_w_;
      int r =
          static_cast<int>((cos(cur_theta) * w + sin(cur_theta) * h) / d_r_) +
          r_size_ / 2;
      if (0 <= r && r < r_size_) {
        query_map_[img_pos][theta_idx] = r * theta_size_ + theta_idx;
      }
    }
  }
  // init distribute map
  distribute_map_.resize(r_size_ * theta_size_);
  for (auto& distribute : distribute_map_) {
    distribute.reserve(vote_reserve_size_);
  }
 
  if (CheckPrepared()) {
    prepared_ = true;
  } else {
    ClearWithShrink();
    prepared_ = false;
  }
  return prepared_;
}

is_prepared()

bool apollo::perception::algorithm::HoughTransfer::is_prepared ( ) const

inline

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

{ return prepared_; }

MemoryConsume()

unsigned int apollo::perception::algorithm::HoughTransfer::MemoryConsume

(

)

const

在文件 hough_transfer.cc 第 158 行定义.

                                                {
  unsigned int size = 0;
  if (is_prepared()) {
    size +=
        static_cast<unsigned int>(vote_map_.capacity() * sizeof(vote_map_[0]));
    size += static_cast<unsigned int>(query_map_.capacity() *
                                      sizeof(query_map_[0]));
    size += static_cast<unsigned int>(theta_size_ * query_map_.size() *
                                      sizeof(query_map_[0][0]));
    size += static_cast<unsigned int>(distribute_map_.capacity() *
                                      sizeof(distribute_map_[0]));
    for (const auto& distribute : distribute_map_) {
      size += static_cast<unsigned int>(distribute.capacity() *
                                        sizeof(distribute[0]));
    }
  }
  return size;
}

name()

std::string apollo::perception::algorithm::HoughTransfer::name ( ) const

inline

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

{ return "HoughTransfer"; }

PointVote() [1/2]

void apollo::perception::algorithm::HoughTransfer::PointVote	(	int	pos,
		bool	with_distribute
	)

在文件 hough_transfer.cc 第 117 行定义.

                                                           {
  for (int theta_idx = 0; theta_idx < theta_size_; ++theta_idx) {
    ++vote_map_[query_map_[pos][theta_idx]];
    if (with_distribute) {
      distribute_map_[query_map_[pos][theta_idx]].push_back(pos);
    }
  }
}

PointVote() [2/2]

void apollo::perception::algorithm::HoughTransfer::PointVote	(	int	x,
		int	y,
		bool	with_distribute
	)

在文件 hough_transfer.cc 第 111 行定义.

                                                                {
  const int pos = y * img_w_ + x;
  PointVote(pos, with_distribute);
}

ResetMaps()

void apollo::perception::algorithm::HoughTransfer::ResetMaps

(

bool

with_distribute

)

在文件 hough_transfer.cc 第 186 行定义.

                                                  {
  memset(vote_map_.data(), 0, vote_map_.size() * sizeof(vote_map_[0]));
  if (with_distribute) {
    for (auto& distribute : distribute_map_) {
      distribute.clear();
    }
  }
}

---

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

• modules/perception/common/algorithm/image_processing/hough_transfer.h
• modules/perception/common/algorithm/image_processing/hough_transfer.cc