首页 > 软件编程 > C语言 > C++ Cartographer源码中关于Sensor的数据走向深扒

C++ Cartographer源码中关于Sensor的数据走向深扒

福牛 3月 30, 2023 38 0

前言

整个Cartographer源码阅读是很枯燥的, 但绝对是可以学到东西的! 坚持每天记录, 加油!

在上一节我们详细了解了MapBuilder类, 发现其构造函数, 以及AddTrajectory中有使用到SensorBridge这个类还有sensor_collator_这个变量, 并且似乎是用这个类进行传感器数据的传递的. 当然啦, 如果想建立一个完整的轨迹(Trajectory)和SLAM功能, 我们肯定需要有传感器的数据灌入的.

在MapBuilder的入口类-MapBuilderBridge中, 可以看到一个变量sensor_bridges_

std::unordered_map<int, std::unique_ptr<SensorBridge>> sensor_bridges_;

sensor_bridges_存储了一系列SensorBridge类的实例, 并且在MapBuilderBridge::AddTrajectory

的第二步使用, 作用是为当前轨迹添加一个SensorBridge.

所以这一节我们重点看看SensorBridge这个类. 我们以最重要的sensor类-LaserScan为例子

Node类的HandleLaserScanMessage函数

我们都知道, ros中软实时的程序数据的入口都是从subscriber的回调函数开始. 之前已经讲过了Node的LaunchSubscriber函数, 用来专门启动所有传感器的订阅. 咱们就看看Node类的HandleLaserScanMessage:

  1. // 调用SensorBridge的传感器处理函数进行数据处理
  2. void Node::HandleLaserScanMessage(const int trajectory_id,
  3.                      const std::string& sensor_id,
  4.                      const sensor_msgs::LaserScan::ConstPtr& msg) {
  5.      absl::MutexLock lock(&mutex_);
  6.      // 根据配置,是否将传感器数据跳过
  7.      if (!sensor_samplers_.at(trajectory_id).rangefinder_sampler.Pulse()) {
  8.      return;
  9.      }
  10.      map_builder_bridge_.sensor_bridge(trajectory_id)
  11.          ->HandleLaserScanMessage(sensor_id, msg);
  12. }

我们可以看到, 他最终是调用了MapBuilderBridge类的sensor_bridge的成员函数-HandleLaserScanMessage来处理传入的传感器的数据.

SensorBridge类的HandleLaserScanMessage函数

咱们再去SensorBridge中看看, 以下是主要代码部分

  1. // 处理LaserScan数据, 先转成点云,再传入trajectory_builder_
  2. void SensorBridge::HandleLaserScanMessage(
  3.      const std::string& sensor_id, const sensor_msgs::LaserScan::ConstPtr& msg) {
  4.      carto::sensor::PointCloudwithIntensities point_cloud;
  5.      carto::common::Time time;
  6.      std::tie(point_cloud, time) = ToPointCloudWithIntensities(*msg);
  7.      HandleLaserScan(sensor_id, time, msg->header.frame_id, point_cloud);
  8. }
  9. void SensorBridge::HandleRangefinder(
  10.      const std::string& sensor_id, const carto::common::Time time,
  11.      const std::string& frame_id, const carto::sensor::TimedPointCloud& ranges) {
  12.      if (sensor_to_tracking != nullptr) {
  13.          trajectory_builder_->AddSensorData(
  14.          sensor_id, carto::sensor::TimedPointCloudData{
  15.      time,
  16.      sensor_to_tracking->translation().cast<float>(),
  17.      carto::sensor::TransformTimedPointCloud(
  18.      ranges, sensor_to_tracking->cast<float>())} ); // 强度始终为空
  19.      }
  20. }

前几节也讲过这部分SensorBridge::HandleLaserScanMessage调用了SensorBridge::HandleRangefinder, 把carto::sensor::TimedPointCloudData这个数据类型和sensor_id通过trajectory_builder_的AddSensorData把点云类型传递给CollatedTrajectoryBuilder的AddSensorData. 为啥是CollatedTrajectoryBuilder的AddSensorData呢?这块我也想了很久. 咱们先去sensor_bridge.h中看

  ::cartographer::mapping::TrajectoryBuilderInterface* const
trajectory_builder_;

发现是TrajectoryBuilderInterface, 这明显是个父类啊,没啥意义. 咱们回到SensorBridge的构造函数

  1. /**
  2.      * @brief 构造函数, 并且初始化TfBridge
  3.      *
  4.      * @param[in] num_subdivisions_per_laser_scan 一帧数据分成几次发送
  5.      * @param[in] tracking_frame 数据都转换到tracking_frame
  6.      * @param[in] lookup_transform_timeout_sec 查找tf的超时时间
  7.      * @param[in] tf_buffer tf_buffer
  8.      * @param[in] trajectory_builder 轨迹构建器
  9.      */
  10. SensorBridge::SensorBridge(
  11.      const int num_subdivisions_per_laser_scan,
  12.      const std::string& tracking_frame,
  13.      const double lookup_transform_timeout_sec, tf2_ros::Buffer* const tf_buffer,
  14.      carto::mapping::TrajectoryBuilderInterface* const trajectory_builder)
  15.      : num_subdivisions_per_laser_scan_(num_subdivisions_per_laser_scan),
  16.          tf_bridge_(tracking_frame, lookup_transform_timeout_sec, tf_buffer),
  17.          trajectory_builder_(trajectory_builder) {}

发现这个trajectory_builder_是SensorBridge构造函数的最后一个参数, 那么这个SensorBridge是在哪构造的呢? 是在map_builder_bridge.cc中, MapBuilderBridge::AddTrajectory的第二步sensor_bridges_[trajectory_id] = absl::make_unique<SensorBridge>. 我们看到最后一个参数是

map_builder_->GetTrajectoryBuilder(trajectory_id)

这个map_builder_是MapBuilderBridge构造函数map_builder_(std::move(map_builder)), 而这个map_builder也是父类定义,没啥参考价值

std::unique_ptr<cartographer::mapping::MapBuilderInterface> map_builder

再向前回溯, 看MapBuilderBridge是咋构造的, 发现是Node的构造函数就构造了map_builder_bridge_

  1. map_builder_bridge_(node_options_, std::move(map_builder), tf_buffer)

又要往前回溯, 在node_main.cc中

  1.      auto map_builder = cartographer::mapping::CreateMapBuilder(node_options.map_builder_options);
  2.      Node node(node_options, std::move(map_builder), &tf_buffer, FLAGS_collect_metrics);

发现map_builder是cartographer::mapping::CreateMapBuilder给的. 咱们再进CreateMapBuilder, 发现其只是一个工厂函数

  1. std::unique_ptr<MapBuilderInterface> CreateMapBuilder(
  2.      const proto::MapBuilderOptions& options) {
  3.      return absl::make_unique<MapBuilder>(options);
  4. }

而这个工厂函数实例化了MapBuilder这个类, 所以map_builder_->GetTrajectoryBuilder(trajectory_id)调用的是MapBuilder的GetTrajectoryBuilder. (有一种峰回路转的感觉), 返回trajectory_builders_的轨迹id为trajectory_id的指针,即:

  1.      mapping::TrajectoryBuilderInterface *GetTrajectoryBuilder(
  2.          int trajectory_id) const override {
  3.      return trajectory_builders_.at(trajectory_id).get();
  4.      }

而trajectory_builders_在map_builder.cc中被压入absl::make_unique<CollatedTrajectoryBuilder>, 如下

  1. trajectory_builders_.push_back(absl::make_unique<CollatedTrajectoryBuilder>(
  2.          trajectory_options, sensor_collator_.get(), trajectory_id,
  3.          expected_sensor_ids,
  4.          // 将3D前端与3D位姿图打包在一起, 传入CollatedTrajectoryBuilder
  5.          CreateGlobalTrajectoryBuilder3D(
  6.              std::move(local_trajectory_builder), trajectory_id,
  7.              static_cast<PoseGraph3D*>(pose_graph_.get()),
  8.              local_slam_result_callback, pose_graph_odometry_motion_filter)));

所以最终SensorBridge的trajectory_builder_实际上是CollatedTrajectoryBuilder的地址, 所以SensorBridge的trajectory_builder_的AddSensorData实际上是把数据添加到了CollatedTrajectoryBuilder里面, 而不是GlobalTrajectoryBuilder或者LocalTrajectoryBuilder(这三个TrajectoryBuilder都继承于TrajectoryBuilderInterface)

这块地方难就难在子类可以用父类代替, 搞不清到底是调用的哪个子类的成员函数.

CollatedTrajectoryBuilder类的AddSensorData函数

既然上面调用的是CollatedTrajectoryBuilder, 那咱们看看CollatedTrajectoryBuilder这个类的AddSensorData

  1. void AddSensorData(
  2.      const std::string& sensor_id,
  3.      const sensor::TimedPointCloudData& timed_point_cloud_data) override {
  4.      AddData(sensor::MakeDispatchable(sensor_id, timed_point_cloud_data));
  5. }
  6. void CollatedTrajectoryBuilder::AddData(std::unique_ptr<sensor::Data> data) {
  7.      sensor_collator_->AddSensorData(trajectory_id_, std::move(data));
  8. }

再看看sensor::MakeDispatchable, 在dispatchable.h文件中

  1. // 根据传入的data的数据类型,自动推断DataType, 实现一个函数处理不同类型的传感器数据
  2. template <typename DataType>
  3. std::unique_ptr<Dispatchable<DataType>> MakeDispatchable(
  4.      const std::string &sensor_id, const DataType &data) {
  5.      return absl::make_unique<Dispatchable<DataType>>(sensor_id, data);
  6. }

这个函数通过模板, 实现了一个函数处理多个类型, 也就是说可以用一个函数去分发上到激光雷达,下到IMU的数据, 值得学习.

CollatedTrajectoryBuilder::AddData又调用sensor_collator_->AddSensorData, 用std::move(data), 把data移动给AddSensorData, 给某个Trajectory加入传感器数据. 而这个sensor_collator_定义如下:

sensor::CollatorInterface* const sensor_collator_;

又是用父类代替子类, 在CollatedTrajectoryBuilder的构造函数中实现实例化, 这个sensor_collator_实际上是sensor::Collator, 原因是在map_builder.cc中的MapBuilder构造函数中有如下一段程序

  1.      // 在 cartographer/configuration_files/map_builder.Lua 中设置
  2.      // param: MAP_BUILDER.collate_by_trajectory 默认为false
  3.      if (options.collate_by_trajectory()) {
  4.      sensor_collator_ = absl::make_unique<sensor::TrajectoryCollator>();
  5.      } else {
  6.      // sensor_collator_初始化, 实际使用这个
  7.      sensor_collator_ = absl::make_unique<sensor::Collator>();
  8.      }

一般collate_by_trajectory设置为false, 所以是absl::make_unique<sensor::Collator>, 即sensor的Collator

  1.      // sensor::Collator的初始化
  2.      sensor_collator_->AddTrajectory(
  3.          trajectory_id, expected_sensor_id_strings,
  4.          [this](const std::string& sensor_id, std::unique_ptr<sensor::Data> data) {
  5.          HandleCollatedSensorData(sensor_id, std::move(data)); //传递给GlobalTrajectoryBuilder类相应的函数
  6.          });

Collator类的AddSensorData函数

咱们进到collator这个类中看看, 发现这个类继承于CollatorInterface, 再看看collator这个类的AddSensorData

  1. // 向数据队列中添加 传感器数据
  2. void Collator::AddSensorData(const int trajectory_id,
  3.                      std::unique_ptr<Data> data) {
  4.      QueueKey queue_key{trajectory_id, data->GetSensorId()};
  5.      queue_.Add(std::move(queue_key), std::move(data));
  6. }

作用是 向队列中添加传感器数据, 啥是队列?以后将在线程池部分详细说说. 现在简单看看

queue_是Cartographer的任务队列, 用于线程池多任务序列的储存与处理.

  1. // Queue keys are a pair of trajectory ID and sensor identifier.
  2.      OrderedMultiQueue queue_;

也就是说Collator::AddSensorData负责把data放在任务队列中等待处理并赋一个key, 并不负责处理数据, 所以咱们再往前看看, 看一下OrderedMultiQueue这个类的关于添加数据的成员函数-Add

OrderedMultiQueue类的Add函数

OrderedMultiQueue这个类定义在ordered_multi_queue.cc中, 添加数据是在Add成员函数实现的:

  1. // 向数据队列中添加数据
  2. void OrderedMultiQueue::Add(const QueueKey& queue_key,
  3.                      std::unique_ptr<Data> data) {
  4.      auto it = queues_.find(queue_key);
  5.      // 如果queue_key不在queues_中, 就忽略data
  6.      if (it == queues_.end()) {
  7.      LOG_EVERY_N(WARNING, 1000)
  8.          << “Ignored data for queue: ‘” << queue_key << “‘”;
  9.      return;
  10.      }
  11.      // 向数据队列中添加数据
  12.      it->second.queue.Push(std::move(data));
  13.      // 传感器数据的分发处理
  14.      Dispatch();
  15. }

可以发现Add就是生产者, 用于生成并传递可用数据.

Dispatch()这个成员函数负责数据分发, 将处于数据队列中的数据根据时间依次传入回调函数. 这个后面再看, 咱们先看看it->second.queue.Push(std::move(data));这个部分.

it这个变量就是queues_最后一个数据,可以理解为最新的一个数据, 而OrderedMultiQueue的queue_和上一小节提到的Collator是不同的, 在OrderedMultiQueue中的queue_是定义为一个std::map

  1. std::map<QueueKey, Queue> queues_; // 多个数据队列

所以it->second就是Queue, 而Queue是个定义在OrderedMultiQueue的结构体

  1.      struct Queue {
  2.      common::BlockingQueue<std::unique_ptr<Data>> queue; // 存储数据的队列
  3.      Callback callback; // 本数据队列对应的回调函数
  4.      bool finished = false; // 这个queue是否finished
  5.      };

Push 也就是把data压入Queue这个结构体中,然后生成map形成个对列. 而这个Push不是push_back, 这个Push是Cartographer自己定义的一种压栈方法. 定义在blocking_queue.h中,如下…

BlockingQueue类的Push函数

  1.      // Pushes a value onto the queue. Blocks if the queue is full.
  2.      // 将值压入队列. 如果队列已满, 则阻塞
  3.      void Push(T t) {
  4.      // 首先定义判断函数
  5.      const auto predicate = [this]() EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
  6.          return QueueNotFullCondition();
  7.      };
  8.      // absl::Mutex的更多信息可看: https://www.jianshu.com/p/d2834abd6796
  9.      // absl官网: https://abseil.io/about/
  10.      // 如果数据满了, 就进行等待
  11.      absl::MutexLock lock(&mutex_);
  12.      mutex_.Await(absl::Condition(&predicate));
  13.      // 将数据加入队列, 移动而非拷贝
  14.      deque_.push_back(std::move(t));
  15.      }

发现Push作用相当于阻塞者, 使用了mutex_.Await和锁用来阻塞数据传入. 看看QueueNotFullCondition这个函数就一目了然了. 当队列为无限大或者小于queue_size_的时候返回true.

  1.      // Returns true iff the queue is not full.
  2.      // 如果队列未满, 则返回true
  3.      bool QueueNotFullCondition() EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
  4.      return queue_size_ == kInfiniteQueueSize || deque_.size() < queue_size_;
  5.      }

除了阻塞作用, 最大的所用就是把数据压入deque_, 咱们再看看这个deque_

  1. template <typename T>
  2. …
  3. std::deque<T> deque_ GUARDED_BY(mutex_);

发现它是std::deque这个基础类型,类型决定于模板T, GUARDED_BY(mutex_)表示这个数据在使用的时候必须要上锁, 否则就会报错.

所以Push的作用就是有阻塞作用的push_back, 负责把data压入OrderedMultiQueue的queue_, 并且在队列满的时候阻塞.

OrderedMultiQueue类的Dispatch函数

咱们再回到OrderedMultiQueue类的Add函数的Dispatch中, 看看Dispatch函数有关数据分发的部分

  1. void OrderedMultiQueue::Dispatch() {
  2.      while (true) {
  3.          const Data* next_data = nullptr;
  4.          Queue* next_queue = nullptr;
  5.          QueueKey next_queue_key;
  6.          // 遍历所有的数据队列, 找到所有数据队列的第一个数据中时间最老的一个数据
  7.          for (auto it = queues_.begin(); it != queues_.end();) {
  8.              const auto* data = it->second.queue.Peek<Data>();
  9.          } // end for
  10.          // 正常情况, 数据时间都超过common_start_time
  11.      if (next_data->GetTime() >= common_start_time) {
  12.              last_dispatched_time_ = next_data->GetTime();
  13.              // 将数据传入 callback() 函数进行处理,并将这个数据从数据队列中删除
  14.              next_queue->callback(next_queue->queue.Pop());
  15.          }
  16.      }
  17. }

Peek是取出队列最前面的一个数据. callback定义在头文件中, 这个是std::function封装的一个函数

  1. using Callback = std::function<void(std::unique_ptr<Data>)>;

而Callback这个函数到底是啥呢? 这个要看OrderedMultiQueue::AddQueue这个成员函数

  1. void OrderedMultiQueue::AddQueue(const QueueKey& queue_key, Callback callback) {
  2.      CHECK_EQ(queues_.count(queue_key), 0);
  3.      queues_[queue_key].callback = std::move(callback);
  4. }

我们看到这个函数把参数传入的callback传入queues_的callback. 那么是谁调用的OrderedMultiQueue的AddQueue这个函数呢? 是Collator的AddTrajectory调用的!

我们在回溯到Collator这个类看看Collator的AddTrajectory成员函数

  1. /**
  2.      * @brief 添加轨迹以生成排序的传感器输出, 每个topic设置一个回调函数
  3.      *
  4.      * @param[in] trajectory_id 新生成的轨迹的id
  5.      * @param[in] expected_sensor_ids 需要排序的topic名字的集合
  6.      * @param[in] callback 2个参数的回调函数, 实际是CollatedTrajectoryBuilder::HandleCollatedSensorData()函数
  7.      */
  8. void Collator::AddTrajectory(
  9.      const int trajectory_id,
  10.      const absl::flat_hash_set<std::string>& expected_sensor_ids,
  11.      const Callback& callback) {
  12.      for (const auto& sensor_id : expected_sensor_ids) {
  13.      const auto queue_key = QueueKey{trajectory_id, sensor_id};
  14.      queue_.AddQueue(queue_key,
  15.                      // void(std::unique_ptr<Data> data) 带了个默认参数sensor_id
  16.                      [callback, sensor_id](std::unique_ptr<Data> data) {
  17.                      callback(sensor_id, std::move(data));
  18.                      });
  19.      queue_keys_[trajectory_id].push_back(queue_key);
  20.      }
  21. }

我们看到它调用了queue_的AddQueue, 而queue_就是OrderedMultiQueue的实例化 ,所以这里的AddQueue是OrderedMultiQueue的AddQueue. Callback又是个lambda函数

  1. [callback, sensor_id](std::unique_ptr<Data> data) {
  2.          callback(sensor_id, std::move(data));
  3. }

这个lambda函数调用的是传入的callback函数, 而这个Collator::AddTrajectory是谁调用的呢?实际上是CollatedTrajectoryBuilder. 在CollatedTrajectoryBuilder的构造函数中就实现了Collator这个类的初始化, 并且调用了AddTrajectory这个函数

  1. CollatedTrajectoryBuilder::CollatedTrajectoryBuilder(
  2.      const proto::TrajectoryBuilderOptions& trajectory_options,
  3.      sensor::CollatorInterface* const sensor_collator, const int trajectory_id,
  4.      const std::set<SensorId>& expected_sensor_ids,
  5.      std::unique_ptr<TrajectoryBuilderInterface> wrapped_trajectory_builder) …
  6. {
  7.      …
  8.      // sensor::Collator的初始化
  9.      sensor_collator_->AddTrajectory(
  10.      trajectory_id, expected_sensor_id_strings,
  11.      [this](const std::string& sensor_id, std::unique_ptr<sensor::Data> data) {
  12.          HandleCollatedSensorData(sensor_id, std::move(data)); //传递给GlobalTrajectoryBuilder类相应的函数
  13.      });
  14. }

所以传入的参数是是HandleCollatedSensorData这个函数.

CollatedTrajectoryBuilder类的HandleCollatedSensorData函数

这个函数才是真正的消费者. 看一下HandleCollatedSensorData传入sensor data的部分:

  1. void CollatedTrajectoryBuilder::HandleCollatedSensorData(
  2.      const std::string& sensor_id, std::unique_ptr<sensor::Data> data) {
  3.      // 将排序好的数据送入 GlobalTrajectoryBuilder中的AddSensorData()函数中进行使用
  4.      data->AddToTrajectoryBuilder(wrapped_trajectory_builder_.get());
  5. }

这个函数的作用是处理按照时间顺序分发的传感器数据, 在进去到Data的AddToTrajectoryBuilder里看看

Data这个类又是个基类, 里面有个纯虚函数

  1.      virtual void AddToTrajectoryBuilder(
  2.          mapping::TrajectoryBuilderInterface *trajectory_builder) = 0;

这个基类只有一个子类: Dispatchable. 进到这个子类中去看看AddToTrajectoryBuilder.

  1.      // 调用传入的trajectory_builder的AddSensorData()
  2.      void AddToTrajectoryBuilder(
  3.          mapping::TrajectoryBuilderInterface *const trajectory_builder) override {
  4.      trajectory_builder->AddSensorData(sensor_id_, data_);
  5.      }

所以这里的trajectory_builder指的就是CollatedTrajectoryBuilder::HandleCollatedSensorData中调用的wrapped_trajectory_builder_. 而这个wrapped_trajectory_builder_是啥呢?这又要回溯到CollatedTrajectoryBuilder的初始构造中去, 在map_builder.cc中实现

  1. trajectory_builders_.push_back(absl::make_unique<CollatedTrajectoryBuilder>(
  2.          trajectory_options, sensor_collator_.get(), trajectory_id,
  3.          expected_sensor_ids,
  4.          // 将2D前端与2D位姿图打包在一起, 传入CollatedTrajectoryBuilder
  5.          CreateGlobalTrajectoryBuilder2D( //全局轨迹构建器
  6.                      //CreateGlobalTrajectoryBuilder2D是global_trajectory_builderd的方法,
  7.                      //继承自TrajectoryBuilderInterface,和CollatedTrajectoryBuilder一个父类
  8.              std::move(local_trajectory_builder), //前端构建器
  9.              trajectory_id, //
  10.              static_cast<PoseGraph2D*>(pose_graph_.get()), //后端位姿图
  11.              local_slam_result_callback, pose_graph_odometry_motion_filter)));

我们看到wrapped_trajectory_builder_实际上是CreateGlobalTrajectoryBuilder2D, 这个在上回也说到就是GlobalTrajectoryBuilder这个类CreateGlobalTrajectoryBuilder2D, 返回Cartographer的前端和后端.

到这里, 整个Cartographer的传感器数据传递过程也就明了了.

从GlobalTrajectoryBuilder2D开始, 数据才真正走到SLAM的前端与后端部分.

总结

Cartographer中传感器数据的传入从Node类的HandleXXXMessage成员函数开始, 传递给SensorBridge类, 然后调用CollatedTrajectoryBuilder把数据给到Collator类, 由Collator进行消费这模式的处理, 然后再返回给CollatedTrajectoryBuilder完成Cartographer的整个前后端.

中间的处理用到了很多父子类的互相调用, 一层套一层, 十分复杂, 要认真看才能懂里面的数据流.

到此这篇关于C++ Cartographer源码中关于Sensor的数据走向深扒的文章就介绍到这了,更多相关C++ Sensor数据走向内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论