apollo::perception::lidar::TrackedObject结构体 参考

#include <tracked_object.h>

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

Public 成员函数
	TrackedObject ()=default
	TrackedObject (base::ObjectPtr obj_ptr, const Eigen::Affine3d &pose)
	TrackedObject (const TrackedObject &rhs)=default
TrackedObject &	operator= (const TrackedObject &rhs)=default
void	Reset ()
	Reset all data
void	Reset (base::ObjectPtr obj_ptr, const Eigen::Affine3d &pose, const Eigen::Vector3d &global_to_local_offset=Eigen::Vector3d::Zero(), const base::SensorInfo &sensor=base::SensorInfo(), double timestamp=0.0)
	Reset all data
std::string	ToString () const
	Transform tracked data state to string
void	ComputeShapeFeatures ()
	Compute shape features
void	AttachObject (base::ObjectPtr obj_ptr, const Eigen::Affine3d &pose, const Eigen::Vector3d &global_to_local_offset=Eigen::Vector3d::Zero(), const base::SensorInfo &sensor=base::SensorInfo(), double timestamp=0.0)
	Attach object
void	TransformObjectCloudToWorld ()
	Transform object cloud to world
void	CopyFrom (std::shared_ptr< TrackedObject > rhs, bool is_deep)
	Copy from tracked object
void	ToObject (base::ObjectPtr obj_ptr) const
	Convert tracked object to base object
float	GetVelThreshold (base::ObjectPtr obj) const
	Get vehicle threshold

Public 属性
std::vector< float >	shape_features
std::vector< float >	shape_features_full
size_t	histogram_bin_size = 10
float	association_score = 0.0f
bool	is_fake = false
int	track_id = -1
double	tracking_time = 0.0
Eigen::Affine3d	sensor_to_local_pose
base::ObjectPtr	object_ptr
Eigen::Vector3d	corners [4]
Eigen::Vector3d	center
Eigen::Vector3d	barycenter
Eigen::Vector3d	anchor_point
Eigen::Vector3d	detection_center
Eigen::Vector3d	detection_corners [4]
Eigen::Vector3d	direction
Eigen::Vector3d	lane_direction
Eigen::Vector3d	size
base::ObjectType	type = base::ObjectType::UNKNOWN
std::vector< float >	type_probs
bool	is_background = false
double	timestamp = 0.0
Eigen::Vector3d	measured_barycenter_velocity
Eigen::Vector3d	measured_center_velocity
Eigen::Vector3d	measured_nearest_corner_velocity
Eigen::Vector3d	measured_corners_velocity [4]
Eigen::Vector3d	measured_history_corners_velocity [4]
Eigen::Vector3d	measured_history_center_velocity
Eigen::Vector3d	measured_detection_center_velocity
Eigen::Vector3d	measured_detection_history_center_velocity
Eigen::Vector3d	measured_detection_history_corners_velocity [4]
int	measured_big_velocity_age
int	boostup_need_history_size = 0
bool	valid = false
bool	converged = true
float	convergence_confidence = 0.0f
double	update_quality = 0.0
Eigen::Vector3d	selected_measured_velocity
Eigen::Vector3d	selected_measured_acceleration
Eigen::Vector3d	belief_anchor_point
Eigen::Vector3d	belief_velocity
Eigen::Vector3d	belief_acceleration
Eigen::Vector3d	belief_velocity_gain
Eigen::Matrix3d	velocity_covariance
Eigen::Matrix3d	belief_velocity_online_covariance
Eigen::Vector4d	state
Eigen::Matrix4d	measurement_covariance
Eigen::Matrix4d	state_covariance
Eigen::Vector3d	motion_score
Eigen::Vector3d	direction_state
Eigen::Matrix3d	direction_state_covariance
Eigen::Vector3d	output_angular
double	direction_convergence_confidence = 0.0
double	direction_converged = false
Eigen::Vector3d	output_velocity
Eigen::Matrix3d	output_velocity_uncertainty
Eigen::Vector3d	output_direction
Eigen::Vector3d	output_center
Eigen::Vector3d	output_size
base::SensorInfo	sensor_info
Eigen::Vector3d	global_local_offset

详细描述

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

构造及析构函数说明

TrackedObject() [1/3]

apollo::perception::lidar::TrackedObject::TrackedObject ( )

default

TrackedObject() [2/3]

apollo::perception::lidar::TrackedObject::TrackedObject	(	base::ObjectPtr	obj_ptr,
		const Eigen::Affine3d &	pose
	)

在文件 tracked_object.cc 第 32 行定义.

                                                        {
  AttachObject(obj_ptr, pose);
}

TrackedObject() [3/3]

apollo::perception::lidar::TrackedObject::TrackedObject ( const TrackedObject &  rhs )

default

成员函数说明

AttachObject()

void apollo::perception::lidar::TrackedObject::AttachObject	(	base::ObjectPtr	obj_ptr,
		const Eigen::Affine3d &	pose,
		const Eigen::Vector3d &	global_to_local_offset = Eigen::Vector3d::Zero(),
		const base::SensorInfo &	sensor = base::SensorInfo(),
		double	timestamp = 0.0
	)

Attach object

参数

obj_ptr
pose
global_to_local_offset
sensor

在文件 tracked_object.cc 第 37 行定义.

                                                   {
  if (obj_ptr) {
    // all state of input obj_ptr will not change except cloud world
    object_ptr = obj_ptr;
 
    sensor_to_local_pose = pose;
    global_local_offset = global_to_local_offset;
    // object info to tracked object
    center = pose * object_ptr->center;
    const PointFCloud& cloud = (object_ptr->lidar_supplement).cloud;
    barycenter = (algorithm::CalculateCentroid(cloud)).cast<double>();
    barycenter = pose * barycenter;
    anchor_point = barycenter;
 
    // object-detection center
    float detection_center_x = obj_ptr->lidar_supplement.detections[0];
    float detection_center_y = obj_ptr->lidar_supplement.detections[1];
    float detection_center_z = obj_ptr->lidar_supplement.detections[2];
    float detection_size_x = obj_ptr->lidar_supplement.detections[3];
    float detection_size_y = obj_ptr->lidar_supplement.detections[4];
    float detection_size_z = obj_ptr->lidar_supplement.detections[5];
    float detection_theta = obj_ptr->lidar_supplement.detections[6];
    Eigen::Vector3d model_center_lidar = Eigen::Vector3d(detection_center_x,
        detection_center_y, detection_center_z);
    detection_center = pose * model_center_lidar;
 
    // object-detection center/size/direction -> corners
    Eigen::Matrix<float, 8, 1> corners;
    algorithm::CalculateCornersFromCenter(
        detection_center_x, detection_center_y, detection_center_z,
        detection_size_x, detection_size_y, detection_size_z,
        detection_theta, &corners);
    for (size_t i = 0; i < 4; i++) {
        Eigen::Vector3d detection_cor = Eigen::Vector3d(
            static_cast<double>(corners[2 * i]),
            static_cast<double>(corners[2 * i + 1]), detection_center_z);
        detection_corners[i] = pose * detection_cor;
    }
 
    Eigen::Matrix3d rotation = pose.rotation();
    direction = rotation * object_ptr->direction.cast<double>();
    lane_direction = direction;
    size = object_ptr->size.cast<double>();
    type = object_ptr->type;
    type_probs = object_ptr->type_probs;
    is_background = object_ptr->lidar_supplement.is_background;
 
    base::PointDCloud& cloud_world = (object_ptr->lidar_supplement).cloud_world;
    cloud_world.clear();
    cloud_world.resize(cloud.size());
    for (size_t i = 0; i < cloud.size(); ++i) {
      Eigen::Vector3d pt(cloud[i].x, cloud[i].y, cloud[i].z);
      Eigen::Vector3d pt_world = pose * pt;
      cloud_world[i].x = pt_world(0);
      cloud_world[i].y = pt_world(1);
      cloud_world[i].z = pt_world(2);
      cloud_world[i].intensity = cloud[i].intensity;
    }
    // memcpy(&(cloud_world.points_height(0)), &(cloud.points_height(0)),
    //        sizeof(float) * cloud.size());
    for (size_t i = 0; i < cloud.size(); ++i) {
      cloud_world.SetPointHeight(i, cloud.points_height(i));
    }
    // other belief information keep as Reset()
    selected_measured_velocity = Eigen::Vector3d::Zero();
    selected_measured_acceleration = Eigen::Vector3d::Zero();
    belief_anchor_point = barycenter;
    belief_velocity = Eigen::Vector3d::Zero();
    belief_acceleration = Eigen::Vector3d::Zero();
 
    direction_state = Eigen::Vector3d::Zero();
    direction_state_covariance = Eigen::Matrix3d::Zero();
    output_angular = Eigen::Vector3d::Zero();
    direction_convergence_confidence = 0.0;
    direction_converged = false;
 
    output_velocity = Eigen::Vector3d::Zero();
    output_velocity_uncertainty = Eigen::Matrix3d::Zero();
    output_direction = direction;
    output_center = center;
    output_size = size;
 
    sensor_info = sensor;
    this->timestamp = timestamp;
  }
}

ComputeShapeFeatures()

void apollo::perception::lidar::TrackedObject::ComputeShapeFeatures

(

)

Compute shape features

在文件 tracked_object.cc 第 296 行定义.

                                         {
  // Compute object's shape feature
  // 1. check whether shape feature is ready
  // 2. compute object's shape feature
  shape_features_full.resize(histogram_bin_size * 7);
  FeatureDescriptor fd(&(object_ptr->lidar_supplement.cloud));
  fd.ComputeHistogram(static_cast<int>(histogram_bin_size),
                      shape_features_full.data());
 
  size_t feature_len = histogram_bin_size * 3;
  shape_features.clear();
  shape_features.resize(feature_len);
  for (size_t i = 0; i < feature_len; ++i) {
    shape_features[i] = shape_features_full[i + 7];
  }
}

CopyFrom()

void apollo::perception::lidar::TrackedObject::CopyFrom	(	std::shared_ptr< TrackedObject >	rhs,
		bool	is_deep
	)

Copy from tracked object

参数

rhs
is_deep

GetVelThreshold()

float apollo::perception::lidar::TrackedObject::GetVelThreshold

(

base::ObjectPtr

obj

)

const

Get vehicle threshold

参数

obj

返回

float

在文件 tracked_object.cc 第 238 行定义.

                                                            {
  if (obj->type == base::ObjectType::VEHICLE) {
    return 0.99f;
  }
  return 0.0f;
}

operator=()

TrackedObject & apollo::perception::lidar::TrackedObject::operator= ( const TrackedObject &  rhs )

default

Reset() [1/2]

void apollo::perception::lidar::TrackedObject::Reset

(

)

Reset all data

在文件 tracked_object.cc 第 145 行定义.

                          {
  object_ptr.reset();
  sensor_to_local_pose = Eigen::Affine3d::Identity();
 
  // measurement reset
  for (int i = 0; i < 4; ++i) {
    corners[i] = Eigen::Vector3d::Zero();
    detection_corners[i] = Eigen::Vector3d::Zero();
    measured_corners_velocity[i] = Eigen::Vector3d::Zero();
    measured_history_corners_velocity[i] = Eigen::Vector3d::Zero();
    measured_detection_history_corners_velocity[i] = Eigen::Vector3d::Zero();
  }
  center = Eigen::Vector3d::Zero();
  barycenter = Eigen::Vector3d::Zero();
  anchor_point = Eigen::Vector3d::Zero();
  detection_center = Eigen::Vector3d::Zero();
  measured_barycenter_velocity = Eigen::Vector3d::Zero();
  measured_center_velocity = Eigen::Vector3d::Zero();
  measured_nearest_corner_velocity = Eigen::Vector3d::Zero();
  measured_history_center_velocity = Eigen::Vector3d::Zero();
  measured_detection_center_velocity = Eigen::Vector3d::Zero();
  measured_detection_history_center_velocity = Eigen::Vector3d::Zero();
  measured_big_velocity_age = 0;
  direction = Eigen::Vector3d::Zero();
  lane_direction = Eigen::Vector3d::Zero();
  size = Eigen::Vector3d::Zero();
  type = base::ObjectType::UNKNOWN;
  type_probs.assign(static_cast<int>(base::ObjectType::MAX_OBJECT_TYPE), 0.0f);
  is_background = false;
  shape_features.clear();
  shape_features_full.clear();
  histogram_bin_size = 10;
  association_score = 0.0;
  is_fake = false;
  track_id = -1;
  tracking_time = 0.0;
 
  // filter reset
  boostup_need_history_size = 0;
  valid = false;
  converged = true;
  convergence_confidence = 0.0;
  update_quality = 0.0;
  selected_measured_velocity = measured_center_velocity;
  selected_measured_acceleration = Eigen::Vector3d::Zero();
  belief_anchor_point = anchor_point;
  belief_velocity = selected_measured_velocity;
  belief_acceleration = selected_measured_acceleration;
  belief_velocity_gain = Eigen::Vector3d::Zero();
  velocity_covariance = Eigen::Matrix3d::Zero();
  belief_velocity_online_covariance = Eigen::Matrix3d::Zero();
 
  state = Eigen::Vector4d::Zero();
  measurement_covariance = Eigen::Matrix4d::Zero();
  state_covariance = Eigen::Matrix4d::Zero();
 
  motion_score = Eigen::Vector3d(1, 1, 1);
 
  direction_state = Eigen::Vector3d::Zero();
  direction_state_covariance = Eigen::Matrix3d::Zero();
  output_angular = Eigen::Vector3d::Zero();
  direction_convergence_confidence = 0.0;
  direction_converged = false;
 
  // output reset
  output_velocity = belief_velocity;
  output_velocity_uncertainty = belief_velocity_online_covariance;
  output_direction = direction;
  output_center = center;
  output_size = size;
 
  // sensor info reset
  sensor_info.Reset();
  timestamp = 0.0;
}

Reset() [2/2]

void apollo::perception::lidar::TrackedObject::Reset	(	base::ObjectPtr	obj_ptr,
		const Eigen::Affine3d &	pose,
		const Eigen::Vector3d &	global_to_local_offset = Eigen::Vector3d::Zero(),
		const base::SensorInfo &	sensor = base::SensorInfo(),
		double	timestamp = 0.0
	)

Reset all data

参数

obj_ptr
pose
global_to_local_offset
sensor

在文件 tracked_object.cc 第 221 行定义.

                                                                          {
  Reset();
  AttachObject(obj_ptr, pose, global_to_local_offset, sensor, timestamp);
}

ToObject()

void apollo::perception::lidar::TrackedObject::ToObject

(

base::ObjectPtr

obj_ptr

)

const

Convert tracked object to base object

参数

obj_ptr

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

                                                    {
  *obj = *object_ptr;
  // obj id keep default
  // obj polygon calculate outside, because
  /* 1. if ConvexHull2D as member variable:
           constructor time consume a little large
     2. if ConvexHull2D as static or global variable:
           need mutex time consume in multi threads
     what a pity!
  */
  obj->direction = output_direction.cast<float>();
  // obj theta_variance not calculate in tracker, keep default
  obj->center = output_center;
  // obj center_uncertainty not calculate in tracker, keep default
  obj->size = output_size.cast<float>();
  // obj size_varuance not calculate in tracker, keep default
  obj->anchor_point = belief_anchor_point;
  obj->type = type;
  // obj type_probs calculate in tracker
  obj->type_probs = type_probs;
  // obj confidence not calculate in tracker, keep default
  obj->track_id = track_id;
  obj->velocity = output_velocity.cast<float>();
  obj->velocity_uncertainty = output_velocity_uncertainty.cast<float>();
  obj->velocity_converged = converged;
  obj->tracking_time = tracking_time;
  if (obj->velocity.norm() > GetVelThreshold(obj)) {
    obj->theta = std::atan2(obj->velocity[1], obj->velocity[0]);
  } else {
    obj->theta = std::atan2(obj->direction[1], obj->direction[0]);
  }
  // obj latest_tracked_time not calculate in tracker, keep default
  // obj car_light not calculate in tracker, keep default
  // obj lidar_supplement cloud_world has passed in *obj = *object_ptr
  // obj lidar_supplement other elements not calculate in tracker, keep default
  // obj radar_supplement not calculate in tracker, keep default
  // obj camera_supplement not calculate in tracker, keep default
}

ToString()

std::string apollo::perception::lidar::TrackedObject::ToString

(

)

const

Transform tracked data state to string

返回

std::string

在文件 tracked_object.cc 第 284 行定义.

                                        {
  // std::string txt;
  // return txt;
  std::ostringstream oos;
  oos << "obj id: " << object_ptr->id << ", track_id: " << object_ptr->track_id
      << ", bary_center: (" << barycenter[0] << "," << barycenter[1] << ","
      << barycenter[2] << ")"
      << ", lane_direction: (" << lane_direction[0] << "," << lane_direction[1]
      << "," << lane_direction[2] << ")";
  return oos.str();
}

TransformObjectCloudToWorld()

void apollo::perception::lidar::TrackedObject::TransformObjectCloudToWorld

(

)

Transform object cloud to world

在文件 tracked_object.cc 第 128 行定义.

                                                {
  const base::PointFCloud& cloud = (object_ptr->lidar_supplement).cloud;
  base::PointDCloud& cloud_world = (object_ptr->lidar_supplement).cloud_world;
  cloud_world.clear();
  cloud_world.resize(cloud.size());
  for (size_t i = 0; i < cloud.size(); ++i) {
    Eigen::Vector3d pt(cloud[i].x, cloud[i].y, cloud[i].z);
    Eigen::Vector3d pt_world = sensor_to_local_pose * pt;
    cloud_world[i].x = pt_world(0);
    cloud_world[i].y = pt_world(1);
    cloud_world[i].z = pt_world(2);
    cloud_world[i].intensity = cloud[i].intensity;
  }
  memcpy(&cloud_world.points_height(0), &cloud.points_height(0),
         sizeof(float) * cloud.size());
}

类成员变量说明

anchor_point

Eigen::Vector3d apollo::perception::lidar::TrackedObject::anchor_point

在文件 tracked_object.h 第 141 行定义.

association_score

float apollo::perception::lidar::TrackedObject::association_score = 0.0f

在文件 tracked_object.h 第 119 行定义.

barycenter

Eigen::Vector3d apollo::perception::lidar::TrackedObject::barycenter

在文件 tracked_object.h 第 140 行定义.

belief_acceleration

Eigen::Vector3d apollo::perception::lidar::TrackedObject::belief_acceleration

在文件 tracked_object.h 第 185 行定义.

belief_anchor_point

Eigen::Vector3d apollo::perception::lidar::TrackedObject::belief_anchor_point

在文件 tracked_object.h 第 183 行定义.

belief_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::belief_velocity

在文件 tracked_object.h 第 184 行定义.

belief_velocity_gain

Eigen::Vector3d apollo::perception::lidar::TrackedObject::belief_velocity_gain

在文件 tracked_object.h 第 186 行定义.

belief_velocity_online_covariance

Eigen::Matrix3d apollo::perception::lidar::TrackedObject::belief_velocity_online_covariance

在文件 tracked_object.h 第 190 行定义.

boostup_need_history_size

int apollo::perception::lidar::TrackedObject::boostup_need_history_size = 0

在文件 tracked_object.h 第 176 行定义.

center

Eigen::Vector3d apollo::perception::lidar::TrackedObject::center

在文件 tracked_object.h 第 139 行定义.

converged

bool apollo::perception::lidar::TrackedObject::converged = true

在文件 tracked_object.h 第 178 行定义.

convergence_confidence

float apollo::perception::lidar::TrackedObject::convergence_confidence = 0.0f

在文件 tracked_object.h 第 179 行定义.

corners

Eigen::Vector3d apollo::perception::lidar::TrackedObject::corners[4]

在文件 tracked_object.h 第 138 行定义.

detection_center

Eigen::Vector3d apollo::perception::lidar::TrackedObject::detection_center

在文件 tracked_object.h 第 143 行定义.

detection_corners

Eigen::Vector3d apollo::perception::lidar::TrackedObject::detection_corners[4]

在文件 tracked_object.h 第 144 行定义.

direction

Eigen::Vector3d apollo::perception::lidar::TrackedObject::direction

在文件 tracked_object.h 第 147 行定义.

direction_converged

double apollo::perception::lidar::TrackedObject::direction_converged = false

在文件 tracked_object.h 第 213 行定义.

direction_convergence_confidence

double apollo::perception::lidar::TrackedObject::direction_convergence_confidence = 0.0

在文件 tracked_object.h 第 212 行定义.

direction_state

Eigen::Vector3d apollo::perception::lidar::TrackedObject::direction_state

在文件 tracked_object.h 第 208 行定义.

direction_state_covariance

Eigen::Matrix3d apollo::perception::lidar::TrackedObject::direction_state_covariance

在文件 tracked_object.h 第 209 行定义.

global_local_offset

Eigen::Vector3d apollo::perception::lidar::TrackedObject::global_local_offset

在文件 tracked_object.h 第 225 行定义.

histogram_bin_size

size_t apollo::perception::lidar::TrackedObject::histogram_bin_size = 10

在文件 tracked_object.h 第 116 行定义.

is_background

bool apollo::perception::lidar::TrackedObject::is_background = false

在文件 tracked_object.h 第 154 行定义.

is_fake

bool apollo::perception::lidar::TrackedObject::is_fake = false

在文件 tracked_object.h 第 124 行定义.

lane_direction

Eigen::Vector3d apollo::perception::lidar::TrackedObject::lane_direction

在文件 tracked_object.h 第 148 行定义.

measured_barycenter_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::measured_barycenter_velocity

在文件 tracked_object.h 第 161 行定义.

measured_big_velocity_age

int apollo::perception::lidar::TrackedObject::measured_big_velocity_age

在文件 tracked_object.h 第 170 行定义.

measured_center_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::measured_center_velocity

在文件 tracked_object.h 第 162 行定义.

measured_corners_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::measured_corners_velocity[4]

在文件 tracked_object.h 第 164 行定义.

measured_detection_center_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::measured_detection_center_velocity

在文件 tracked_object.h 第 167 行定义.

measured_detection_history_center_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::measured_detection_history_center_velocity

在文件 tracked_object.h 第 168 行定义.

measured_detection_history_corners_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::measured_detection_history_corners_velocity[4]

在文件 tracked_object.h 第 169 行定义.

measured_history_center_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::measured_history_center_velocity

在文件 tracked_object.h 第 166 行定义.

measured_history_corners_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::measured_history_corners_velocity[4]

在文件 tracked_object.h 第 165 行定义.

measured_nearest_corner_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::measured_nearest_corner_velocity

在文件 tracked_object.h 第 163 行定义.

measurement_covariance

Eigen::Matrix4d apollo::perception::lidar::TrackedObject::measurement_covariance

在文件 tracked_object.h 第 194 行定义.

motion_score

Eigen::Vector3d apollo::perception::lidar::TrackedObject::motion_score

在文件 tracked_object.h 第 203 行定义.

object_ptr

base::ObjectPtr apollo::perception::lidar::TrackedObject::object_ptr

在文件 tracked_object.h 第 136 行定义.

output_angular

Eigen::Vector3d apollo::perception::lidar::TrackedObject::output_angular

在文件 tracked_object.h 第 210 行定义.

output_center

Eigen::Vector3d apollo::perception::lidar::TrackedObject::output_center

在文件 tracked_object.h 第 221 行定义.

output_direction

Eigen::Vector3d apollo::perception::lidar::TrackedObject::output_direction

在文件 tracked_object.h 第 220 行定义.

output_size

Eigen::Vector3d apollo::perception::lidar::TrackedObject::output_size

在文件 tracked_object.h 第 222 行定义.

output_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::output_velocity

在文件 tracked_object.h 第 218 行定义.

output_velocity_uncertainty

Eigen::Matrix3d apollo::perception::lidar::TrackedObject::output_velocity_uncertainty

在文件 tracked_object.h 第 219 行定义.

selected_measured_acceleration

Eigen::Vector3d apollo::perception::lidar::TrackedObject::selected_measured_acceleration

在文件 tracked_object.h 第 182 行定义.

selected_measured_velocity

Eigen::Vector3d apollo::perception::lidar::TrackedObject::selected_measured_velocity

在文件 tracked_object.h 第 181 行定义.

sensor_info

base::SensorInfo apollo::perception::lidar::TrackedObject::sensor_info

在文件 tracked_object.h 第 223 行定义.

sensor_to_local_pose

Eigen::Affine3d apollo::perception::lidar::TrackedObject::sensor_to_local_pose

在文件 tracked_object.h 第 131 行定义.

shape_features

std::vector<float> apollo::perception::lidar::TrackedObject::shape_features

在文件 tracked_object.h 第 114 行定义.

shape_features_full

std::vector<float> apollo::perception::lidar::TrackedObject::shape_features_full

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

size

Eigen::Vector3d apollo::perception::lidar::TrackedObject::size

在文件 tracked_object.h 第 149 行定义.

state

Eigen::Vector4d apollo::perception::lidar::TrackedObject::state

在文件 tracked_object.h 第 193 行定义.

state_covariance

Eigen::Matrix4d apollo::perception::lidar::TrackedObject::state_covariance

在文件 tracked_object.h 第 195 行定义.

timestamp

double apollo::perception::lidar::TrackedObject::timestamp = 0.0

在文件 tracked_object.h 第 156 行定义.

track_id

int apollo::perception::lidar::TrackedObject::track_id = -1

在文件 tracked_object.h 第 125 行定义.

tracking_time

double apollo::perception::lidar::TrackedObject::tracking_time = 0.0

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

type

base::ObjectType apollo::perception::lidar::TrackedObject::type = base::ObjectType::UNKNOWN

在文件 tracked_object.h 第 151 行定义.

type_probs

std::vector<float> apollo::perception::lidar::TrackedObject::type_probs

在文件 tracked_object.h 第 153 行定义.

update_quality

double apollo::perception::lidar::TrackedObject::update_quality = 0.0

在文件 tracked_object.h 第 180 行定义.

valid

bool apollo::perception::lidar::TrackedObject::valid = false

在文件 tracked_object.h 第 177 行定义.

velocity_covariance

Eigen::Matrix3d apollo::perception::lidar::TrackedObject::velocity_covariance

在文件 tracked_object.h 第 189 行定义.

---

该结构体的文档由以下文件生成:

• modules/perception/lidar_tracking/tracker/common/tracked_object.h
• modules/perception/lidar_tracking/tracker/common/tracked_object.cc