apollo::perception::fusion::TrackObjectDistance类 参考

#include <track_object_distance.h>

apollo::perception::fusion::TrackObjectDistance 的协作图:

Public 类型
template<class EigenType >
using	EigenVector = apollo::common::EigenVector< EigenType >

Public 成员函数
	TrackObjectDistance ()=default
	~TrackObjectDistance ()=default
void	set_distance_thresh (const float distance_thresh)
	Set the distance thresh
void	ResetProjectionCache (std::string sensor_id, double timestamp)
float	Compute (const TrackPtr &fused_track, const SensorObjectPtr &sensor_object, const TrackObjectDistanceOptions &options)
double	ComputeLidarCameraSimilarity (const SensorObjectConstPtr &lidar, const SensorObjectConstPtr &camera, const bool measurement_is_lidar)
double	ComputeRadarCameraSimilarity (const SensorObjectConstPtr &radar, const SensorObjectConstPtr &camera)

Protected 成员函数
float	ComputeLidarLidar (const SensorObjectConstPtr &fused_object, const SensorObjectPtr &sensor_object, const Eigen::Vector3d &ref_pos, int range=3)
float	ComputeLidarRadar (const SensorObjectConstPtr &fused_object, const SensorObjectPtr &sensor_object, const Eigen::Vector3d &ref_pos, int range=3)
float	ComputeRadarRadar (const SensorObjectConstPtr &fused_object, const SensorObjectPtr &sensor_object, const Eigen::Vector3d &ref_pos, int range=3)
float	ComputeLidarCamera (const SensorObjectConstPtr &lidar, const SensorObjectConstPtr &camera, const bool measurement_is_lidar, const bool is_track_id_consistent)
float	ComputeRadarCamera (const SensorObjectConstPtr &radar, const SensorObjectConstPtr &camera)
float	ComputeCameraCamera (const SensorObjectPtr &fused_camera, const SensorObjectPtr &sensor_camera)
float	ComputePolygonDistance3d (const SensorObjectConstPtr &fused_object, const SensorObjectPtr &sensor_object, const Eigen::Vector3d &ref_pos, int range)
float	ComputeEuclideanDistance (const Eigen::Vector3d &des, const Eigen::Vector3d &src)
bool	ComputePolygonCenter (const base::PolygonDType &polygon, Eigen::Vector3d *center)
bool	ComputePolygonCenter (const base::PolygonDType &polygon, const Eigen::Vector3d &ref_pos, int range, Eigen::Vector3d *center)

详细描述

在文件 track_object_distance.h 第 41 行定义.

成员类型定义说明

EigenVector

template<class EigenType >

using apollo::perception::fusion::TrackObjectDistance::EigenVector = apollo::common::EigenVector<EigenType>

在文件 track_object_distance.h 第 44 行定义.

构造及析构函数说明

TrackObjectDistance()

apollo::perception::fusion::TrackObjectDistance::TrackObjectDistance ( )

default

~TrackObjectDistance()

apollo::perception::fusion::TrackObjectDistance::~TrackObjectDistance ( )

default

成员函数说明

Compute()

float apollo::perception::fusion::TrackObjectDistance::Compute	(	const TrackPtr &	fused_track,
		const SensorObjectPtr &	sensor_object,
		const TrackObjectDistanceOptions &	options
	)

在文件 track_object_distance.cc 第 305 行定义.

                                                                              {
  FusedObjectPtr fused_object = fused_track->GetFusedObject();
  if (fused_object == nullptr) {
    AERROR << "fused object is nullptr";
    return (std::numeric_limits<float>::max)();
  }
  Eigen::Vector3d* ref_point = options.ref_point;
  if (ref_point == nullptr) {
    AERROR << "reference point is nullptr";
    return (std::numeric_limits<float>::max)();
  }
  float distance = (std::numeric_limits<float>::max)();
  float min_distance = (std::numeric_limits<float>::max)();
  SensorObjectConstPtr lidar_object = fused_track->GetLatestLidarObject();
  SensorObjectConstPtr radar_object = fused_track->GetLatestRadarObject();
  SensorObjectConstPtr camera_object = fused_track->GetLatestCameraObject();
  if (IsLidar(sensor_object)) {
    if (lidar_object != nullptr) {
      distance = ComputeLidarLidar(lidar_object, sensor_object, *ref_point);
      min_distance = std::min(distance, min_distance);
    }
    if (radar_object != nullptr) {
      distance = ComputeLidarRadar(radar_object, sensor_object, *ref_point);
      min_distance = std::min(distance, min_distance);
    }
    if (camera_object != nullptr) {
      bool is_lidar_track_id_consistent =
          IsTrackIdConsistent(lidar_object, sensor_object);
      distance = ComputeLidarCamera(sensor_object, camera_object, true,
                                    is_lidar_track_id_consistent);
      min_distance = std::min(distance, min_distance);
    }
  } else if (IsRadar(sensor_object)) {
    if (lidar_object != nullptr) {
      distance = ComputeLidarRadar(lidar_object, sensor_object, *ref_point);
      min_distance = std::min(distance, min_distance);
    }
    if (radar_object != nullptr) {
      distance = ComputeRadarRadar(radar_object, sensor_object, *ref_point);
      min_distance = std::min(distance, min_distance);
    }
    if (camera_object != nullptr) {
      distance = ComputeRadarCamera(sensor_object, camera_object);
      min_distance = std::min(distance, min_distance);
    }
  } else if (IsCamera(sensor_object)) {
    if (lidar_object != nullptr) {
      bool is_camera_track_id_consistent =
          IsTrackIdConsistent(camera_object, sensor_object);
      distance = ComputeLidarCamera(lidar_object, sensor_object, false,
                                    is_camera_track_id_consistent);
      min_distance = std::min(distance, min_distance);
    }
  } else {
    AERROR << "fused sensor type is not support";
  }
  return min_distance;
}

ComputeCameraCamera()

float apollo::perception::fusion::TrackObjectDistance::ComputeCameraCamera ( const SensorObjectPtr &  fused_camera, const SensorObjectPtr &  sensor_camera  )

protected

在文件 track_object_distance.cc 第 603 行定义.

                                                                               {
  return (std::numeric_limits<float>::max());
}

ComputeEuclideanDistance()

float apollo::perception::fusion::TrackObjectDistance::ComputeEuclideanDistance ( const Eigen::Vector3d &  des, const Eigen::Vector3d &  src  )

protected

在文件 track_object_distance.cc 第 749 行定义.

                                                        {
  Eigen::Vector3d diff_pos = des - src;
  float distance = static_cast<float>(
      std::sqrt(diff_pos.head(2).cwiseProduct(diff_pos.head(2)).sum()));
  return distance;
}

ComputeLidarCamera()

float apollo::perception::fusion::TrackObjectDistance::ComputeLidarCamera ( const SensorObjectConstPtr &  lidar, const SensorObjectConstPtr &  camera, const bool  measurement_is_lidar, const bool  is_track_id_consistent  )

protected

在文件 track_object_distance.cc 第 441 行定义.

                                                                        {
  if (!is_track_id_consistent) {
    if (LidarCameraCenterDistanceExceedDynamicThreshold(lidar, camera)) {
      return distance_thresh_;
    }
  }
  float distance = distance_thresh_;
  // 1. get camera intrinsic and pose
  base::BaseCameraModelPtr camera_model = QueryCameraModel(camera);
  if (camera_model == nullptr) {
    AERROR << "Failed to get camera model for " << camera->GetSensorId();
    return distance;
  }
  Eigen::Matrix4d world2camera_pose;
  if (!QueryWorld2CameraPose(camera, &world2camera_pose)) {
    AERROR << "Failed to query camera pose";
    return distance;
  }
  Eigen::Matrix4d lidar2world_pose;
  if (!QueryLidar2WorldPose(lidar, &lidar2world_pose)) {
    AERROR << "Failed to query lidar pose";
    return distance;
  }
  Eigen::Matrix4d lidar2camera_pose =
      static_cast<Eigen::Matrix<double, 4, 4, 0, 4, 4>>(world2camera_pose *
                                                        lidar2world_pose);
  // 2. compute distance of camera vs. lidar observation
  const base::PointFCloud& cloud =
      lidar->GetBaseObject()->lidar_supplement.cloud;
  const base::BBox2DF& camera_bbox =
      camera->GetBaseObject()->camera_supplement.box;
  const base::Point2DF camera_bbox_ct = camera_bbox.Center();
  const Eigen::Vector2d box2d_ct =
      Eigen::Vector2d(camera_bbox_ct.x, camera_bbox_ct.y);
  ADEBUG << "object cloud size : " << cloud.size();
  if (cloud.size() > 0) {
    // 2.1 if cloud is not empty, calculate distance according to pts box
    // similarity
    ProjectionCacheObject* cache_object = QueryProjectionCacheObject(
        lidar, camera, camera_model, measurement_is_lidar);
    if (cache_object == nullptr) {
      AERROR << "Failed to query projection cached object";
      return distance;
    }
    double similarity =
        ComputePtsBoxSimilarity(&projection_cache_, cache_object, camera_bbox);
    distance =
        distance_thresh_ * ((1.0f - static_cast<float>(similarity)) /
                            (1.0f - vc_similarity2distance_penalize_thresh_));
  } else {
    // 2.2 if cloud is empty, calculate distance according to ct diff
    Eigen::Vector3d projected_velo_ct;
    QueryProjectedVeloCtOnCamera(lidar, camera, lidar2camera_pose,
                                 &projected_velo_ct);
    if (projected_velo_ct[2] > 0) {
      Eigen::Vector2f project_pt2f = camera_model->Project(
          Eigen::Vector3f(static_cast<float>(projected_velo_ct[0]),
                          static_cast<float>(projected_velo_ct[1]),
                          static_cast<float>(projected_velo_ct[2])));
      Eigen::Vector2d project_pt2d = project_pt2f.cast<double>();
      Eigen::Vector2d ct_diff = project_pt2d - box2d_ct;
      distance =
          static_cast<float>(ct_diff.norm()) * vc_diff2distance_scale_factor_;
    } else {
      distance = std::numeric_limits<float>::max();
    }
  }
  ADEBUG << "ComputeLidarCamera distance: " << distance;
  return distance;
}

ComputeLidarCameraSimilarity()

double apollo::perception::fusion::TrackObjectDistance::ComputeLidarCameraSimilarity	(	const SensorObjectConstPtr &	lidar,
		const SensorObjectConstPtr &	camera,
		const bool	measurement_is_lidar
	)

在文件 track_object_distance.cc 第 618 行定义.

                                     {
  double similarity = 0.0;
  // 1. get camera intrinsic and pose
  base::BaseCameraModelPtr camera_model = QueryCameraModel(camera);
  if (camera_model == nullptr) {
    AERROR << "Failed to get camera model for " << camera->GetSensorId();
    return similarity;
  }
  Eigen::Matrix4d world2camera_pose;
  if (!QueryWorld2CameraPose(camera, &world2camera_pose)) {
    return similarity;
  }
  Eigen::Matrix4d lidar2world_pose;
  if (!QueryLidar2WorldPose(lidar, &lidar2world_pose)) {
    return similarity;
  }
  // Eigen::Matrix4d lidar2camera_pose = world2camera_pose * lidar2world_pose;
  // 2. compute similarity of camera vs. velodyne64 observation
  const base::PointFCloud& cloud =
      lidar->GetBaseObject()->lidar_supplement.cloud;
  const base::BBox2DF& camera_bbox =
      camera->GetBaseObject()->camera_supplement.box;
  if (cloud.size() > 0) {
    ProjectionCacheObject* cache_object = QueryProjectionCacheObject(
        lidar, camera, camera_model, measurement_is_lidar);
    if (cache_object == nullptr) {
      return similarity;
    }
    similarity =
        ComputePtsBoxSimilarity(&projection_cache_, cache_object, camera_bbox);
  }
  return similarity;
}

ComputeLidarLidar()

float apollo::perception::fusion::TrackObjectDistance::ComputeLidarLidar ( const SensorObjectConstPtr &  fused_object, const SensorObjectPtr &  sensor_object, const Eigen::Vector3d &  ref_pos, int  range = 3  )

protected

在文件 track_object_distance.cc 第 369 行定义.

               {
  double center_distance = (sensor_object->GetBaseObject()->center -
                            fused_object->GetBaseObject()->center)
                               .head(2)
                               .norm();
  if (center_distance > s_lidar2lidar_association_center_dist_threshold_) {
    ADEBUG << "center distance exceed lidar2lidar tight threshold: "
           << "center_dist@" << center_distance << ", "
           << "tight_threh@"
           << s_lidar2lidar_association_center_dist_threshold_;
    return (std::numeric_limits<float>::max)();
  }
  float distance =
      ComputePolygonDistance3d(fused_object, sensor_object, ref_pos, range);
  ADEBUG << "ComputeLidarLidar distance: " << distance;
  return distance;
}

ComputeLidarRadar()

float apollo::perception::fusion::TrackObjectDistance::ComputeLidarRadar ( const SensorObjectConstPtr &  fused_object, const SensorObjectPtr &  sensor_object, const Eigen::Vector3d &  ref_pos, int  range = 3  )

protected

在文件 track_object_distance.cc 第 393 行定义.

               {
  double center_distance = (sensor_object->GetBaseObject()->center -
                            fused_object->GetBaseObject()->center)
                               .head(2)
                               .norm();
  if (center_distance > s_lidar2radar_association_center_dist_threshold_) {
    ADEBUG << "center distance exceed lidar2radar tight threshold: "
           << "center_dist@" << center_distance << ", "
           << "tight_threh@"
           << s_lidar2radar_association_center_dist_threshold_;
    return (std::numeric_limits<float>::max)();
  }
  float distance =
      ComputePolygonDistance3d(fused_object, sensor_object, ref_pos, range);
  ADEBUG << "ComputeLidarRadar distance: " << distance;
  return distance;
}

ComputePolygonCenter() [1/2]

bool apollo::perception::fusion::TrackObjectDistance::ComputePolygonCenter ( const base::PolygonDType &  polygon, const Eigen::Vector3d &  ref_pos, int  range, Eigen::Vector3d *  center  )

protected

在文件 track_object_distance.cc 第 777 行定义.

                                      {
  base::PolygonDType polygon_part;
  std::map<double, int> distance2idx;
  for (size_t idx = 0; idx < polygon.size(); ++idx) {
    const auto& point = polygon.at(idx);
    double distance =
        sqrt(pow(point.x - ref_pos(0), 2) + pow(point.y - ref_pos(1), 2));
    distance2idx.insert(std::make_pair(distance, idx));
  }
  int size = static_cast<int>(distance2idx.size());
  int nu = std::max(range, size / range + 1);
  nu = std::min(nu, size);
  int count = 0;
  std::map<double, int>::iterator it = distance2idx.begin();
  for (; it != distance2idx.end(), count < nu; ++it, ++count) {
    polygon_part.push_back(polygon[it->second]);
  }
  bool state = ComputePolygonCenter(polygon_part, center);
  return state;
}

ComputePolygonCenter() [2/2]

bool apollo::perception::fusion::TrackObjectDistance::ComputePolygonCenter ( const base::PolygonDType &  polygon, Eigen::Vector3d *  center  )

protected

在文件 track_object_distance.cc 第 759 行定义.

                                                            {
  int size = static_cast<int>(polygon.size());
  if (size == 0) {
    return false;
  }
  *center = Eigen::Vector3d(0, 0, 0);
  for (int i = 0; i < size; ++i) {
    const auto& point = polygon.at(i);
    (*center)[0] += point.x;
    (*center)[1] += point.y;
  }
  (*center) /= size;
  return true;
}

ComputePolygonDistance3d()

float apollo::perception::fusion::TrackObjectDistance::ComputePolygonDistance3d ( const SensorObjectConstPtr &  fused_object, const SensorObjectPtr &  sensor_object, const Eigen::Vector3d &  ref_pos, int  range  )

protected

在文件 track_object_distance.cc 第 723 行定义.

               {
  const base::ObjectConstPtr& obj_f = fused_object->GetBaseObject();
  Eigen::Vector3d fused_poly_center(0, 0, 0);
  if (!QueryPolygonDCenter(obj_f, ref_pos, range, &fused_poly_center)) {
    return (std::numeric_limits<float>::max());
  }
  const base::ObjectConstPtr obj_s = sensor_object->GetBaseObject();
  Eigen::Vector3d sensor_poly_center(0, 0, 0);
  if (!QueryPolygonDCenter(obj_s, ref_pos, range, &sensor_poly_center)) {
    return (std::numeric_limits<float>::max());
  }
  double fusion_timestamp = fused_object->GetTimestamp();
  double sensor_timestamp = sensor_object->GetTimestamp();
  double time_diff = sensor_timestamp - fusion_timestamp;
  fused_poly_center(0) += obj_f->velocity(0) * time_diff;
  fused_poly_center(1) += obj_f->velocity(1) * time_diff;
  float distance =
      ComputeEuclideanDistance(fused_poly_center, sensor_poly_center);
  return distance;
}

ComputeRadarCamera()

float apollo::perception::fusion::TrackObjectDistance::ComputeRadarCamera ( const SensorObjectConstPtr &  radar, const SensorObjectConstPtr &  camera  )

protected

在文件 track_object_distance.cc 第 517 行定义.

                                                                           {
  float distance = distance_thresh_;
  // 1. get camera model and pose
  base::BaseCameraModelPtr camera_model = QueryCameraModel(camera);
  if (camera_model == nullptr) {
    AERROR << "Failed to get camera model for " << camera->GetSensorId();
    return distance;
  }
  Eigen::Matrix4d world2camera_pose;
  if (!QueryWorld2CameraPose(camera, &world2camera_pose)) {
    return distance;
  }
  // get camera useful information
  const base::BBox2DF& camera_bbox =
      camera->GetBaseObject()->camera_supplement.box;
  const base::Point2DF camera_bbox_ct = camera_bbox.Center();
  const Eigen::Vector2d box2d_ct =
      Eigen::Vector2d(camera_bbox_ct.x, camera_bbox_ct.y);
  Eigen::Vector2d box2d_size = Eigen::Vector2d(
      camera_bbox.xmax - camera_bbox.xmin, camera_bbox.ymax - camera_bbox.ymin);
  Eigen::Vector2d rc_min_box_size(rc_min_box_size_[0], rc_min_box_size_[1]);
  box2d_size = box2d_size.cwiseMax(rc_min_box_size);
  double width = static_cast<double>(camera_model->get_width());
  double height = static_cast<double>(camera_model->get_height());
  // get radar useful information
  double time_diff = camera->GetTimestamp() - radar->GetTimestamp();
  Eigen::Vector3d offset =
      radar->GetBaseObject()->velocity.cast<double>() * time_diff;
  offset.setZero();
  Eigen::Vector3d radar_ct = radar->GetBaseObject()->center + offset;
  Eigen::Vector4d local_pt = static_cast<Eigen::Matrix<double, 4, 1, 0, 4, 1>>(
      world2camera_pose *
      Eigen::Vector4d(radar_ct[0], radar_ct[1], radar_ct[2], 1.0));
  EigenVector<Eigen::Vector3d> radar_box_vertices;
  GetObjectEightVertices(radar->GetBaseObject(), &radar_box_vertices);
  EigenVector<Eigen::Vector2d> radar_box2d_vertices;
  GetModified2DRadarBoxVertices(radar_box_vertices, camera, camera_model,
                                world2camera_pose, &radar_box2d_vertices);
  // compute similarity
  double fused_similarity = 0.0;
  if (local_pt[2] > 0) {
    Eigen::Vector3f pt3f;
    pt3f << camera_model->Project(Eigen::Vector3f(
        static_cast<float>(local_pt[0]), static_cast<float>(local_pt[1]),
        static_cast<float>(local_pt[2]))),
        static_cast<float>(local_pt[2]);
    Eigen::Vector3d pt3d = pt3f.cast<double>();
    if (IsPtInFrustum(pt3d, width, height)) {
      // compute similarity on x direction
      double x_similarity = ComputeRadarCameraXSimilarity(
          pt3d.x(), box2d_ct.x(), box2d_size.x(), rc_x_similarity_params_);
      // compute similarity on y direction
      double y_similarity = ComputeRadarCameraYSimilarity(
          pt3d.y(), box2d_ct.y(), box2d_size.y(), rc_y_similarity_params_);
      // compute similarity on height
      // use camera car height to modify the radar location
      double h_similarity = ComputeRadarCameraHSimilarity(
          radar, camera, box2d_size.y(), radar_box2d_vertices,
          rc_h_similarity_params_);
      // compute similarity on width
      double w_similarity = ComputeRadarCameraWSimilarity(
          radar, width, box2d_size.x(), radar_box2d_vertices,
          rc_w_similarity_params_);
      // compute similarity on offset 3d
      double loc_similarity = ComputeRadarCameraLocSimilarity(
          radar_ct, camera, world2camera_pose, rc_loc_similarity_params_);
      // compute similarity on velocity
      double velocity_similarity =
          ComputeRadarCameraVelocitySimilarity(radar, camera);
      // fuse similarity
      std::vector<double> multiple_similarities = {
          x_similarity,        y_similarity, loc_similarity,
          velocity_similarity, h_similarity, w_similarity};
      fused_similarity = FuseMultipleProbabilities(multiple_similarities);
    }
  }
  distance = distance_thresh_ * static_cast<float>(1.0 - fused_similarity) /
             (1.0f - rc_similarity2distance_penalize_thresh_);
  ADEBUG << "ComputeRadarCamera distance: " << distance;
  return distance;
}

ComputeRadarCameraSimilarity()

double apollo::perception::fusion::TrackObjectDistance::ComputeRadarCameraSimilarity	(	const SensorObjectConstPtr &	radar,
		const SensorObjectConstPtr &	camera
	)

在文件 track_object_distance.cc 第 661 行定义.

                                                                           {
  double similarity = 0.0;
  // 1. get camera intrinsic and pose
  base::BaseCameraModelPtr camera_model = QueryCameraModel(camera);
  if (camera_model == nullptr) {
    AERROR << "Failed to get camera model for " << camera->GetSensorId();
    return similarity;
  }
  Eigen::Matrix4d world2camera_pose;
  if (!QueryWorld2CameraPose(camera, &world2camera_pose)) {
    return similarity;
  }
  // 2. get information of camera
  const base::BBox2DF& camera_bbox =
      camera->GetBaseObject()->camera_supplement.box;
  const base::Point2DF camera_bbox_ct = camera_bbox.Center();
  const Eigen::Vector2d box2d_ct =
      Eigen::Vector2d(camera_bbox_ct.x, camera_bbox_ct.y);
  Eigen::Vector2d box2d_size = Eigen::Vector2d(
      camera_bbox.xmax - camera_bbox.xmin, camera_bbox.ymax - camera_bbox.ymin);
  Eigen::Vector2d rc_min_box_size(rc_min_box_size_[0], rc_min_box_size_[1]);
  box2d_size = box2d_size.cwiseMax(rc_min_box_size);
  double width = static_cast<double>(camera_model->get_width());
  double height = static_cast<double>(camera_model->get_height());
  // 3. get information of radar
  Eigen::Vector3d radar_ct = radar->GetBaseObject()->center;
  Eigen::Vector4d local_pt = static_cast<Eigen::Matrix<double, 4, 1, 0, 4, 1>>(
      world2camera_pose *
      Eigen::Vector4d(radar_ct[0], radar_ct[1], radar_ct[2], 1.0));
  // 4. similarity computation
  Eigen::Vector3d camera_ct = camera->GetBaseObject()->center;
  Eigen::Vector3d camera_ct_c =
      (world2camera_pose * camera_ct.homogeneous()).head(3);
  double depth_diff = local_pt.z() - camera_ct_c.z();
  const double depth_diff_th = 0.1;
  depth_diff /= camera_ct_c.z();
  if (local_pt[2] > 0 && depth_diff > -depth_diff_th) {
    Eigen::Vector3f pt3f;
    pt3f << camera_model->Project(Eigen::Vector3f(
        static_cast<float>(local_pt[0]), static_cast<float>(local_pt[1]),
        static_cast<float>(local_pt[2]))),
        static_cast<float>(local_pt[2]);
    Eigen::Vector3d pt3d = pt3f.cast<double>();
    if (IsPtInFrustum(pt3d, width, height)) {
      rc_x_similarity_params_2_.welsh_loss_scale_ =
          rc_x_similarity_params_2_welsh_loss_scale_;
      // compute similarity on x direction
      double x_similarity = ComputeRadarCameraXSimilarity(
          pt3d.x(), box2d_ct.x(), box2d_size.x(), rc_x_similarity_params_2_);
      // compute similarity on y direction
      double y_similarity = ComputeRadarCameraXSimilarity(
          pt3d.y(), box2d_ct.y(), box2d_size.y(), rc_x_similarity_params_2_);
      std::vector<double> multiple_similarities = {x_similarity, y_similarity};
      similarity = FuseMultipleProbabilities(multiple_similarities);
    }
  }
  return similarity;
}

ComputeRadarRadar()

float apollo::perception::fusion::TrackObjectDistance::ComputeRadarRadar ( const SensorObjectConstPtr &  fused_object, const SensorObjectPtr &  sensor_object, const Eigen::Vector3d &  ref_pos, int  range = 3  )

protected

在文件 track_object_distance.cc 第 417 行定义.

               {
  double center_distance = (sensor_object->GetBaseObject()->center -
                            fused_object->GetBaseObject()->center)
                               .head(2)
                               .norm();
  if (center_distance > s_radar2radar_association_center_dist_threshold_) {
    ADEBUG << "center distance exceed radar2radar tight threshold: "
           << "center_dist@" << center_distance << ", "
           << "tight_threh@"
           << s_radar2radar_association_center_dist_threshold_;
    return (std::numeric_limits<float>::max)();
  }
  float distance =
      ComputePolygonDistance3d(fused_object, sensor_object, ref_pos, range);
  ADEBUG << "ComputeRadarRadar distance: " << distance;
  return distance;
}

ResetProjectionCache()

void apollo::perception::fusion::TrackObjectDistance::ResetProjectionCache ( std::string  sensor_id, double  timestamp  )

inline

参数

sensor_id
timestamp

在文件 track_object_distance.h 第 65 行定义.

                                                                   {
    projection_cache_.Reset(sensor_id, timestamp);
  }

set_distance_thresh()

void apollo::perception::fusion::TrackObjectDistance::set_distance_thresh ( const float  distance_thresh )

inline

Set the distance thresh

参数

distance_thresh

在文件 track_object_distance.h 第 55 行定义.

                                                        {
    distance_thresh_ = distance_thresh;
  }

---

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

• modules/perception/multi_sensor_fusion/fusion/data_association/hm_data_association/track_object_distance.h
• modules/perception/multi_sensor_fusion/fusion/data_association/hm_data_association/track_object_distance.cc