apollo::drivers::lidar::FusionAndCompensatorComponent类 参考

#include <fusion_and_compensator_component.h>

类 apollo::drivers::lidar::FusionAndCompensatorComponent 继承关系图:

apollo::drivers::lidar::FusionAndCompensatorComponent 的协作图:

Public 成员函数
bool	Init () override
bool	Proc (const std::shared_ptr< PointCloud > &point_cloud) override
Public 成员函数 继承自 apollo::cyber::Component< M0, M1, M2, M3 >
	Component ()
	~Component () override
bool	Initialize (const ComponentConfig &config) override
	init the component by protobuf object.
bool	Process (const std::shared_ptr< M0 > &msg0, const std::shared_ptr< M1 > &msg1, const std::shared_ptr< M2 > &msg2, const std::shared_ptr< M3 > &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_

详细描述

在文件 fusion_and_compensator_component.h 第 48 行定义.

成员函数说明

Init()

bool apollo::drivers::lidar::FusionAndCompensatorComponent::Init ( )

overridevirtual

实现了 apollo::cyber::ComponentBase.

在文件 fusion_and_compensator_component.cc 第 30 行定义.

                                         {
    if (!GetProtoConfig(&conf_)) {
        AWARN << "Load config failed, config file" << ConfigFilePath();
        return false;
    }
    tf2_buffer_ptr_ = apollo::transform::Buffer::Instance();
 
    writer_ = node_->CreateWriter<PointCloud>(conf_.output_channel());
 
    for (const auto& channel : conf_.input_channel()) {
        auto reader = node_->CreateReader<PointCloud>(channel);
 
        readers_.emplace_back(reader);
    }
    for (const auto& filter_config : conf_.filter_config()) {
        filter_map_.emplace(filter_config.frame_id(), &filter_config);
    }
    return true;
}

Proc()

bool apollo::drivers::lidar::FusionAndCompensatorComponent::Proc ( const std::shared_ptr< PointCloud > &  point_cloud )

override

在文件 fusion_and_compensator_component.cc 第 50 行定义.

                                                                                     {
    auto target = writer_->AcquireMessage();
    target->Clear();
    target->mutable_point()->Reserve(reserved_point_size_);
    target->mutable_header()->set_lidar_timestamp(point_cloud->header().lidar_timestamp());
    if (conf_.has_target_frame_id()) {
        target->mutable_header()->set_frame_id(conf_.target_frame_id());
    } else {
        target->mutable_header()->set_frame_id(point_cloud->header().frame_id());
    }
 
    auto start_time = Time::Now().ToSecond();
    std::vector<std::shared_ptr<PointCloud>> point_clouds = {point_cloud};
    auto fusion_readers = readers_;
    while ((Time::Now().ToSecond() - start_time) < conf_.wait_time_s() && fusion_readers.size() > 0) {
        for (auto itr = fusion_readers.begin(); itr != fusion_readers.end();) {
            (*itr)->Observe();
            if (!(*itr)->Empty()) {
                auto source = (*itr)->GetLatestObserved();
                if (conf_.drop_expired_data() && IsExpired(target, source)) {
                    ++itr;
                } else {
                    point_clouds.emplace_back(source);
                    itr = fusion_readers.erase(itr);
                }
            } else {
                ++itr;
            }
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
 
    auto diff = Time::Now().ToNanosecond() - target->header().lidar_timestamp();
    AINFO << "Pointcloud fusion diff: " << diff / 1000000 << "ms";
 
    uint64_t timestamp_min = 0;
    uint64_t timestamp_max = 0;
    GetTimestampInterval(point_clouds, &timestamp_min, &timestamp_max);
 
    for (const auto& pc : point_clouds) {
        if (!FusionAndCompensator(pc, timestamp_min, timestamp_max, target)) {
            return false;
        }
    }
 
    target->mutable_header()->set_sequence_num(seq_num_++);
    target->mutable_header()->set_timestamp_sec(cyber::Time::Now().ToSecond());
    target->set_height(point_cloud->height());
    target->set_width(target->point_size() / target->height());
    target->set_is_dense(point_cloud->is_dense());
    target->set_measurement_time(point_cloud->measurement_time());
 
    writer_->Write(target);
    return true;
}

---

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

• modules/drivers/lidar_fusion_and_compensator/fusion_and_compensator_component.h
• modules/drivers/lidar_fusion_and_compensator/fusion_and_compensator_component.cc