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 第 108 行定义.

                                                                       {
  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