Method Run

executor/operator/common/detection_output.cpp:128–240

    }

    bool Run(Node* node)
    {
        const Tensor* loc_tensor = node->GetInputTensor(0);
        const Tensor* conf_tensor = node->GetInputTensor(1);
        const Tensor* priorbox_tensor = node->GetInputTensor(2);
        Tensor* output_tensor = node->GetOutputTensor(0);

        DetectionOutput* detect_op = dynamic_cast<DetectionOutput*>(node->GetOp());
        DetectionOutputParam* param_ = detect_op->GetParam();

        // location   [b,num_prior*4,1,1]
        float* location = ( float* )get_tensor_mem(loc_tensor);
        // confidence [b,num_prior*21,1,1]
        float* confidence = ( float* )get_tensor_mem(conf_tensor);
        // priorbox   [b,2,num_prior*4,1]
        float* priorbox = ( float* )get_tensor_mem(priorbox_tensor);

        const std::vector<int>& dims = priorbox_tensor->GetShape().GetDim();
        const int num_priorx4 = dims[2];
        const int num_prior = num_priorx4 / 4;
        const int num_classes = param_->num_classes;
        // const int batch=dims[0];

        // only support for batch=1

        // for(int b=0;b<batch;b++)
        //{
        int b = 0;
        float* loc_ptr = location + b * num_priorx4;
        float* conf_ptr = confidence + b * num_prior * num_classes;
        float* prior_ptr = priorbox + b * num_priorx4 * 2;

        std::vector<Box> boxes(num_prior);
        get_boxes(boxes, num_prior, loc_ptr, prior_ptr);

        std::vector<std::vector<Box>> all_class_bbox_rects;
        all_class_bbox_rects.resize(num_classes);
        // start from 1 to ignore background class
        for(int i = 1; i < num_classes; i++)
        {
            std::vector<Box> class_box;
            for(int j = 0; j < num_prior; j++)
            {
                float score = conf_ptr[j * num_classes + i];
                if(score > param_->confidence_threshold)
                {
                    boxes[j].score = score;
                    boxes[j].class_idx = i;
                    class_box.push_back(boxes[j]);
                }
            }
            // sort
            std::sort(class_box.begin(), class_box.end(), [](const Box& a, const Box& b) { return a.score > b.score; });

            // keep nms_top_k
            if(param_->nms_top_k < ( int )class_box.size())
            {
                class_box.resize(param_->nms_top_k);