mv_machine_learning: give input type as template parameter

[Issue type] code refactoring

This patch adds the input type in the template declaration of the
AsyncManager class to drop template from the individual functions.

Change-Id: I37fe087d253383db87eff46e634a688ffba9a83c
Signed-off-by: Vibhav Aggarwal <v.aggarwal@samsung.com>

diff --git a/mv_machine_learning/common/include/async_manager.h b/mv_machine_learning/common/include/async_manager.h
index b7385c3..0ae85c3 100644 (file)
--- a/mv_machine_learning/common/include/async_manager.h
+++ b/mv_machine_learning/common/include/async_manager.h
@@ -45,14 +45,14 @@ template<typename T> struct AsyncInputQueue {
        std::vector<std::vector<T> > inputs;
 };
 
-template<typename R> class AsyncManager
+template<typename T, typename R> class AsyncManager
 {
 private:
        using CallbackType = std::function<void()>;
 
        const std::chrono::seconds _INPUT_QUEUE_WAIT_TIME_SEC { 1 };
        const std::chrono::seconds _OUTPUT_QUEUE_WAIT_TIME_SEC { 3 };
-       std::queue<AsyncInputQueue<unsigned char> > _incoming_queue;
+       std::queue<AsyncInputQueue<T> > _incoming_queue;
        std::queue<R> _outgoing_queue;
        std::mutex _incoming_queue_mutex;
        std::mutex _outgoing_queue_mutex;
@@ -63,29 +63,14 @@ private:
        unsigned long _input_frame_number {};
        CallbackType _callback;
 
-       template<typename T> void pushToInput(AsyncInputQueue<T> &inputQueue)
+       void pushToInput(AsyncInputQueue<T> &inputQueue)
        {
                std::lock_guard<std::mutex> lock(_incoming_queue_mutex);
-               AsyncInputQueue<unsigned char> dstQueue;
 
-               dstQueue.frame_number = inputQueue.frame_number;
-
-               for (auto &elms : inputQueue.inputs) {
-                       std::vector<unsigned char> dst_vector;
-
-                       for (auto &elm : elms) {
-                               unsigned char *bytes = reinterpret_cast<unsigned char *>(&elm);
-
-                               std::copy_n(bytes, sizeof(T), back_inserter(dst_vector));
-                       }
-
-                       dstQueue.inputs.push_back(dst_vector);
-               }
-
-               _incoming_queue.push(dstQueue);
+               _incoming_queue.push(inputQueue);
                _incoming_queue_event.notify_one();
        }
-       template<typename T> bool isInputQueueEmpty()
+       bool isInputQueueEmpty()
        {
                std::lock_guard<std::mutex> lock(_incoming_queue_mutex);
 
@@ -100,7 +85,7 @@ private:
 
                return output;
        }
-       template<typename T> void inferenceThreadLoop()
+       void inferenceThreadLoop()
        {
                // If user called destroy API then this thread loop will be terminated.
                while (!_exit_thread) {
@@ -126,10 +111,10 @@ private:
                // So make sure to call notify_one() here.
                _outgoing_queue_event.notify_one();
        }
-       template<typename T> void invoke()
+       void invoke()
        {
                if (!_thread_handle)
-                       _thread_handle = std::make_unique<std::thread>(&AsyncManager::inferenceThreadLoop<T>, this);
+                       _thread_handle = std::make_unique<std::thread>(&AsyncManager::inferenceThreadLoop, this);
        }
        bool waitforInputQueue()
        {
@@ -189,31 +174,14 @@ public:
 
                swap(_outgoing_queue, empty);
        }
-       template<typename T> AsyncInputQueue<T> popFromInput()
+       AsyncInputQueue<T> popFromInput()
        {
                std::lock_guard<std::mutex> lock(_incoming_queue_mutex);
-               AsyncInputQueue<unsigned char> inputQueue = _incoming_queue.front();
+               AsyncInputQueue<T> inputQueue = _incoming_queue.front();
 
                _incoming_queue.pop();
 
-               AsyncInputQueue<T> dstQueue;
-
-               dstQueue.frame_number = inputQueue.frame_number;
-
-               for (auto &elms : inputQueue.inputs) {
-                       std::vector<T> dst_vector;
-
-                       for (size_t idx = 0; idx < elms.size(); idx += sizeof(T)) {
-                               T dst_data;
-
-                               std::copy_n(elms.begin() + idx, sizeof(T), reinterpret_cast<unsigned char *>(&dst_data));
-                               dst_vector.push_back(dst_data);
-                       }
-
-                       dstQueue.inputs.push_back(dst_vector);
-               }
-
-               return dstQueue;
+               return inputQueue;
        }
        void pushToOutput(R &output)
        {
@@ -222,22 +190,22 @@ public:
                _outgoing_queue.push(output);
                _outgoing_queue_event.notify_one();
        }
-       template<typename T> void push(std::vector<std::vector<T> > &inputs)
+       void push(std::vector<std::vector<T> > &inputs)
        {
                _input_frame_number++;
 
-               if (!isInputQueueEmpty<T>()) {
+               if (!isInputQueueEmpty()) {
                        LOGD("input frame number(%ld) has been skipped.", _input_frame_number);
                        return;
                }
 
                AsyncInputQueue<T> in_queue = { _input_frame_number, inputs };
 
-               pushToInput<T>(in_queue);
+               pushToInput(in_queue);
 
                LOGD("Pushed : input frame number = %lu", in_queue.frame_number);
 
-               invoke<T>();
+               invoke();
        }
        R pop()
        {

diff --git a/mv_machine_learning/image_classification/include/image_classification.h b/mv_machine_learning/image_classification/include/image_classification.h
index 71cd2c5..7e0229d 100644 (file)
--- a/mv_machine_learning/image_classification/include/image_classification.h
+++ b/mv_machine_learning/image_classification/include/image_classification.h
@@ -39,7 +39,7 @@ namespace machine_learning
 template<typename T> class ImageClassification : public IImageClassification
 {
 private:
-       std::unique_ptr<AsyncManager<ImageClassificationResult> > _async_manager;
+       std::unique_ptr<AsyncManager<T, ImageClassificationResult> > _async_manager;
        ImageClassificationResult _current_result;
 
        void loadLabel();

diff --git a/mv_machine_learning/image_classification/src/image_classification.cpp b/mv_machine_learning/image_classification/src/image_classification.cpp
index a88e28a..d4bf394 100644 (file)
--- a/mv_machine_learning/image_classification/src/image_classification.cpp
+++ b/mv_machine_learning/image_classification/src/image_classification.cpp
@@ -283,8 +283,8 @@ template<typename T> ImageClassificationResult &ImageClassification<T>::getOutpu
 template<typename T> void ImageClassification<T>::performAsync(ImageClassificationInput &input)
 {
        if (!_async_manager) {
-               _async_manager = make_unique<AsyncManager<ImageClassificationResult> >([this]() {
-                       AsyncInputQueue<T> inputQueue = _async_manager->popFromInput<T>();
+               _async_manager = make_unique<AsyncManager<T, ImageClassificationResult> >([this]() {
+                       AsyncInputQueue<T> inputQueue = _async_manager->popFromInput();
 
                        inference(inputQueue.inputs);
 

diff --git a/mv_machine_learning/image_segmentation/include/image_segmentation.h b/mv_machine_learning/image_segmentation/include/image_segmentation.h
index 247c256..81a4cdb 100644 (file)
--- a/mv_machine_learning/image_segmentation/include/image_segmentation.h
+++ b/mv_machine_learning/image_segmentation/include/image_segmentation.h
@@ -44,7 +44,7 @@ namespace machine_learning
 template<typename T> class ImageSegmentation : public IImageSegmentation
 {
 private:
-       std::unique_ptr<AsyncManager<ImageSegmentationResult> > _async_manager;
+       std::unique_ptr<AsyncManager<T, ImageSegmentationResult> > _async_manager;
        ImageSegmentationResult _current_result {};
 
        void loadLabel();

diff --git a/mv_machine_learning/image_segmentation/src/image_segmentation.cpp b/mv_machine_learning/image_segmentation/src/image_segmentation.cpp
index ad3630d..30d065c 100644 (file)
--- a/mv_machine_learning/image_segmentation/src/image_segmentation.cpp
+++ b/mv_machine_learning/image_segmentation/src/image_segmentation.cpp
@@ -269,8 +269,8 @@ template<typename T> void ImageSegmentation<T>::perform(mv_source_h &mv_src)
 template<typename T> void ImageSegmentation<T>::performAsync(ImageSegmentationInput &input)
 {
        if (!_async_manager) {
-               _async_manager = make_unique<AsyncManager<ImageSegmentationResult> >([this]() {
-                       AsyncInputQueue<T> inputQueue = _async_manager->popFromInput<T>();
+               _async_manager = make_unique<AsyncManager<T, ImageSegmentationResult> >([this]() {
+                       AsyncInputQueue<T> inputQueue = _async_manager->popFromInput();
 
                        inference(inputQueue.inputs);
 

diff --git a/mv_machine_learning/landmark_detection/include/landmark_detection.h b/mv_machine_learning/landmark_detection/include/landmark_detection.h
index 9eb6e38..075c6ba 100644 (file)
--- a/mv_machine_learning/landmark_detection/include/landmark_detection.h
+++ b/mv_machine_learning/landmark_detection/include/landmark_detection.h
@@ -39,7 +39,7 @@ namespace machine_learning
 template<typename T> class LandmarkDetection : public ILandmarkDetection
 {
 private:
-       std::unique_ptr<AsyncManager<LandmarkDetectionResult> > _async_manager;
+       std::unique_ptr<AsyncManager<T, LandmarkDetectionResult> > _async_manager;
        LandmarkDetectionResult _current_result {};
        LandmarkDetectionTaskType _task_type;
 

diff --git a/mv_machine_learning/landmark_detection/src/landmark_detection.cpp b/mv_machine_learning/landmark_detection/src/landmark_detection.cpp
index 98b9662..a813635 100644 (file)
--- a/mv_machine_learning/landmark_detection/src/landmark_detection.cpp
+++ b/mv_machine_learning/landmark_detection/src/landmark_detection.cpp
@@ -287,8 +287,8 @@ template<typename T> LandmarkDetectionResult &LandmarkDetection<T>::getOutput()
 template<typename T> void LandmarkDetection<T>::performAsync(LandmarkDetectionInput &input)
 {
        if (!_async_manager) {
-               _async_manager = make_unique<AsyncManager<LandmarkDetectionResult> >([this]() {
-                       AsyncInputQueue<T> inputQueue = _async_manager->popFromInput<T>();
+               _async_manager = make_unique<AsyncManager<T, LandmarkDetectionResult> >([this]() {
+                       AsyncInputQueue<T> inputQueue = _async_manager->popFromInput();
 
                        LOGD("Poped input frame number = %ld", inputQueue.frame_number);
 

diff --git a/mv_machine_learning/object_detection/include/object_detection.h b/mv_machine_learning/object_detection/include/object_detection.h
index a13acad..a839ad2 100644 (file)
--- a/mv_machine_learning/object_detection/include/object_detection.h
+++ b/mv_machine_learning/object_detection/include/object_detection.h
@@ -45,7 +45,7 @@ template<typename T> class ObjectDetection : public IObjectDetection
 {
 private:
        ObjectDetectionTaskType _task_type { ObjectDetectionTaskType::OBJECT_DETECTION_TASK_NONE };
-       std::unique_ptr<AsyncManager<ObjectDetectionResult> > _async_manager;
+       std::unique_ptr<AsyncManager<T, ObjectDetectionResult> > _async_manager;
        ObjectDetectionResult _current_result;
 
        void loadLabel();

diff --git a/mv_machine_learning/object_detection/src/object_detection.cpp b/mv_machine_learning/object_detection/src/object_detection.cpp
index 73ddff7..539dd18 100644 (file)
--- a/mv_machine_learning/object_detection/src/object_detection.cpp
+++ b/mv_machine_learning/object_detection/src/object_detection.cpp
@@ -271,8 +271,8 @@ template<typename T> void ObjectDetection<T>::perform(mv_source_h &mv_src)
 template<typename T> void ObjectDetection<T>::performAsync(ObjectDetectionInput &input)
 {
        if (!_async_manager) {
-               _async_manager = make_unique<AsyncManager<ObjectDetectionResult> >([this]() {
-                       AsyncInputQueue<T> inputQueue = _async_manager->popFromInput<T>();
+               _async_manager = make_unique<AsyncManager<T, ObjectDetectionResult> >([this]() {
+                       AsyncInputQueue<T> inputQueue = _async_manager->popFromInput();
 
                        inference(inputQueue.inputs);