百度apollo自动驾驶planning代码学习-Apollo\modules\planning\common\history类代码详解

概述

history类是apollo planning模块下modules\planning\common\history.cc/.h实现
通过history_test.cc给出的示例，可以了解该类的功能及使用方式。

history.cc里定义了很多类。

从类名来看，应该是历史数据类，

从代码来看history类主要是实现：
储存针对其他目标决策类型历史信息，其他目标是动/静态物体的历史信息，储存历史规划轨迹，序列号等

history.h

#pragma once

#include <list>
#include <string>
#include <unordered_map>
#include <vector>

#include "cyber/common/macros.h"
#include "modules/planning/proto/planning.pb.h"

namespace apollo {
namespace planning {


//历史目标决策类，里面储存的是目标决策类列表
class HistoryObjectDecision {
 public:
  HistoryObjectDecision() = default;
  
  //输入参数ObjectDecision类对象，由modules\planning\proto\decision.proto生成的c++类
//里面包括目标的id以及相应的决策——停车避让/绕行/接近/跟车/超车/忽略等
//其实就是将HistoryObjectDecision类数据成员object_decision_目标决策列表挨个用输入参数初始化
  void Init(const ObjectDecision& object_decisions);
  
  //又来一个HistoryObjectDecision类的Init函数，重载，输入参数不同
//这次输入参数为id，和目标决策类型列表，这次其实是将输入参数的id和相应的目标决策塞入
//HistoryObjectDecision类数据成员目标决策类object_decision_对象
  void Init(const std::string& id,
            const std::vector<ObjectDecisionType>& object_decisions);

  //返回数据成员id
  const std::string& id() const { return id_; }
  
  //返回HistoryObjectDecision类里储存的目标决策类对象object_decision_
  std::vector<const ObjectDecisionType*> GetObjectDecision() const;

 private:
  std::string id_;
  std::vector<ObjectDecisionType> object_decision_;
};

//历史帧类，里面储存序列号，规划轨迹，目标决策id和决策的映射map，目标决策列表
class HistoryFrame {
 public:
  HistoryFrame() = default;

//初始化，用规划轨迹类ADCTrajectory类对象作参数，去赋值给其HistoryFrame类数据成员adc_trajactory_
//其实就是把输入参数 规划轨迹上的目标决策对象截出来放入自己的类成员object_decisions_里
 //输入轨迹及其序列号也放入自己的数据成员中
  void Init(const ADCTrajectory& adc_trajactory);

//返回历史帧的规划轨迹序列号
  int seq_num() const { return seq_num_; }

//返回历史帧里的目标决策列表
  std::vector<const HistoryObjectDecision*> GetObjectDecisions() const;
 //返回历史帧里的目标决策列表中决策为STOP的决策列表 
  std::vector<const HistoryObjectDecision*> GetStopObjectDecisions() const;

  //通过id获取目标决策列表
  const HistoryObjectDecision* GetObjectDecisionsById(
      const std::string& id) const;

 private:
  int seq_num_;
  ADCTrajectory adc_trajactory_;
  std::unordered_map<std::string, HistoryObjectDecision> object_decisions_map_;
  std::vector<HistoryObjectDecision> object_decisions_;
};

//历史目标状态类
//里面储存了了目标的id，目标是静态/动态物体，对于目标的决策类型:停车避让/绕行/接近/跟车/超车/忽略等
class HistoryObjectStatus {
 public:
  HistoryObjectStatus() = default;

  //历史目标状态类的Init初始化函数，输入参数id,以及目标状态来赋值类数据成员
//id_,object_status_，所以HistoryObjectStatus历史目标状态类其实主要就是储存
//历史目标的id及状态
  void Init(const std::string& id, const ObjectStatus& object_status);

  //获取历史目标状态类对象的数据成员id
  const std::string& id() const { return id_; }
  //获取历史目标状态类对象的数据成员目标状态
  const ObjectStatus GetObjectStatus() const { return object_status_; }

 private:
  std::string id_;
  ObjectStatus object_status_;
};

//历史状态类，里面储存的是id和目标状态类对象的映射关系map
class HistoryStatus {
 public:
  HistoryStatus() = default;

  //设置历史状态类HistoryStatus，输入参数id，以及目标状态类对象
//建立目标状态和Id的映射map,其实就是在map再加一对key-value映射对
  void SetObjectStatus(const std::string& id,
                       const ObjectStatus& object_status);

//在历史状态类对象里储存的map里根据目标id查询目标状态
  bool GetObjectStatus(const std::string& id,
                       ObjectStatus* const object_status);

 private:
  std::unordered_map<std::string, ObjectStatus> object_id_to_status_;
};

//历史类
//里面储存了历史帧类对象的列表以及历史状态类对象
class History {
 public:
  History() = default;
  const HistoryFrame* GetLastFrame() const;
  int Add(const ADCTrajectory& adc_trajectory_pb);
  void Clear();
  size_t Size() const;
  HistoryStatus* mutable_history_status() { return &history_status_; }

 private:
  std::list<HistoryFrame> history_frames_;
  HistoryStatus history_status_;
};

}  // namespace planning
}  // namespace apollo

history.cc

#include "modules/planning/common/history.h"

#include <utility>

#include "cyber/common/log.h"
#include "modules/planning/common/planning_gflags.h"

namespace apollo {
namespace planning {


//历史目标决策类init初始化函数，在history.h除了History类还定义了好几个其他的类

//输入参数 ObjectDecision类对象，由modules\planning\proto\decision.proto生成的c++类
//里面包括目标的id以及相应的决策——停车避让/绕行/接近/跟车/超车/忽略等
//其实就是将HistoryObjectDecision类数据成员object_decision_目标决策列表挨个用输入参数初始化
void HistoryObjectDecision::Init(const ObjectDecision& object_decisions) {
  id_ = object_decisions.id();
  object_decision_.clear();
  for (int i = 0; i < object_decisions.object_decision_size(); i++) {
    object_decision_.push_back(object_decisions.object_decision(i));
  }
}

//又来一个HistoryObjectDecision类的Init函数，重载，输入参数不同
//这次输入参数为id，和目标决策类型列表，这次其实是将输入参数的id和相应的目标决策塞入
//HistoryObjectDecision类数据成员目标决策类object_decision_对象
void HistoryObjectDecision::Init(
    const std::string& id,
    const std::vector<ObjectDecisionType>& object_decision) {
  id_ = id;
  object_decision_.clear();
  for (const auto decision_type : object_decision) {
    object_decision_.push_back(decision_type);
  }
}

//返回HistoryObjectDecision类里储存的目标决策类对象object_decision_
//为什么不直接返回object_decision_，而是要再复制一遍？
std::vector<const ObjectDecisionType*>
HistoryObjectDecision::GetObjectDecision() const {
  std::vector<const ObjectDecisionType*> result;
  for (size_t i = 0; i < object_decision_.size(); i++) {
    result.push_back(&(object_decision_[i]));
  }

  return result;
}


// HistoryFrame历史帧类， 就是储存规划轨迹上的目标决策列表？

//初始化，用规划轨迹类ADCTrajectory类对象作参数，去赋值给其HistoryFrame类数据成员adc_trajactory_
//其实就是把输入参数 规划轨迹上的目标决策对象截出来放入自己的类成员object_decisions_里
//输入轨迹及其序列号也放入自己的数据成员中
void HistoryFrame::Init(const ADCTrajectory& adc_trajactory) {
  adc_trajactory_.CopyFrom(adc_trajactory);
  //获取输入参数轨迹序列号
  seq_num_ = adc_trajactory.header().sequence_num();
  //或取输入参数轨迹中的目标决策列表
  const auto& object_decisions = adc_trajactory.decision().object_decision();
  //遍历目标决策列表
  for (int i = 0; i < object_decisions.decision_size(); i++) {
    //获取第i个目标决策的id
    const std::string id = object_decisions.decision(i).id();
    
    //定义一个历史目标决策类对象object_decision，调用其初始化函数
    HistoryObjectDecision object_decision;
    object_decision.Init(object_decisions.decision(i));
    //建立map也就是id与目标决策对象的映射关系
    object_decisions_map_[id] = object_decision;
    //目标决策对象塞入HistoryFrame类的列表中
    object_decisions_.push_back(object_decision);
  }
}

//HistoryFrame类成员函数获取历史目标决策列表？
//其实就是把数据成员object_decisions_拷贝出来返回？
std::vector<const HistoryObjectDecision*> HistoryFrame::GetObjectDecisions()
    const {
  std::vector<const HistoryObjectDecision*> result;
  for (size_t i = 0; i < object_decisions_.size(); i++) {
    result.push_back(&(object_decisions_[i]));
  }

  return result;
}

//HistoryFrame的成员函数获取历史目标决策列表中决策类型为STOP的目标决策类对象列表
std::vector<const HistoryObjectDecision*> HistoryFrame::GetStopObjectDecisions()
    const {
  std::vector<const HistoryObjectDecision*> result;
  for (size_t i = 0; i < object_decisions_.size(); i++) {
    auto obj_decision = object_decisions_[i].GetObjectDecision();
    for (const ObjectDecisionType* decision_type : obj_decision) {
      if (decision_type->has_stop()) {
        std::vector<ObjectDecisionType> object_decision;
        object_decision.push_back(*decision_type);

        HistoryObjectDecision* decision = new HistoryObjectDecision();
        decision->Init(object_decisions_[i].id(), object_decision);
        result.push_back(decision);
      }
    }
  }

  // sort
  std::sort(
      result.begin(), result.end(),
      [](const HistoryObjectDecision* lhs, const HistoryObjectDecision* rhs) {
        return lhs->id() < rhs->id();
      });

  return result;
}

//根据id查询，目标决策类对象
const HistoryObjectDecision* HistoryFrame::GetObjectDecisionsById(
    const std::string& id) const {
  if (object_decisions_map_.find(id) == object_decisions_map_.end()) {
    return nullptr;
  }
  return &(object_decisions_map_.at(id));
}


// HistoryObjectStatus历史目标状态类

//历史目标状态类的Init初始化函数，输入参数id,以及目标状态来赋值类数据成员
//id_,object_status_，所以HistoryObjectStatus历史目标状态类其实主要就是储存
//历史目标的id及状态
void HistoryObjectStatus::Init(const std::string& id,
                               const ObjectStatus& object_status) {
  id_ = id;
  object_status_ = object_status;
}


// HistoryStatus历史状态类

//设置历史状态类HistoryStatus，输入参数id，以及目标状态类对象
//建立目标状态和Id的映射map
void HistoryStatus::SetObjectStatus(const std::string& id,
                                    const ObjectStatus& object_status) {
  object_id_to_status_[id] = object_status;
}

//根据id去查询目标状态
bool HistoryStatus::GetObjectStatus(const std::string& id,
                                    ObjectStatus* const object_status) {
  if (object_id_to_status_.count(id) == 0) {
    return false;
  }

  *object_status = object_id_to_status_[id];
  return true;
}


// History类

//History类的成员函数，获取最后一帧
const HistoryFrame* History::GetLastFrame() const {
  if (history_frames_.empty()) {
    return nullptr;
  } else {
    return &(history_frames_.back());
  }
}
//History类的成员函数，清空其里面储存的信息
void History::Clear() { history_frames_.clear(); }

//History类成员函数，增加加一个HistoryFrame类对象A到history_frames_，输入参数是一个规划轨迹
int History::Add(const ADCTrajectory& adc_trajectory_pb) {
  if (history_frames_.size() >=
      static_cast<size_t>(FLAGS_history_max_record_num)) {
    history_frames_.pop_front();
  }

  HistoryFrame history_frame;
  history_frame.Init(adc_trajectory_pb);
  history_frames_.emplace_back(std::move(history_frame));

  return 0;
}

//返回历史目标决策列表的数量
size_t History::Size() const { return history_frames_.size(); }

}  // namespace planning
}  // namespace apollo