apollo::perception::lidar::LidarOutputComponent类 参考

#include <lidar_output_component.h>

类 apollo::perception::lidar::LidarOutputComponent 继承关系图:

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

Public 成员函数
	LidarOutputComponent ()
virtual	~LidarOutputComponent ()
bool	Init () override
	Init lidar output component
bool	Proc (const std::shared_ptr< SensorFrameMessage > &message) override
	Process of lidar output component
bool	SaveBenchmarkFrame (const std::shared_ptr< SensorFrameMessage > &message)
	Save benchmark frame for end-to-end evaluation
bool	SaveBenchmarkLidarFrame (const std::shared_ptr< LidarFrameMessage > &message)
void	BenchmarkThreadFunc ()
	Benchmark thread fucntion
Public 成员函数 继承自 apollo::cyber::Component< SensorFrameMessage >
	Component ()
	~Component () override
bool	Initialize (const ComponentConfig &config) override
	init the component by protobuf object.
bool	Process (const std::shared_ptr< SensorFrameMessage > &msg0, const std::shared_ptr< NullType > &msg1, const std::shared_ptr< NullType > &msg2, const std::shared_ptr< NullType > &msg3)
Public 成员函数 继承自 apollo::cyber::ComponentBase
virtual	~ComponentBase ()
virtual bool	Initialize (const TimerComponentConfig &config)
virtual void	Shutdown ()
template<typename T >
bool	GetProtoConfig (T *config) const

额外继承的成员函数
Public 类型 继承自 apollo::cyber::ComponentBase
template<typename M >
using	Reader = cyber::Reader< M >
Protected 成员函数 继承自 apollo::cyber::ComponentBase
virtual void	Clear ()
const std::string &	ConfigFilePath () const
void	LoadConfigFiles (const ComponentConfig &config)
void	LoadConfigFiles (const TimerComponentConfig &config)
Protected 属性 继承自 apollo::cyber::ComponentBase
std::atomic< bool >	is_shutdown_ = {false}
std::shared_ptr< Node >	node_ = nullptr
std::string	config_file_path_ = ""
std::vector< std::shared_ptr< ReaderBase > >	readers_

详细描述

在文件 lidar_output_component.h 第 42 行定义.

构造及析构函数说明

LidarOutputComponent()

apollo::perception::lidar::LidarOutputComponent::LidarOutputComponent ( )

inline

在文件 lidar_output_component.h 第 44 行定义.

{}

~LidarOutputComponent()

apollo::perception::lidar::LidarOutputComponent::~LidarOutputComponent ( )

virtual

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

                                            {
  if (save_benchmark_frame_) {
    is_terminate_.store(true);
    benchmark_thread_->join();
  }
}

成员函数说明

BenchmarkThreadFunc()

void apollo::perception::lidar::LidarOutputComponent::BenchmarkThreadFunc

(

)

Benchmark thread fucntion

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

                                               {
  std::shared_ptr<SensorFrameMessage> message = nullptr;
  while (true) {
    {
      std::lock_guard<std::mutex> lock(benchmark_mutex_);
      if (!message_buffer_.empty()) {
        message = message_buffer_.front();
        message_buffer_.pop();
      } else {
        message = nullptr;
      }
    }
 
    if (is_terminate_.load()) {
      break;
    }
    if (message != nullptr) {
      SaveBenchmarkFrame(message);
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
  }
  AINFO << "Save benchmark frames finished.";
}

Init()

bool apollo::perception::lidar::LidarOutputComponent::Init ( )

overridevirtual

Init lidar output component

返回

true

false

实现了 apollo::cyber::ComponentBase.

在文件 lidar_output_component.cc 第 39 行定义.

                                {
  LidarOutputComponentConfig comp_config;
  if (!GetProtoConfig(&comp_config)) {
    AERROR << "Get LidarOutputComponentConfig file failed";
    return false;
  }
  AINFO << "Lidar Output Component Configs: "
        << comp_config.DebugString();
 
  // writer
  output_channel_name_ = comp_config.output_channel_name();
  writer_ = node_->CreateWriter<PerceptionObstacles>(output_channel_name_);
  // for saving benchmark frame
  save_benchmark_frame_ = comp_config.save_benchmark_frame();
  benchmark_frame_output_dir_ = comp_config.benchmark_frame_output_dir();
  is_terminate_.store(false);
  if (save_benchmark_frame_) {
    benchmark_thread_.reset(
        new std::thread(&LidarOutputComponent::BenchmarkThreadFunc, this));
  }
 
  // for saving LidarFrame
  lidar_frame_output_dir_ = comp_config.lidar_frame_output_dir();
  use_lidar_cooridinate_ = comp_config.use_lidar_cooridinate();
  cyber::ReaderConfig reader_config;
  reader_config.channel_name = comp_config.lidar_frame_channel_name();
  reader_config.pending_queue_size = 5;
  if (!comp_config.save_lidar_frame_message()) {
      return true;
  }
  std::function<void(const std::shared_ptr<LidarFrameMessage>&)> model_call
        = std::bind(&LidarOutputComponent::SaveBenchmarkLidarFrame,
            this, std::placeholders::_1);
  lidar_frame_reader_ = this->node_->CreateReader<LidarFrameMessage>(
      reader_config, model_call);
 
  // Attention:
  // For DKIT-2024 Part2 benchmark-data: timestamp is just two-decimal-places
  // But in apollo-benchmark, the timestamp diff is set to 1e-4
  // So this should also save timestamp to two-decimal-places
  // Trick-action: WE should modify apollo-benchmark code
  // PS: part1 is RIGHT, completely equal to pointcloud-timestamp)
  timestamp_two_decimal_format_ = comp_config.timestamp_two_decimal_format();
 
  AINFO << "Register LidarFrameMessage for benchmark";
  return true;
}

Proc()

bool apollo::perception::lidar::LidarOutputComponent::Proc ( const std::shared_ptr< SensorFrameMessage > &  message )

override

Process of lidar output component

参数

message

sensor frame message

返回

true

false

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

                                                         {
  std::shared_ptr<PerceptionObstacles> out_message(new (std::nothrow)
                                                       PerceptionObstacles);
  double timestamp = in_message->timestamp_;
  double lidar_timestamp = in_message->lidar_timestamp_;
  apollo::common::ErrorCode error_code = apollo::common::ErrorCode::OK;
  std::vector<base::ObjectPtr> valid_objects;
 
  if (in_message != nullptr && in_message->frame_ != nullptr) {
    auto lidar_objects = in_message->frame_->objects;
    valid_objects.assign(lidar_objects.begin(), lidar_objects.end());
  }
 
  if (save_benchmark_frame_) {
    std::lock_guard<std::mutex> lock(benchmark_mutex_);
    message_buffer_.push(in_message);
  }
 
  if (!onboard::MsgSerializer::SerializeMsg(
          timestamp,
          lidar_timestamp,
          in_message->seq_num_,
          valid_objects,
          error_code,
          out_message.get())) {
    AERROR << "Failed to gen PerceptionObstacles object.";
    return false;
  }
 
  writer_->Write(out_message);
  AINFO << "Send lidar tracking output message.";
 
  return true;
}

SaveBenchmarkFrame()

bool apollo::perception::lidar::LidarOutputComponent::SaveBenchmarkFrame

(

const std::shared_ptr< SensorFrameMessage > &

message

)

Save benchmark frame for end-to-end evaluation

参数

message

sensor frame message

返回

true

false

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

                                                         {
  std::shared_ptr<PerceptionBenchmarkFrame> out_message(new (std::nothrow)
      PerceptionBenchmarkFrame);
  double timestamp = in_message->timestamp_;
  double lidar_timestamp = in_message->lidar_timestamp_;
  std::vector<base::ObjectPtr> valid_objects;
 
  if (in_message != nullptr && in_message->frame_ != nullptr) {
    auto lidar_objects = in_message->frame_->objects;
    valid_objects.assign(lidar_objects.begin(), lidar_objects.end());
  }
 
  auto sensor_frame_info = out_message->mutable_sensor_frame_info();
  sensor_frame_info->set_sensor_id(in_message->sensor_id_);
  sensor_frame_info->set_timestamp(timestamp);
 
  Eigen::Affine3d sensor2world_pose = Eigen::Affine3d::Identity();
  if (in_message == nullptr || in_message->frame_ == nullptr) {
    AERROR << "SaveBenchmarkFrame error, Can't get sensor2world_pose.";
  }
  sensor2world_pose = in_message->frame_->sensor2world_pose;
  for (int i = 0; i < 4; ++i) {
    for (int j = 0; j < 4; ++j) {
      double val = sensor2world_pose.matrix()(i, j);
      sensor_frame_info->add_sensor2world_pose(val);
    }
  }
 
  // Serialize benchmark message
  if (!onboard::MsgSerializer::SerializeBenchmarkMsg(
      timestamp,
      lidar_timestamp,
      in_message->seq_num_,
      valid_objects,
      out_message.get())) {
    AERROR << "Failed to get PerceptionBenchmarkFrame object.";
    return false;
  }
 
  if (!EnsureDirectory(benchmark_frame_output_dir_)) {
    AINFO << "Create dir " << benchmark_frame_output_dir_ << " error.";
    return false;
  }
 
  double two_demical_time = round(timestamp * 100) / 100.0;
  std::string pb_name = "";
  if (timestamp_two_decimal_format_) {
      pb_name = GetAbsolutePath(benchmark_frame_output_dir_,
          std::to_string(two_demical_time) + ".pb");
  } else {
      pb_name = GetAbsolutePath(benchmark_frame_output_dir_,
          std::to_string(timestamp) + ".pb");
  }
  SetProtoToASCIIFile(*out_message, pb_name);
 
  return true;
}

SaveBenchmarkLidarFrame()

bool apollo::perception::lidar::LidarOutputComponent::SaveBenchmarkLidarFrame

(

const std::shared_ptr< LidarFrameMessage > &

message

)

在文件 lidar_output_component.cc 第 182 行定义.

                                                        {
    std::shared_ptr<PerceptionBenchmarkFrame> out_message(
        new (std::nothrow) PerceptionBenchmarkFrame);
    double timestamp = in_message->timestamp_;
    double lidar_timestamp = in_message->lidar_timestamp_;
 
    std::vector<base::ObjectPtr> valid_objects;
    if (in_message != nullptr && in_message->lidar_frame_ != nullptr) {
        auto lidar_objects = in_message->lidar_frame_->segmented_objects;
        valid_objects.assign(lidar_objects.begin(), lidar_objects.end());
    }
 
    auto sensor_frame_info = out_message->mutable_sensor_frame_info();
    sensor_frame_info->set_sensor_id(
        in_message->lidar_frame_->sensor_info.name);
    sensor_frame_info->set_timestamp(timestamp);
 
    Eigen::Affine3d sensor2world_pose = Eigen::Affine3d::Identity();
    if (in_message == nullptr || in_message->lidar_frame_ == nullptr) {
        AERROR << "SaveBenchmarkLidarFrame Error, Can't get lidar2world_pose";
    }
    sensor2world_pose = in_message->lidar_frame_->lidar2world_pose;
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            double val = sensor2world_pose.matrix()(i, j);
            sensor_frame_info->add_sensor2world_pose(val);
        }
    }
 
    // Serialize LidarFrame benchmark message
    if (!onboard::MsgSerializer::SerializeLidarFrameMsg(
                timestamp,
                lidar_timestamp,
                in_message->seq_num_,
                sensor2world_pose,
                valid_objects,
                out_message.get(),
                use_lidar_cooridinate_)) {
        AERROR << "Failed to get SerializeLidarFrameMsg object.";
        return false;
    }
 
    if (!EnsureDirectory(lidar_frame_output_dir_)) {
        AERROR << "Create dir " << lidar_frame_output_dir_ << " error.";
        return false;
    }
    double two_demical_time = round(timestamp * 100) / 100.0;
    std::string pb_name = "";
    if (timestamp_two_decimal_format_) {
        pb_name = GetAbsolutePath(lidar_frame_output_dir_,
            std::to_string(two_demical_time) + ".pb");
    } else {
        pb_name = GetAbsolutePath(lidar_frame_output_dir_,
            std::to_string(timestamp) + ".pb");
    }
    SetProtoToASCIIFile(*out_message, pb_name);
 
    AINFO << "SaveBenchmarkLidarFrame Success: time is "
          << std::to_string(timestamp);
    return true;
}

---

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

• modules/perception/lidar_output/lidar_output_component.h
• modules/perception/lidar_output/lidar_output_component.cc