apollo::perception::camera::DarkSCNNLanePostprocessor类 参考

#include <darkSCNN_lane_postprocessor.h>

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

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

Public 类型
template<class EigenType >
using	EigenVector = apollo::common::EigenVector< EigenType >

Public 成员函数
	DarkSCNNLanePostprocessor ()
virtual	~DarkSCNNLanePostprocessor ()=default
bool	Init (const LanePostprocessorInitOptions &options=LanePostprocessorInitOptions()) override
bool	Process2D (const LanePostprocessorOptions &options, CameraFrame *frame) override
bool	Process3D (const LanePostprocessorOptions &options, CameraFrame *frame) override
void	SetIm2CarHomography (const Eigen::Matrix3d &homography_im2car) override
std::vector< std::vector< LanePointInfo > >	GetLanelinePointSet ()
std::vector< LanePointInfo >	GetAllInferLinePointSet ()
std::string	Name () const override
Public 成员函数 继承自 apollo::perception::camera::BaseLanePostprocessor
	BaseLanePostprocessor ()=default
virtual	~BaseLanePostprocessor ()=default
	DISALLOW_COPY_AND_ASSIGN (BaseLanePostprocessor)

详细描述

在文件 darkSCNN_lane_postprocessor.h 第 38 行定义.

成员类型定义说明

EigenVector

template<class EigenType >

using apollo::perception::camera::DarkSCNNLanePostprocessor::EigenVector = apollo::common::EigenVector<EigenType>

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

构造及析构函数说明

DarkSCNNLanePostprocessor()

apollo::perception::camera::DarkSCNNLanePostprocessor::DarkSCNNLanePostprocessor ( )

inline

在文件 darkSCNN_lane_postprocessor.h 第 46 行定义.

: BaseLanePostprocessor() {}

~DarkSCNNLanePostprocessor()

virtual apollo::perception::camera::DarkSCNNLanePostprocessor::~DarkSCNNLanePostprocessor ( )

virtualdefault

成员函数说明

GetAllInferLinePointSet()

std::vector< LanePointInfo > apollo::perception::camera::DarkSCNNLanePostprocessor::GetAllInferLinePointSet

(

)

GetLanelinePointSet()

std::vector< std::vector< LanePointInfo > > apollo::perception::camera::DarkSCNNLanePostprocessor::GetLanelinePointSet

(

)

Init()

bool apollo::perception::camera::DarkSCNNLanePostprocessor::Init ( const LanePostprocessorInitOptions &  options = LanePostprocessorInitOptions() )

overridevirtual

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

在文件 darkSCNN_lane_postprocessor.cc 第 77 行定义.

                                                 {
  // Read postprocessor parameter
  std::string config_file =
      GetConfigFile(options.config_path, options.config_file);
  if (!cyber::common::GetProtoFromFile(config_file,
                                       &lane_postprocessor_param_)) {
    AERROR << "Failed to read config detect_param: " << config_file;
    return false;
  }
  AINFO << "lane_postprocessor param: "
        << lane_postprocessor_param_.DebugString();
 
  input_offset_x_ = lane_postprocessor_param_.input_offset_x();
  input_offset_y_ = lane_postprocessor_param_.input_offset_y();
  lane_map_width_ = lane_postprocessor_param_.resize_width();
  lane_map_height_ = lane_postprocessor_param_.resize_height();
  DCHECK_LT(lane_map_width_, kMaxValidSize);
  DCHECK_GT(lane_map_width_, 0);
  DCHECK_LT(lane_map_height_, kMaxValidSize);
  DCHECK_GT(lane_map_height_, 0);
 
  roi_height_ = lane_postprocessor_param_.roi_height();
  roi_start_ = lane_postprocessor_param_.roi_start();
  roi_width_ = lane_postprocessor_param_.roi_width();
 
  lane_type_num_ = static_cast<int>(spatialLUTind.size());
  AINFO << "lane_type_num_: " << lane_type_num_;
  return true;
}

Name()

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

overridevirtual

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

在文件 darkSCNN_lane_postprocessor.cc 第 467 行定义.

                                                {
  return "DarkSCNNLanePostprocessor";
}

Process2D()

bool apollo::perception::camera::DarkSCNNLanePostprocessor::Process2D ( const LanePostprocessorOptions &  options, CameraFrame *  frame  )

overridevirtual

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

在文件 darkSCNN_lane_postprocessor.cc 第 108 行定义.

                                                                 {
  ADEBUG << "Begin to Process2D.";
  frame->lane_objects.clear();
  auto start = std::chrono::high_resolution_clock::now();
 
  cv::Mat lane_map(lane_map_height_, lane_map_width_, CV_32FC1);
  memcpy(lane_map.data, frame->lane_detected_blob->cpu_data(),
         lane_map_width_ * lane_map_height_ * sizeof(float));
 
  // if (options.use_lane_history &&
  //     (!use_history_ || time_stamp_ > options.timestamp)) {
  //   InitLaneHistory();
  // }
 
  // 1. Sample points on lane_map and project them onto world coordinate
 
  // TODO(techoe): Should be fixed
  int y = static_cast<int>(lane_map.rows * 0.9 - 1);
  // TODO(techoe): Should be fixed
  int step_y = (y - 40) * (y - 40) / 6400 + 1;
 
  xy_points.clear();
  xy_points.resize(lane_type_num_);
  uv_points.clear();
  uv_points.resize(lane_type_num_);
 
  while (y > 0) {
    for (int x = 1; x < lane_map.cols - 1; ++x) {
      int value = static_cast<int>(round(lane_map.at<float>(y, x)));
      // lane on left
 
      if ((value > 0 && value < 5) || value == 11) {
        // right edge (inner) of the lane
        if (value != static_cast<int>(round(lane_map.at<float>(y, x + 1)))) {
          Eigen::Matrix<float, 3, 1> img_point(
              static_cast<float>(x * roi_width_ / lane_map.cols),
              static_cast<float>(y * roi_height_ / lane_map.rows + roi_start_),
              1.0);
          Eigen::Matrix<float, 3, 1> xy_p;
          xy_p = trans_mat_ * img_point;
          Eigen::Matrix<float, 2, 1> xy_point;
          Eigen::Matrix<float, 2, 1> uv_point;
          if (std::fabs(xy_p(2)) < 1e-6) continue;
          xy_point << xy_p(0) / xy_p(2), xy_p(1) / xy_p(2);
 
          // Filter out lane line points
          if (xy_point(0) < 0.0 ||  // This condition is only for front camera
              xy_point(0) > max_longitudinal_distance_ ||
              std::abs(xy_point(1)) > 30.0) {
            continue;
          }
          uv_point << static_cast<float>(x * roi_width_ / lane_map.cols),
              static_cast<float>(y * roi_height_ / lane_map.rows + roi_start_);
          if (xy_points[value].size() < minNumPoints_ || xy_point(0) < 50.0f ||
              std::fabs(xy_point(1) - xy_points[value].back()(1)) < 1.0f) {
            xy_points[value].push_back(xy_point);
            uv_points[value].push_back(uv_point);
          }
        }
      } else if (value >= 5 && value < lane_type_num_) {
        // Left edge (inner) of the lane
        if (value != static_cast<int>(round(lane_map.at<float>(y, x - 1)))) {
          Eigen::Matrix<float, 3, 1> img_point(
              static_cast<float>(x * roi_width_ / lane_map.cols),
              static_cast<float>(y * roi_height_ / lane_map.rows + roi_start_),
              1.0);
          Eigen::Matrix<float, 3, 1> xy_p;
          xy_p = trans_mat_ * img_point;
          Eigen::Matrix<float, 2, 1> xy_point;
          Eigen::Matrix<float, 2, 1> uv_point;
          if (std::fabs(xy_p(2)) < 1e-6) continue;
          xy_point << xy_p(0) / xy_p(2), xy_p(1) / xy_p(2);
          // Filter out lane line points
          if (xy_point(0) < 0.0 ||  // This condition is only for front camera
              xy_point(0) > max_longitudinal_distance_ ||
              std::abs(xy_point(1)) > 30.0) {
            continue;
          }
          uv_point << static_cast<float>(x * roi_width_ / lane_map.cols),
              static_cast<float>(y * roi_height_ / lane_map.rows + roi_start_);
          if (xy_points[value].size() < minNumPoints_ || xy_point(0) < 50.0f ||
              std::fabs(xy_point(1) - xy_points[value].back()(1)) < 1.0f) {
            xy_points[value].push_back(xy_point);
            uv_points[value].push_back(uv_point);
          }
        } else if (value >= lane_type_num_) {
          AWARN << "Lane line value shouldn't be equal or more than: "
                << lane_type_num_;
        }
      }
    }
    step_y = (y - 45) * (y - 45) / 6400 + 1;
    y -= step_y;
  }
 
  auto elapsed_1 = std::chrono::high_resolution_clock::now() - start;
  int64_t microseconds_1 =
      std::chrono::duration_cast<std::chrono::microseconds>(elapsed_1).count();
  time_1 += microseconds_1;
 
  // 2. Remove outliers and Do a ransac fitting
  EigenVector<Eigen::Matrix<float, 4, 1>> coeffs;
  EigenVector<Eigen::Matrix<float, 4, 1>> img_coeffs;
  EigenVector<Eigen::Matrix<float, 2, 1>> selected_xy_points;
  coeffs.resize(lane_type_num_);
  img_coeffs.resize(lane_type_num_);
  for (int i = 1; i < lane_type_num_; ++i) {
    coeffs[i] << 0, 0, 0, 0;
    if (xy_points[i].size() < minNumPoints_) continue;
    Eigen::Matrix<float, 4, 1> coeff;
    // Solve linear system to estimate polynomial coefficients
    if (RansacFitting<float>(xy_points[i], &selected_xy_points, &coeff, 200,
                             static_cast<int>(minNumPoints_), 0.1f)) {
      coeffs[i] = coeff;
 
      xy_points[i].clear();
      xy_points[i] = selected_xy_points;
    } else {
      xy_points[i].clear();
    }
  }
 
  auto elapsed_2 = std::chrono::high_resolution_clock::now() - start;
  int64_t microseconds_2 =
      std::chrono::duration_cast<std::chrono::microseconds>(elapsed_2).count();
  time_2 += microseconds_2 - microseconds_1;
 
  // 3. Write values into lane_objects
  std::vector<float> c0s(lane_type_num_, 0);
  for (int i = 1; i < lane_type_num_; ++i) {
    if (xy_points[i].size() < minNumPoints_) continue;
    c0s[i] = GetPolyValue(
        static_cast<float>(coeffs[i](3)), static_cast<float>(coeffs[i](2)),
        static_cast<float>(coeffs[i](1)), static_cast<float>(coeffs[i](0)),
        static_cast<float>(3.0));
  }
  // [1] Determine lane spatial tag in special cases
  if (xy_points[4].size() < minNumPoints_ &&
      xy_points[5].size() >= minNumPoints_) {
    std::swap(xy_points[4], xy_points[5]);
    std::swap(uv_points[4], uv_points[5]);
    std::swap(coeffs[4], coeffs[5]);
    std::swap(c0s[4], c0s[5]);
  } else if (xy_points[6].size() < minNumPoints_ &&
             xy_points[5].size() >= minNumPoints_) {
    std::swap(xy_points[6], xy_points[5]);
    std::swap(uv_points[6], uv_points[5]);
    std::swap(coeffs[6], coeffs[5]);
    std::swap(c0s[6], c0s[5]);
  }
 
  if (xy_points[4].size() < minNumPoints_ &&
      xy_points[11].size() >= minNumPoints_) {
    // Use left lane boundary as the right most missing left lane,
    bool use_boundary = true;
    for (int k = 3; k >= 1; --k) {
      if (xy_points[k].size() >= minNumPoints_) {
        use_boundary = false;
        break;
      }
    }
    if (use_boundary) {
      std::swap(xy_points[4], xy_points[11]);
      std::swap(uv_points[4], uv_points[11]);
      std::swap(coeffs[4], coeffs[11]);
      std::swap(c0s[4], c0s[11]);
    }
  }
 
  if (xy_points[6].size() < minNumPoints_ &&
      xy_points[12].size() >= minNumPoints_) {
    // Use right lane boundary as the left most missing right lane,
    bool use_boundary = true;
    for (int k = 7; k <= 9; ++k) {
      if (xy_points[k].size() >= minNumPoints_) {
        use_boundary = false;
        break;
      }
    }
    if (use_boundary) {
      std::swap(xy_points[6], xy_points[12]);
      std::swap(uv_points[6], uv_points[12]);
      std::swap(coeffs[6], coeffs[12]);
      std::swap(c0s[6], c0s[12]);
    }
  }
 
  for (int i = 1; i < lane_type_num_; ++i) {
    base::LaneLine cur_object;
    if (xy_points[i].size() < minNumPoints_) {
      continue;
    }
 
    // [2] Set spatial label
    cur_object.pos_type = spatialLUT[i];
 
    // [3] Determine which lines are valid according to the y value at x = 3
    if ((i < 5 && c0s[i] < c0s[i + 1]) ||
        (i > 5 && i < 10 && c0s[i] > c0s[i - 1])) {
      continue;
    }
    if (i == 11 || i == 12) {
      std::sort(c0s.begin(), c0s.begin() + 10);
      if ((c0s[i] > c0s[0] && i == 12) || (c0s[i] < c0s[9] && i == 11)) {
        continue;
      }
    }
    // [4] Write values
    cur_object.curve_car_coord.x_start =
        static_cast<float>(xy_points[i].front()(0));
    cur_object.curve_car_coord.x_end =
        static_cast<float>(xy_points[i].back()(0));
    cur_object.curve_car_coord.a = static_cast<float>(coeffs[i](3));
    cur_object.curve_car_coord.b = static_cast<float>(coeffs[i](2));
    cur_object.curve_car_coord.c = static_cast<float>(coeffs[i](1));
    cur_object.curve_car_coord.d = static_cast<float>(coeffs[i](0));
    // if (cur_object.curve_car_coord.x_end -
    //     cur_object.curve_car_coord.x_start < 5) continue;
    // cur_object.order = 2;
    cur_object.curve_car_coord_point_set.clear();
    for (size_t j = 0; j < xy_points[i].size(); ++j) {
      base::Point2DF p_j;
      p_j.x = static_cast<float>(xy_points[i][j](0));
      p_j.y = static_cast<float>(xy_points[i][j](1));
      cur_object.curve_car_coord_point_set.push_back(p_j);
    }
 
    cur_object.curve_image_point_set.clear();
    for (size_t j = 0; j < uv_points[i].size(); ++j) {
      base::Point2DF p_j;
      p_j.x = static_cast<float>(uv_points[i][j](0));
      p_j.y = static_cast<float>(uv_points[i][j](1));
      cur_object.curve_image_point_set.push_back(p_j);
    }
 
    // cur_object.confidence.push_back(1);
    cur_object.confidence = 1.0f;
    frame->lane_objects.push_back(cur_object);
  }
 
  // Special case riding on a lane:
  // 0: no center lane, 1: center lane as left, 2: center lane as right
  int has_center_ = 0;
  for (auto lane_ : frame->lane_objects) {
    if (lane_.pos_type == base::LaneLinePositionType::EGO_CENTER) {
      if (lane_.curve_car_coord.d >= 0) {
        has_center_ = 1;
      } else if (lane_.curve_car_coord.d < 0) {
        has_center_ = 2;
      }
      break;
    }
  }
  // Change labels for all lanes from one side
  if (has_center_ == 1) {
    for (auto& lane_ : frame->lane_objects) {
      int spatial_id = spatialLUTind[lane_.pos_type];
      if (spatial_id >= 1 && spatial_id <= 5) {
        lane_.pos_type = spatialLUT[spatial_id - 1];
      }
    }
  } else if (has_center_ == 2) {
    for (auto& lane_ : frame->lane_objects) {
      int spatial_id = spatialLUTind[lane_.pos_type];
      if (spatial_id >= 5 && spatial_id <= 9) {
        lane_.pos_type = spatialLUT[spatial_id + 1];
      }
    }
  }
 
  auto elapsed = std::chrono::high_resolution_clock::now() - start;
  int64_t microseconds =
      std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count();
  // AINFO << "Time for writing: " << microseconds - microseconds_2 << " us";
  time_3 += microseconds - microseconds_2;
  ++time_num;
 
  ADEBUG << "frame->lane_objects.size(): " << frame->lane_objects.size();
 
  ADEBUG << "Avg sampling time: " << time_1 / time_num
         << " Avg fitting time: " << time_2 / time_num
         << " Avg writing time: " << time_3 / time_num;
  ADEBUG << "darkSCNN lane_postprocess done!";
  return true;
}

Process3D()

bool apollo::perception::camera::DarkSCNNLanePostprocessor::Process3D ( const LanePostprocessorOptions &  options, CameraFrame *  frame  )

overridevirtual

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

在文件 darkSCNN_lane_postprocessor.cc 第 396 行定义.

                                                                 {
  ConvertImagePoint2Camera(frame);
  PolyFitCameraLaneline(frame);
  return true;
}

SetIm2CarHomography()

void apollo::perception::camera::DarkSCNNLanePostprocessor::SetIm2CarHomography ( const Eigen::Matrix3d &  homography_im2car )

inlineoverridevirtual

重载 apollo::perception::camera::BaseLanePostprocessor .

在文件 darkSCNN_lane_postprocessor.h 第 65 行定义.

                                                                            {
    Eigen::Matrix3d im2car = homography_im2car;
    trans_mat_ = im2car.cast<float>();
    trans_mat_inv = trans_mat_.inverse();
  }

---

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

• modules/perception/lane_detection/lib/postprocessor/darkSCNN/darkSCNN_lane_postprocessor.h
• modules/perception/lane_detection/lib/postprocessor/darkSCNN/darkSCNN_lane_postprocessor.cc