apollo::perception::camera::ObjMapper类 参考

#include <obj_mapper.h>

apollo::perception::camera::ObjMapper 的协作图:

Public 成员函数
	ObjMapper ()
	~ObjMapper ()=default
void	set_default_variance ()
	Set the default variance object
void	Init (const float *k_mat, int width, int height)
	Init for ObjectTemplateManager
void	resize_ry_score (int size)
	Split the ry_score_ accoring to the specified nr_bins_ry.
std::vector< float >	get_ry_score ()
	Get the ry score object
std::vector< float >	get_ry_score (float ry)
	Get the ry score object
Eigen::Vector3d	get_orientation_var ()
	Get the orientation var object
Eigen::Matrix3d	get_position_uncertainty ()
	Get the position uncertainty object
bool	Solve3dBbox (const ObjMapperOptions &options, float center[3], float hwl[3], float *ry)
	Calculate 3d result

Protected 属性
ObjectTemplateManager *	object_template_manager_ = nullptr

详细描述

在文件 obj_mapper.h 第 68 行定义.

构造及析构函数说明

ObjMapper()

apollo::perception::camera::ObjMapper::ObjMapper ( )

inline

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

              : width_(0), height_(0) {
    memset(k_mat_, 0, sizeof(float) * 9);
    resize_ry_score(params_.nr_bins_ry);
    set_default_variance();
  }

~ObjMapper()

apollo::perception::camera::ObjMapper::~ObjMapper ( )

default

成员函数说明

get_orientation_var()

Eigen::Vector3d apollo::perception::camera::ObjMapper::get_orientation_var ( )

inline

Get the orientation var object

返回

Eigen::Vector3d

在文件 obj_mapper.h 第 126 行定义.

{ return orientation_variance_; }

get_position_uncertainty()

Eigen::Matrix3d apollo::perception::camera::ObjMapper::get_position_uncertainty ( )

inline

Get the position uncertainty object

返回

Eigen::Matrix3d

在文件 obj_mapper.h 第 132 行定义.

{ return position_uncertainty_; }

get_ry_score() [1/2]

std::vector< float > apollo::perception::camera::ObjMapper::get_ry_score ( )

inline

Get the ry score object

返回

std::vector<float>

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

{ return ry_score_; }

get_ry_score() [2/2]

std::vector< float > apollo::perception::camera::ObjMapper::get_ry_score ( float  ry )

inline

Get the ry score object

参数

ry

返回

std::vector<float>

在文件 obj_mapper.h 第 117 行定义.

                                          {
    FillRyScoreSingleBin(ry);
    return ry_score_;
  }

Init()

void apollo::perception::camera::ObjMapper::Init ( const float *  k_mat, int  width, int  height  )

inline

Init for ObjectTemplateManager

参数

k_mat	K matrix
width	width of image
height	height of image

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

                                                       {
    memcpy(k_mat_, k_mat, sizeof(float) * 9);
    width_ = width;
    height_ = height;
    object_template_manager_ = ObjectTemplateManager::Instance();
  }

resize_ry_score()

void apollo::perception::camera::ObjMapper::resize_ry_score ( int  size )

inline

Split the ry_score_ accoring to the specified nr_bins_ry.

参数

size

在文件 obj_mapper.h 第 104 行定义.

{ ry_score_.resize(size); }

set_default_variance()

void apollo::perception::camera::ObjMapper::set_default_variance ( )

inline

Set the default variance object

在文件 obj_mapper.h 第 81 行定义.

                              {
    orientation_variance_(0) = 1.0f;
    orientation_variance_(1) = orientation_variance_(2) = 0.0f;
    position_uncertainty_ << 1, 0, 0, 0, 0, 0, 0, 0, 1;
  }

Solve3dBbox()

bool apollo::perception::camera::ObjMapper::Solve3dBbox	(	const ObjMapperOptions &	options,
		float	center[3],
		float	hwl[3],
		float *	ry
	)

Calculate 3d result

参数

options	options contains hyper parameters
center	3d center of the object
hwl	3d w h l of the object
ry	rotation y of the object

返回

true

false

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

                                                     {
  // set default value for variance
  set_default_variance();
  float var_yaw = 0.0f;
  float var_z = 0.0f;
 
  // get input from options
  memcpy(hwl, options.hwl, sizeof(float) * 3);
  float bbox[4] = {0};
  memcpy(bbox, options.bbox, sizeof(float) * 4);
  *ry = options.ry;
  bool check_dimension = options.check_dimension;
  int type_min_vol_index = options.type_min_vol_index;
 
  // check input hwl insanity
  if (options.is_veh && check_dimension) {
    assert(type_min_vol_index >= 0);
    const std::vector<float> &kVehHwl = object_template_manager_->VehHwl();
    const float *tmplt_with_min_vol = &kVehHwl[type_min_vol_index];
    float min_tmplt_vol =
        tmplt_with_min_vol[0] * tmplt_with_min_vol[1] * tmplt_with_min_vol[2];
    float shrink_ratio_vol = algorithm::ISqr(sqrtf(params_.iou_high));
    shrink_ratio_vol *= shrink_ratio_vol;
    // float shrink_ratio_vol = sqrt(params_.iou_high);
    if (hwl[0] < params_.abnormal_h_veh ||
        hwl[0] * hwl[1] * hwl[2] < min_tmplt_vol * shrink_ratio_vol) {
      memcpy(hwl, tmplt_with_min_vol, sizeof(float) * 3);
    } else {
      float hwl_tmplt[3] = {hwl[0], hwl[1], hwl[2]};
      int tmplt_index = -1;
      float score = object_template_manager_->VehObjHwlBySearchTemplates(
          hwl_tmplt, &tmplt_index);
      float thres_min_score = shrink_ratio_vol;
 
      const int kNrDimPerTmplt = object_template_manager_->NrDimPerTmplt();
      bool search_success = score > thres_min_score;
      bool is_same_type = (type_min_vol_index / kNrDimPerTmplt) == tmplt_index;
      const std::map<TemplateIndex, int> &kLookUpTableMinVolumeIndex =
          object_template_manager_->LookUpTableMinVolumeIndex();
      bool is_car_pred =
          type_min_vol_index ==
          kLookUpTableMinVolumeIndex.at(TemplateIndex::CAR_MIN_VOLUME_INDEX);
 
      bool hwl_is_reliable = search_success && is_same_type;
      if (hwl_is_reliable) {
        memcpy(hwl, hwl_tmplt, sizeof(float) * 3);
      } else if (is_car_pred) {
        const float *tmplt_with_median_vol =
            tmplt_with_min_vol + kNrDimPerTmplt;
        memcpy(hwl, tmplt_with_median_vol, sizeof(float) * 3);
      }
    }
  }
 
  // call 3d solver
  bool success =
      Solve3dBboxGivenOneFullBboxDimensionOrientation(bbox, hwl, ry, center);
 
  // calculate variance for yaw & z
  float yaw_score_mean =
      algorithm::IMean(ry_score_.data(), static_cast<int>(ry_score_.size()));
  float yaw_score_sdv = algorithm::ISdv(ry_score_.data(), yaw_score_mean,
                                        static_cast<int>(ry_score_.size()));
  var_yaw =
      algorithm::ISqrt(algorithm::IRec(yaw_score_sdv + params_.eps_mapper));
 
  float z = center[2];
  float rz = z * params_.rz_ratio;
  float nr_bins_z = static_cast<float>(params_.nr_bins_z);
  std::vector<float> buffer(static_cast<size_t>(2 * nr_bins_z), 0);
  float *score_z = buffer.data();
  float dz = 2 * rz / nr_bins_z;
  float z_start = std::max(z - rz, params_.depth_min);
  float z_end = z + rz;
  int count_z_test = 0;
  for (float z_test = z_start; z_test <= z_end; z_test += dz) {
    float center_test[3] = {center[0], center[1], center[2]};
    float sf = z_test * algorithm::IRec(center_test[2]);
    algorithm::IScale3(center_test, sf);
    float score_test = GetProjectionScore(*ry, bbox, hwl, center_test);
    score_z[count_z_test++] = score_test;
  }
  float z_score_mean = algorithm::IMean(score_z, count_z_test);
  float z_score_sdv = algorithm::ISdv(score_z, z_score_mean, count_z_test);
  var_z = algorithm::ISqr(algorithm::IRec(z_score_sdv + params_.eps_mapper));
 
  // fill the position_uncertainty_ and orientation_variance_
  orientation_variance_(0) = var_yaw;
  float bbox_cx = (bbox[0] + bbox[2]) / 2;
  float focal = (k_mat_[0] + k_mat_[4]) / 2;
  float sf_z_to_x = fabsf(bbox_cx - k_mat_[2]) * algorithm::IRec(focal);
  float var_x = var_z * algorithm::ISqr(sf_z_to_x);
  float var_xz = sf_z_to_x * var_z;
  position_uncertainty_(0, 0) = var_x;
  position_uncertainty_(2, 2) = var_z;
  position_uncertainty_(0, 2) = position_uncertainty_(2, 0) = var_xz;
  return success;
}

类成员变量说明

object_template_manager_

ObjectTemplateManager* apollo::perception::camera::ObjMapper::object_template_manager_ = nullptr

protected

在文件 obj_mapper.h 第 296 行定义.

---

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

• modules/perception/camera_location_estimation/transformer/multicue/obj_mapper.h
• modules/perception/camera_location_estimation/transformer/multicue/obj_mapper.cc