apollo::drivers::camera::CameraComponent类 参考

#include <camera_component.h>

类 apollo::drivers::camera::CameraComponent 继承关系图:

apollo::drivers::camera::CameraComponent 的协作图:

Public 成员函数
bool	Init () override
	~CameraComponent ()
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_

详细描述

在文件 camera_component.h 第 34 行定义.

构造及析构函数说明

~CameraComponent()

apollo::drivers::camera::CameraComponent::~CameraComponent

(

)

在文件 camera_component.cc 第 186 行定义.

                                  {
    if (running_.load()) {
        running_.exchange(false);
#ifndef __aarch64__
        free(raw_image_->image);
#else
        cudaFreeHost(raw_image_->image);
#endif
        async_result_.wait();
    }
}

成员函数说明

Init()

bool apollo::drivers::camera::CameraComponent::Init ( )

overridevirtual

实现了 apollo::cyber::ComponentBase.

在文件 camera_component.cc 第 34 行定义.

                           {
    // hook: Apollo License Verification: v_apollo_park
    camera_config_ = std::make_shared<Config>();
    if (!apollo::cyber::common::GetProtoFromFile(config_file_path_, camera_config_.get())) {
        return false;
    }
    AINFO << "UsbCam config: " << camera_config_->DebugString();
 
    camera_device_.reset(new UsbCam());
    camera_device_->init(camera_config_);
    raw_image_.reset(new CameraImage);
    raw_image_for_compress_.reset(new CameraImage);
 
    raw_image_->width = camera_config_->width();
    raw_image_->height = camera_config_->height();
    raw_image_->bytes_per_pixel = camera_config_->bytes_per_pixel();
 
    raw_image_for_compress_->width = camera_config_->width();
    raw_image_for_compress_->height = camera_config_->height();
    raw_image_for_compress_->bytes_per_pixel = camera_config_->bytes_per_pixel();
 
    if (camera_config_->pixel_format() == "yuyv" || camera_config_->pixel_format() == "uyvy"
        || camera_config_->pixel_format() == "yuvmono10") {
        raw_image_for_compress_->image_size = raw_image_for_compress_->width * raw_image_for_compress_->height * 2;
    } else if (camera_config_->pixel_format() == "mjpeg") {
        AINFO << "Disable sensor raw camera output with format mjpeg";
        raw_image_for_compress_->image_size = 0;
    } else if (camera_config_->pixel_format() == "rgb24") {
        raw_image_for_compress_->image_size = raw_image_for_compress_->width * raw_image_for_compress_->height * 3;
    } else {
        AERROR << "Wrong pixel fromat:" << camera_config_->pixel_format()
               << ",must be yuyv | uyvy | mjpeg | yuvmono10 | rgb24";
        return false;
    }
 
    if (raw_image_for_compress_->image_size == 0) {
        raw_image_for_compress_->image = nullptr;
    } else {
        raw_image_for_compress_->image
                = reinterpret_cast<char*>(calloc(raw_image_for_compress_->image_size, sizeof(char)));
    }
 
    device_wait_ = camera_config_->device_wait_ms();
    spin_rate_ = static_cast<uint32_t>((1.0 / camera_config_->spin_rate()) * 1e6);
 
    if (camera_config_->output_type() == YUYV) {
        raw_image_->image_size = raw_image_->width * raw_image_->height * 2;
    } else if (camera_config_->output_type() == RGB) {
        raw_image_->image_size = raw_image_->width * raw_image_->height * 3;
    }
    if (raw_image_->image_size > MAX_IMAGE_SIZE) {
        AERROR << "image size is too big ,must less than " << MAX_IMAGE_SIZE << " bytes.";
        return false;
    }
    raw_image_->is_new = 0;
    // free memory in this struct desturctor
#ifndef __aarch64__
    raw_image_->image = reinterpret_cast<char*>(calloc(raw_image_->image_size, sizeof(char)));
    if (raw_image_->image == nullptr) {
        AERROR << "system calloc memory error, size:" << raw_image_->image_size;
        return false;
    }
#else
    if (camera_config_->arm_gpu_acceleration()) {
        if (cudaMallocHost(&raw_image_->image, raw_image_->image_size * sizeof(char), cudaHostAllocMapped)
            != cudaSuccess) {
            AERROR << "cuda malloc memory error, size:" << raw_image_->image_size;
            return false;
        }
    } else {
        raw_image_->image = reinterpret_cast<char*>(calloc(raw_image_->image_size, sizeof(char)));
        if (raw_image_->image == nullptr) {
            AERROR << "system calloc memory error, size:" << raw_image_->image_size;
            return false;
        }
    }
#endif
 
    writer_ = node_->CreateWriter<Image>(camera_config_->channel_name());
    raw_writer_ = node_->CreateWriter<Image>(camera_config_->raw_channel_name());
 
    async_result_ = cyber::Async(&CameraComponent::run, this);
    return true;
}

---

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

• modules/drivers/camera/camera_component.h
• modules/drivers/camera/camera_component.cc