Remove unnecessary variables copying outputData, instead use outputData itself

Change-Id: I03f67afaaa83042812de7323f9b90714ba37f80a
Signed-off-by: Tae-Young Chung <ty83.chung@samsung.com>

diff --git a/mv_machine_learning/mv_inference/inference/src/Inference.cpp b/mv_machine_learning/mv_inference/inference/src/Inference.cpp
index c7ca663..5ff3235 100755 (executable)
--- a/mv_machine_learning/mv_inference/inference/src/Inference.cpp
+++ b/mv_machine_learning/mv_inference/inference/src/Inference.cpp
@@ -1243,13 +1243,9 @@ namespace inference
                                        top_result_pq;
                        float value = 0.0f;
 
-                       std::vector<std::vector<int> > inferDimInfo(outputData.dimInfo);
-                       std::vector<void *> inferResults(outputData.data.begin(),
-                                                                                       outputData.data.end());
-
-                       int count = inferDimInfo[0][1];
+                       int count = outputData.dimInfo[0][1];
                        LOGI("count: %d", count);
-                       float *prediction = reinterpret_cast<float *>(inferResults[0]);
+                       float *prediction = reinterpret_cast<float *>(outputData.data[0]);
                        for (int i = 0; i < count; ++i) {
                                value = prediction[i];
 
@@ -1270,20 +1266,17 @@ namespace inference
                        }
                        std::reverse(top_results.begin(), top_results.end());
 
-                       int classIdx = -1;
                        ImageClassificationResults results;
                        results.number_of_classes = 0;
-                       for (size_t idx = 0; idx < top_results.size(); ++idx) {
-                               if (top_results[idx].first < mThreshold)
+                       for (auto& result : top_results) {
+                               if (result.first < mThreshold)
                                        continue;
-                               LOGI("idx:%zu", idx);
-                               LOGI("classIdx: %d", top_results[idx].second);
-                               LOGI("classProb: %f", top_results[idx].first);
-
-                               classIdx = top_results[idx].second;
-                               results.indices.push_back(classIdx);
-                               results.confidences.push_back(top_results[idx].first);
-                               results.names.push_back(mUserListName[classIdx]);
+
+                               LOGI("class Idx: %d, Prob: %.4f", result.second, result.first);
+
+                               results.indices.push_back(result.second);
+                               results.confidences.push_back(result.first);
+                               results.names.push_back(mUserListName[result.second]);
                                results.number_of_classes++;
                        }
 
@@ -1372,12 +1365,6 @@ namespace inference
                        // In case of object detection,
                        // a model may apply post-process but others may not.
                        // Thus, those cases should be hanlded separately.
-                       std::vector<std::vector<int> > inferDimInfo(outputData.dimInfo);
-                       LOGI("inferDimInfo size: %zu", outputData.dimInfo.size());
-
-                       std::vector<void *> inferResults(outputData.data.begin(),
-                                                                                       outputData.data.end());
-                       LOGI("inferResults size: %zu", inferResults.size());
 
                        float *boxes = nullptr;
                        float *classes = nullptr;
@@ -1395,7 +1382,7 @@ namespace inference
 
                                number_of_detections = static_cast<int>(
                                                *reinterpret_cast<float *>(outputData.data[0]));
-                               cv::Mat cvOutputData(number_of_detections, inferDimInfo[0][3],
+                               cv::Mat cvOutputData(number_of_detections, outputData.dimInfo[0][3],
                                                                        CV_32F, outputData.data[0]);
 
                                // boxes
@@ -1418,11 +1405,11 @@ namespace inference
                                scores = cvScores.ptr<float>(0);
 
                        } else {
-                               boxes = reinterpret_cast<float *>(inferResults[0]);
-                               classes = reinterpret_cast<float *>(inferResults[1]);
-                               scores = reinterpret_cast<float *>(inferResults[2]);
+                               boxes = reinterpret_cast<float *>(outputData.data[0]);
+                               classes = reinterpret_cast<float *>(outputData.data[1]);
+                               scores = reinterpret_cast<float *>(outputData.data[2]);
                                number_of_detections =
-                                               (int) (*reinterpret_cast<float *>(inferResults[3]));
+                                               (int) (*reinterpret_cast<float *>(outputData.data[3]));
                        }
 
                        LOGI("number_of_detections = %d", number_of_detections);
@@ -1542,12 +1529,6 @@ namespace inference
                        // In case of object detection,
                        // a model may apply post-process but others may not.
                        // Thus, those cases should be handled separately.
-                       std::vector<std::vector<int> > inferDimInfo(outputData.dimInfo);
-                       LOGI("inferDimInfo size: %zu", outputData.dimInfo.size());
-
-                       std::vector<void *> inferResults(outputData.data.begin(),
-                                                                                       outputData.data.end());
-                       LOGI("inferResults size: %zu", inferResults.size());
 
                        float *boxes = nullptr;
                        float *classes = nullptr;
@@ -1565,7 +1546,7 @@ namespace inference
 
                                number_of_detections = static_cast<int>(
                                                *reinterpret_cast<float *>(outputData.data[0]));
-                               cv::Mat cvOutputData(number_of_detections, inferDimInfo[0][3],
+                               cv::Mat cvOutputData(number_of_detections, outputData.dimInfo[0][3],
                                                                        CV_32F, outputData.data[0]);
 
                                // boxes
@@ -1588,11 +1569,11 @@ namespace inference
                                scores = cvScores.ptr<float>(0);
 
                        } else {
-                               boxes = reinterpret_cast<float *>(inferResults[0]);
-                               classes = reinterpret_cast<float *>(inferResults[1]);
-                               scores = reinterpret_cast<float *>(inferResults[2]);
+                               boxes = reinterpret_cast<float *>(outputData.data[0]);
+                               classes = reinterpret_cast<float *>(outputData.data[1]);
+                               scores = reinterpret_cast<float *>(outputData.data[2]);
                                number_of_detections = static_cast<int>(
-                                               *reinterpret_cast<float *>(inferResults[3]));
+                                               *reinterpret_cast<float *>(outputData.data[3]));
                        }
 
                        int left, top, right, bottom;
@@ -1707,30 +1688,22 @@ namespace inference
                                return ret;
                        }
 
-                       std::vector<std::vector<int> > inferDimInfo(outputData.dimInfo);
-                       std::vector<void *> inferResults(outputData.data.begin(),
-                                                                                       outputData.data.end());
+                       int number_of_detections = outputData.dimInfo[0][1] >> 1;
+                       float *loc = reinterpret_cast<float *>(outputData.data[0]);
+                       results.number_of_landmarks = number_of_detections;
+                       results.locations.resize(number_of_detections);
 
-                       long number_of_detections = inferDimInfo[0][1];
-                       float *loc = reinterpret_cast<float *>(inferResults[0]);
-
-                       results.number_of_landmarks = 0;
-
-                       cv::Point point(0, 0);
                        LOGI("imgW:%d, imgH:%d", mSourceSize.width, mSourceSize.height);
-                       for (int idx = 0; idx < number_of_detections; idx += 2) {
-                               point.x = static_cast<int>(loc[idx] * mSourceSize.width);
-                               point.y = static_cast<int>(loc[idx + 1] * mSourceSize.height);
-
-                               results.locations.push_back(point);
-                               results.number_of_landmarks++;
+                       for (auto& point : results.locations) {
+                               point.x = static_cast<int>(*loc++ * mSourceSize.width);
+                               point.y = static_cast<int>(*loc++ * mSourceSize.height);
 
                                LOGI("x:%d, y:%d", point.x, point.y);
                        }
 
                        *detectionResults = results;
                }
-               LOGE("Inference: FacialLandmarkDetectionResults: %d\n",
+               LOGI("Inference: FacialLandmarkDetectionResults: %d\n",
                         results.number_of_landmarks);
                return MEDIA_VISION_ERROR_NONE;
        }
@@ -1848,28 +1821,24 @@ namespace inference
                                        return ret;
                        }
 
-                       std::vector<std::vector<int> > inferDimInfo(outputData.dimInfo);
-                       std::vector<void *> inferResults(outputData.data.begin(),
-                                                                                       outputData.data.end());
-
                        long number_of_poses = 1;
-                       long number_of_landmarks = inferDimInfo[0][3];
-                       float *tmp = static_cast<float *>(inferResults[0]);
-                       cv::Size heatMapSize(inferDimInfo[0][1], inferDimInfo[0][2]);
+                       long number_of_landmarks = outputData.dimInfo[0][3];
+                       float *tmp = static_cast<float *>(outputData.data[0]);
+                       cv::Size heatMapSize(outputData.dimInfo[0][1], outputData.dimInfo[0][2]);
 
                        cv::Point loc;
                        cv::Point2f loc2f;
                        double score;
                        cv::Mat blurredHeatMap;
 
-                       cv::Mat reShapeTest(cv::Size(inferDimInfo[0][2], inferDimInfo[0][1]),
-                                                                                                       CV_32FC(inferDimInfo[0][3]), (void *) tmp);
+                       cv::Mat reShapeTest(cv::Size(outputData.dimInfo[0][2], outputData.dimInfo[0][1]),
+                                                                                                       CV_32FC(outputData.dimInfo[0][3]), (void *) tmp);
 
-                       cv::Mat multiChannels[inferDimInfo[0][3]];
+                       cv::Mat multiChannels[outputData.dimInfo[0][3]];
                        split(reShapeTest, multiChannels);
 
-                       float ratioX = static_cast<float>(inferDimInfo[0][2]);
-                       float ratioY = static_cast<float>(inferDimInfo[0][1]);
+                       float ratioX = static_cast<float>(outputData.dimInfo[0][2]);
+                       float ratioY = static_cast<float>(outputData.dimInfo[0][1]);
 
                        if (mPoseResult == NULL) {
                                if(!mUserListName.empty()) {