apollo::perception::trafficlight::ClassifyBySimple类 参考

#include <classify.h>

apollo::perception::trafficlight::ClassifyBySimple 的协作图:

Public 成员函数
	ClassifyBySimple ()=default
	Construct a new classify by simple object.
	~ClassifyBySimple ()=default
	Destroy the new classify by simple object.
void	Init (const ClassifyParam &model_config, const int gpu_id)
	Initialize traffic light classify parameters.
void	Perform (const camera::TrafficLightFrame *frame, std::vector< base::TrafficLightPtr > *lights)
	Classify model inference process.

详细描述

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

构造及析构函数说明

ClassifyBySimple()

apollo::perception::trafficlight::ClassifyBySimple::ClassifyBySimple ( )

default

Construct a new classify by simple object.

~ClassifyBySimple()

apollo::perception::trafficlight::ClassifyBySimple::~ClassifyBySimple ( )

default

Destroy the new classify by simple object.

成员函数说明

Init()

void apollo::perception::trafficlight::ClassifyBySimple::Init	(	const ClassifyParam &	model_config,
		const int	gpu_id
	)

Initialize traffic light classify parameters.

参数

model_config
gpu_id

在文件 classify.cc 第 31 行定义.

                                                                               {
    AINFO << "Enter Classify init";
    net_inputs_.clear();
    net_outputs_.clear();
    AINFO << "clear success";
    net_inputs_ = inference::GetBlobNames(model_config.info().inputs());
    net_outputs_ = inference::GetBlobNames(model_config.info().outputs());
 
    AINFO << net_inputs_.size();
    AINFO << net_outputs_.size();
 
    for (auto name : net_inputs_) {
        AINFO << "net input blobs: " << name;
    }
    for (auto name : net_outputs_) {
        AINFO << "net output blobs: " << name;
    }
 
    std::string model_path = GetModelPath(model_config.info().name());
 
    std::string proto_file = GetModelFile(model_path, model_config.info().proto_file().file());
    AINFO << "proto_file " << proto_file;
 
    std::string weight_file = GetModelFile(model_path, model_config.info().weight_file().file());
 
    AINFO << "weight_file" << weight_file;
 
    const auto& model_type = model_config.info().framework();
    rt_net_.reset(inference::CreateInferenceByName(
            model_type, proto_file, weight_file, net_outputs_, net_inputs_, model_path));
 
    rt_net_->set_gpu_id(gpu_id);
    gpu_id_ = gpu_id;
 
    resize_height_ = model_config.classify_resize_height();
    resize_width_ = model_config.classify_resize_width();
    unknown_threshold_ = model_config.classify_threshold();
    mean_.reset(new base::Blob<float>(1, 3, 1, 1));
    float* p = mean_->mutable_cpu_data();
    if (model_config.is_bgr()) {
        data_provider_image_option_.target_color = base::Color::BGR;
        p[0] = model_config.mean_b();
        p[1] = model_config.mean_g();
        p[2] = model_config.mean_r();
    } else {
        data_provider_image_option_.target_color = base::Color::RGB;
        p[0] = model_config.mean_r();
        p[1] = model_config.mean_g();
        p[2] = model_config.mean_b();
    }
    scale_ = model_config.scale();
 
    std::vector<int> shape = {1, resize_height_, resize_width_, 3};
    mean_buffer_.reset(new base::Blob<float>(shape));
 
    std::map<std::string, std::vector<int>> input_reshape;
    inference::AddShape(&input_reshape, model_config.info().inputs());
 
    AINFO << "input_reshape: " << input_reshape[net_inputs_[0]][0] << ", " << input_reshape[net_inputs_[0]][1] << ", "
          << input_reshape[net_inputs_[0]][2] << ", " << input_reshape[net_inputs_[0]][3];
 
    if (!rt_net_->Init(input_reshape)) {
        AWARN << "net init fail.";
    }
 
    image_.reset(new base::Image8U(resize_height_, resize_width_, base::Color::BGR));
}

Perform()

void apollo::perception::trafficlight::ClassifyBySimple::Perform	(	const camera::TrafficLightFrame *	frame,
		std::vector< base::TrafficLightPtr > *	lights
	)

Classify model inference process.

参数

frame
lights

在文件 classify.cc 第 99 行定义.

                                                                                                           {
    if (cudaSetDevice(gpu_id_) != cudaSuccess) {
        AERROR << "Failed to set device to " << gpu_id_;
        return;
    }
    std::shared_ptr<base::Blob<uint8_t>> rectified_blob;
 
    auto input_blob_recog = rt_net_->get_blob(net_inputs_[0]);
    auto output_blob_recog = rt_net_->get_blob(net_outputs_[0]);
 
    for (base::TrafficLightPtr light : *lights) {
        if (!light->region.is_detected) {
            continue;
        }
 
        data_provider_image_option_.crop_roi = light->region.detection_roi;
        data_provider_image_option_.do_crop = true;
        data_provider_image_option_.target_color = base::Color::BGR;
        frame->data_provider->GetImage(data_provider_image_option_, image_.get());
 
        AINFO << "get img done";
 
        const float* mean = mean_.get()->cpu_data();
        inference::ResizeGPU(
                *image_,
                input_blob_recog,
                frame->data_provider->src_width(),
                0,
                mean[0],
                mean[1],
                mean[2],
                true,
                scale_);
 
        AINFO << "resize gpu finish.";
        cudaDeviceSynchronize();
 
        PERF_BLOCK("traffic_light_recognition_inference")
        rt_net_->Infer();
        PERF_BLOCK_END
 
        cudaDeviceSynchronize();
        AINFO << "infer finish.";
 
        float* out_put_data = output_blob_recog->mutable_cpu_data();
        Prob2Color(out_put_data, unknown_threshold_, light);
    }
}

---

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

• modules/perception/traffic_light_recognition/recognition/caffe_recognizer/classify.h
• modules/perception/traffic_light_recognition/recognition/caffe_recognizer/classify.cc