apollo::planning::Frame类 参考

Frame holds all data for one planning cycle. 更多...

#include <frame.h>

apollo::planning::Frame 的协作图:

Public 成员函数
	Frame (uint32_t sequence_num)
	Frame (uint32_t sequence_num, const LocalView &local_view, const common::TrajectoryPoint &planning_start_point, const common::VehicleState &vehicle_state, ReferenceLineProvider *reference_line_provider)
	Frame (uint32_t sequence_num, const LocalView &local_view, const common::TrajectoryPoint &planning_start_point, const common::VehicleState &vehicle_state)
virtual	~Frame ()=default
const common::TrajectoryPoint &	PlanningStartPoint () const
common::Status	Init (const common::VehicleStateProvider *vehicle_state_provider, const std::list< ReferenceLine > &reference_lines, const std::list< hdmap::RouteSegments > &segments, const std::vector< routing::LaneWaypoint > &future_route_waypoints, const EgoInfo *ego_info)
common::Status	InitForOpenSpace (const common::VehicleStateProvider *vehicle_state_provider, const EgoInfo *ego_info)
uint32_t	SequenceNum () const
std::string	DebugString () const
const PublishableTrajectory &	ComputedTrajectory () const
void	RecordInputDebug (planning_internal::Debug *debug)
const std::list< ReferenceLineInfo > &	reference_line_info () const
std::list< ReferenceLineInfo > *	mutable_reference_line_info ()
Obstacle *	Find (const std::string &id)
const ReferenceLineInfo *	FindDriveReferenceLineInfo ()
const ReferenceLineInfo *	FindTargetReferenceLineInfo ()
const ReferenceLineInfo *	FindFailedReferenceLineInfo ()
const ReferenceLineInfo *	DriveReferenceLineInfo () const
const std::vector< const Obstacle * >	obstacles () const
const Obstacle *	CreateStopObstacle (ReferenceLineInfo *const reference_line_info, const std::string &obstacle_id, const double obstacle_s, double stop_wall_width=4.0)
	: create static virtual object with lane width, mainly used for virtual stop wall
const Obstacle *	CreateStopObstacle (const std::string &obstacle_id, const std::string &lane_id, const double lane_s)
	: create static virtual object with lane width, mainly used for virtual stop wall
const Obstacle *	CreateStaticObstacle (ReferenceLineInfo *const reference_line_info, const std::string &obstacle_id, const double obstacle_start_s, const double obstacle_end_s)
	: create static virtual object with lane width,
bool	Rerouting (PlanningContext *planning_context)
const common::VehicleState &	vehicle_state () const
void	set_current_frame_planned_trajectory (ADCTrajectory current_frame_planned_trajectory)
const ADCTrajectory &	current_frame_planned_trajectory () const
void	set_current_frame_planned_path (DiscretizedPath current_frame_planned_path)
const DiscretizedPath &	current_frame_planned_path () const
const bool	is_near_destination () const
void	UpdateReferenceLinePriority (const std::map< std::string, uint32_t > &id_to_priority)
	Adjust reference line priority according to actual road conditions @id_to_priority lane id and reference line priority mapping relationship
const LocalView &	local_view () const
ThreadSafeIndexedObstacles *	GetObstacleList ()
const OpenSpaceInfo &	open_space_info () const
OpenSpaceInfo *	mutable_open_space_info ()
perception::TrafficLight	GetSignal (const std::string &traffic_light_id) const
const PadMessage::DrivingAction &	GetPadMsgDrivingAction () const

静态 Public 成员函数
static void	AlignPredictionTime (const double planning_start_time, prediction::PredictionObstacles *prediction_obstacles)

详细描述

Frame holds all data for one planning cycle.

在文件 frame.h 第 62 行定义.

构造及析构函数说明

Frame() [1/3]

Frame::Frame ( uint32_t  sequence_num )

explicit

在文件 frame.cc 第 58 行定义.

    : sequence_num_(sequence_num),
      monitor_logger_buffer_(common::monitor::MonitorMessageItem::PLANNING) {}

Frame() [2/3]

Frame::Frame	(	uint32_t	sequence_num,
		const LocalView &	local_view,
		const common::TrajectoryPoint &	planning_start_point,
		const common::VehicleState &	vehicle_state,
		ReferenceLineProvider *	reference_line_provider
	)

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

    : sequence_num_(sequence_num),
      local_view_(local_view),
      planning_start_point_(planning_start_point),
      vehicle_state_(vehicle_state),
      reference_line_provider_(reference_line_provider),
      monitor_logger_buffer_(common::monitor::MonitorMessageItem::PLANNING) {}

Frame() [3/3]

Frame::Frame	(	uint32_t	sequence_num,
		const LocalView &	local_view,
		const common::TrajectoryPoint &	planning_start_point,
		const common::VehicleState &	vehicle_state
	)

在文件 frame.cc 第 73 行定义.

    : Frame(sequence_num, local_view, planning_start_point, vehicle_state,
            nullptr) {}

~Frame()

virtual apollo::planning::Frame::~Frame ( )

virtualdefault

成员函数说明

AlignPredictionTime()

void Frame::AlignPredictionTime ( const double  planning_start_time, prediction::PredictionObstacles *  prediction_obstacles  )

static

在文件 frame.cc 第 458 行定义.

                                                                           {
  if (!prediction_obstacles || !prediction_obstacles->has_header() ||
      !prediction_obstacles->header().has_timestamp_sec()) {
    return;
  }
  double prediction_header_time =
      prediction_obstacles->header().timestamp_sec();
  for (auto &obstacle : *prediction_obstacles->mutable_prediction_obstacle()) {
    for (auto &trajectory : *obstacle.mutable_trajectory()) {
      for (auto &point : *trajectory.mutable_trajectory_point()) {
        point.set_relative_time(prediction_header_time + point.relative_time() -
                                planning_start_time);
      }
      if (!trajectory.trajectory_point().empty() &&
          trajectory.trajectory_point().begin()->relative_time() < 0) {
        auto it = trajectory.trajectory_point().begin();
        while (it != trajectory.trajectory_point().end() &&
               it->relative_time() < 0) {
          ++it;
        }
        trajectory.mutable_trajectory_point()->erase(
            trajectory.trajectory_point().begin(), it);
      }
    }
  }
}

ComputedTrajectory()

const PublishableTrajectory & apollo::planning::Frame::ComputedTrajectory

(

)

const

CreateStaticObstacle()

const Obstacle * Frame::CreateStaticObstacle	(	ReferenceLineInfo *const	reference_line_info,
		const std::string &	obstacle_id,
		const double	obstacle_start_s,
		const double	obstacle_end_s
	)

: create static virtual object with lane width,

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

                                 {
  if (reference_line_info == nullptr) {
    AERROR << "reference_line_info nullptr";
    return nullptr;
  }
 
  const auto &reference_line = reference_line_info->reference_line();
 
  // start_xy
  common::SLPoint sl_point;
  sl_point.set_s(obstacle_start_s);
  sl_point.set_l(0.0);
  common::math::Vec2d obstacle_start_xy;
  if (!reference_line.SLToXY(sl_point, &obstacle_start_xy)) {
    AERROR << "Failed to get start_xy from sl: " << sl_point.DebugString();
    return nullptr;
  }
 
  // end_xy
  sl_point.set_s(obstacle_end_s);
  sl_point.set_l(0.0);
  common::math::Vec2d obstacle_end_xy;
  if (!reference_line.SLToXY(sl_point, &obstacle_end_xy)) {
    AERROR << "Failed to get end_xy from sl: " << sl_point.DebugString();
    return nullptr;
  }
 
  double left_lane_width = 0.0;
  double right_lane_width = 0.0;
  if (!reference_line.GetLaneWidth(obstacle_start_s, &left_lane_width,
                                   &right_lane_width)) {
    AERROR << "Failed to get lane width at s[" << obstacle_start_s << "]";
    return nullptr;
  }
 
  common::math::Box2d obstacle_box{
      common::math::LineSegment2d(obstacle_start_xy, obstacle_end_xy),
      left_lane_width + right_lane_width};
 
  return CreateStaticVirtualObstacle(obstacle_id, obstacle_box);
}

CreateStopObstacle() [1/2]

const Obstacle * Frame::CreateStopObstacle	(	const std::string &	obstacle_id,
		const std::string &	lane_id,
		const double	lane_s
	)

: create static virtual object with lane width, mainly used for virtual stop wall

在文件 frame.cc 第 237 行定义.

                                                               {
  if (!hdmap_) {
    AERROR << "Invalid HD Map.";
    return nullptr;
  }
  hdmap::LaneInfoConstPtr lane = nullptr;
  if (nullptr == reference_line_provider_) {
    lane = hdmap_->GetLaneById(hdmap::MakeMapId(lane_id));
  } else {
    lane = reference_line_provider_->GetLaneById(hdmap::MakeMapId(lane_id));
  }
 
  if (!lane) {
    AERROR << "Failed to find lane[" << lane_id << "]";
    return nullptr;
  }
 
  double dest_lane_s = std::max(0.0, lane_s);
  auto dest_point = lane->GetSmoothPoint(dest_lane_s);
 
  double lane_left_width = 0.0;
  double lane_right_width = 0.0;
  lane->GetWidth(dest_lane_s, &lane_left_width, &lane_right_width);
 
  Box2d stop_wall_box{{dest_point.x(), dest_point.y()},
                      lane->Heading(dest_lane_s),
                      FLAGS_virtual_stop_wall_length,
                      lane_left_width + lane_right_width};
 
  return CreateStaticVirtualObstacle(obstacle_id, stop_wall_box);
}

CreateStopObstacle() [2/2]

const Obstacle * Frame::CreateStopObstacle	(	ReferenceLineInfo *const	reference_line_info,
		const std::string &	obstacle_id,
		const double	obstacle_s,
		double	stop_wall_width = 4.0
	)

: create static virtual object with lane width, mainly used for virtual stop wall

在文件 frame.cc 第 214 行定义.

                            {
  if (reference_line_info == nullptr) {
    AERROR << "reference_line_info nullptr";
    return nullptr;
  }
 
  const auto &reference_line = reference_line_info->reference_line();
  const double box_center_s = obstacle_s + FLAGS_virtual_stop_wall_length / 2.0;
  auto box_center = reference_line.GetReferencePoint(box_center_s);
  double heading = reference_line.GetReferencePoint(obstacle_s).heading();
  Box2d stop_wall_box{box_center, heading, FLAGS_virtual_stop_wall_length,
                      stop_wall_width};
 
  return CreateStaticVirtualObstacle(obstacle_id, stop_wall_box);
}

current_frame_planned_path()

const DiscretizedPath & apollo::planning::Frame::current_frame_planned_path ( ) const

inline

在文件 frame.h 第 150 行定义.

                                                            {
    return current_frame_planned_path_;
  }

current_frame_planned_trajectory()

const ADCTrajectory & apollo::planning::Frame::current_frame_planned_trajectory ( ) const

inline

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

                                                                {
    return current_frame_planned_trajectory_;
  }

DebugString()

std::string Frame::DebugString

(

)

const

在文件 frame.cc 第 425 行定义.

                                   {
  return absl::StrCat("Frame: ", sequence_num_);
}

DriveReferenceLineInfo()

const ReferenceLineInfo * Frame::DriveReferenceLineInfo

(

)

const

在文件 frame.cc 第 573 行定义.

                                                             {
  return drive_reference_line_info_;
}

Find()

Obstacle * Frame::Find

(

const std::string &

id

)

在文件 frame.cc 第 486 行定义.

{ return obstacles_.Find(id); }

FindDriveReferenceLineInfo()

const ReferenceLineInfo * Frame::FindDriveReferenceLineInfo

(

)

在文件 frame.cc 第 538 行定义.

                                                           {
  double min_cost = std::numeric_limits<double>::infinity();
  drive_reference_line_info_ = nullptr;
  for (const auto &reference_line_info : reference_line_info_) {
    if (reference_line_info.IsDrivable() &&
        reference_line_info.Cost() < min_cost) {
      drive_reference_line_info_ = &reference_line_info;
      min_cost = reference_line_info.Cost();
    }
  }
  return drive_reference_line_info_;
}

FindFailedReferenceLineInfo()

const ReferenceLineInfo * Frame::FindFailedReferenceLineInfo

(

)

在文件 frame.cc 第 562 行定义.

                                                            {
  for (const auto &reference_line_info : reference_line_info_) {
    // Find the unsuccessful lane-change path
    if (!reference_line_info.IsDrivable() &&
        reference_line_info.IsChangeLanePath()) {
      return &reference_line_info;
    }
  }
  return nullptr;
}

FindTargetReferenceLineInfo()

const ReferenceLineInfo * Frame::FindTargetReferenceLineInfo

(

)

在文件 frame.cc 第 551 行定义.

                                                            {
  const ReferenceLineInfo *target_reference_line_info = nullptr;
  for (const auto &reference_line_info : reference_line_info_) {
    if (reference_line_info.IsChangeLanePath()) {
      return &reference_line_info;
    }
    target_reference_line_info = &reference_line_info;
  }
  return target_reference_line_info;
}

GetObstacleList()

ThreadSafeIndexedObstacles * apollo::planning::Frame::GetObstacleList ( )

inline

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

{ return &obstacles_; }

GetPadMsgDrivingAction()

const PadMessage::DrivingAction & apollo::planning::Frame::GetPadMsgDrivingAction ( ) const

inline

在文件 frame.h 第 173 行定义.

                                                                {
    return pad_msg_driving_action_;
  }

GetSignal()

perception::TrafficLight Frame::GetSignal

(

const std::string &

traffic_light_id

)

const

在文件 frame.cc 第 511 行定义.

                                             {
  const auto *result =
      apollo::common::util::FindPtrOrNull(traffic_lights_, traffic_light_id);
  if (result == nullptr) {
    perception::TrafficLight traffic_light;
    traffic_light.set_id(traffic_light_id);
    traffic_light.set_color(perception::TrafficLight::UNKNOWN);
    traffic_light.set_confidence(0.0);
    traffic_light.set_tracking_time(0.0);
    return traffic_light;
  }
  return *result;
}

Init()

Status Frame::Init	(	const common::VehicleStateProvider *	vehicle_state_provider,
		const std::list< ReferenceLine > &	reference_lines,
		const std::list< hdmap::RouteSegments > &	segments,
		const std::vector< routing::LaneWaypoint > &	future_route_waypoints,
		const EgoInfo *	ego_info
	)

在文件 frame.cc 第 334 行定义.

                             {
  // TODO(QiL): refactor this to avoid redundant nullptr checks in scenarios.
  auto status = InitFrameData(vehicle_state_provider, ego_info);
  if (!status.ok()) {
    AERROR << "failed to init frame:" << status.ToString();
    return status;
  }
  if (!CreateReferenceLineInfo(reference_lines, segments)) {
    const std::string msg = "Failed to init reference line info.";
    AERROR << msg;
    return Status(ErrorCode::PLANNING_ERROR, msg);
  }
  future_route_waypoints_ = future_route_waypoints;
  for (auto &reference_line_info : reference_line_info_) {
    reference_line_info.PrintReferenceSegmentDebugString();
  }
  return Status::OK();
}

InitForOpenSpace()

Status Frame::InitForOpenSpace	(	const common::VehicleStateProvider *	vehicle_state_provider,
		const EgoInfo *	ego_info
	)

在文件 frame.cc 第 358 行定义.

                             {
  return InitFrameData(vehicle_state_provider, ego_info);
}

is_near_destination()

const bool apollo::planning::Frame::is_near_destination ( ) const

inline

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

{ return is_near_destination_; }

local_view()

const LocalView & apollo::planning::Frame::local_view ( ) const

inline

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

{ return local_view_; }

mutable_open_space_info()

OpenSpaceInfo * apollo::planning::Frame::mutable_open_space_info ( )

inline

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

{ return &open_space_info_; }

mutable_reference_line_info()

std::list< ReferenceLineInfo > * Frame::mutable_reference_line_info

(

)

在文件 frame.cc 第 127 行定义.

                                                               {
  return &reference_line_info_;
}

obstacles()

const std::vector< const Obstacle * > Frame::obstacles

(

)

const

在文件 frame.cc 第 577 行定义.

                                                         {
  return obstacles_.Items();
}

open_space_info()

const OpenSpaceInfo & apollo::planning::Frame::open_space_info ( ) const

inline

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

{ return open_space_info_; }

PlanningStartPoint()

const common::TrajectoryPoint & Frame::PlanningStartPoint

(

)

const

在文件 frame.cc 第 79 行定义.

                                                             {
  return planning_start_point_;
}

RecordInputDebug()

void Frame::RecordInputDebug

(

planning_internal::Debug *

debug

)

在文件 frame.cc 第 429 行定义.

                                                          {
  if (!debug) {
    ADEBUG << "Skip record input into debug";
    return;
  }
  auto *planning_debug_data = debug->mutable_planning_data();
  auto *adc_position = planning_debug_data->mutable_adc_position();
  adc_position->CopyFrom(*local_view_.localization_estimate);
 
  auto debug_chassis = planning_debug_data->mutable_chassis();
  debug_chassis->CopyFrom(*local_view_.chassis);
 
  if (!FLAGS_use_navigation_mode) {
    auto debug_routing = planning_debug_data->mutable_routing();
    debug_routing->CopyFrom(
        local_view_.planning_command->lane_follow_command());
  }
 
  planning_debug_data->mutable_prediction_header()->CopyFrom(
      local_view_.prediction_obstacles->header());
  /*
  auto relative_map = AdapterManager::GetRelativeMap();
  if (!relative_map->Empty()) {
    planning_debug_data->mutable_relative_map()->mutable_header()->CopyFrom(
        relative_map->GetLatestObserved().header());
  }
  */
}

reference_line_info()

const std::list< ReferenceLineInfo > & Frame::reference_line_info

(

)

const

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

                                                                   {
  return reference_line_info_;
}

Rerouting()

bool Frame::Rerouting

(

PlanningContext *

planning_context

)

在文件 frame.cc 第 87 行定义.

                                                       {
  if (FLAGS_use_navigation_mode) {
    AERROR << "Rerouting not supported in navigation mode";
    return false;
  }
  if (local_view_.planning_command == nullptr) {
    AERROR << "No previous routing available";
    return false;
  }
  if (!hdmap_) {
    AERROR << "Invalid HD Map.";
    return false;
  }
  auto *rerouting =
      planning_context->mutable_planning_status()->mutable_rerouting();
  rerouting->set_need_rerouting(true);
  auto *lane_follow_command = rerouting->mutable_lane_follow_command();
  if (future_route_waypoints_.size() < 1) {
    AERROR << "Failed to find future waypoints";
    return false;
  }
  for (size_t i = 0; i < future_route_waypoints_.size() - 1; i++) {
    auto waypoint = lane_follow_command->add_way_point();
    waypoint->set_x(future_route_waypoints_[i].pose().x());
    waypoint->set_y(future_route_waypoints_[i].pose().y());
    waypoint->set_heading(future_route_waypoints_[i].heading());
  }
  auto *end_pose = lane_follow_command->mutable_end_pose();
  end_pose->set_x(future_route_waypoints_.back().pose().x());
  end_pose->set_y(future_route_waypoints_.back().pose().y());
  end_pose->set_heading(future_route_waypoints_.back().heading());
 
  monitor_logger_buffer_.INFO("Planning send Rerouting request");
  return true;
}

SequenceNum()

uint32_t Frame::SequenceNum

(

)

const

在文件 frame.cc 第 423 行定义.

{ return sequence_num_; }

set_current_frame_planned_path()

void apollo::planning::Frame::set_current_frame_planned_path ( DiscretizedPath  current_frame_planned_path )

inline

在文件 frame.h 第 145 行定义.

                                                  {
    current_frame_planned_path_ = std::move(current_frame_planned_path);
  }

set_current_frame_planned_trajectory()

void apollo::planning::Frame::set_current_frame_planned_trajectory ( ADCTrajectory  current_frame_planned_trajectory )

inline

在文件 frame.h 第 135 行定义.

                                                      {
    current_frame_planned_trajectory_ =
        std::move(current_frame_planned_trajectory);
  }

UpdateReferenceLinePriority()

void Frame::UpdateReferenceLinePriority

(

const std::map< std::string, uint32_t > &

id_to_priority

)

Adjust reference line priority according to actual road conditions @id_to_priority lane id and reference line priority mapping relationship

在文件 frame.cc 第 131 行定义.

                                                       {
  for (const auto &pair : id_to_priority) {
    const auto id = pair.first;
    const auto priority = pair.second;
    auto ref_line_info_itr =
        std::find_if(reference_line_info_.begin(), reference_line_info_.end(),
                     [&id](const ReferenceLineInfo &ref_line_info) {
                       return ref_line_info.Lanes().Id() == id;
                     });
    if (ref_line_info_itr != reference_line_info_.end()) {
      ref_line_info_itr->SetPriority(priority);
    }
  }
}

vehicle_state()

const common::VehicleState & Frame::vehicle_state

(

)

const

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

                                                     {
  return vehicle_state_;
}

---

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

• modules/planning/planning_base/common/frame.h
• modules/planning/planning_base/common/frame.cc