← Back to branch summary

~iliaplatone/spacedrone.eu/inova-sis-pack

« back to all changes in this revision

Viewing changes to usr/src/extension/ext_priorbox_clustered.cpp

  • Committer: Ilia Platone
  • Date: 2022-11-15 16:19:28 UTC
  • Revision ID: git-v1:b9f4c8dff67bb705341db6a18f84a3d5f61c23ce
Initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
usr/src/extension/ext_priorbox_clustered.cpp
 
1
// Copyright (C) 2018-2019 Intel Corporation
 
2
// SPDX-License-Identifier: Apache-2.0
 
3
//
 
4
 
 
5
#include "ext_list.hpp"
 
6
#include "ext_base.hpp"
 
7
#include <algorithm>
 
8
#include <vector>
 
9
 
 
10
namespace InferenceEngine {
 
11
namespace Extensions {
 
12
namespace Cpu {
 
13
 
 
14
class PriorBoxClusteredImpl: public ExtLayerBase {
 
15
public:
 
16
    explicit PriorBoxClusteredImpl(const CNNLayer* layer) {
 
17
        try {
 
18
            if (layer->insData.size() != 2 || layer->outData.empty())
 
19
                THROW_IE_EXCEPTION << "Incorrect number of input/output edges!";
 
20
 
 
21
            if (layer->insData[0].lock()->getTensorDesc().getDims().size() != 4 ||
 
22
                    layer->insData[1].lock()->getTensorDesc().getDims().size() != 4)
 
23
                THROW_IE_EXCEPTION << "PriorBoxClustered supports only 4D blobs!";
 
24
 
 
25
            widths_ = layer->GetParamAsFloats("width", {});
 
26
            heights_ = layer->GetParamAsFloats("height", {});
 
27
            clip_ = layer->GetParamAsInt("clip");
 
28
            variance_ = layer->GetParamAsFloats("variance", {});
 
29
            img_h_ = layer->GetParamAsInt("img_h", 0);
 
30
            img_w_ = layer->GetParamAsInt("img_w", 0);
 
31
            step_ = layer->GetParamAsFloat("step", 0);
 
32
            step_h_ = layer->GetParamAsFloat("step_h", 0);
 
33
            step_w_ = layer->GetParamAsFloat("step_w", 0);
 
34
            offset_ = layer->GetParamAsFloat("offset");
 
35
 
 
36
            addConfig(layer, {{ConfLayout::PLN, true}, {ConfLayout::PLN, true}}, {{ConfLayout::PLN, true}});
 
37
        } catch (InferenceEngine::details::InferenceEngineException &ex) {
 
38
            errorMsg = ex.what();
 
39
        }
 
40
    }
 
41
 
 
42
    StatusCode init(LayerConfig& config, ResponseDesc *resp) noexcept override {
 
43
        return OK;
 
44
    }
 
45
 
 
46
    StatusCode execute(std::vector<Blob::Ptr>& inputs, std::vector<Blob::Ptr>& outputs,
 
47
                       ResponseDesc *resp) noexcept override {
 
48
        int num_priors_ = widths_.size();
 
49
 
 
50
        if (variance_.empty())
 
51
            variance_.push_back(0.1f);
 
52
 
 
53
        // Execute
 
54
        const int layer_width = inputs[0]->getTensorDesc().getDims()[3];
 
55
        const int layer_height = inputs[0]->getTensorDesc().getDims()[2];
 
56
 
 
57
        int img_width = img_w_ == 0 ? inputs[1]->getTensorDesc().getDims()[3] : img_w_;
 
58
        int img_height = img_h_ == 0 ? inputs[1]->getTensorDesc().getDims()[2] : img_h_;
 
59
 
 
60
        float step_w = step_w_ == 0 ? step_ : step_w_;
 
61
        float step_h = step_h_ == 0 ? step_ : step_h_;
 
62
        if (step_w == 0 && step_h == 0) {
 
63
            step_w = static_cast<float>(img_width) / layer_width;
 
64
            step_h = static_cast<float>(img_height) / layer_height;
 
65
        }
 
66
 
 
67
        auto *top_data_0 = outputs[0]->buffer().as<float *>();
 
68
        float *top_data_1 = top_data_0 + outputs[0]->getTensorDesc().getDims()[2];
 
69
        int var_size = variance_.size();
 
70
 
 
71
        for (int h = 0; h < layer_height; ++h) {
 
72
            for (int w = 0; w < layer_width; ++w) {
 
73
                float center_x = (w + offset_) * step_w;
 
74
                float center_y = (h + offset_) * step_h;
 
75
 
 
76
                for (int s = 0; s < num_priors_; ++s) {
 
77
                    float box_width = widths_[s];
 
78
                    float box_height = heights_[s];
 
79
 
 
80
                    float xmin = (center_x - box_width / 2.0f) / img_width;
 
81
                    float ymin = (center_y - box_height / 2.0f) / img_height;
 
82
                    float xmax = (center_x + box_width / 2.0f) / img_width;
 
83
                    float ymax = (center_y + box_height / 2.0f) / img_height;
 
84
 
 
85
                    if (clip_) {
 
86
                        xmin = std::min(std::max(xmin, 0.0f), 1.0f);
 
87
                        ymin = std::min(std::max(ymin, 0.0f), 1.0f);
 
88
                        xmax = std::min(std::max(xmax, 0.0f), 1.0f);
 
89
                        ymax = std::min(std::max(ymax, 0.0f), 1.0f);
 
90
                    }
 
91
 
 
92
                    top_data_0[h * layer_width * num_priors_ * 4 + w * num_priors_ * 4 + s * 4 + 0] = xmin;
 
93
                    top_data_0[h * layer_width * num_priors_ * 4 + w * num_priors_ * 4 + s * 4 + 1] = ymin;
 
94
                    top_data_0[h * layer_width * num_priors_ * 4 + w * num_priors_ * 4 + s * 4 + 2] = xmax;
 
95
                    top_data_0[h * layer_width * num_priors_ * 4 + w * num_priors_ * 4 + s * 4 + 3] = ymax;
 
96
 
 
97
                    for (int j = 0; j < var_size; j++)
 
98
                        top_data_1[h * layer_width * num_priors_ * var_size + w * num_priors_ * var_size +
 
99
                                   s * var_size +
 
100
                                   j] = variance_[j];
 
101
                }
 
102
            }
 
103
        }
 
104
        return OK;
 
105
    }
 
106
 
 
107
private:
 
108
    std::vector<float> widths_;
 
109
    std::vector<float> heights_;
 
110
    std::vector<float> variance_;
 
111
    int clip_;
 
112
    int img_h_;
 
113
    int img_w_;
 
114
    float step_;
 
115
    float step_h_;
 
116
    float step_w_;
 
117
    float offset_;
 
118
};
 
119
 
 
120
REG_FACTORY_FOR(ImplFactory<PriorBoxClusteredImpl>, PriorBoxClustered);
 
121
 
 
122
}  // namespace Cpu
 
123
}  // namespace Extensions
 
124
}  // namespace InferenceEngine