【实践】基于插件进行开发

# 进入到application-perception代码库
cd application-perception

# 拉取并启动docker容器，如果已拉取不需要执行这条命令
aem start_gpu
# 进入容器
aem enter
# 下载安装依赖包： 会拉取安装core目录下的cyberfile.xml里面所有的依赖包
buildtool build --gpu

#创建插件，--namespace说明命名空间，--template说明创建的是插件，最后是插件的路径
buildtool create --namespace perception --template plugin modules/perception/fp_filter

  <depend repo_name="perception-lidar-detection-filter" type="binary">perception-lidar-detection-filter</depend>

#pragma once

#include <memory>
#include "cyber/plugin_manager/plugin_manager.h"

#include "modules/perception/lidar_detection_filter/interface/base_object_filter.h"  // 0.添加头文件

namespace apollo {
namespace perception {
namespace lidar {  // 1.定义命名空间

class FpFilter : public BaseObjectFilter {  // 2.继承基类
public:
    FpFilter() = default;  // 3.定义构造和析构函数
    virtual ~FpFilter() = default;

public:
    // 4.重写如下三个函数； 声明 FilterFlag 方法
    bool Init(const ObjectFilterInitOptions& options = ObjectFilterInitOptions()) override;
    bool Filter(const ObjectFilterOptions& options, LidarFrame* frame) override;
    std::string Name() const override {
        return "FalsePositiveFilter";
    }
    bool FilterFlag(base::ObjectPtr obj, double confidence_thresh, double volume_thresh, double height_diff_thresh);

private:
    std::vector<bool> fp_flag_;  // 5.定义数据结构
};

CYBER_PLUGIN_MANAGER_REGISTER_PLUGIN(apollo::perception::lidar::FpFilter, BaseObjectFilter)  // 6.修改插件配置

}  // namespace lidar
}  // namespace perception
}  // namespace apollo

<library path="modules/perception/fp_filter/libfp_filter.so">
    <class type="apollo::perception::lidar::FpFilter" base_class="apollo::perception::lidar::BaseObjectFilter"></class>
</library>

apollo_plugin(
    name = "libfp_filter.so",
    srcs = [
        "fp_filter.cc",
    ],
    hdrs = [
        "fp_filter.h",
    ],
    description = ":plugin_fp_filter_description.xml",
    deps = [
        "//cyber",
        "//modules/perception/fp_filter/proto:fp_filter_proto",
        "//modules/perception/lidar_detection_filter:apollo_perception_lidar_detection_filter",  # 增加依赖项
    ],
)

#include <memory>
#include "modules/perception/fp_filter/fp_filter.h"

namespace apollo {
namespace perception {
namespace lidar {

bool FpFilter::Init(const ObjectFilterInitOptions& options) {
    fp_flag_.clear();
    return true;
}

bool FpFilter::Filter(const ObjectFilterOptions& options, LidarFrame* frame) {
    if (!frame) {
        AINFO << "Lidar frame is nullptr.";
        return false;
    }
    fp_flag_.clear();
    size_t size = frame->segmented_objects.size();
    fp_flag_.assign(size, false);  // filter object if true
    // 除了vehicle，对其他类别的目标做误检过滤
    for (size_t i = 0; i < size; ++i) {
        base::ObjectPtr obj = frame->segmented_objects.at(i);
        base::ObjectType type = obj->type;
        if (type == base::ObjectType::UNKNOWN || type == base::ObjectType::UNKNOWN_MOVABLE
            || type == base::ObjectType::UNKNOWN_UNMOVABLE) {
            fp_flag_.at(i) = FilterFlag(obj, 0.4, 0.3, 0.3);
        } else if (type == base::ObjectType::BICYCLE) {
            fp_flag_.at(i) = FilterFlag(obj, 0.4, 0.4, 0.8);
        } else if (type == base::ObjectType::PEDESTRIAN) {
            fp_flag_.at(i) = FilterFlag(obj, 0.4, 0.3, 1.0);
        }
    }

    // do filter
    size_t valid_num = 0;
    for (size_t i = 0; i < fp_flag_.size(); ++i) {
        base::ObjectPtr obj = frame->segmented_objects.at(i);
        if (!fp_flag_.at(i)) {
            frame->segmented_objects.at(valid_num) = obj;
            valid_num++;
        }
    }
    frame->segmented_objects.resize(valid_num);
    AINFO << "FalsePositiveFilter, filter fp " << size - valid_num << " objects, from " << size << " objects";

    return true;
}

/**
 * @brief
 *
 * @param obj
 * @param confidence_thresh 过滤置信度较低的目标
 * @param volume_thresh 过滤体积较小的目标
 * @param height_diff_thresh 过滤
 * @return true
 * @return false
 */
bool FpFilter::FilterFlag(
        base::ObjectPtr obj,
        double confidence_thresh,
        double volume_thresh,
        double height_diff_thresh) {
    // confidence
    if (obj->confidence < confidence_thresh) {
        return true;
    }
    // volume
    auto obj_size = obj->size;
    double volume = obj_size[0] * obj_size[1] * obj_size[2];
    if (volume < volume_thresh) {
        return true;
    }
    // height diff
    double max_z = -10000.0;
    double min_z = 10000.0;
    for (size_t i = 0; i < obj->lidar_supplement.cloud.size(); ++i) {
        double val_z = obj->lidar_supplement.cloud[i].z;
        max_z = std::max(max_z, val_z);
        min_z = std::min(min_z, val_z);
    }
    double height_diff = max_z - min_z;
    if (height_diff < height_diff_thresh) {
        return true;
    }

    return false;
}

}  // namespace lidar
}  // namespace perception
}  // namespace apollo

cyber_recorder play -f demo3_mkz_110_sunnybigloop.record -c /tf /apollo/sensor/velodyne64/compensator/PointCloud2 /apollo/localization/pose