Method Run

executor/operator/common/rpn.cpp:241–321

struct RPNOps : public NodeOps
{
    bool Run(Node* node)
    {
        const Tensor* score_tensor = node->GetInputTensor(0);
        const Tensor* featmap_tensor = node->GetInputTensor(1);
        const Tensor* info_tensor = node->GetInputTensor(2);
        Tensor* output_tensor = node->GetOutputTensor(0);
        TShape& out_shape = output_tensor->GetShape();

        float* output = ( float* )get_tensor_mem(output_tensor);
        const float* im_info = ( float* )get_tensor_mem(info_tensor);
        const float* m_score_ = ( float* )get_tensor_mem(score_tensor);
        const float* m_box_ = ( float* )get_tensor_mem(featmap_tensor);

        const TShape& featmap_shape = featmap_tensor->GetShape();
        const TShape& score_shape = score_tensor->GetShape();
        const int feat_height = featmap_shape.GetH();
        const int feat_width = featmap_shape.GetW();
        const int feat_channel = featmap_shape.GetC();
        const int score_channel = score_shape.GetC();
        const int feat_size = feat_height * feat_width;
        int src_height_ = im_info[0];
        int src_width_ = im_info[1];
        int src_scale_ = im_info[2];

        RPN* RPN_op = dynamic_cast<RPN*>(node->GetOp());
        RPNParam* param_ = RPN_op->GetParam();
        int feat_stride = param_->feat_stride;
        int num_anchors = ( int )param_->anchors_.size();

        // local_anchors (1, anchors_nums_ * 4, map_height_, map_width_);
        float* local_anchors = new float[num_anchors * 4 * feat_size];
        proposal_local_anchor(feat_height, feat_width, feat_stride, param_->anchors_, local_anchors);

        float* m_box = new float[feat_channel * feat_size];
        for(int i = 0; i < feat_channel * feat_size; i++)
            m_box[i] = m_box_[i];
        bbox_tranform_inv(m_box, local_anchors, feat_height, feat_width, feat_channel, num_anchors);

        delete[] local_anchors;
        std::vector<SBox> boxes;
        float* m_score = new float[score_channel * feat_size];
        for(int i = 0; i < score_channel * feat_size; i++)
            m_score[i] = m_score_[i];
        filter_boxs(boxes, m_box, m_score, param_->min_size, src_scale_, src_width_, src_height_, feat_width,
                    feat_height, num_anchors, feat_channel);
        delete[] m_box;
        delete[] m_score;

        std::sort(boxes.rbegin(), boxes.rend());

        if(param_->per_nms_topn > 0)
        {
            int tmp = MIN(param_->per_nms_topn, ( int )boxes.size());
            boxes.erase(boxes.begin() + tmp, boxes.end());
        }
        nms_rpn(boxes, param_->nms_thresh);

        if(param_->post_nms_topn > 0)