Correct use tensor and data pointer (#4005)

praasz · web-flow · commit 74fd62acea98 · 2025-03-27T17:10:03.000+04:00
Signed-off-by: Raasz, Pawel &lt;pawel.raasz@intel.com&gt;
diff --git a/demos/common/cpp/models/src/detection_model_centernet.cpp b/demos/common/cpp/models/src/detection_model_centernet.cpp
@@ -185,7 +185,8 @@ std::vector<std::pair<size_t, float>> nms(float* scoresPtr, const ov::Shape& sha
     return scores;
 }
 
-static std::vector<std::pair<size_t, float>> filterScores(const ov::Tensor& scoresTensor, float threshold) {
+static std::vector<std::pair<size_t, float>>
+filterScores(ov::Tensor &scoresTensor, float threshold) {
     auto shape = scoresTensor.get_shape();
     float* scoresPtr = scoresTensor.data<float>();
 
@@ -259,7 +260,7 @@ void transform(std::vector<ModelCenterNet::BBox>& boxes,
 
 std::unique_ptr<ResultBase> ModelCenterNet::postprocess(InferenceResult& infResult) {
     // --------------------------- Filter data and get valid indices ---------------------------------
-    const auto& heatmapTensor = infResult.outputsData[outputsNames[0]];
+    auto &heatmapTensor = infResult.outputsData[outputsNames[0]];
     const auto& heatmapTensorShape = heatmapTensor.get_shape();
     const auto chSize = heatmapTensorShape[2] * heatmapTensorShape[3];
     const auto scores = filterScores(heatmapTensor, confidenceThreshold);
diff --git a/demos/common/cpp/models/src/detection_model_ssd.cpp b/demos/common/cpp/models/src/detection_model_ssd.cpp
@@ -42,7 +42,7 @@ ModelSSD::ModelSSD(const std::string& modelFileName,
 
 std::shared_ptr<InternalModelData> ModelSSD::preprocess(const InputData& inputData, ov::InferRequest& request) {
     if (inputsNames.size() > 1) {
-        const auto& imageInfoTensor = request.get_tensor(inputsNames[1]);
+        auto imageInfoTensor = request.get_tensor(inputsNames[1]);
         const auto info = imageInfoTensor.data<float>();
         info[0] = static_cast<float>(netInputHeight);
         info[1] = static_cast<float>(netInputWidth);
diff --git a/demos/common/cpp/models/src/detection_model_yolox.cpp b/demos/common/cpp/models/src/detection_model_yolox.cpp
@@ -127,7 +127,7 @@ std::unique_ptr<ResultBase> ModelYoloX::postprocess(InferenceResult& infResult)
     const auto& scale = infResult.internalModelData->asRef<InternalScaleData>();
 
     // Get output tensor
-    const ov::Tensor& output = infResult.outputsData[outputsNames[0]];
+    ov::Tensor &output = infResult.outputsData[outputsNames[0]];
     const auto& outputShape = output.get_shape();
     float* outputPtr = output.data<float>();
 
diff --git a/demos/common/cpp/models/src/hpe_model_associative_embedding.cpp b/demos/common/cpp/models/src/hpe_model_associative_embedding.cpp
@@ -153,19 +153,19 @@ std::shared_ptr<InternalModelData> HpeAssociativeEmbedding::preprocess(const Inp
 std::unique_ptr<ResultBase> HpeAssociativeEmbedding::postprocess(InferenceResult& infResult) {
     HumanPoseResult* result = new HumanPoseResult(infResult.frameId, infResult.metaData);
 
-    const auto& aembds = infResult.outputsData[embeddingsTensorName];
+    auto &aembds = infResult.outputsData[embeddingsTensorName];
     const ov::Shape& aembdsShape = aembds.get_shape();
     float* const aembdsMapped = aembds.data<float>();
     std::vector<cv::Mat> aembdsMaps = split(aembdsMapped, aembdsShape);
 
-    const auto& heats = infResult.outputsData[heatmapsTensorName];
+    auto &heats = infResult.outputsData[heatmapsTensorName];
     const ov::Shape& heatMapsShape = heats.get_shape();
     float* const heatMapsMapped = heats.data<float>();
     std::vector<cv::Mat> heatMaps = split(heatMapsMapped, heatMapsShape);
 
     std::vector<cv::Mat> nmsHeatMaps = heatMaps;
     if (nmsHeatmapsTensorName != heatmapsTensorName) {
-        const auto& nmsHeats = infResult.outputsData[nmsHeatmapsTensorName];
+        auto& nmsHeats = infResult.outputsData[nmsHeatmapsTensorName];
         const ov::Shape& nmsHeatMapsShape = nmsHeats.get_shape();
         float* const nmsHeatMapsMapped = nmsHeats.data<float>();
         nmsHeatMaps = split(nmsHeatMapsMapped, nmsHeatMapsShape);
diff --git a/demos/common/cpp/models/src/hpe_model_openpose.cpp b/demos/common/cpp/models/src/hpe_model_openpose.cpp
@@ -160,8 +160,8 @@ std::shared_ptr<InternalModelData> HPEOpenPose::preprocess(const InputData& inpu
 std::unique_ptr<ResultBase> HPEOpenPose::postprocess(InferenceResult& infResult) {
     HumanPoseResult* result = new HumanPoseResult(infResult.frameId, infResult.metaData);
 
-    const auto& heatMapsMapped = infResult.outputsData[outputsNames[0]];
-    const auto& outputMapped = infResult.outputsData[outputsNames[1]];
+    auto& heatMapsMapped = infResult.outputsData[outputsNames[0]];
+    auto& outputMapped = infResult.outputsData[outputsNames[1]];
 
     const ov::Shape& outputShape = outputMapped.get_shape();
     const ov::Shape& heatMapShape = heatMapsMapped.get_shape();
diff --git a/demos/common/cpp/models/src/segmentation_model.cpp b/demos/common/cpp/models/src/segmentation_model.cpp
@@ -116,7 +116,7 @@ void SegmentationModel::prepareInputsOutputs(std::shared_ptr<ov::Model>& model)
 std::unique_ptr<ResultBase> SegmentationModel::postprocess(InferenceResult& infResult) {
     ImageResult* result = new ImageResult(infResult.frameId, infResult.metaData);
     const auto& inputImgSize = infResult.internalModelData->asRef<InternalImageModelData>();
-    const auto& outTensor = infResult.getFirstOutputTensor();
+    auto outTensor = infResult.getFirstOutputTensor();
 
     result->resultImage = cv::Mat(outHeight, outWidth, CV_8UC1);
 
diff --git a/demos/common/cpp/utils/include/utils/ocv_common.hpp b/demos/common/cpp/utils/include/utils/ocv_common.hpp
@@ -35,7 +35,8 @@ const T getMatValue(const cv::Mat& mat, size_t h, size_t w, size_t c) {
 * @param tensor - Tensor object which to be filled by an image data.
 * @param batchIndex - batch index of an image inside of the blob.
 */
-static UNUSED void matToTensor(const cv::Mat& mat, const ov::Tensor& tensor, int batchIndex = 0) {
+static UNUSED void matToTensor(const cv::Mat &mat, ov::Tensor &tensor,
+                               int batchIndex = 0) {
     ov::Shape tensorShape = tensor.get_shape();
     static const ov::Layout layout("NCHW");
     const size_t width = tensorShape[ov::layout::width_idx(layout)];
@@ -99,7 +100,7 @@ static UNUSED ov::Tensor wrapMat2Tensor(const cv::Mat& mat) {
     return ov::Tensor(precision, ov::Shape{ 1, height, width, channels }, SharedMatAllocator{mat});
 }
 
-static inline void resize2tensor(const cv::Mat& mat, const ov::Tensor& tensor) {
+static inline void resize2tensor(const cv::Mat &mat, ov::Tensor &tensor) {
     static const ov::Layout layout{"NHWC"};
     const ov::Shape& shape = tensor.get_shape();
     cv::Size size{int(shape[ov::layout::width_idx(layout)]), int(shape[ov::layout::height_idx(layout)])};
diff --git a/demos/interactive_face_detection_demo/cpp/detectors.cpp b/demos/interactive_face_detection_demo/cpp/detectors.cpp
@@ -203,7 +203,10 @@ void AntispoofingClassifier::enqueue(const cv::Mat& face) {
     if (!enabled()) {
         return;
     }
-    resize2tensor(face, ov::Tensor{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}});
+    ov::Tensor t{inTensor,
+                 {enquedFaces, 0, 0, 0},
+                 {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}};
+    resize2tensor(face, t);
     enquedFaces++;
 }
 
@@ -253,7 +256,8 @@ void AgeGenderDetection::enqueue(const cv::Mat &face) {
     if (!enabled()) {
         return;
     }
-    resize2tensor(face, ov::Tensor{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}});
+    ov::Tensor t{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}};
+    resize2tensor(face, t);
     enquedFaces++;
 }
 
@@ -309,7 +313,8 @@ void HeadPoseDetection::enqueue(const cv::Mat &face) {
     if (!enabled()) {
         return;
     }
-    resize2tensor(face, ov::Tensor{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}});
+    ov::Tensor t{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}};
+    resize2tensor(face, t);
     enquedFaces++;
 }
 
@@ -364,7 +369,8 @@ void EmotionsDetection::enqueue(const cv::Mat &face) {
     if (!enabled()) {
         return;
     }
-    resize2tensor(face, ov::Tensor{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}});
+    ov::Tensor t{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}};
+    resize2tensor(face, t);
     enquedFaces++;
 }
 
@@ -381,7 +387,7 @@ std::map<std::string, float> EmotionsDetection::operator[](int idx) {
                                "to used emotions vector size (" +
                                std::to_string(emotionsVecSize) + ")");
     }
-    float* emotionsValues = tensor.data<float>();
+    auto emotionsValues = tensor.data<float>();
     auto outputIdxPos = emotionsValues + idx * emotionsVecSize;
     std::map<std::string, float> emotions;
 
@@ -440,7 +446,8 @@ void FacialLandmarksDetection::enqueue(const cv::Mat &face) {
     if (!enabled()) {
         return;
     }
-    resize2tensor(face, ov::Tensor{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}});
+    ov::Tensor t{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}};
+    resize2tensor(face, t);
     enquedFaces++;
 }
 
diff --git a/demos/multi_channel_common/cpp/graph.cpp b/demos/multi_channel_common/cpp/graph.cpp
@@ -13,7 +13,7 @@
 #include "threading.hpp"
 
 namespace {
-void framesToTensor(const std::vector<std::shared_ptr<VideoFrame>>& frames, const ov::Tensor& tensor) {
+void framesToTensor(const std::vector<std::shared_ptr<VideoFrame>>& frames, ov::Tensor tensor) {
     static const ov::Layout layout{"NHWC"};
     static const ov::Shape shape = tensor.get_shape();
     static const size_t batchSize = shape[ov::layout::batch_idx(layout)];
diff --git a/demos/pedestrian_tracker_demo/cpp/include/cnn.hpp b/demos/pedestrian_tracker_demo/cpp/include/cnn.hpp
@@ -57,7 +57,7 @@ class BaseModel {
      * @param results_fetcher Callback to fetch inference results
      */
     void InferBatch(const std::vector<cv::Mat>& frames,
-                    const std::function<void(const ov::Tensor&, size_t)>& results_fetcher) const;
+                    const std::function<void(ov::Tensor, size_t)>& results_fetcher) const;
 
     /** @brief Config */
     Config config;
diff --git a/demos/pedestrian_tracker_demo/cpp/src/cnn.cpp b/demos/pedestrian_tracker_demo/cpp/src/cnn.cpp
@@ -60,7 +60,7 @@ void BaseModel::Load() {
 }
 
 void BaseModel::InferBatch(const std::vector<cv::Mat>& frames,
-                           const std::function<void(const ov::Tensor&, size_t)>& fetch_results) const {
+                           const std::function<void(ov::Tensor, size_t)>& fetch_results) const {
     size_t num_imgs = frames.size();
     input_tensor.set_shape(input_shape);
     for (size_t batch_i = 0; batch_i < num_imgs;) {
@@ -97,7 +97,7 @@ void VectorCNN::Compute(const std::vector<cv::Mat>& images, std::vector<cv::Mat>
         return;
     }
     vectors->clear();
-    auto results_fetcher = [vectors](const ov::Tensor& tensor, size_t batch_size) {
+    auto results_fetcher = [vectors](ov::Tensor tensor, size_t batch_size) {
         ov::Shape shape = tensor.get_shape();
         std::vector<int> tensor_sizes(shape.size(), 0);
         for (size_t i = 0; i < tensor_sizes.size(); ++i) {
diff --git a/demos/smart_classroom_demo/cpp/src/cnn.cpp b/demos/smart_classroom_demo/cpp/src/cnn.cpp
@@ -74,7 +74,8 @@ void CnnDLSDKBase::InferBatch(
     size_t c = m_modelShape[ov::layout::channels_idx(m_desired_layout)];
     std::cout << m_in_tensor.get_shape() << ' ' << num_imgs << ' ' << m_modelShape << '\n';
     for (size_t i = 0; i < num_imgs; i++) {
-        resize2tensor(frames[i], ov::Tensor{ m_in_tensor, {i, 0, 0, 0}, {i + 1, h, w, c} });
+        ov::Tensor t{ m_in_tensor, {i, 0, 0, 0}, {i + 1, h, w, c} };
+        resize2tensor(frames[i], t);
     }
     m_infer_request.set_input_tensor(ov::Tensor{ m_in_tensor, { 0, 0, 0, 0 }, {num_imgs, h, w, c} });
 
diff --git a/demos/text_detection_demo/cpp/src/text_detection.cpp b/demos/text_detection_demo/cpp/src/text_detection.cpp
@@ -223,7 +223,7 @@ std::vector<cv::RotatedRect> TextDetector::postProcess(
         ov::Shape link_shape = output_tensors.at(kLocOutputName).get_shape();
         size_t link_data_size = link_shape[0] * link_shape[1] * link_shape[2] * link_shape[3];
 
-        float* link_data_pointer = output_tensors.at(kLocOutputName).data<float>();
+        auto link_data_pointer = output_tensors.at(kLocOutputName).data<float>();
 
         std::vector<float> link_data(link_data_pointer, link_data_pointer + link_data_size);;
         if (m_modelLayout == ov::Layout("NCHW")) {
@@ -243,7 +243,7 @@ std::vector<cv::RotatedRect> TextDetector::postProcess(
         ov::Shape cls_shape = output_tensors.at(kClsOutputName).get_shape();
         size_t cls_data_size = cls_shape[0] * cls_shape[1] * cls_shape[2] * cls_shape[3];
 
-        float* cls_data_pointer = output_tensors.at(kClsOutputName).data<float>();
+        auto cls_data_pointer = output_tensors.at(kClsOutputName).data<float>();
 
         std::vector<float> cls_data(cls_data_pointer, cls_data_pointer + cls_data_size);
         if (m_modelLayout == ov::Layout("NCHW")) {

Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,10 @@ void AntispoofingClassifier::enqueue(const cv::Mat& face) {`
`203`	`203`	`if (!enabled()) {`
`204`	`204`	`return;`
`205`	`205`	`}`
`206`		`- resize2tensor(face, ov::Tensor{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}});`
	`206`	`+ ov::Tensor t{inTensor,`
	`207`	`+ {enquedFaces, 0, 0, 0},`
	`208`	`+ {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}};`
	`209`	`+ resize2tensor(face, t);`
`207`	`210`	`enquedFaces++;`
`208`	`211`	`}`
`209`	`212`
`@@ -253,7 +256,8 @@ void AgeGenderDetection::enqueue(const cv::Mat &face) {`
`253`	`256`	`if (!enabled()) {`
`254`	`257`	`return;`
`255`	`258`	`}`
`256`		`- resize2tensor(face, ov::Tensor{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}});`
	`259`	`+ ov::Tensor t{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}};`
	`260`	`+ resize2tensor(face, t);`
`257`	`261`	`enquedFaces++;`
`258`	`262`	`}`
`259`	`263`
`@@ -309,7 +313,8 @@ void HeadPoseDetection::enqueue(const cv::Mat &face) {`
`309`	`313`	`if (!enabled()) {`
`310`	`314`	`return;`
`311`	`315`	`}`
`312`		`- resize2tensor(face, ov::Tensor{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}});`
	`316`	`+ ov::Tensor t{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}};`
	`317`	`+ resize2tensor(face, t);`
`313`	`318`	`enquedFaces++;`
`314`	`319`	`}`
`315`	`320`
`@@ -364,7 +369,8 @@ void EmotionsDetection::enqueue(const cv::Mat &face) {`
`364`	`369`	`if (!enabled()) {`
`365`	`370`	`return;`
`366`	`371`	`}`
`367`		`- resize2tensor(face, ov::Tensor{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}});`
	`372`	`+ ov::Tensor t{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}};`
	`373`	`+ resize2tensor(face, t);`
`368`	`374`	`enquedFaces++;`
`369`	`375`	`}`
`370`	`376`
`@@ -381,7 +387,7 @@ std::map<std::string, float> EmotionsDetection::operator[](int idx) {`
`381`	`387`	`"to used emotions vector size (" +`
`382`	`388`	`std::to_string(emotionsVecSize) + ")");`
`383`	`389`	`}`
`384`		`- float* emotionsValues = tensor.data<float>();`
	`390`	`+ auto emotionsValues = tensor.data<float>();`
`385`	`391`	`auto outputIdxPos = emotionsValues + idx * emotionsVecSize;`
`386`	`392`	`std::map<std::string, float> emotions;`
`387`	`393`
`@@ -440,7 +446,8 @@ void FacialLandmarksDetection::enqueue(const cv::Mat &face) {`
`440`	`446`	`if (!enabled()) {`
`441`	`447`	`return;`
`442`	`448`	`}`
`443`		`- resize2tensor(face, ov::Tensor{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}});`
	`449`	`+ ov::Tensor t{inTensor, {enquedFaces, 0, 0, 0}, {enquedFaces + 1, inShape[1], inShape[2], inShape[3]}};`
	`450`	`+ resize2tensor(face, t);`
`444`	`451`	`enquedFaces++;`
`445`	`452`	`}`
`446`	`453`