Removed runtime::Tensor usage (#3901)

Author: ilya-lavrenov

demos/text_detection_demo/cpp/include/text_detection.hpp

@@ -23,7 +23,7 @@ class TextDetector : public Cnn {
     std::map<std::string, ov::Tensor> Infer(const cv::Mat& frame) override;
 
     std::vector<cv::RotatedRect> postProcess(
-        const std::map<std::string, ov::runtime::Tensor>& output_tensors, const cv::Size& image_size,
+        const std::map<std::string, ov::Tensor>& output_tensors, const cv::Size& image_size,
         const cv::Size& image_shape, float cls_conf_threshold, float link_conf_threshold);
 private:
     cv::Mat decodeImageByJoin(

demos/text_detection_demo/cpp/include/text_recognition.hpp

@@ -30,7 +30,7 @@ class TextRecognizer : public Cnn {
         size_t end_token,
         bool use_auto_resize = false);
 
-    std::map<std::string, ov::runtime::Tensor> Infer(const cv::Mat& frame) override;
+    std::map<std::string, ov::Tensor> Infer(const cv::Mat& frame) override;
 
     const cv::Size& input_size() const { return m_input_size; }
 

demos/text_detection_demo/cpp/main.cpp

@@ -254,7 +254,7 @@ int main(int argc, char* argv[]) {
 
             std::vector<cv::RotatedRect> rects;
             if (text_detector != nullptr) {
-                std::map<std::string, ov::runtime::Tensor> output_tensors = text_detector->Infer(image);
+                std::map<std::string, ov::Tensor> output_tensors = text_detector->Infer(image);
 
                 std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
                 rects = text_detector->postProcess(output_tensors, image.size(), text_detector->input_size(),
@@ -306,9 +306,9 @@ int main(int argc, char* argv[]) {
                 std::string res = "";
                 double conf = 1.0;
                 if (text_recognition != nullptr) {
-                    std::map<std::string, ov::runtime::Tensor> output_tensors = text_recognition->Infer(cropped_text);
+                    std::map<std::string, ov::Tensor> output_tensors = text_recognition->Infer(cropped_text);
 
-                    ov::runtime::Tensor out_tensor = output_tensors.begin()->second;
+                    ov::Tensor out_tensor = output_tensors.begin()->second;
                     if (FLAGS_tr_o_blb_nm != "") {
                         const auto& it = output_tensors.find(FLAGS_tr_o_blb_nm);
                         if (it == output_tensors.end()) {

demos/text_detection_demo/cpp/src/text_detection.cpp

@@ -171,7 +171,7 @@ cv::Mat get_all(const std::vector<cv::Point>& points, int w, int h, std::unorder
 } // namespace
 
 
-std::map<std::string, ov::runtime::Tensor> TextDetector::Infer(const cv::Mat& frame) {
+std::map<std::string, ov::Tensor> TextDetector::Infer(const cv::Mat& frame) {
     std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
 
     cv::Mat resizedImg = frame;
@@ -184,7 +184,7 @@ std::map<std::string, ov::runtime::Tensor> TextDetector::Infer(const cv::Mat& fr
     m_infer_request.infer();
 
     // Processing output
-    std::map<std::string, ov::runtime::Tensor> output_tensors;
+    std::map<std::string, ov::Tensor> output_tensors;
     for (const auto& output_name : m_output_names) {
         output_tensors[output_name] = m_infer_request.get_tensor(output_name);
     }
@@ -197,7 +197,7 @@ std::map<std::string, ov::runtime::Tensor> TextDetector::Infer(const cv::Mat& fr
 }
 
 std::vector<cv::RotatedRect> TextDetector::postProcess(
-    const std::map<std::string, ov::runtime::Tensor>& output_tensors,
+    const std::map<std::string, ov::Tensor>& output_tensors,
     const cv::Size& image_size, const cv::Size& input_shape,
     float cls_conf_threshold, float link_conf_threshold) {
     const int kMinArea = 300;

demos/text_detection_demo/cpp/src/text_recognition.cpp

@@ -224,7 +224,7 @@ TextRecognizer::TextRecognizer(
     m_infer_request_decoder = compiled_model_decoder.create_infer_request();
 }
 
-std::map<std::string, ov::runtime::Tensor> TextRecognizer::Infer(const cv::Mat& frame) {
+std::map<std::string, ov::Tensor> TextRecognizer::Infer(const cv::Mat& frame) {
     std::chrono::steady_clock::time_point begin_enc = std::chrono::steady_clock::now();
 
     cv::Mat image;
@@ -243,7 +243,7 @@ std::map<std::string, ov::runtime::Tensor> TextRecognizer::Infer(const cv::Mat&
     m_infer_request.infer();
 
     // Processing output
-    std::map<std::string, ov::runtime::Tensor> output_tensors;
+    std::map<std::string, ov::Tensor> output_tensors;
     for (const auto& output_name : m_output_names) {
         output_tensors[output_name] = m_infer_request.get_tensor(output_name);
     }
@@ -261,18 +261,18 @@ std::map<std::string, ov::runtime::Tensor> TextRecognizer::Infer(const cv::Mat&
     // Processing encoder output
     // tensors here are set for concrete network
     // in case of different network this needs to be changed or generalized
-    ov::runtime::Tensor features_tensor = output_tensors[m_features_name];
+    ov::Tensor features_tensor = output_tensors[m_features_name];
     m_infer_request_decoder.set_tensor(m_features_name, features_tensor);
 
-    ov::runtime::Tensor out_enc_hidden_tensor = output_tensors[m_out_enc_hidden_name];
+    ov::Tensor out_enc_hidden_tensor = output_tensors[m_out_enc_hidden_name];
     m_infer_request_decoder.set_tensor(m_in_dec_hidden_name, out_enc_hidden_tensor);
 
     float* input_data_decoder = m_infer_request_decoder.get_tensor(m_in_dec_symbol_name).data<float>();
 
     input_data_decoder[0] = 0;
     size_t num_classes = m_infer_request_decoder.get_tensor(m_out_dec_symbol_name).get_size();
 
-    ov::runtime::Tensor targets(ov::element::f32, { 1, MAX_NUM_DECODER, num_classes });
+    ov::Tensor targets(ov::element::f32, { 1, MAX_NUM_DECODER, num_classes });
     float* data_targets = targets.data<float>();
 
     for (size_t num_decoder = 0; num_decoder < MAX_NUM_DECODER; num_decoder++) {
@@ -290,7 +290,7 @@ std::map<std::string, ov::runtime::Tensor> TextRecognizer::Infer(const cv::Mat&
 
         input_data_decoder[0] = float(argmax);
 
-        ov::runtime::Tensor out_enc_hidden_tensor = m_infer_request_decoder.get_tensor(m_out_enc_hidden_name);
+        ov::Tensor out_enc_hidden_tensor = m_infer_request_decoder.get_tensor(m_out_enc_hidden_name);
         m_infer_request_decoder.set_tensor(m_in_dec_hidden_name, out_enc_hidden_tensor);
     }