apollo::perception::camera::LaneCameraPerception类 参考

#include <lane_camera_perception.h>

类 apollo::perception::camera::LaneCameraPerception 继承关系图:

apollo::perception::camera::LaneCameraPerception 的协作图:

Public 类型
template<typename T , class EigenType >
using	EigenMap = apollo::common::EigenMap< T, EigenType >

Public 成员函数
	LaneCameraPerception ()=default
	~LaneCameraPerception ()=default
bool	Init (const CameraPerceptionInitOptions &options) override
void	InitLane (base::BaseCameraModelPtr &model, const app::PerceptionParam &perception_param)
void	InitCalibrationService (const base::BaseCameraModelPtr model, const app::PerceptionParam &perception_param)
void	SetCameraHeightAndPitch (const std::map< std::string, float > name_camera_ground_height_map, const std::map< std::string, float > name_camera_pitch_angle_diff_map, const float &pitch_angle_calibrator_working_sensor)
void	SetIm2CarHomography (const Eigen::Matrix3d &homography_im2car)
bool	GetCalibrationService (BaseCalibrationService **calibration_service)
bool	Perception (const CameraPerceptionOptions &options, CameraFrame *frame) override
std::string	Name () const override
Public 成员函数 继承自 apollo::perception::camera::BaseCameraPerception
	BaseCameraPerception ()=default
virtual	~BaseCameraPerception ()=default
	DISALLOW_COPY_AND_ASSIGN (BaseCameraPerception)

详细描述

在文件 lane_camera_perception.h 第 40 行定义.

成员类型定义说明

EigenMap

template<typename T , class EigenType >

using apollo::perception::camera::LaneCameraPerception::EigenMap = apollo::common::EigenMap<T, EigenType>

在文件 lane_camera_perception.h 第 43 行定义.

构造及析构函数说明

LaneCameraPerception()

apollo::perception::camera::LaneCameraPerception::LaneCameraPerception ( )

default

~LaneCameraPerception()

apollo::perception::camera::LaneCameraPerception::~LaneCameraPerception ( )

default

成员函数说明

GetCalibrationService()

bool apollo::perception::camera::LaneCameraPerception::GetCalibrationService

(

BaseCalibrationService **

calibration_service

)

在文件 lane_camera_perception.cc 第 187 行定义.

                                                  {
  *calibration_service = calibration_service_.get();
  return true;
}

Init()

bool apollo::perception::camera::LaneCameraPerception::Init ( const CameraPerceptionInitOptions &  options )

overridevirtual

实现了 apollo::perception::camera::BaseCameraPerception.

在文件 lane_camera_perception.cc 第 46 行定义.

                                                                          {
  std::string config_file =
      GetConfigFile(options.config_path, options.config_file);
  ACHECK(cyber::common::GetProtoFromFile(config_file, &perception_param_))
      << "Read config failed: " << config_file;
  ACHECK(inference::CudaUtil::set_device_id(perception_param_.gpu_id()));
 
  lane_calibration_working_sensor_name_ =
      options.lane_calibration_working_sensor_name;
 
  // Init lane
  base::BaseCameraModelPtr model;
  InitLane(model, perception_param_);
 
  // Init calibration service
  InitCalibrationService(model, perception_param_);
 
  return true;
}

InitCalibrationService()

void apollo::perception::camera::LaneCameraPerception::InitCalibrationService	(	const base::BaseCameraModelPtr	model,
		const app::PerceptionParam &	perception_param
	)

在文件 lane_camera_perception.cc 第 137 行定义.

                                                {
  // Init calibration service
  ACHECK(perception_param.has_calibration_service_param())
      << "Failed to include calibration_service_param";
 
  auto calibration_service_param = perception_param.calibration_service_param();
  CalibrationServiceInitOptions calibration_service_init_options;
  calibration_service_init_options.calibrator_working_sensor_name =
      lane_calibration_working_sensor_name_;
  calibration_service_init_options.name_intrinsic_map = name_intrinsic_map_;
  calibration_service_init_options.calibrator_method =
      calibration_service_param.calibrator_method();
  calibration_service_init_options.image_height =
      static_cast<int>(model->get_height());
  calibration_service_init_options.image_width =
      static_cast<int>(model->get_width());
 
  calibration_service_.reset(
      BaseCalibrationServiceRegisterer::GetInstanceByName(
          calibration_service_param.plugin_param().name()));
  CHECK_NOTNULL(calibration_service_);
  ACHECK(calibration_service_->Init(calibration_service_init_options))
      << "Failed to init " << calibration_service_param.plugin_param().name();
  AINFO << "Calibration service: " << calibration_service_->Name();
}

InitLane()

void apollo::perception::camera::LaneCameraPerception::InitLane	(	base::BaseCameraModelPtr &	model,
		const app::PerceptionParam &	perception_param
	)

在文件 lane_camera_perception.cc 第 66 行定义.

                                                {
  // Init lane
  CHECK_GT(perception_param.lane_param_size(), 0)
      << "Failed to include lane_param";
  for (int i = 0; i < perception_param.lane_param_size(); ++i) {
    // Initialize lane detector
    const auto &lane_param = perception_param.lane_param(i);
    ACHECK(lane_param.has_lane_detector_param())
        << "Failed to include lane_detector_param.";
    LaneDetectorInitOptions lane_detector_init_options;
    const auto &lane_detector_param = lane_param.lane_detector_param();
    const auto &lane_detector_plugin_param = lane_detector_param.plugin_param();
    lane_detector_init_options.config_file =
        lane_detector_plugin_param.config_file();
    lane_detector_init_options.config_path =
        lane_detector_plugin_param.config_path();
    model = algorithm::SensorManager::Instance()->GetUndistortCameraModel(
        lane_detector_param.camera_name());
    ACHECK(model) << "Can't find " << lane_detector_param.camera_name()
                  << " in data/conf/sensor_meta.pb.txt";
    auto pinhole = static_cast<base::PinholeCameraModel *>(model.get());
    name_intrinsic_map_.insert(std::pair<std::string, Eigen::Matrix3f>(
        lane_detector_param.camera_name(), pinhole->get_intrinsic_params()));
    lane_detector_init_options.gpu_id = perception_param.gpu_id();
    lane_detector_init_options.base_camera_model = model;
    AINFO << "lane_detector_name: " << lane_detector_plugin_param.name();
 
    // Initialize lane detector
    lane_detector_.reset(BaseLaneDetectorRegisterer::GetInstanceByName(
        lane_detector_plugin_param.name()));
    CHECK_NOTNULL(lane_detector_);
    ACHECK(lane_detector_->Init(lane_detector_init_options))
        << "Failed to init: " << lane_detector_plugin_param.name();
    AINFO << "Detector: " << lane_detector_->Name();
 
    // Initialize lane postprocessor
    const auto &lane_postprocessor_param =
        lane_param.lane_postprocessor_param();
    LanePostprocessorInitOptions postprocessor_init_options;
    postprocessor_init_options.config_path =
        lane_postprocessor_param.config_path();
    postprocessor_init_options.config_file =
        lane_postprocessor_param.config_file();
 
    lane_postprocessor_.reset(
        BaseLanePostprocessorRegisterer::GetInstanceByName(
            lane_postprocessor_param.name()));
    CHECK_NOTNULL(lane_postprocessor_);
    ACHECK(lane_postprocessor_->Init(postprocessor_init_options))
        << "Failed to init: " << lane_postprocessor_param.name();
    AINFO << "lane_postprocessor: " << lane_postprocessor_->Name();
 
    // Init output file folder
    if (perception_param.has_debug_param() &&
        perception_param.debug_param().has_lane_out_dir()) {
      write_out_lane_file_ = true;
      out_lane_dir_ = perception_param.debug_param().lane_out_dir();
      EnsureDirectory(out_lane_dir_);
    }
 
    if (perception_param.has_debug_param() &&
        perception_param.debug_param().has_calibration_out_dir()) {
      write_out_calib_file_ = true;
      out_calib_dir_ = perception_param.debug_param().calibration_out_dir();
      EnsureDirectory(out_calib_dir_);
    }
  }
}

Name()

std::string apollo::perception::camera::LaneCameraPerception::Name ( ) const

inlineoverridevirtual

实现了 apollo::perception::camera::BaseCameraPerception.

在文件 lane_camera_perception.h 第 63 行定义.

{ return "LaneCameraPerception"; }

Perception()

bool apollo::perception::camera::LaneCameraPerception::Perception ( const CameraPerceptionOptions &  options, CameraFrame *  frame  )

overridevirtual

实现了 apollo::perception::camera::BaseCameraPerception.

在文件 lane_camera_perception.cc 第 193 行定义.

                                                          {
  PERF_FUNCTION();
  inference::CudaUtil::set_device_id(perception_param_.gpu_id());
  PERF_BLOCK_START();
 
  if (frame->calibration_service == nullptr) {
    AERROR << "Calibraion service is not available";
    return false;
  }
 
  // Lane detector and postprocessor: work on front_6mm only
  if (lane_calibration_working_sensor_name_ ==
      frame->data_provider->sensor_name()) {
    frame->camera_k_matrix =
        name_intrinsic_map_.at(frame->data_provider->sensor_name());
    LaneDetectorOptions lane_detetor_options;
    LanePostprocessorOptions lane_postprocessor_options;
    if (!lane_detector_->Detect(lane_detetor_options, frame)) {
      AERROR << "Failed to detect lane.";
      return false;
    }
    PERF_BLOCK_END_WITH_INDICATOR(frame->data_provider->sensor_name(),
                                  "LaneDetector");
 
    if (!lane_postprocessor_->Process2D(lane_postprocessor_options, frame)) {
      AERROR << "Failed to postprocess lane 2D.";
      return false;
    }
    PERF_BLOCK_END_WITH_INDICATOR(frame->data_provider->sensor_name(),
                                  "LanePostprocessor2D");
 
    // Calibration service
    frame->calibration_service->Update(frame);
    PERF_BLOCK_END_WITH_INDICATOR(frame->data_provider->sensor_name(),
                                  "CalibrationService");
 
    if (!lane_postprocessor_->Process3D(lane_postprocessor_options, frame)) {
      AERROR << "Failed to postprocess lane 3D.";
      return false;
    }
    PERF_BLOCK_END_WITH_INDICATOR(frame->data_provider->sensor_name(),
                                  "LanePostprocessor3D");
 
    if (write_out_lane_file_) {
      std::string lane_file_path =
          absl::StrCat(out_lane_dir_, "/", frame->frame_id, ".txt");
      WriteLanelines(write_out_lane_file_, lane_file_path, frame->lane_objects);
    }
  } else {
    AINFO << "Skip lane detection & calibration due to sensor mismatch.";
    AINFO << "Will use service sync from obstacle camera instead.";
    // fill the frame using previous estimates
    frame->calibration_service->Update(frame);
    PERF_BLOCK_END_WITH_INDICATOR(frame->data_provider->sensor_name(),
                                  "CalibrationService");
  }
 
  if (write_out_calib_file_) {
    std::string calib_file_path =
        absl::StrCat(out_calib_dir_, "/", frame->frame_id, ".txt");
    WriteCalibrationOutput(write_out_calib_file_, calib_file_path, frame);
  }
  return true;
}

SetCameraHeightAndPitch()

void apollo::perception::camera::LaneCameraPerception::SetCameraHeightAndPitch	(	const std::map< std::string, float >	name_camera_ground_height_map,
		const std::map< std::string, float >	name_camera_pitch_angle_diff_map,
		const float &	pitch_angle_calibrator_working_sensor
	)

在文件 lane_camera_perception.cc 第 165 行定义.

                                                        {
  if (calibration_service_ == nullptr) {
    AERROR << "Calibraion service is not available";
    return;
  }
  calibration_service_->SetCameraHeightAndPitch(
      name_camera_ground_height_map, name_camera_pitch_angle_diff_map,
      pitch_angle_calibrator_working_sensor);
}

SetIm2CarHomography()

void apollo::perception::camera::LaneCameraPerception::SetIm2CarHomography

(

const Eigen::Matrix3d &

homography_im2car

)

在文件 lane_camera_perception.cc 第 178 行定义.

                                            {
  if (calibration_service_ == nullptr) {
    AERROR << "Calibraion service is not available";
    return;
  }
  lane_postprocessor_->SetIm2CarHomography(homography_im2car);
}

---

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

• modules/perception/lane_detection/app/lane_camera_perception.h
• modules/perception/lane_detection/app/lane_camera_perception.cc