Function ref_dpp_common

executor/operator/ref/kernel/dpp/ref_dpp_kernel.h:193–266

}

int ref_dpp_common(const float* input_f, const float* score_f, const float* anchor_f, dpp_param* param,
                   float* detect_num, float* detect_class, float* detect_score, float* detect_boxes)
{
    const int num_classes = param->num_classes + 1;
    const int num_boxes = param->num_boxes;
    const int max_detections = param->max_detections;

    struct Dpp_Box* all_boxes = ( struct Dpp_Box* )malloc(num_classes * num_boxes * sizeof(struct Dpp_Box));
    memset(all_boxes, 0, sizeof(struct Dpp_Box) * num_classes * num_boxes);

    get_all_boxes_rect(all_boxes, input_f, score_f, anchor_f, num_boxes, num_classes, param->scales);

    int max_picked_boxes = 2 * max_detections * num_classes;
    struct Dpp_Box* picked_boxes = ( struct Dpp_Box* )malloc(max_picked_boxes * sizeof(struct Dpp_Box));
    memset(picked_boxes, 0, sizeof(struct Dpp_Box) * max_picked_boxes);
    int all_picked_size = 0;

    for(int i = 1; i < num_classes; i++)
    {
        struct Dpp_Box* class_box = all_boxes + i * num_boxes;

        // sort
        sort_boxes_by_score(class_box, num_boxes);
        int box_size = 0;
        for(int j = 0; j < num_boxes; j++)
        {
            if(class_box[j].score < 0.6)
                break;
            box_size++;
        }
        if(box_size == 0)
            continue;

        if(box_size > max_detections * 2)
            box_size = max_detections * 2;

        int picked[num_boxes];
        int picked_size = 0;

        picked[0] = 0;
        nms_sorted_bboxes(class_box, box_size, picked, &picked_size, param->nms_iou_threshold);

        // save the survivors
        for(int j = 0; j < picked_size; j++)
        {
            int z = picked[j];
            memcpy(picked_boxes + all_picked_size, class_box + z, sizeof(struct Dpp_Box));
            all_picked_size++;
        }
    }

    sort_boxes_by_score(picked_boxes, max_picked_boxes);
    if(all_picked_size > max_detections)
        all_picked_size = max_detections;

    // generate output tensors
    detect_num[0] = all_picked_size;