apollo::prediction::Obstacle类 参考

Prediction obstacle. 更多...

#include <obstacle.h>

apollo::prediction::Obstacle 的协作图:

Public 成员函数
	Obstacle ()=default
virtual	~Obstacle ()=default
	Destructor
void	SetJunctionAnalyzer (JunctionAnalyzer *junction_analyzer)
bool	Insert (const perception::PerceptionObstacle &perception_obstacle, const double timestamp, const int prediction_id)
	Insert a perception obstacle with its timestamp.
bool	InsertFeature (const Feature &feature)
	Insert a feature proto message.
void	ClearOldInformation ()
void	TrimHistory (const size_t remain_size)
perception::PerceptionObstacle::Type	type () const
	Get the type of perception obstacle's type.
bool	IsPedestrian () const
int	id () const
	Get the obstacle's ID.
double	timestamp () const
	Get the obstacle's timestamp.
bool	ReceivedOlderMessage (const double timestamp) const
const Feature &	feature (const size_t i) const
	Get the ith feature from latest to earliest.
Feature *	mutable_feature (const size_t i)
	Get a pointer to the ith feature from latest to earliest.
const Feature &	latest_feature () const
	Get the latest feature.
const Feature &	earliest_feature () const
	Get the earliest feature.
Feature *	mutable_latest_feature ()
	Get a pointer to the latest feature.
void	SetNearbyObstacles ()
	Set nearby obstacles.
size_t	history_size () const
	Get the number of historical features.
bool	IsStill ()
	Check if the obstacle is still.
bool	IsSlow ()
	Check if the obstacle is slow.
bool	IsOnLane () const
	Check if the obstacle is on any lane.
bool	ToIgnore ()
	Check if the obstacle can be ignored.
bool	IsNearJunction ()
	Check if the obstacle is near a junction.
bool	IsInJunction (const std::string &junction_id) const
	Check if the obstacle is a junction.
bool	IsCloseToJunctionExit () const
	Check if the obstacle is close to a junction exit.
bool	HasJunctionFeatureWithExits () const
	Check if the obstacle has junction feature.
void	BuildJunctionFeature ()
	Build junction feature.
void	BuildLaneGraph ()
	Build obstacle's lane graph
void	BuildLaneGraphFromLeftToRight ()
	Build obstacle's lane graph with lanes being ordered.
void	SetCaution ()
	Set the obstacle as caution level
bool	IsCaution () const
void	SetInteractiveTag ()
	Set the obstacle as interactive obstacle.
void	SetNonInteractiveTag ()
	Set the obstacle as noninteractive obstacle.
bool	IsInteractiveObstacle () const
void	SetEvaluatorType (const ObstacleConf::EvaluatorType &evaluator_type)
void	SetPredictorType (const ObstacleConf::PredictorType &predictor_type)
const ObstacleConf &	obstacle_conf ()
PredictionObstacle	GeneratePredictionObstacle ()

静态 Public 成员函数
static std::unique_ptr< Obstacle >	Create (const perception::PerceptionObstacle &perception_obstacle, const double timestamp, const int prediction_id, ObstacleClusters *clusters_ptr)
	Constructor
static std::unique_ptr< Obstacle >	Create (const Feature &feature, ObstacleClusters *clusters_ptr)

详细描述

Prediction obstacle.

在文件 obstacle.h 第 52 行定义.

构造及析构函数说明

Obstacle()

apollo::prediction::Obstacle::Obstacle ( )

default

~Obstacle()

virtual apollo::prediction::Obstacle::~Obstacle ( )

virtualdefault

Destructor

成员函数说明

BuildJunctionFeature()

void apollo::prediction::Obstacle::BuildJunctionFeature

(

)

Build junction feature.

在文件 obstacle.cc 第 242 行定义.

                                    {
  // If obstacle has no history at all, then exit.
  if (feature_history_.empty()) {
    AERROR << "Obstacle [" << id_ << "] has no history";
    return;
  }
  // If obstacle is not in the given junction, then exit.
  const std::string& junction_id = junction_analyzer_->GetJunctionId();
  if (!IsInJunction(junction_id)) {
    ADEBUG << "Obstacle [" << id_ << "] is not in junction [" << junction_id
           << "]";
    return;
  }
 
  // Set the junction features by calling SetJunctionFeatureWithoutEnterLane.
  Feature* latest_feature_ptr = mutable_latest_feature();
  if (feature_history_.size() == 1) {
    SetJunctionFeatureWithoutEnterLane(latest_feature_ptr);
    return;
  }
  const Feature& prev_feature = feature(1);
  if (prev_feature.junction_feature().has_enter_lane()) {
    ACHECK(prev_feature.junction_feature().enter_lane().has_lane_id());
    std::string enter_lane_id =
        prev_feature.junction_feature().enter_lane().lane_id();
    // TODO(all) use enter lane when tracking is better
    SetJunctionFeatureWithoutEnterLane(latest_feature_ptr);
  } else {
    SetJunctionFeatureWithoutEnterLane(latest_feature_ptr);
  }
}

BuildLaneGraph()

void apollo::prediction::Obstacle::BuildLaneGraph

(

)

Build obstacle's lane graph

在文件 obstacle.cc 第 804 行定义.

                              {
  // Sanity checks.
  if (history_size() == 0) {
    AERROR << "No feature found.";
    return;
  }
 
  Feature* feature = mutable_latest_feature();
  // No need to BuildLaneGraph for those non-moving obstacles.
  if (feature->is_still() && id_ != FLAGS_ego_vehicle_id) {
    ADEBUG << "Not build lane graph for still obstacle";
    return;
  }
  if (feature->lane().lane_graph().lane_sequence_size() > 0) {
    ADEBUG << "Not build lane graph for an old obstacle";
    return;
  }
  double speed = feature->speed();
  double t_max = FLAGS_prediction_trajectory_time_length;
  auto estimated_move_distance = speed * t_max;
 
  double road_graph_search_distance = std::fmax(
      estimated_move_distance, FLAGS_min_prediction_trajectory_spatial_length);
 
  bool is_in_junction = HasJunctionFeatureWithExits();
  std::unordered_set<std::string> exit_lane_id_set;
  if (is_in_junction) {
    for (const auto& exit : feature->junction_feature().junction_exit()) {
      exit_lane_id_set.insert(exit.exit_lane_id());
    }
  }
 
  // BuildLaneGraph for current lanes:
  // Go through all the LaneSegments in current_lane,
  // construct up to max_num_current_lane of them.
  int seq_id = 0;
  int curr_lane_count = 0;
  for (auto& lane : feature->lane().current_lane_feature()) {
    std::shared_ptr<const LaneInfo> lane_info =
        PredictionMap::LaneById(lane.lane_id());
    LaneGraph lane_graph = clusters_ptr_->GetLaneGraph(
        lane.lane_s(), road_graph_search_distance, true, lane_info);
    if (lane_graph.lane_sequence_size() > 0) {
      ++curr_lane_count;
    }
    for (const auto& lane_seq : lane_graph.lane_sequence()) {
      if (is_in_junction && !HasJunctionExitLane(lane_seq, exit_lane_id_set)) {
        continue;
      }
      LaneSequence* lane_seq_ptr =
          feature->mutable_lane()->mutable_lane_graph()->add_lane_sequence();
      lane_seq_ptr->CopyFrom(lane_seq);
      lane_seq_ptr->set_lane_sequence_id(seq_id++);
      lane_seq_ptr->set_lane_s(lane.lane_s());
      lane_seq_ptr->set_lane_l(lane.lane_l());
      lane_seq_ptr->set_vehicle_on_lane(true);
      lane_seq_ptr->set_lane_type(lane.lane_type());
      SetLaneSequenceStopSign(lane_seq_ptr);
      ADEBUG << "Obstacle [" << id_ << "] set a lane sequence ["
             << lane_seq.ShortDebugString() << "].";
    }
    if (curr_lane_count >= FLAGS_max_num_current_lane) {
      break;
    }
  }
 
  // BuildLaneGraph for neighbor lanes.
  int nearby_lane_count = 0;
  for (auto& lane : feature->lane().nearby_lane_feature()) {
    std::shared_ptr<const LaneInfo> lane_info =
        PredictionMap::LaneById(lane.lane_id());
    LaneGraph lane_graph = clusters_ptr_->GetLaneGraph(
        lane.lane_s(), road_graph_search_distance, false, lane_info);
    if (lane_graph.lane_sequence_size() > 0) {
      ++nearby_lane_count;
    }
    for (const auto& lane_seq : lane_graph.lane_sequence()) {
      if (is_in_junction && !HasJunctionExitLane(lane_seq, exit_lane_id_set)) {
        continue;
      }
      LaneSequence* lane_seq_ptr =
          feature->mutable_lane()->mutable_lane_graph()->add_lane_sequence();
      lane_seq_ptr->CopyFrom(lane_seq);
      lane_seq_ptr->set_lane_sequence_id(seq_id++);
      lane_seq_ptr->set_lane_s(lane.lane_s());
      lane_seq_ptr->set_lane_l(lane.lane_l());
      lane_seq_ptr->set_vehicle_on_lane(false);
      lane_seq_ptr->set_lane_type(lane.lane_type());
      SetLaneSequenceStopSign(lane_seq_ptr);
      ADEBUG << "Obstacle [" << id_ << "] set a lane sequence ["
             << lane_seq.ShortDebugString() << "].";
    }
    if (nearby_lane_count >= FLAGS_max_num_nearby_lane) {
      break;
    }
  }
 
  if (feature->has_lane() && feature->lane().has_lane_graph()) {
    SetLanePoints(feature);
    SetLaneSequencePath(feature->mutable_lane()->mutable_lane_graph());
  }
  ADEBUG << "Obstacle [" << id_ << "] set lane graph features.";
}

BuildLaneGraphFromLeftToRight()

void apollo::prediction::Obstacle::BuildLaneGraphFromLeftToRight

(

)

Build obstacle's lane graph with lanes being ordered.

This would be useful for lane-scanning algorithms.

在文件 obstacle.cc 第 981 行定义.

                                             {
  // Sanity checks.
  if (history_size() == 0) {
    AERROR << "No feature found.";
    return;
  }
 
  // No need to BuildLaneGraph for those non-moving obstacles.
  Feature* feature = mutable_latest_feature();
  if (feature->is_still()) {
    ADEBUG << "Don't build lane graph for non-moving obstacle.";
    return;
  }
  if (feature->lane().lane_graph_ordered().lane_sequence_size() > 0) {
    ADEBUG << "Don't build lane graph for an old obstacle.";
    return;
  }
  // double speed = feature->speed();
  double road_graph_search_distance = 50.0 * 0.95;  // (45mph for 3sec)
  // std::fmax(speed * FLAGS_prediction_trajectory_time_length +
  //               0.5 * FLAGS_vehicle_max_linear_acc *
  //               FLAGS_prediction_trajectory_time_length *
  //               FLAGS_prediction_trajectory_time_length,
  //           FLAGS_min_prediction_trajectory_spatial_length);
 
  // Treat the most probable lane_segment as the center, put its left
  // and right neighbors into a vector following the left-to-right order.
  if (!feature->has_lane() || !feature->lane().has_lane_feature()) {
    return;
  }
 
  bool is_in_junction = HasJunctionFeatureWithExits();
  std::unordered_set<std::string> exit_lane_id_set;
  if (is_in_junction) {
    for (const auto& exit : feature->junction_feature().junction_exit()) {
      exit_lane_id_set.insert(exit.exit_lane_id());
    }
  }
 
  std::shared_ptr<const LaneInfo> center_lane_info =
      PredictionMap::LaneById(feature->lane().lane_feature().lane_id());
  std::list<std::string> lane_ids_ordered_list;
  std::unordered_set<std::string> existing_lane_ids;
  GetNeighborLaneSegments(center_lane_info, true, 2, &lane_ids_ordered_list,
                          &existing_lane_ids);
  lane_ids_ordered_list.push_back(feature->lane().lane_feature().lane_id());
  existing_lane_ids.insert(feature->lane().lane_feature().lane_id());
  GetNeighborLaneSegments(center_lane_info, false, 2, &lane_ids_ordered_list,
                          &existing_lane_ids);
 
  const std::vector<std::string> lane_ids_ordered(lane_ids_ordered_list.begin(),
                                                  lane_ids_ordered_list.end());
  // TODO(all): sort the lane_segments from left to right (again)
  //            to double-check and make sure it's well sorted.
  // Build lane_graph for every lane_segment and update it into proto.
  int seq_id = 0;
  for (const std::string& lane_id : lane_ids_ordered) {
    // Construct the local lane_graph based on the current lane_segment.
    bool vehicle_is_on_lane = (lane_id == center_lane_info->lane().id().id());
    std::shared_ptr<const LaneInfo> curr_lane_info =
        PredictionMap::LaneById(lane_id);
    LaneGraph local_lane_graph = clusters_ptr_->GetLaneGraphWithoutMemorizing(
        feature->lane().lane_feature().lane_s(), road_graph_search_distance,
        true, curr_lane_info);
    // Update it into the Feature proto
    for (const auto& lane_seq : local_lane_graph.lane_sequence()) {
      if (is_in_junction && !HasJunctionExitLane(lane_seq, exit_lane_id_set)) {
        continue;
      }
      LaneSequence* lane_seq_ptr = feature->mutable_lane()
                                       ->mutable_lane_graph_ordered()
                                       ->add_lane_sequence();
      lane_seq_ptr->CopyFrom(lane_seq);
      lane_seq_ptr->set_lane_sequence_id(seq_id++);
      lane_seq_ptr->set_lane_s(feature->lane().lane_feature().lane_s());
      lane_seq_ptr->set_lane_l(feature->lane().lane_feature().lane_l());
      lane_seq_ptr->set_vehicle_on_lane(vehicle_is_on_lane);
      ADEBUG << "Obstacle [" << id_ << "] set a lane sequence ["
             << lane_seq.ShortDebugString() << "].";
    }
  }
 
  // Build lane_points.
  if (feature->lane().has_lane_graph_ordered()) {
    SetLanePoints(feature, 0.5, 100, true,
                  feature->mutable_lane()->mutable_lane_graph_ordered());
    SetLaneSequencePath(feature->mutable_lane()->mutable_lane_graph_ordered());
  }
  ADEBUG << "Obstacle [" << id_ << "] set lane graph features.";
}

ClearOldInformation()

void apollo::prediction::Obstacle::ClearOldInformation

(

)

在文件 obstacle.cc 第 205 行定义.

                                   {
  if (feature_history_.size() <= 1) {
    return;
  }
  feature_history_[1].clear_predicted_trajectory();
  Lane* lane = feature_history_[1].mutable_lane();
  lane->clear_current_lane_feature();
  lane->clear_nearby_lane_feature();
  lane->clear_lane_graph();
  lane->clear_lane_graph_ordered();
}

Create() [1/2]

std::unique_ptr< Obstacle > apollo::prediction::Obstacle::Create ( const Feature &  feature, ObstacleClusters *  clusters_ptr  )

static

在文件 obstacle.cc 第 1417 行定义.

                                                                           {
  std::unique_ptr<Obstacle> ptr_obstacle(new Obstacle());
  ptr_obstacle->SetClusters(clusters_ptr);
  ptr_obstacle->InsertFeatureToHistory(feature);
  return ptr_obstacle;
}

Create() [2/2]

std::unique_ptr< Obstacle > apollo::prediction::Obstacle::Create ( const perception::PerceptionObstacle &  perception_obstacle, const double  timestamp, const int  prediction_id, ObstacleClusters *  clusters_ptr  )

static

Constructor

在文件 obstacle.cc 第 1406 行定义.

                                                             {
  std::unique_ptr<Obstacle> ptr_obstacle(new Obstacle());
  ptr_obstacle->SetClusters(clusters_ptr);
  if (!ptr_obstacle->Insert(perception_obstacle, timestamp, prediction_id)) {
    return nullptr;
  }
  return ptr_obstacle;
}

earliest_feature()

const Feature & apollo::prediction::Obstacle::earliest_feature

(

)

const

Get the earliest feature.

返回

The earliest feature.

在文件 obstacle.cc 第 83 行定义.

                                                {
  ACHECK(!feature_history_.empty());
  return feature_history_.back();
}

feature()

const Feature & apollo::prediction::Obstacle::feature

(

const size_t

i

)

const

Get the ith feature from latest to earliest.

参数

i	The index of the feature.

返回

The ith feature.

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

                                                     {
  ACHECK(i < feature_history_.size());
  return feature_history_[i];
}

GeneratePredictionObstacle()

PredictionObstacle apollo::prediction::Obstacle::GeneratePredictionObstacle

(

)

在文件 obstacle.cc 第 1494 行定义.

                                                        {
  PredictionObstacle prediction_obstacle;
  // TODO(kechxu) implement
  return prediction_obstacle;
}

HasJunctionFeatureWithExits()

bool apollo::prediction::Obstacle::HasJunctionFeatureWithExits

(

)

const

Check if the obstacle has junction feature.

返回

If the obstacle has junction feature.

在文件 obstacle.cc 第 622 行定义.

                                                 {
  if (history_size() == 0) {
    return false;
  }
  return latest_feature().has_junction_feature() &&
         latest_feature().junction_feature().junction_exit_size() > 0;
}

history_size()

size_t apollo::prediction::Obstacle::history_size

(

)

const

Get the number of historical features.

返回

The number of historical features.

在文件 obstacle.cc 第 93 行定义.

{ return feature_history_.size(); }

id()

int apollo::prediction::Obstacle::id

(

)

const

Get the obstacle's ID.

返回

The obstacle's ID.

在文件 obstacle.cc 第 60 行定义.

{ return id_; }

Insert()

bool apollo::prediction::Obstacle::Insert	(	const perception::PerceptionObstacle &	perception_obstacle,
		const double	timestamp,
		const int	prediction_id
	)

Insert a perception obstacle with its timestamp.

参数

perception_obstacle	The obstacle from perception.
timestamp	The timestamp when the perception obstacle was detected.

在文件 obstacle.cc 第 140 行定义.

                                                        {
  if (!perception_obstacle.has_id() || !perception_obstacle.has_type()) {
    AERROR << "Perception obstacle has incomplete information; "
              "skip insertion";
    return false;
  }
 
  if (ReceivedOlderMessage(timestamp)) {
    AERROR << "Obstacle [" << id_ << "] received an older frame ["
           << std::setprecision(20) << timestamp
           << "] than the most recent timestamp [ " << this->timestamp()
           << "].";
    return false;
  }
 
  // Set ID, Type, and Status of the feature.
  Feature feature;
  if (!SetId(perception_obstacle, &feature, prediction_obstacle_id)) {
    return false;
  }
 
  SetType(perception_obstacle, &feature);
 
  SetStatus(perception_obstacle, timestamp, &feature);
 
  // Set obstacle lane features
  if (type_ != PerceptionObstacle::PEDESTRIAN) {
    SetCurrentLanes(&feature);
    SetNearbyLanes(&feature);
  }
 
  if (FLAGS_prediction_offline_mode ==
      PredictionConstants::kDumpDataForLearning) {
    SetSurroundingLaneIds(&feature, FLAGS_surrounding_lane_search_radius);
  }
 
  if (FLAGS_adjust_vehicle_heading_by_lane &&
      type_ == PerceptionObstacle::VEHICLE) {
    AdjustHeadingByLane(&feature);
  }
 
  // Insert obstacle feature to history
  InsertFeatureToHistory(feature);
 
  // Set obstacle motion status
  if (FLAGS_use_navigation_mode) {
    SetMotionStatusBySpeed();
  } else {
    SetMotionStatus();
  }
 
  // Trim historical features
  DiscardOutdatedHistory();
  return true;
}

InsertFeature()

bool apollo::prediction::Obstacle::InsertFeature

(

const Feature &

feature

)

Insert a feature proto message.

参数

feature

proto message.

在文件 obstacle.cc 第 198 行定义.

                                                   {
  InsertFeatureToHistory(feature);
  type_ = feature.type();
  id_ = feature.id();
  return true;
}

IsCaution()

bool apollo::prediction::Obstacle::IsCaution

(

)

const

在文件 obstacle.cc 第 1453 行定义.

                               {
  if (feature_history_.empty()) {
    return false;
  }
  const Feature& feature = latest_feature();
  return feature.priority().priority() == ObstaclePriority::CAUTION;
}

IsCloseToJunctionExit()

bool apollo::prediction::Obstacle::IsCloseToJunctionExit

(

)

const

Check if the obstacle is close to a junction exit.

返回

If the obstacle is closed to a junction exit.

在文件 obstacle.cc 第 274 行定义.

                                           {
  if (!HasJunctionFeatureWithExits()) {
    AERROR << "No junction feature found";
    return false;
  }
  CHECK_GT(history_size(), 0U);
  const Feature& latest_feature = feature_history_.front();
  double position_x = latest_feature.position().x();
  double position_y = latest_feature.position().y();
  double raw_velocity_heading = std::atan2(latest_feature.raw_velocity().y(),
                                           latest_feature.raw_velocity().x());
  for (const JunctionExit& junction_exit :
       latest_feature.junction_feature().junction_exit()) {
    double exit_x = junction_exit.exit_position().x();
    double exit_y = junction_exit.exit_position().y();
    double exit_heading = junction_exit.exit_heading();
    if (IsClosed(position_x, position_y, raw_velocity_heading, exit_x, exit_y,
                 exit_heading)) {
      return true;
    }
  }
  return false;
}

IsInJunction()

bool apollo::prediction::Obstacle::IsInJunction

(

const std::string &

junction_id

)

const

Check if the obstacle is a junction.

参数

junction

ID

返回

If the obstacle is in a junction.

在文件 obstacle.cc 第 223 行定义.

                                                              {
  // TODO(all) Consider if need to use vehicle front rather than position
  if (feature_history_.empty()) {
    AERROR << "Obstacle [" << id_ << "] has no history";
    return false;
  }
  if (junction_id.empty()) {
    return false;
  }
  std::shared_ptr<const JunctionInfo> junction_info_ptr =
      PredictionMap::JunctionById(junction_id);
  if (junction_info_ptr == nullptr) {
    return false;
  }
  const auto& position = latest_feature().position();
  return PredictionMap::IsPointInJunction(position.x(), position.y(),
                                          junction_info_ptr);
}

IsInteractiveObstacle()

bool apollo::prediction::Obstacle::IsInteractiveObstacle

(

)

const

在文件 obstacle.cc 第 1475 行定义.

                                           {
  if (feature_history_.empty()) {
    return false;
  }
  const Feature& feature = latest_feature();
  return feature.interactive_tag().interactive_tag() ==
                 ObstacleInteractiveTag::INTERACTION;
}

IsNearJunction()

bool apollo::prediction::Obstacle::IsNearJunction

(

)

Check if the obstacle is near a junction.

返回

If the obstacle is near a junction.

在文件 obstacle.cc 第 130 行定义.

                              {
  if (feature_history_.empty()) {
    return false;
  }
  double pos_x = latest_feature().position().x();
  double pos_y = latest_feature().position().y();
  return PredictionMap::NearJunction({pos_x, pos_y},
                                     FLAGS_junction_search_radius);
}

IsOnLane()

bool apollo::prediction::Obstacle::IsOnLane

(

)

const

Check if the obstacle is on any lane.

返回

If the obstacle is on any lane.

在文件 obstacle.cc 第 107 行定义.

                              {
  if (feature_history_.empty() || !latest_feature().has_lane() ||
      latest_feature().lane().current_lane_feature().empty()) {
    return false;
  }
  for (const auto& curr_lane : latest_feature().lane().current_lane_feature()) {
    if (curr_lane.lane_type() != hdmap::Lane::CITY_DRIVING &&
        curr_lane.lane_type() != hdmap::Lane::BIKING) {
      return false;
    }
  }
 
  ADEBUG << "Obstacle [" << id_ << "] is on lane.";
  return true;
}

IsPedestrian()

bool apollo::prediction::Obstacle::IsPedestrian

(

)

const

在文件 obstacle.cc 第 56 行定义.

                                  {
  return type_ == PerceptionObstacle::PEDESTRIAN;
}

IsSlow()

bool apollo::prediction::Obstacle::IsSlow

(

)

Check if the obstacle is slow.

返回

If the obstacle is slow.

在文件 obstacle.cc 第 102 行定义.

                      {
  const Feature& feature = latest_feature();
  return feature.speed() < FLAGS_slow_obstacle_speed_threshold;
}

IsStill()

bool apollo::prediction::Obstacle::IsStill

(

)

Check if the obstacle is still.

返回

If the obstacle is still.

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

                       {
  if (feature_history_.size() > 0) {
    return feature_history_.front().is_still();
  }
  return true;
}

latest_feature()

const Feature & apollo::prediction::Obstacle::latest_feature

(

)

const

Get the latest feature.

返回

The latest feature.

在文件 obstacle.cc 第 78 行定义.

                                              {
  ACHECK(!feature_history_.empty());
  return feature_history_.front();
}

mutable_feature()

Feature * apollo::prediction::Obstacle::mutable_feature

(

const size_t

i

)

Get a pointer to the ith feature from latest to earliest.

参数

i	The index of the feature.

返回

A pointer to the ith feature.

在文件 obstacle.cc 第 72 行定义.

                                                 {
  ACHECK(!feature_history_.empty());
  ACHECK(i < feature_history_.size());
  return &feature_history_[i];
}

mutable_latest_feature()

Feature * apollo::prediction::Obstacle::mutable_latest_feature

(

)

Get a pointer to the latest feature.

返回

A pointer to the latest feature.

在文件 obstacle.cc 第 88 行定义.

                                          {
  ACHECK(!feature_history_.empty());
  return &(feature_history_.front());
}

obstacle_conf()

const ObstacleConf & apollo::prediction::Obstacle::obstacle_conf ( )

inline

在文件 obstacle.h 第 246 行定义.

{ return obstacle_conf_; }

ReceivedOlderMessage()

bool apollo::prediction::Obstacle::ReceivedOlderMessage

(

const double

timestamp

)

const

在文件 obstacle.cc 第 1425 行定义.

                                                                {
  if (feature_history_.empty()) {
    return false;
  }
  auto last_timestamp_received = feature_history_.front().timestamp();
  return timestamp <= last_timestamp_received;
}

SetCaution()

void apollo::prediction::Obstacle::SetCaution

(

)

Set the obstacle as caution level

在文件 obstacle.cc 第 1447 行定义.

                          {
  CHECK_GT(feature_history_.size(), 0U);
  Feature* feature = mutable_latest_feature();
  feature->mutable_priority()->set_priority(ObstaclePriority::CAUTION);
}

SetEvaluatorType()

void apollo::prediction::Obstacle::SetEvaluatorType

(

const ObstacleConf::EvaluatorType &

evaluator_type

)

在文件 obstacle.cc 第 1484 行定义.

                                                     {
  obstacle_conf_.set_evaluator_type(evaluator_type);
}

SetInteractiveTag()

void apollo::prediction::Obstacle::SetInteractiveTag

(

)

Set the obstacle as interactive obstacle.

在文件 obstacle.cc 第 1461 行定义.

                                 {
  CHECK_GT(feature_history_.size(), 0U);
  Feature* feature = mutable_latest_feature();
  feature->mutable_interactive_tag()
      ->set_interactive_tag(ObstacleInteractiveTag::INTERACTION);
}

SetJunctionAnalyzer()

void apollo::prediction::Obstacle::SetJunctionAnalyzer ( JunctionAnalyzer *  junction_analyzer )

inline

在文件 obstacle.h 第 72 行定义.

                                                                {
    junction_analyzer_ = junction_analyzer;
  }

SetNearbyObstacles()

void apollo::prediction::Obstacle::SetNearbyObstacles

(

)

Set nearby obstacles.

在文件 obstacle.cc 第 1279 行定义.

                                  {
  // This function runs after all basic features have been set up
  Feature* feature_ptr = mutable_latest_feature();
 
  LaneGraph* lane_graph = feature_ptr->mutable_lane()->mutable_lane_graph();
  for (int i = 0; i < lane_graph->lane_sequence_size(); ++i) {
    LaneSequence* lane_sequence = lane_graph->mutable_lane_sequence(i);
    if (lane_sequence->lane_segment_size() == 0) {
      AERROR << "Empty lane sequence found.";
      continue;
    }
    double obstacle_s = lane_sequence->lane_s();
    double obstacle_l = lane_sequence->lane_l();
    NearbyObstacle forward_obstacle;
    if (clusters_ptr_->ForwardNearbyObstacle(*lane_sequence, id_, obstacle_s,
                                             obstacle_l, &forward_obstacle)) {
      lane_sequence->add_nearby_obstacle()->CopyFrom(forward_obstacle);
    }
    NearbyObstacle backward_obstacle;
    if (clusters_ptr_->BackwardNearbyObstacle(*lane_sequence, id_, obstacle_s,
                                              obstacle_l, &backward_obstacle)) {
      lane_sequence->add_nearby_obstacle()->CopyFrom(backward_obstacle);
    }
  }
}

SetNonInteractiveTag()

void apollo::prediction::Obstacle::SetNonInteractiveTag

(

)

Set the obstacle as noninteractive obstacle.

在文件 obstacle.cc 第 1468 行定义.

                                    {
  CHECK_GT(feature_history_.size(), 0U);
  Feature* feature = mutable_latest_feature();
  feature->mutable_interactive_tag()
      ->set_interactive_tag(ObstacleInteractiveTag::NONINTERACTION);
}

SetPredictorType()

void apollo::prediction::Obstacle::SetPredictorType

(

const ObstacleConf::PredictorType &

predictor_type

)

在文件 obstacle.cc 第 1489 行定义.

                                                     {
  obstacle_conf_.set_predictor_type(predictor_type);
}

timestamp()

double apollo::prediction::Obstacle::timestamp

(

)

const

Get the obstacle's timestamp.

返回

The obstacle's timestamp.

在文件 obstacle.cc 第 62 行定义.

                                 {
  ACHECK(!feature_history_.empty());
  return feature_history_.front().timestamp();
}

ToIgnore()

bool apollo::prediction::Obstacle::ToIgnore

(

)

Check if the obstacle can be ignored.

返回

If the obstacle can be ignored.

在文件 obstacle.cc 第 123 行定义.

                        {
  if (feature_history_.empty()) {
    return true;
  }
  return latest_feature().priority().priority() == ObstaclePriority::IGNORE;
}

TrimHistory()

void apollo::prediction::Obstacle::TrimHistory

(

const size_t

remain_size

)

在文件 obstacle.cc 第 217 行定义.

                                                   {
  if (feature_history_.size() > remain_size) {
    feature_history_.resize(remain_size);
  }
}

type()

PerceptionObstacle::Type apollo::prediction::Obstacle::type

(

)

const

Get the type of perception obstacle's type.

返回

The type pf perception obstacle.

在文件 obstacle.cc 第 54 行定义.

{ return type_; }

---

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

• modules/prediction/container/obstacles/obstacle.h
• modules/prediction/container/obstacles/obstacle.cc