apollo::perception::lidar::OfflineLidarDetection类 参考

apollo::perception::lidar::OfflineLidarDetection 的协作图:

Public 成员函数
	OfflineLidarDetection ()=default
	~OfflineLidarDetection ()=default
bool	Init ()
bool	TransformCloud (const base::PointFCloudPtr &local_cloud, const Eigen::Affine3d &pose, base::PointDCloudPtr world_cloud) const
bool	Run ()
bool	WriteObjectsForNewBenchmark (size_t frame_id, LidarFrame *frame, const std::string &path)

Protected 属性
std::unique_ptr< BaseLidarDetector >	detector_
std::unique_ptr< ObjectBuilder >	builder_

详细描述

在文件 offline_lidar_detection.cc 第 42 行定义.

构造及析构函数说明

OfflineLidarDetection()

apollo::perception::lidar::OfflineLidarDetection::OfflineLidarDetection ( )

default

~OfflineLidarDetection()

apollo::perception::lidar::OfflineLidarDetection::~OfflineLidarDetection ( )

default

成员函数说明

Init()

bool apollo::perception::lidar::OfflineLidarDetection::Init ( )

inline

在文件 offline_lidar_detection.cc 第 48 行定义.

              {
    BaseLidarDetector* detector =
        BaseLidarDetectorRegisterer::GetInstanceByName(FLAGS_detector_name);
    CHECK_NOTNULL(detector);
    detector_.reset(detector);
 
    LidarDetectorInitOptions detection_init_options;
    detection_init_options.sensor_name = FLAGS_sensor_name;
    detection_init_options.config_path = FLAGS_config_path;
    detection_init_options.config_file = FLAGS_config_file;
    ACHECK(detector_->Init(detection_init_options))
        << "lidar detector init error";
 
    ObjectBuilderInitOptions builder_init_options;
    builder_.reset(new ObjectBuilder);
    ACHECK(builder_->Init(builder_init_options));
 
    return true;
  }

Run()

bool apollo::perception::lidar::OfflineLidarDetection::Run ( )

inline

在文件 offline_lidar_detection.cc 第 92 行定义.

             {
    std::string pcd_folder = FLAGS_pcd_path;
    std::vector<std::string> pcd_file_names;
    if (!algorithm::GetFileList(pcd_folder, ".pcd", &pcd_file_names)) {
      AERROR << "pcd_folder: " << pcd_folder << " get file list error.";
      return false;
    }
 
    std::sort(pcd_file_names.begin(), pcd_file_names.end(),
              [](const std::string& lhs, const std::string& rhs) {
                if (lhs.length() != rhs.length()) {
                  return lhs.length() < rhs.length();
                }
                return lhs <= rhs;
              });
 
    for (size_t i = 0; i < pcd_file_names.size(); ++i) {
      AINFO << "***************** Frame " << i << " ******************";
      AINFO << pcd_file_names[i];
 
      std::shared_ptr<LidarFrame> frame = LidarFramePool::Instance().Get();
      if (frame->cloud == nullptr) {
        frame->cloud = base::PointFCloudPool::Instance().Get();
      }
      if (frame->world_cloud == nullptr) {
        frame->world_cloud = base::PointDCloudPool::Instance().Get();
      }
      LoadPCLPCD(pcd_file_names[i], frame->cloud.get());
      // frame->lidar2world_pose is default identity matrix
      TransformCloud(frame->cloud, frame->lidar2world_pose, frame->world_cloud);
      AINFO << "Read point cloud from " << pcd_file_names[i]
            << " with cloud size: " << frame->cloud->size();
 
      LidarDetectorOptions detection_options;
      if (!detector_->Detect(detection_options, frame.get())) {
        AERROR << "Lidar detector detect error!";
        return false;
      }
 
      ObjectBuilderOptions builder_options;
      if (!builder_->Build(builder_options, frame.get())) {
        AERROR << "Lidar detector, object builder error.";
        return false;
      }
 
      std::string output_path = FLAGS_output_path;
      WriteObjectsForNewBenchmark(i, frame.get(), output_path);
    }
 
    return true;
  }

TransformCloud()

bool apollo::perception::lidar::OfflineLidarDetection::TransformCloud ( const base::PointFCloudPtr &  local_cloud, const Eigen::Affine3d &  pose, base::PointDCloudPtr  world_cloud  ) const

inline

在文件 offline_lidar_detection.cc 第 68 行定义.

                                                            {
    if (local_cloud == nullptr) {
      return false;
    }
    world_cloud->clear();
    world_cloud->reserve(local_cloud->size());
    for (size_t i = 0; i < local_cloud->size(); ++i) {
      auto& pt = local_cloud->at(i);
      Eigen::Vector3d trans_point(pt.x, pt.y, pt.z);
      trans_point = pose * trans_point;
      base::PointD world_point;
      world_point.x = trans_point(0);
      world_point.y = trans_point(1);
      world_point.z = trans_point(2);
      world_point.intensity = pt.intensity;
      world_cloud->push_back(world_point, local_cloud->points_timestamp(i),
                             std::numeric_limits<float>::max(),
                             local_cloud->points_beam_id()[i], 0);
    }
    return true;
  }

WriteObjectsForNewBenchmark()

bool apollo::perception::lidar::OfflineLidarDetection::WriteObjectsForNewBenchmark ( size_t  frame_id, LidarFrame *  frame, const std::string &  path  )

inline

在文件 offline_lidar_detection.cc 第 144 行定义.

                                                          {
    if (!cyber::common::EnsureDirectory(path)) {
      AERROR << "Failed to create: " << path;
      return false;
    }
    std::ofstream fout;
    fout.open(absl::StrCat(path, "/", frame_id, ".txt"));
    fout << frame_id << " " << frame->segmented_objects.size() << std::endl;
 
    for (auto& object : frame->segmented_objects) {
      fout << "velodyne_64"
           << " " << object->id << " " << object->track_id << " "
           << object->lidar_supplement.is_background << " "
           << std::setprecision(8) << object->confidence << " ";
 
      std::string type = "unknow";
      if (object->type == base::ObjectType::UNKNOWN ||
          object->type == base::ObjectType::UNKNOWN_MOVABLE ||
          object->type == base::ObjectType::UNKNOWN_UNMOVABLE) {
        // type is unknow in this case
      } else if (object->type == base::ObjectType::PEDESTRIAN) {
        type = "pedestrian";
      } else if (object->type == base::ObjectType::VEHICLE) {
        type = "smallMot";
      } else if (object->type == base::ObjectType::BICYCLE) {
        type = "nonMot";
      }
 
      double yaw = atan2(object->direction(1), object->direction(0));
      auto& object_cloud = object->lidar_supplement.cloud;
 
      fout << type << " " << object->center(0) << " " << object->center(1)
           << " " << object->center(2) << " " << object->size(0) << " "
           << object->size(1) << " " << object->size(2) << " "
           << yaw /*yaw*/ << " " << 0 /*roll*/ << " " << 0 /*pitch*/ << " "
           << 0 /*truncated*/ << " " << 0 /*occluded*/ << " "
           << object->velocity(0) << " " << object->velocity(1) << " "
           << object->velocity(2) << " ";
      fout << object_cloud.size() << " ";
      for (size_t i = 0; i < object_cloud.size(); ++i) {
        auto& pt = object_cloud.at(i);
        fout << std::setprecision(8) << pt.x << " " << pt.y << " " << pt.z
             << " " << pt.intensity << " ";
      }
      // fout << 0/*#indices*/ << " ";
      // we save polygon here for debug
      int polygon_size = -static_cast<int>(object->polygon.size());
      fout << polygon_size /*negative polygon size*/ << " ";
      for (size_t i = 0; i < object->polygon.size(); ++i) {
        const auto& pt = object->polygon[i];
        fout << std::setprecision(8) << pt.x << " " << pt.y << " " << pt.z
             << " ";
      }
      fout << std::endl;
    }
 
    fout.close();
    return true;
  }

类成员变量说明

builder_

std::unique_ptr<ObjectBuilder> apollo::perception::lidar::OfflineLidarDetection::builder_

protected

在文件 offline_lidar_detection.cc 第 207 行定义.

detector_

std::unique_ptr<BaseLidarDetector> apollo::perception::lidar::OfflineLidarDetection::detector_

protected

在文件 offline_lidar_detection.cc 第 206 行定义.

---

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

• modules/perception/lidar_detection/tools/offline_lidar_detection.cc