OV2.0 c++ mri reconstruction demo (#3086)

* start migration

* handle multiple outputs in model

* undo vs 2019 auto fomatting

* use common functions

* old/new api for showAvailableDevices for demos which are on the old api yet

* fix merge arftifacts

* use channels num to determine output

* Update demos/mri_reconstruction_demo/cpp/main.cpp

Co-authored-by: Anzhella Pankratova <[email protected]>

* removed runtime namespace

Co-authored-by: Vladimir Dudnik <[email protected]>
Co-authored-by: Anzhella Pankratova <[email protected]>

Author: 3 people

demos/common/cpp/utils/include/utils/common.hpp

@@ -210,8 +210,13 @@ inline std::size_t getTensorBatch(const InferenceEngine::TensorDesc& desc) {
 }
 
 inline void showAvailableDevices() {
+#if defined(OV_NEW_API)
+    ov::Core core;
+    std::vector<std::string> devices = core.get_available_devices();
+#else
     InferenceEngine::Core ie;
     std::vector<std::string> devices = ie.GetAvailableDevices();
+#endif
 
     std::cout << std::endl;
     std::cout << "Available target devices:";

demos/common/cpp/utils/include/utils/ocv_common.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2018-2021 Intel Corporation
+// Copyright (C) 2018-2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 
@@ -11,15 +11,16 @@
 
 #include <opencv2/opencv.hpp>
 
+#include "openvino/openvino.hpp"
+
 #include "utils/common.hpp"
 #include "utils/shared_blob_allocator.h"
 
-#include "openvino/openvino.hpp"
 
 
- /**
- * @brief Get cv::Mat value in the correct format.
- */
+/**
+* @brief Get cv::Mat value in the correct format.
+*/
 template <typename T>
 static const T getMatValue(const cv::Mat& mat, size_t h, size_t w, size_t c) {
     switch (mat.type()) {
@@ -112,8 +113,7 @@ static UNUSED void matToTensor(const cv::Mat& mat, const ov::Tensor& tensor, int
                 for (size_t w = 0; w < width; w++)
                     tensorData[batchOffset + c * width * height + h * width + w] =
                         getMatValue<float_t>(resizedMat, h, w, c);
-    }
-    else {
+    } else {
         uint8_t* tensorData = tensor.data<uint8_t>();
         if (resizedMat.depth() == CV_32F) {
             throw std::runtime_error("Conversion of cv::Mat from float_t to uint8_t is forbidden");
@@ -155,8 +155,8 @@ static UNUSED InferenceEngine::Blob::Ptr wrapMat2Blob(const cv::Mat& mat) {
     InferenceEngine::Precision precision = isMatFloat ?
         InferenceEngine::Precision::FP32 : InferenceEngine::Precision::U8;
     InferenceEngine::TensorDesc tDesc(precision,
-        { 1, channels, height, width },
-        InferenceEngine::Layout::NHWC);
+                                      {1, channels, height, width},
+                                      InferenceEngine::Layout::NHWC);
 
     InferenceEngine::Blob::Ptr blob;
     if (isMatFloat) {
@@ -195,12 +195,12 @@ static UNUSED ov::Tensor wrapMat2Tensor(const cv::Mat& mat) {
  * @param thickness - thickness of the lines used to draw a text.
  */
 inline void putHighlightedText(const cv::Mat& frame,
-    const std::string& message,
-    cv::Point position,
-    int fontFace,
-    double fontScale,
-    cv::Scalar color,
-    int thickness) {
+                               const std::string& message,
+                               cv::Point position,
+                               int fontFace,
+                               double fontScale,
+                               cv::Scalar color,
+                               int thickness) {
     cv::putText(frame, message, position, fontFace, fontScale, cv::Scalar(255, 255, 255), thickness + 1);
     cv::putText(frame, message, position, fontFace, fontScale, color, thickness);
 }
@@ -217,7 +217,7 @@ class OutputTransform {
         float inputWidth = static_cast<float>(inputSize.width);
         float inputHeight = static_cast<float>(inputSize.height);
         scaleFactor = std::min(outputResolution.height / inputHeight, outputResolution.width / inputWidth);
-        newResolution = cv::Size{ static_cast<int>(inputWidth * scaleFactor), static_cast<int>(inputHeight * scaleFactor) };
+        newResolution = cv::Size{static_cast<int>(inputWidth * scaleFactor), static_cast<int>(inputHeight * scaleFactor)};
         return newResolution;
     }
 

demos/mri_reconstruction_demo/cpp/CMakeLists.txt

@@ -1,3 +1,7 @@
+# Copyright (C) 2021-2022 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
 file(GLOB SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
 file(GLOB HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/*.hpp)
 

demos/mri_reconstruction_demo/cpp/main.cpp

@@ -1,7 +1,7 @@
-// Copyright (C) 2018-2021 Intel Corporation
+// Copyright (C) 2021-2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
-#include <inference_engine.hpp>
+#include <openvino/openvino.hpp>
 #include <opencv2/opencv.hpp>
 #include <utils/common.hpp>
 #include <utils/performance_metrics.hpp>
@@ -12,7 +12,7 @@
 
 bool ParseAndCheckCommandLine(int argc, char *argv[]);
 
-static cv::Mat infEngineBlobToMat(const InferenceEngine::Blob::Ptr& blob);
+static cv::Mat tensorToMat(const ov::Tensor& tensor);
 
 struct MRIData {
     cv::Mat data;
@@ -38,16 +38,32 @@ int main(int argc, char** argv) {
         return 0;
     }
 
-    slog::info << *InferenceEngine::GetInferenceEngineVersion() << slog::endl;
-    InferenceEngine::Core ie;
+    slog::info << ov::get_openvino_version() << slog::endl;
+    ov::Core core;
 
-    InferenceEngine::CNNNetwork net = ie.ReadNetwork(FLAGS_m);
-    net.getInputsInfo().begin()->second->setLayout(InferenceEngine::Layout::NHWC);
+    slog::info << "Reading model " << FLAGS_m << slog::endl;
+    std::shared_ptr<ov::Model> model = core.read_model(FLAGS_m);
+    logBasicModelInfo(model);
 
-    InferenceEngine::ExecutableNetwork execNet = ie.LoadNetwork(net, FLAGS_d);
-    logExecNetworkInfo(execNet, FLAGS_m, FLAGS_d);
+    std::string outputTensorName = "";
+    ov::Layout outputLayout("NHWC");
+    for (const auto& output : model->outputs()) {
+        if (output.get_shape()[ov::layout::channels_idx(outputLayout)] == 1) {
+            outputTensorName = output.get_any_name();
+        }
+    }
+    if (outputTensorName.empty()) {
+        throw std::logic_error("Not found suitable output!");
+    }
+
+    ov::preprocess::PrePostProcessor ppp(model);
+    ppp.input().model().set_layout("NHWC");
+    model = ppp.build();
 
-    InferenceEngine::InferRequest infReq = execNet.CreateInferRequest();
+    ov::CompiledModel compiledModel = core.compile_model(model, FLAGS_d);
+    logCompiledModelInfo(compiledModel, FLAGS_m, FLAGS_d);
+
+    ov::InferRequest infReq = compiledModel.create_infer_request();
 
     // Hybrid-CS-Model-MRI/Data/sampling_mask_20perc.npy
     MRIData mri;
@@ -65,8 +81,8 @@ int main(int argc, char** argv) {
 
     slog::info << "Compute..." << slog::endl;
 
-    cv::Mat inputBlob = infEngineBlobToMat(infReq.GetBlob(net.getInputsInfo().begin()->first));
-    cv::Mat outputBlob = infEngineBlobToMat(infReq.GetBlob(net.getOutputsInfo().begin()->first));
+    cv::Mat inputBlob = tensorToMat(infReq.get_input_tensor());
+    cv::Mat outputBlob = tensorToMat(infReq.get_tensor(outputTensorName));
     outputBlob = outputBlob.reshape(1, height);
 
     const auto startTime = std::chrono::steady_clock::now();
@@ -77,9 +93,8 @@ int main(int argc, char** argv) {
         kspace.setTo(0, mri.samplingMask);
         kspace = (kspace - cv::Scalar(mri.stats[0], mri.stats[0])) / cv::Scalar(mri.stats[1], mri.stats[1]);
         kspace.reshape(1, 1).convertTo(inputBlob.reshape(1, 1), CV_32F);
-
         // Forward pass
-        infReq.Infer();
+        infReq.infer();
 
         // Save prediction
         cv::Mat slice(height, width, CV_8UC1, mri.reconstructed.ptr<uint8_t>(i));
@@ -102,13 +117,13 @@ int main(int argc, char** argv) {
     return 0;
 }
 
-cv::Mat infEngineBlobToMat(const InferenceEngine::Blob::Ptr& blob) {
+cv::Mat tensorToMat(const ov::Tensor& tensor) {
     // NOTE: Inference Engine sizes are reversed.
-    std::vector<size_t> dims = blob->getTensorDesc().getDims();
-    std::vector<int> size(dims.begin(), dims.end());
-    auto precision = blob->getTensorDesc().getPrecision();
-    CV_Assert(precision == InferenceEngine::Precision::FP32);
-    return cv::Mat(size, CV_32F, (void*)blob->buffer());
+    ov::Shape tensorShape = tensor.get_shape();
+    std::vector<int> size(tensorShape.begin(), tensorShape.end());
+    ov::element::Type precision = tensor.get_element_type();
+    CV_Assert(precision == ov::element::f32);
+    return cv::Mat(size, CV_32F, (void*)tensor.data());
 }
 
 void callback(int sliceId, void* userdata) {

demos/mri_reconstruction_demo/cpp/mri_reconstruction_demo.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2018-2021 Intel Corporation
+// Copyright (C) 2021-2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 

demos/mri_reconstruction_demo/cpp/npy_reader.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2018-2021 Intel Corporation
+// Copyright (C) 2021-2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 #pragma once