ncnn+PPYOLOv2首次结合！全网最详细代码解读来了（3）

// examples/test2_06_ppyolo_ncnn.cpp
...
struct Bbox
{
    float x0;
    float y0;
    float x1;
    float y1;
    int clsid;
    float score;
};
bool compare_desc(Bbox bbox1, Bbox bbox2)
{
    return bbox1.score > bbox2.score;
}
float calc_iou(Bbox bbox1, Bbox bbox2)
{
    float area_1 = (bbox1.y1 - bbox1.y0) * (bbox1.x1 - bbox1.x0);
    float area_2 = (bbox2.y1 - bbox2.y0) * (bbox2.x1 - bbox2.x0);
    float inter_x0 = std::max(bbox1.x0, bbox2.x0);
    float inter_y0 = std::max(bbox1.y0, bbox2.y0);
    float inter_x1 = std::min(bbox1.x1, bbox2.x1);
    float inter_y1 = std::min(bbox1.y1, bbox2.y1);
    float inter_w = std::max(0.f, inter_x1 - inter_x0);
    float inter_h = std::max(0.f, inter_y1 - inter_y0);
    float inter_area = inter_w * inter_h;
    float union_area = area_1 + area_2 - inter_area + 0.000000001f;
    return inter_area / union_area;
}
...
class PPYOLODecodeMatrixNMS : public ncnn::Layer
{
public:
...
    virtual int forward(const std::vector<ncnn::Mat>& bottom_blobs, std::vector<ncnn::Mat>& top_blobs, const ncnn::Option& opt) const
    {
  ...
        // keep bbox whose score > score_threshold
        std::vector<Bbox> bboxes_vec;
        for (int i = 0; i < out_num; i++)
        {
            float x0 = bboxes[i * 4];
            float y0 = bboxes[i * 4 + 1];
            float x1 = bboxes[i * 4 + 2];
            float y1 = bboxes[i * 4 + 3];
            for (int j = 0; j < num_classes; j++)
            {
                float score = scores[i * num_classes + j];
                if (score > score_threshold)
                {
                    Bbox bbox;
                    bbox.x0 = x0;
                    bbox.y0 = y0;
                    bbox.x1 = x1;
                    bbox.y1 = y1;
                    bbox.clsid = j;
                    bbox.score = score;
                    bboxes_vec.push_back(bbox);
                }
            }
        }
        if (bboxes_vec.size() == 0)
        {
            ncnn::Mat& pred = top_blobs[0];
            pred.create(0, 0, elemsize, opt.blob_allocator);
            if (pred.empty())
                return -100;
            return 0;
        }
        // sort and keep top nms_top_k
        int nms_top_k_ = nms_top_k;
        if (bboxes_vec.size() < nms_top_k)
            nms_top_k_ = bboxes_vec.size();
        size_t count {(size_t)nms_top_k_};
        std::partial_sort(std::begin(bboxes_vec), std::begin(bboxes_vec) + count, std::end(bboxes_vec), compare_desc);
        if (bboxes_vec.size() > nms_top_k)
            bboxes_vec.resize(nms_top_k);
        // ---------------------- Matrix NMS ----------------------
        // calc a iou matrix whose shape is [n, n], n is bboxes_vec.size()
        int n = bboxes_vec.size();
        float* decay_iou = new float[n * n];
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (j < i + 1)
                {
                    decay_iou[i * n + j] = 0.f;
                }else
                {
                    bool same_clsid = bboxes_vec[i].clsid == bboxes_vec[j].clsid;
                    if (same_clsid)
                    {
                        float iou = calc_iou(bboxes_vec[i], bboxes_vec[j]);
                        decay_iou[i * n + j] = iou;
                    }else
                    {
                        decay_iou[i * n + j] = 0.f;
                    }
                }
            }
        }
        // get max iou of each col
        float* compensate_iou = new float[n];
        for (int i = 0; i < n; i++)
        {
            float max_iou = decay_iou[i];
            for (int j = 0; j < n; j++)
            {
                if (decay_iou[j * n + i] > max_iou)
                    max_iou = decay_iou[j * n + i];
            }
            compensate_iou[i] = max_iou;
        }
        float* decay_matrix = new float[n * n];
        // get min decay_value of each col
        float* decay_coefficient = new float[n];
        if (kernel == 0) // gaussian
        {
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    decay_matrix[i * n + j] = static_cast<float>(expf(gaussian_sigma * (compensate_iou[i] * compensate_iou[i] - decay_iou[i * n + j] * decay_iou[i * n + j])));
                }
            }
        }else if (kernel == 1) // linear
        {
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    decay_matrix[i * n + j] = (1.f  - decay_iou[i * n + j]) / (1.f  - compensate_iou[i]);
                }
            }
        }
        for (int i = 0; i < n; i++)
        {
            float min_v = decay_matrix[i];
            for (int j = 0; j < n; j++)
            {
                if (decay_matrix[j * n + i] < min_v)
                    min_v = decay_matrix[j * n + i];
            }
            decay_coefficient[i] = min_v;
        }
        for (int i = 0; i < n; i++)
        {
            bboxes_vec[i].score *= decay_coefficient[i];
        }
        // ---------------------- Matrix NMS (end) ----------------------
        std::vector<Bbox> bboxes_vec_keep;
        for (int i = 0; i < n; i++)
        {
            if (bboxes_vec[i].score > post_threshold)
            {
                bboxes_vec_keep.push_back(bboxes_vec[i]);
            }
        }
        n = bboxes_vec_keep.size();
        if (n == 0)
        {
            ncnn::Mat& pred = top_blobs[0];
            pred.create(0, 0, elemsize, opt.blob_allocator);
            if (pred.empty())
                return -100;
            return 0;
        }
        // sort and keep keep_top_k
        int keep_top_k_ = keep_top_k;
        if (n < keep_top_k)
            keep_top_k_ = n;
        size_t keep_count {(size_t)keep_top_k_};
        std::partial_sort(std::begin(bboxes_vec_keep), std::begin(bboxes_vec_keep) + keep_count, std::end(bboxes_vec_keep), compare_desc);
        if (bboxes_vec_keep.size() > keep_top_k)
            bboxes_vec_keep.resize(keep_top_k);
        ncnn::Mat& pred = top_blobs[0];
        pred.create(6 * n, elemsize, opt.blob_allocator);
        if (pred.empty())
            return -100;
        float* pred_ptr = pred;
        for (int i = 0; i < n; i++)
        {
            pred_ptr[i * 6] = (float)bboxes_vec_keep[i].clsid;
            pred_ptr[i * 6 + 1] = bboxes_vec_keep[i].score;
            pred_ptr[i * 6 + 2] = bboxes_vec_keep[i].x0;
            pred_ptr[i * 6 + 3] = bboxes_vec_keep[i].y0;
            pred_ptr[i * 6 + 4] = bboxes_vec_keep[i].x1;
            pred_ptr[i * 6 + 5] = bboxes_vec_keep[i].y1;
        }
        pred = pred.reshape(6, n);
        return 0;
    }