mv_machine_learning: convert char* to string and change return types

[Issue type] code refactoring

This patch changes the char arrays to std::string and also
changes the return type of getXYZ() functions from void to
the type of data they return.

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

diff --git a/mv_machine_learning/common/include/itask.h b/mv_machine_learning/common/include/itask.h
index 92258f7..a55865c 100644 (file)
--- a/mv_machine_learning/common/include/itask.h
+++ b/mv_machine_learning/common/include/itask.h
@@ -18,6 +18,7 @@
 #define __ITASK_H__
 
 #include "MachineLearningType.h"
+#include <string>
 
 namespace mediavision
 {
@@ -27,14 +28,14 @@ class ITask
 {
 public:
        virtual ~ITask() {};
-       virtual void setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                                         const char *model_name = "") = 0;
-       virtual void setEngineInfo(const char *engine_type, const char *device_type) = 0;
+       virtual void setModelInfo(const std::string &model_file, const std::string &meta_file,
+                                                         const std::string &label_file, const std::string &model_name = "") = 0;
+       virtual void setEngineInfo(const std::string &engine_type, const std::string &device_type) = 0;
        virtual void configure() = 0;
-       virtual void getNumberOfEngines(unsigned int *number_of_engines) = 0;
-       virtual void getEngineType(unsigned int engine_index, char **engine_type) = 0;
-       virtual void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) = 0;
-       virtual void getDeviceType(const char *engine_type, unsigned int device_index, char **device_type) = 0;
+       virtual unsigned int getNumberOfEngines() = 0;
+       virtual const std::string &getEngineType(unsigned int engine_index) = 0;
+       virtual unsigned int getNumberOfDevices(const std::string &engine_type) = 0;
+       virtual const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) = 0;
        virtual void prepare() = 0;
        virtual void perform(mediavision::machine_learning::InputBaseType &input) = 0;
        virtual void performAsync(mediavision::machine_learning::InputBaseType &input) = 0;

diff --git a/mv_machine_learning/common/src/MachineLearningNative.cpp b/mv_machine_learning/common/src/MachineLearningNative.cpp
index e767b92..f1c714c 100644 (file)
--- a/mv_machine_learning/common/src/MachineLearningNative.cpp
+++ b/mv_machine_learning/common/src/MachineLearningNative.cpp
@@ -115,7 +115,7 @@ void machine_learning_native_get_engine_count(void *handle, const string &task_n
 {
        auto task = get_task(handle, task_name);
 
-       task->getNumberOfEngines(engine_count);
+       *engine_count = task->getNumberOfEngines();
 }
 
 void machine_learning_native_get_engine_type(void *handle, const string &task_name, const unsigned int engine_index,
@@ -123,7 +123,7 @@ void machine_learning_native_get_engine_type(void *handle, const string &task_na
 {
        auto task = get_task(handle, task_name);
 
-       task->getEngineType(engine_index, engine_type);
+       *engine_type = (char *) task->getEngineType(engine_index).c_str();
 }
 
 void machine_learning_native_get_device_count(void *handle, const string &task_name, const char *engine_type,
@@ -131,7 +131,7 @@ void machine_learning_native_get_device_count(void *handle, const string &task_n
 {
        auto task = get_task(handle, task_name);
 
-       task->getNumberOfDevices(engine_type, device_count);
+       *device_count = task->getNumberOfDevices(engine_type);
 }
 
 void machine_learning_native_get_device_type(void *handle, const string &task_name, const char *engine_type,
@@ -139,7 +139,7 @@ void machine_learning_native_get_device_type(void *handle, const string &task_na
 {
        auto task = get_task(handle, task_name);
 
-       task->getDeviceType(engine_type, device_index, device_type);
+       *device_type = (char *) task->getDeviceType(engine_type, device_index).c_str();
 }
 
 }

diff --git a/mv_machine_learning/face_recognition/include/face_recognition_adapter.h b/mv_machine_learning/face_recognition/include/face_recognition_adapter.h
index 0bb5f4c..3487d72 100644 (file)
--- a/mv_machine_learning/face_recognition/include/face_recognition_adapter.h
+++ b/mv_machine_learning/face_recognition/include/face_recognition_adapter.h
@@ -42,14 +42,14 @@ public:
                return _config;
        }
 
-       void setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                         const char *model_name) override;
-       void setEngineInfo(const char *engine_type, const char *device_type) override;
+       void setModelInfo(const std::string &model_file, const std::string &meta_file, const std::string &label_file,
+                                         const std::string &model_name) override;
+       void setEngineInfo(const std::string &engine_type, const std::string &device_type) override;
        void configure() override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) override;
        void prepare() override;
        void perform(InputBaseType &input) override;
        void performAsync(InputBaseType &input) override;

diff --git a/mv_machine_learning/face_recognition/include/facenet_adapter.h b/mv_machine_learning/face_recognition/include/facenet_adapter.h
index 664cd31..cfb81ee 100644 (file)
--- a/mv_machine_learning/face_recognition/include/facenet_adapter.h
+++ b/mv_machine_learning/face_recognition/include/facenet_adapter.h
@@ -37,14 +37,14 @@ public:
        FacenetAdapter();
        ~FacenetAdapter();
 
-       void setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                         const char *model_name) override;
-       void setEngineInfo(const char *engine_type, const char *device_type) override;
+       void setModelInfo(const std::string &model_file, const std::string &meta_file, const std::string &label_file,
+                                         const std::string &model_name) override;
+       void setEngineInfo(const std::string &engine_type, const std::string &device_type) override;
        void configure() override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) override;
        void prepare() override;
        void perform(InputBaseType &input) override;
        void performAsync(InputBaseType &input) override;

diff --git a/mv_machine_learning/face_recognition/src/face_recognition_adapter.cpp b/mv_machine_learning/face_recognition/src/face_recognition_adapter.cpp
index f4a155c..e3821e4 100644 (file)
--- a/mv_machine_learning/face_recognition/src/face_recognition_adapter.cpp
+++ b/mv_machine_learning/face_recognition/src/face_recognition_adapter.cpp
@@ -36,12 +36,16 @@ FaceRecognitionAdapter::FaceRecognitionAdapter()
 FaceRecognitionAdapter::~FaceRecognitionAdapter()
 {}
 
-void FaceRecognitionAdapter::setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                                                                 const char *model_name)
-{}
+void FaceRecognitionAdapter::setModelInfo(const string &model_file, const string &meta_file, const string &label_file,
+                                                                                 const string &model_name)
+{
+       throw InvalidOperation("Not yet implemented");
+}
 
-void FaceRecognitionAdapter::setEngineInfo(const char *engine_type, const char *device_type)
-{}
+void FaceRecognitionAdapter::setEngineInfo(const string &engine_type, const string &device_type)
+{
+       throw InvalidOperation("Not yet implemented");
+}
 
 void FaceRecognitionAdapter::configure()
 {
@@ -89,17 +93,25 @@ void FaceRecognitionAdapter::configure()
        _face_recognition->setConfig(config);
 }
 
-void FaceRecognitionAdapter::getNumberOfEngines(unsigned int *number_of_engines)
-{}
+unsigned int FaceRecognitionAdapter::getNumberOfEngines()
+{
+       throw InvalidOperation("Not yet implemented");
+}
 
-void FaceRecognitionAdapter::getEngineType(unsigned int engine_index, char **engine_type)
-{}
+const string &FaceRecognitionAdapter::getEngineType(unsigned int engine_index)
+{
+       throw InvalidOperation("Not yet implemented");
+}
 
-void FaceRecognitionAdapter::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
-{}
+unsigned int FaceRecognitionAdapter::getNumberOfDevices(const string &engine_type)
+{
+       throw InvalidOperation("Not yet implemented");
+}
 
-void FaceRecognitionAdapter::getDeviceType(const char *engine_type, unsigned int device_index, char **device_type)
-{}
+const string &FaceRecognitionAdapter::getDeviceType(const string &engine_type, unsigned int device_index)
+{
+       throw InvalidOperation("Not yet implemented");
+}
 
 void FaceRecognitionAdapter::prepare()
 {

diff --git a/mv_machine_learning/face_recognition/src/facenet_adapter.cpp b/mv_machine_learning/face_recognition/src/facenet_adapter.cpp
index ec04b25..21b4b0d 100644 (file)
--- a/mv_machine_learning/face_recognition/src/facenet_adapter.cpp
+++ b/mv_machine_learning/face_recognition/src/facenet_adapter.cpp
@@ -34,11 +34,11 @@ FacenetAdapter::FacenetAdapter()
 FacenetAdapter::~FacenetAdapter()
 {}
 
-void FacenetAdapter::setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                                                 const char *model_name)
+void FacenetAdapter::setModelInfo(const string &model_file, const string &meta_file, const string &label_file,
+                                                                 const string &model_name)
 {}
 
-void FacenetAdapter::setEngineInfo(const char *engine_type, const char *device_type)
+void FacenetAdapter::setEngineInfo(const string &engine_type, const string &device_type)
 {}
 
 void FacenetAdapter::configure()
@@ -47,17 +47,25 @@ void FacenetAdapter::configure()
        _facenet->configure();
 }
 
-void FacenetAdapter::getNumberOfEngines(unsigned int *number_of_engines)
-{}
+unsigned int FacenetAdapter::getNumberOfEngines()
+{
+       throw InvalidOperation("Not yet implemented");
+}
 
-void FacenetAdapter::getEngineType(unsigned int engine_index, char **engine_type)
-{}
+const string &FacenetAdapter::getEngineType(unsigned int engine_index)
+{
+       throw InvalidOperation("Not yet implemented");
+}
 
-void FacenetAdapter::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
-{}
+unsigned int FacenetAdapter::getNumberOfDevices(const string &engine_type)
+{
+       throw InvalidOperation("Not yet implemented");
+}
 
-void FacenetAdapter::getDeviceType(const char *engine_type, unsigned int device_index, char **device_type)
-{}
+const string &FacenetAdapter::getDeviceType(const string &engine_type, unsigned int device_index)
+{
+       throw InvalidOperation("Not yet implemented");
+}
 
 void FacenetAdapter::prepare()
 {

diff --git a/mv_machine_learning/image_classification/include/iimage_classification.h b/mv_machine_learning/image_classification/include/iimage_classification.h
index 342fb0d..ed3412a 100644 (file)
--- a/mv_machine_learning/image_classification/include/iimage_classification.h
+++ b/mv_machine_learning/image_classification/include/iimage_classification.h
@@ -32,11 +32,10 @@ public:
 
        virtual void preDestroy() = 0;
        virtual void setEngineInfo(std::string engine_type, std::string device_type) = 0;
-       virtual void getNumberOfEngines(unsigned int *number_of_engines) = 0;
-       virtual void getEngineType(unsigned int engine_index, std::string **engine_type) = 0;
-       virtual void getNumberOfDevices(const std::string &engine_type, unsigned int *number_of_devices) = 0;
-       virtual void getDeviceType(const std::string &engine_type, const unsigned int device_index,
-                                                          std::string **device_type) = 0;
+       virtual unsigned int getNumberOfEngines() = 0;
+       virtual const std::string &getEngineType(unsigned int engine_index) = 0;
+       virtual unsigned int getNumberOfDevices(const std::string &engine_type) = 0;
+       virtual const std::string &getDeviceType(const std::string &engine_type, const unsigned int device_index) = 0;
        virtual void configure() = 0;
        virtual void prepare() = 0;
        virtual void perform(mv_source_h &mv_src) = 0;

diff --git a/mv_machine_learning/image_classification/include/image_classification.h b/mv_machine_learning/image_classification/include/image_classification.h
index ed91df9..71cd2c5 100644 (file)
--- a/mv_machine_learning/image_classification/include/image_classification.h
+++ b/mv_machine_learning/image_classification/include/image_classification.h
@@ -67,10 +67,10 @@ public:
 
        void preDestroy();
        void setEngineInfo(std::string engine_type_name, std::string device_type_name);
-       void getNumberOfEngines(unsigned int *number_of_engines);
-       void getEngineType(unsigned int engine_index, std::string **engine_type);
-       void getNumberOfDevices(const std::string &engine_type, unsigned int *number_of_devices);
-       void getDeviceType(const std::string &engine_type, const unsigned int device_index, std::string **device_type);
+       unsigned int getNumberOfEngines();
+       const std::string &getEngineType(unsigned int engine_index);
+       unsigned int getNumberOfDevices(const std::string &engine_type);
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index);
        void configure();
        void prepare();
        void perform(mv_source_h &mv_src);

diff --git a/mv_machine_learning/image_classification/include/image_classification_adapter.h b/mv_machine_learning/image_classification/include/image_classification_adapter.h
index 7a3b36a..9011f46 100644 (file)
--- a/mv_machine_learning/image_classification/include/image_classification_adapter.h
+++ b/mv_machine_learning/image_classification/include/image_classification_adapter.h
@@ -42,14 +42,14 @@ public:
        ImageClassificationAdapter();
        ~ImageClassificationAdapter();
 
-       void setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                         const char *model_name) override;
-       void setEngineInfo(const char *engine_type, const char *device_type) override;
+       void setModelInfo(const std::string &model_file, const std::string &meta_file, const std::string &label_file,
+                                         const std::string &model_name) override;
+       void setEngineInfo(const std::string &engine_type, const std::string &device_type) override;
        void configure() override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) override;
        void prepare() override;
        void perform(InputBaseType &input) override;
        void performAsync(InputBaseType &input) override;

diff --git a/mv_machine_learning/image_classification/src/image_classification.cpp b/mv_machine_learning/image_classification/src/image_classification.cpp
index 6b45647..a88e28a 100644 (file)
--- a/mv_machine_learning/image_classification/src/image_classification.cpp
+++ b/mv_machine_learning/image_classification/src/image_classification.cpp
@@ -121,25 +121,23 @@ void ImageClassification<T>::setEngineInfo(std::string engine_type_name, std::st
                 device_type_name.c_str(), device_type);
 }
 
-template<typename T> void ImageClassification<T>::getNumberOfEngines(unsigned int *number_of_engines)
+template<typename T> unsigned int ImageClassification<T>::getNumberOfEngines()
 {
        if (!_valid_backends.empty()) {
-               *number_of_engines = _valid_backends.size();
-               return;
+               return _valid_backends.size();
        }
 
        getEngineList();
-       *number_of_engines = _valid_backends.size();
+       return _valid_backends.size();
 }
 
-template<typename T> void ImageClassification<T>::getEngineType(unsigned int engine_index, string **engine_type)
+template<typename T> const string &ImageClassification<T>::getEngineType(unsigned int engine_index)
 {
        if (!_valid_backends.empty()) {
                if (_valid_backends.size() <= engine_index)
                        throw InvalidParameter("Invalid engine index.");
 
-               *engine_type = &_valid_backends[engine_index];
-               return;
+               return _valid_backends[engine_index];
        }
 
        getEngineList();
@@ -147,31 +145,27 @@ template<typename T> void ImageClassification<T>::getEngineType(unsigned int eng
        if (_valid_backends.size() <= engine_index)
                throw InvalidParameter("Invalid engine index.");
 
-       *engine_type = &_valid_backends[engine_index];
+       return _valid_backends[engine_index];
 }
 
-template<typename T>
-void ImageClassification<T>::getNumberOfDevices(const string &engine_type, unsigned int *number_of_devices)
+template<typename T> unsigned int ImageClassification<T>::getNumberOfDevices(const string &engine_type)
 {
        if (!_valid_devices.empty()) {
-               *number_of_devices = _valid_devices.size();
-               return;
+               return _valid_devices.size();
        }
 
        getDeviceList(engine_type);
-       *number_of_devices = _valid_devices.size();
+       return _valid_devices.size();
 }
 
 template<typename T>
-void ImageClassification<T>::getDeviceType(const string &engine_type, const unsigned int device_index,
-                                                                                  string **device_type)
+const string &ImageClassification<T>::getDeviceType(const string &engine_type, unsigned int device_index)
 {
        if (!_valid_devices.empty()) {
                if (_valid_devices.size() <= device_index)
                        throw InvalidParameter("Invalid device index.");
 
-               *device_type = &_valid_devices[device_index];
-               return;
+               return _valid_devices[device_index];
        }
 
        getDeviceList(engine_type);
@@ -179,7 +173,7 @@ void ImageClassification<T>::getDeviceType(const string &engine_type, const unsi
        if (_valid_devices.size() <= device_index)
                throw InvalidParameter("Invalid device index.");
 
-       *device_type = &_valid_devices[device_index];
+       return _valid_devices[device_index];
 }
 
 template<typename T> void ImageClassification<T>::prepare()

diff --git a/mv_machine_learning/image_classification/src/image_classification_adapter.cpp b/mv_machine_learning/image_classification/src/image_classification_adapter.cpp
index fc01256..c47d1d0 100644 (file)
--- a/mv_machine_learning/image_classification/src/image_classification_adapter.cpp
+++ b/mv_machine_learning/image_classification/src/image_classification_adapter.cpp
@@ -59,19 +59,19 @@ void ImageClassificationAdapter::create()
        }
 }
 
-void ImageClassificationAdapter::setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                                                                         const char *model_name)
+void ImageClassificationAdapter::setModelInfo(const string &model_file, const string &meta_file,
+                                                                                         const string &label_file, const string &model_name)
 {
        _config->setUserModel(model_file, meta_file, label_file);
        create();
 
-       if (!model_file && !meta_file) {
+       if (model_file.empty() && meta_file.empty()) {
                LOGW("Given model info is invalid so default model info will be used instead.");
                return;
        }
 }
 
-void ImageClassificationAdapter::setEngineInfo(const char *engine_type, const char *device_type)
+void ImageClassificationAdapter::setEngineInfo(const string &engine_type, const string &device_type)
 {
        _image_classification->setEngineInfo(engine_type, device_type);
 }
@@ -81,28 +81,24 @@ void ImageClassificationAdapter::configure()
        _image_classification->configure();
 }
 
-void ImageClassificationAdapter::getNumberOfEngines(unsigned int *number_of_engines)
+unsigned int ImageClassificationAdapter::getNumberOfEngines()
 {
-       _image_classification->getNumberOfEngines(number_of_engines);
+       return _image_classification->getNumberOfEngines();
 }
 
-void ImageClassificationAdapter::getEngineType(unsigned int engine_index, char **engine_type)
+const string &ImageClassificationAdapter::getEngineType(unsigned int engine_index)
 {
-       string *engine_type_str;
-       _image_classification->getEngineType(engine_index, &engine_type_str);
-       *engine_type = (char *) engine_type_str->c_str();
+       return _image_classification->getEngineType(engine_index);
 }
 
-void ImageClassificationAdapter::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+unsigned int ImageClassificationAdapter::getNumberOfDevices(const string &engine_type)
 {
-       _image_classification->getNumberOfDevices(engine_type, number_of_devices);
+       return _image_classification->getNumberOfDevices(engine_type);
 }
 
-void ImageClassificationAdapter::getDeviceType(const char *engine_type, unsigned int device_index, char **device_type)
+const string &ImageClassificationAdapter::getDeviceType(const string &engine_type, unsigned int device_index)
 {
-       string *device_type_str;
-       _image_classification->getDeviceType(engine_type, device_index, &device_type_str);
-       *device_type = (char *) device_type_str->c_str();
+       return _image_classification->getDeviceType(engine_type, device_index);
 }
 
 void ImageClassificationAdapter::prepare()

diff --git a/mv_machine_learning/image_classification/src/mv_image_classification.cpp b/mv_machine_learning/image_classification/src/mv_image_classification.cpp
index 1134e73..777719e 100644 (file)
--- a/mv_machine_learning/image_classification/src/mv_image_classification.cpp
+++ b/mv_machine_learning/image_classification/src/mv_image_classification.cpp
@@ -289,7 +289,7 @@ int mv_image_classification_get_device_count(mv_image_classification_h handle, c
 }
 
 int mv_image_classification_get_device_type(mv_image_classification_h handle, const char *engine_type,
-                                                                                       const unsigned int device_index, char **device_type)
+                                                                                       unsigned int device_index, char **device_type)
 {
        MEDIA_VISION_SUPPORT_CHECK(mv_check_feature_key(feature_keys, num_keys, false));
        MEDIA_VISION_INSTANCE_CHECK(handle);

diff --git a/mv_machine_learning/image_segmentation/include/iimage_segmentation.h b/mv_machine_learning/image_segmentation/include/iimage_segmentation.h
index bfee8c0..3305d36 100644 (file)
--- a/mv_machine_learning/image_segmentation/include/iimage_segmentation.h
+++ b/mv_machine_learning/image_segmentation/include/iimage_segmentation.h
@@ -33,10 +33,10 @@ public:
        virtual void preDestroy() = 0;
        virtual void setUserModel(std::string model_file, std::string meta_file, std::string label_file) = 0;
        virtual void setEngineInfo(std::string engine_type, std::string device_type) = 0;
-       virtual void getNumberOfEngines(unsigned int *number_of_engines) = 0;
-       virtual void getEngineType(unsigned int engine_index, char **engine_type) = 0;
-       virtual void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) = 0;
-       virtual void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type) = 0;
+       virtual unsigned int getNumberOfEngines() = 0;
+       virtual const std::string &getEngineType(unsigned int engine_index) = 0;
+       virtual unsigned int getNumberOfDevices(const std::string &engine_type) = 0;
+       virtual const std::string &getDeviceType(const std::string &engine_type, const unsigned int device_index) = 0;
        virtual void configure() = 0;
        virtual void prepare() = 0;
        virtual void perform(mv_source_h &mv_src) = 0;

diff --git a/mv_machine_learning/image_segmentation/include/image_segmentation.h b/mv_machine_learning/image_segmentation/include/image_segmentation.h
index b56df31..247c256 100644 (file)
--- a/mv_machine_learning/image_segmentation/include/image_segmentation.h
+++ b/mv_machine_learning/image_segmentation/include/image_segmentation.h
@@ -49,7 +49,7 @@ private:
 
        void loadLabel();
        void getEngineList();
-       void getDeviceList(const char *engine_type);
+       void getDeviceList(const std::string &engine_type);
        void preprocess(mv_source_h &mv_src, std::shared_ptr<MetaInfo> metaInfo, std::vector<T> &inputVector);
        std::shared_ptr<MetaInfo> getInputMetaInfo();
 
@@ -73,10 +73,10 @@ public:
        void preDestroy() override;
        void setUserModel(std::string model_file, std::string meta_file, std::string label_file) override;
        void setEngineInfo(std::string engine_type, std::string device_type) override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, const unsigned int device_index) override;
        void configure() override;
        void prepare() override;
        void perform(mv_source_h &mv_src) override;

diff --git a/mv_machine_learning/image_segmentation/include/image_segmentation_external.h b/mv_machine_learning/image_segmentation/include/image_segmentation_external.h
index 4897796..c663480 100644 (file)
--- a/mv_machine_learning/image_segmentation/include/image_segmentation_external.h
+++ b/mv_machine_learning/image_segmentation/include/image_segmentation_external.h
@@ -39,16 +39,16 @@ private:
        ImageSegmentationResult _current_result;
 
 public:
-       ImageSegmentationExternal(ImageSegmentationTaskType task_type, const char *plugin_name);
+       ImageSegmentationExternal(ImageSegmentationTaskType task_type, const std::string &plugin_name);
        virtual ~ImageSegmentationExternal();
 
        void preDestroy() override;
        void setUserModel(std::string model_file, std::string meta_file, std::string label_file) override;
        void setEngineInfo(std::string engine_type, std::string device_type) override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, const unsigned int device_index) override;
        void configure() override;
        void prepare() override;
        void perform(mv_source_h &mv_src) override;

diff --git a/mv_machine_learning/image_segmentation/include/selfie_segmentation_adapter.h b/mv_machine_learning/image_segmentation/include/selfie_segmentation_adapter.h
index 45e7598..82ed323 100644 (file)
--- a/mv_machine_learning/image_segmentation/include/selfie_segmentation_adapter.h
+++ b/mv_machine_learning/image_segmentation/include/selfie_segmentation_adapter.h
@@ -44,14 +44,14 @@ public:
        ImageSegmentationAdapter();
        ~ImageSegmentationAdapter();
 
-       void setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                         const char *model_name) override;
-       void setEngineInfo(const char *engine_type, const char *device_type) override;
+       void setModelInfo(const std::string &model_file, const std::string &meta_file, const std::string &label_file,
+                                         const std::string &model_name) override;
+       void setEngineInfo(const std::string &engine_type, const std::string &device_type) override;
        void configure() override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) override;
        void prepare() override;
        void perform(InputBaseType &input) override;
        void performAsync(InputBaseType &input) override;

diff --git a/mv_machine_learning/image_segmentation/src/image_segmentation.cpp b/mv_machine_learning/image_segmentation/src/image_segmentation.cpp
index 2868954..ad3630d 100644 (file)
--- a/mv_machine_learning/image_segmentation/src/image_segmentation.cpp
+++ b/mv_machine_learning/image_segmentation/src/image_segmentation.cpp
@@ -59,7 +59,7 @@ template<typename T> void ImageSegmentation<T>::getEngineList()
        }
 }
 
-template<typename T> void ImageSegmentation<T>::getDeviceList(const char *engine_type)
+template<typename T> void ImageSegmentation<T>::getDeviceList(const string &engine_type)
 {
        // TODO. add device types available for a given engine type later.
        //       In default, cpu and gpu only.
@@ -93,25 +93,23 @@ void ImageSegmentation<T>::setEngineInfo(std::string engine_type_name, std::stri
                 device_type_name.c_str(), device_type);
 }
 
-template<typename T> void ImageSegmentation<T>::getNumberOfEngines(unsigned int *number_of_engines)
+template<typename T> unsigned int ImageSegmentation<T>::getNumberOfEngines()
 {
        if (!_valid_backends.empty()) {
-               *number_of_engines = _valid_backends.size();
-               return;
+               return _valid_backends.size();
        }
 
        getEngineList();
-       *number_of_engines = _valid_backends.size();
+       return _valid_backends.size();
 }
 
-template<typename T> void ImageSegmentation<T>::getEngineType(unsigned int engine_index, char **engine_type)
+template<typename T> const string &ImageSegmentation<T>::getEngineType(unsigned int engine_index)
 {
        if (!_valid_backends.empty()) {
                if (_valid_backends.size() <= engine_index)
                        throw InvalidParameter("Invalid engine index.");
 
-               *engine_type = const_cast<char *>(_valid_backends[engine_index].data());
-               return;
+               return _valid_backends[engine_index];
        }
 
        getEngineList();
@@ -119,30 +117,27 @@ template<typename T> void ImageSegmentation<T>::getEngineType(unsigned int engin
        if (_valid_backends.size() <= engine_index)
                throw InvalidParameter("Invalid engine index.");
 
-       *engine_type = const_cast<char *>(_valid_backends[engine_index].data());
+       return _valid_backends[engine_index];
 }
 
-template<typename T>
-void ImageSegmentation<T>::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+template<typename T> unsigned int ImageSegmentation<T>::getNumberOfDevices(const string &engine_type)
 {
        if (!_valid_devices.empty()) {
-               *number_of_devices = _valid_devices.size();
-               return;
+               return _valid_devices.size();
        }
 
        getDeviceList(engine_type);
-       *number_of_devices = _valid_devices.size();
+       return _valid_devices.size();
 }
 
 template<typename T>
-void ImageSegmentation<T>::getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type)
+const string &ImageSegmentation<T>::getDeviceType(const string &engine_type, unsigned int device_index)
 {
        if (!_valid_devices.empty()) {
                if (_valid_devices.size() <= device_index)
                        throw InvalidParameter("Invalid device index.");
 
-               *device_type = const_cast<char *>(_valid_devices[device_index].data());
-               return;
+               return _valid_devices[device_index];
        }
 
        getDeviceList(engine_type);
@@ -150,7 +145,7 @@ void ImageSegmentation<T>::getDeviceType(const char *engine_type, const unsigned
        if (_valid_devices.size() <= device_index)
                throw InvalidParameter("Invalid device index.");
 
-       *device_type = const_cast<char *>(_valid_devices[device_index].data());
+       return _valid_devices[device_index];
 }
 
 template<typename T> void ImageSegmentation<T>::loadLabel()

diff --git a/mv_machine_learning/image_segmentation/src/image_segmentation_external.cpp b/mv_machine_learning/image_segmentation/src/image_segmentation_external.cpp
index 0e1a8d7..bf3083e 100644 (file)
--- a/mv_machine_learning/image_segmentation/src/image_segmentation_external.cpp
+++ b/mv_machine_learning/image_segmentation/src/image_segmentation_external.cpp
@@ -32,12 +32,12 @@ namespace machine_learning
 typedef IImageSegmentation *create_t(ImageSegmentationTaskType task_type);
 typedef void destroy_t(IImageSegmentation *);
 
-ImageSegmentationExternal::ImageSegmentationExternal(ImageSegmentationTaskType task_type, const char *plugin_name)
+ImageSegmentationExternal::ImageSegmentationExternal(ImageSegmentationTaskType task_type, const string &plugin_name)
                : _plugin_handle(), _image_segmentation_plugin()
 {
        // Load external plugin library.
-       LOGI("lib: %s", plugin_name);
-       _plugin_handle = dlopen(plugin_name, RTLD_NOW);
+       LOGI("lib: %s", plugin_name.c_str());
+       _plugin_handle = dlopen(plugin_name.c_str(), RTLD_NOW);
 
        if (!_plugin_handle)
                throw InvalidOperation("Fail to open plugin library.");
@@ -74,35 +74,34 @@ void ImageSegmentationExternal::preDestroy()
        _image_segmentation_plugin->preDestroy();
 }
 
-void ImageSegmentationExternal::setUserModel(std::string model_file, std::string meta_file, std::string label_file)
+void ImageSegmentationExternal::setUserModel(string model_file, string meta_file, string label_file)
 {
        _image_segmentation_plugin->setUserModel(model_file, meta_file, label_file);
 }
 
-void ImageSegmentationExternal::setEngineInfo(std::string engine_type, std::string device_type)
+void ImageSegmentationExternal::setEngineInfo(string engine_type, string device_type)
 {
        _image_segmentation_plugin->setEngineInfo(engine_type, device_type);
 }
 
-void ImageSegmentationExternal::getNumberOfEngines(unsigned int *number_of_engines)
+unsigned int ImageSegmentationExternal::getNumberOfEngines()
 {
-       _image_segmentation_plugin->getNumberOfEngines(number_of_engines);
+       return _image_segmentation_plugin->getNumberOfEngines();
 }
 
-void ImageSegmentationExternal::getEngineType(unsigned int engine_index, char **engine_type)
+const string &ImageSegmentationExternal::getEngineType(unsigned int engine_index)
 {
-       _image_segmentation_plugin->getEngineType(engine_index, engine_type);
+       return _image_segmentation_plugin->getEngineType(engine_index);
 }
 
-void ImageSegmentationExternal::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+unsigned int ImageSegmentationExternal::getNumberOfDevices(const string &engine_type)
 {
-       _image_segmentation_plugin->getNumberOfDevices(engine_type, number_of_devices);
+       return _image_segmentation_plugin->getNumberOfDevices(engine_type.c_str());
 }
 
-void ImageSegmentationExternal::getDeviceType(const char *engine_type, const unsigned int device_index,
-                                                                                         char **device_type)
+const string &ImageSegmentationExternal::getDeviceType(const string &engine_type, unsigned int device_index)
 {
-       _image_segmentation_plugin->getDeviceType(engine_type, device_index, device_type);
+       return _image_segmentation_plugin->getDeviceType(engine_type.c_str(), device_index);
 }
 
 void ImageSegmentationExternal::configure()

diff --git a/mv_machine_learning/image_segmentation/src/mv_selfie_segmentation.cpp b/mv_machine_learning/image_segmentation/src/mv_selfie_segmentation.cpp
index cf86d85..ecf71b5 100644 (file)
--- a/mv_machine_learning/image_segmentation/src/mv_selfie_segmentation.cpp
+++ b/mv_machine_learning/image_segmentation/src/mv_selfie_segmentation.cpp
@@ -150,7 +150,7 @@ int mv_selfie_segmentation_get_engine_count(mv_selfie_segmentation_h handle, uns
                auto context = static_cast<Context *>(handle);
                auto task = context->__tasks.at("selfie_segmentation");
 
-               task->getNumberOfEngines(engine_count);
+               *engine_count = task->getNumberOfEngines();
                // TODO.
        } catch (const BaseException &e) {
                LOGE("%s", e.what());
@@ -176,7 +176,7 @@ int mv_selfie_segmentation_get_engine_type(mv_selfie_segmentation_h handle, cons
                auto context = static_cast<Context *>(handle);
                auto task = context->__tasks.at("selfie_segmentation");
 
-               task->getEngineType(engine_index, engine_type);
+               *engine_type = (char *) task->getEngineType(engine_index).c_str();
                // TODO.
        } catch (const BaseException &e) {
                LOGE("%s", e.what());
@@ -202,7 +202,7 @@ int mv_selfie_segmentation_get_device_count(mv_selfie_segmentation_h handle, con
                auto context = static_cast<Context *>(handle);
                auto task = context->__tasks.at("selfie_segmentation");
 
-               task->getNumberOfDevices(engine_type, device_count);
+               *device_count = task->getNumberOfDevices(engine_type);
                // TODO.
        } catch (const BaseException &e) {
                LOGE("%s", e.what());
@@ -229,7 +229,7 @@ int mv_selfie_segmentation_get_device_type(mv_selfie_segmentation_h handle, cons
                auto context = static_cast<Context *>(handle);
                auto task = context->__tasks.at("selfie_segmentation");
 
-               task->getDeviceType(engine_type, device_index, device_type);
+               *device_type = (char *) task->getDeviceType(engine_type, device_index).c_str();
                // TODO.
        } catch (const BaseException &e) {
                LOGE("%s", e.what());

diff --git a/mv_machine_learning/image_segmentation/src/selfie_segmentation_adapter.cpp b/mv_machine_learning/image_segmentation/src/selfie_segmentation_adapter.cpp
index e5a2700..584fbc2 100644 (file)
--- a/mv_machine_learning/image_segmentation/src/selfie_segmentation_adapter.cpp
+++ b/mv_machine_learning/image_segmentation/src/selfie_segmentation_adapter.cpp
@@ -93,8 +93,8 @@ ImageSegmentationTaskType ImageSegmentationAdapter::convertToTaskType(string mod
        throw InvalidParameter("Invalid selfie segmentation model name.");
 }
 
-void ImageSegmentationAdapter::setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                                                                       const char *model_name)
+void ImageSegmentationAdapter::setModelInfo(const string &model_file, const string &meta_file, const string &label_file,
+                                                                                       const string &model_name)
 {
        try {
                _config->setUserModel(model_file, meta_file, label_file);
@@ -103,7 +103,7 @@ void ImageSegmentationAdapter::setModelInfo(const char *model_file, const char *
                LOGW("A given model name is invalid so default task type will be used.");
        }
 
-       if (!model_file && !meta_file) {
+       if (model_file.empty() && meta_file.empty()) {
                LOGW("Given model info is invalid so default model info will be used instead.");
                return;
        }
@@ -111,9 +111,9 @@ void ImageSegmentationAdapter::setModelInfo(const char *model_file, const char *
        _selfie_segmentation->setUserModel(model_file, meta_file, label_file);
 }
 
-void ImageSegmentationAdapter::setEngineInfo(const char *engine_type, const char *device_type)
+void ImageSegmentationAdapter::setEngineInfo(const string &engine_type, const string &device_type)
 {
-       _selfie_segmentation->setEngineInfo(string(engine_type), string(device_type));
+       _selfie_segmentation->setEngineInfo(engine_type, device_type);
 }
 
 void ImageSegmentationAdapter::configure()
@@ -121,24 +121,24 @@ void ImageSegmentationAdapter::configure()
        _selfie_segmentation->configure();
 }
 
-void ImageSegmentationAdapter::getNumberOfEngines(unsigned int *number_of_engines)
+unsigned int ImageSegmentationAdapter::getNumberOfEngines()
 {
-       _selfie_segmentation->getNumberOfEngines(number_of_engines);
+       return _selfie_segmentation->getNumberOfEngines();
 }
 
-void ImageSegmentationAdapter::getEngineType(unsigned int engine_index, char **engine_type)
+const string &ImageSegmentationAdapter::getEngineType(unsigned int engine_index)
 {
-       _selfie_segmentation->getEngineType(engine_index, engine_type);
+       return _selfie_segmentation->getEngineType(engine_index);
 }
 
-void ImageSegmentationAdapter::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+unsigned int ImageSegmentationAdapter::getNumberOfDevices(const string &engine_type)
 {
-       _selfie_segmentation->getNumberOfDevices(engine_type, number_of_devices);
+       return _selfie_segmentation->getNumberOfDevices(engine_type);
 }
 
-void ImageSegmentationAdapter::getDeviceType(const char *engine_type, unsigned int device_index, char **device_type)
+const string &ImageSegmentationAdapter::getDeviceType(const string &engine_type, unsigned int device_index)
 {
-       _selfie_segmentation->getDeviceType(engine_type, device_index, device_type);
+       return _selfie_segmentation->getDeviceType(engine_type, device_index);
 }
 
 void ImageSegmentationAdapter::prepare()

diff --git a/mv_machine_learning/landmark_detection/include/facial_landmark_adapter.h b/mv_machine_learning/landmark_detection/include/facial_landmark_adapter.h
index d114d1a..7302719 100644 (file)
--- a/mv_machine_learning/landmark_detection/include/facial_landmark_adapter.h
+++ b/mv_machine_learning/landmark_detection/include/facial_landmark_adapter.h
@@ -44,14 +44,14 @@ public:
        FacialLandmarkAdapter();
        ~FacialLandmarkAdapter();
 
-       void setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                         const char *model_name) override;
-       void setEngineInfo(const char *engine_type, const char *device_type) override;
+       void setModelInfo(const std::string &model_file, const std::string &meta_file, const std::string &label_file,
+                                         const std::string &model_name) override;
+       void setEngineInfo(const std::string &engine_type, const std::string &device_type) override;
        void configure() override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) override;
        void prepare() override;
        void perform(InputBaseType &input) override;
        void performAsync(InputBaseType &input) override;

diff --git a/mv_machine_learning/landmark_detection/include/ilandmark_detection.h b/mv_machine_learning/landmark_detection/include/ilandmark_detection.h
index ca05d7e..0d709ad 100644 (file)
--- a/mv_machine_learning/landmark_detection/include/ilandmark_detection.h
+++ b/mv_machine_learning/landmark_detection/include/ilandmark_detection.h
@@ -33,10 +33,10 @@ public:
        virtual void preDestroy() = 0;
        virtual LandmarkDetectionTaskType getTaskType() = 0;
        virtual void setEngineInfo(std::string engine_type, std::string device_type) = 0;
-       virtual void getNumberOfEngines(unsigned int *number_of_engines) = 0;
-       virtual void getEngineType(unsigned int engine_index, char **engine_type) = 0;
-       virtual void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) = 0;
-       virtual void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type) = 0;
+       virtual unsigned int getNumberOfEngines() = 0;
+       virtual const std::string &getEngineType(unsigned int engine_index) = 0;
+       virtual unsigned int getNumberOfDevices(const std::string &engine_type) = 0;
+       virtual const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) = 0;
        virtual void configure() = 0;
        virtual void prepare() = 0;
        virtual void perform(mv_source_h &mv_src) = 0;

diff --git a/mv_machine_learning/landmark_detection/include/landmark_detection.h b/mv_machine_learning/landmark_detection/include/landmark_detection.h
index 6f55f0e..9eb6e38 100644 (file)
--- a/mv_machine_learning/landmark_detection/include/landmark_detection.h
+++ b/mv_machine_learning/landmark_detection/include/landmark_detection.h
@@ -45,7 +45,7 @@ private:
 
        void loadLabel();
        void getEngineList();
-       void getDeviceList(const char *engine_type);
+       void getDeviceList(const std::string &engine_type);
 
        void preprocess(mv_source_h &mv_src, std::shared_ptr<MetaInfo> metaInfo, std::vector<T> &inputVector);
        std::shared_ptr<MetaInfo> getInputMetaInfo();
@@ -69,10 +69,10 @@ public:
        void preDestroy();
        LandmarkDetectionTaskType getTaskType();
        void setEngineInfo(std::string engine_type_name, std::string device_type_name);
-       void getNumberOfEngines(unsigned int *number_of_engines);
-       void getEngineType(unsigned int engine_index, char **engine_type);
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices);
-       void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type);
+       unsigned int getNumberOfEngines();
+       const std::string &getEngineType(unsigned int engine_index);
+       unsigned int getNumberOfDevices(const std::string &engine_type);
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index);
        void configure();
        void prepare();
        void perform(mv_source_h &mv_src);

diff --git a/mv_machine_learning/landmark_detection/include/pose_landmark_adapter.h b/mv_machine_learning/landmark_detection/include/pose_landmark_adapter.h
index 9e8f42c..484246a 100644 (file)
--- a/mv_machine_learning/landmark_detection/include/pose_landmark_adapter.h
+++ b/mv_machine_learning/landmark_detection/include/pose_landmark_adapter.h
@@ -44,14 +44,14 @@ public:
        PoseLandmarkAdapter();
        ~PoseLandmarkAdapter();
 
-       void setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                         const char *model_name) override;
-       void setEngineInfo(const char *engine_type, const char *device_type) override;
+       void setModelInfo(const std::string &model_file, const std::string &meta_file, const std::string &label_file,
+                                         const std::string &model_name) override;
+       void setEngineInfo(const std::string &engine_type, const std::string &device_type) override;
        void configure() override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) override;
        void prepare() override;
        void perform(InputBaseType &input) override;
        void performAsync(InputBaseType &input) override;

diff --git a/mv_machine_learning/landmark_detection/src/facial_landmark_adapter.cpp b/mv_machine_learning/landmark_detection/src/facial_landmark_adapter.cpp
index 1b285d1..d277767 100644 (file)
--- a/mv_machine_learning/landmark_detection/src/facial_landmark_adapter.cpp
+++ b/mv_machine_learning/landmark_detection/src/facial_landmark_adapter.cpp
@@ -83,8 +83,8 @@ LandmarkDetectionTaskType FacialLandmarkAdapter::convertToTaskType(string model_
        throw InvalidParameter("Invalid facial detection model name.");
 }
 
-void FacialLandmarkAdapter::setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                                                                const char *model_name)
+void FacialLandmarkAdapter::setModelInfo(const string &model_file, const string &meta_file, const string &label_file,
+                                                                                const string &model_name)
 {
        try {
                _config->setUserModel(model_file, meta_file, label_file);
@@ -93,13 +93,13 @@ void FacialLandmarkAdapter::setModelInfo(const char *model_file, const char *met
                LOGW("A given model name is invalid so default task type will be used.");
        }
 
-       if (!model_file && !meta_file) {
+       if (model_file.empty() && meta_file.empty()) {
                LOGW("Given model info is invalid so default model info will be used instead.");
                return;
        }
 }
 
-void FacialLandmarkAdapter::setEngineInfo(const char *engine_type, const char *device_type)
+void FacialLandmarkAdapter::setEngineInfo(const string &engine_type, const string &device_type)
 {
        _landmark_detection->setEngineInfo(string(engine_type), string(device_type));
 }
@@ -109,24 +109,24 @@ void FacialLandmarkAdapter::configure()
        _landmark_detection->configure();
 }
 
-void FacialLandmarkAdapter::getNumberOfEngines(unsigned int *number_of_engines)
+unsigned int FacialLandmarkAdapter::getNumberOfEngines()
 {
-       _landmark_detection->getNumberOfEngines(number_of_engines);
+       return _landmark_detection->getNumberOfEngines();
 }
 
-void FacialLandmarkAdapter::getEngineType(unsigned int engine_index, char **engine_type)
+const string &FacialLandmarkAdapter::getEngineType(unsigned int engine_index)
 {
-       _landmark_detection->getEngineType(engine_index, engine_type);
+       return _landmark_detection->getEngineType(engine_index);
 }
 
-void FacialLandmarkAdapter::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+unsigned int FacialLandmarkAdapter::getNumberOfDevices(const string &engine_type)
 {
-       _landmark_detection->getNumberOfDevices(engine_type, number_of_devices);
+       return _landmark_detection->getNumberOfDevices(engine_type);
 }
 
-void FacialLandmarkAdapter::getDeviceType(const char *engine_type, unsigned int device_index, char **device_type)
+const string &FacialLandmarkAdapter::getDeviceType(const string &engine_type, unsigned int device_index)
 {
-       _landmark_detection->getDeviceType(engine_type, device_index, device_type);
+       return _landmark_detection->getDeviceType(engine_type, device_index);
 }
 
 void FacialLandmarkAdapter::prepare()

diff --git a/mv_machine_learning/landmark_detection/src/landmark_detection.cpp b/mv_machine_learning/landmark_detection/src/landmark_detection.cpp
index bc2bb59..98b9662 100644 (file)
--- a/mv_machine_learning/landmark_detection/src/landmark_detection.cpp
+++ b/mv_machine_learning/landmark_detection/src/landmark_detection.cpp
@@ -66,7 +66,7 @@ template<typename T> void LandmarkDetection<T>::getEngineList()
        }
 }
 
-template<typename T> void LandmarkDetection<T>::getDeviceList(const char *engine_type)
+template<typename T> void LandmarkDetection<T>::getDeviceList(const string &engine_type)
 {
        // TODO. add device types available for a given engine type later.
        //       In default, cpu and gpu only.
@@ -95,25 +95,23 @@ template<typename T> void LandmarkDetection<T>::setEngineInfo(string engine_type
                 device_type_name.c_str(), device_type);
 }
 
-template<typename T> void LandmarkDetection<T>::getNumberOfEngines(unsigned int *number_of_engines)
+template<typename T> unsigned int LandmarkDetection<T>::getNumberOfEngines()
 {
        if (!_valid_backends.empty()) {
-               *number_of_engines = _valid_backends.size();
-               return;
+               return _valid_backends.size();
        }
 
        getEngineList();
-       *number_of_engines = _valid_backends.size();
+       return _valid_backends.size();
 }
 
-template<typename T> void LandmarkDetection<T>::getEngineType(unsigned int engine_index, char **engine_type)
+template<typename T> const string &LandmarkDetection<T>::getEngineType(unsigned int engine_index)
 {
        if (!_valid_backends.empty()) {
                if (_valid_backends.size() <= engine_index)
                        throw InvalidParameter("Invalid engine index.");
 
-               *engine_type = const_cast<char *>(_valid_backends[engine_index].data());
-               return;
+               return _valid_backends[engine_index];
        }
 
        getEngineList();
@@ -121,30 +119,27 @@ template<typename T> void LandmarkDetection<T>::getEngineType(unsigned int engin
        if (_valid_backends.size() <= engine_index)
                throw InvalidParameter("Invalid engine index.");
 
-       *engine_type = const_cast<char *>(_valid_backends[engine_index].data());
+       return _valid_backends[engine_index];
 }
 
-template<typename T>
-void LandmarkDetection<T>::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+template<typename T> unsigned int LandmarkDetection<T>::getNumberOfDevices(const string &engine_type)
 {
        if (!_valid_devices.empty()) {
-               *number_of_devices = _valid_devices.size();
-               return;
+               return _valid_devices.size();
        }
 
        getDeviceList(engine_type);
-       *number_of_devices = _valid_devices.size();
+       return _valid_devices.size();
 }
 
 template<typename T>
-void LandmarkDetection<T>::getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type)
+const string &LandmarkDetection<T>::getDeviceType(const string &engine_type, const unsigned int device_index)
 {
        if (!_valid_devices.empty()) {
                if (_valid_devices.size() <= device_index)
                        throw InvalidParameter("Invalid device index.");
 
-               *device_type = const_cast<char *>(_valid_devices[device_index].data());
-               return;
+               return _valid_devices[device_index];
        }
 
        getDeviceList(engine_type);
@@ -152,7 +147,7 @@ void LandmarkDetection<T>::getDeviceType(const char *engine_type, const unsigned
        if (_valid_devices.size() <= device_index)
                throw InvalidParameter("Invalid device index.");
 
-       *device_type = const_cast<char *>(_valid_devices[device_index].data());
+       return _valid_devices[device_index];
 }
 
 template<typename T> void LandmarkDetection<T>::loadLabel()

diff --git a/mv_machine_learning/landmark_detection/src/pose_landmark_adapter.cpp b/mv_machine_learning/landmark_detection/src/pose_landmark_adapter.cpp
index b1e5650..d7d9922 100644 (file)
--- a/mv_machine_learning/landmark_detection/src/pose_landmark_adapter.cpp
+++ b/mv_machine_learning/landmark_detection/src/pose_landmark_adapter.cpp
@@ -82,8 +82,8 @@ LandmarkDetectionTaskType PoseLandmarkAdapter::convertToTaskType(string model_na
        throw InvalidParameter("Invalid pose landmark model name.");
 }
 
-void PoseLandmarkAdapter::setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                                                          const char *model_name)
+void PoseLandmarkAdapter::setModelInfo(const string &model_file, const string &meta_file, const string &label_file,
+                                                                          const string &model_name)
 {
        try {
                _config->setUserModel(model_file, meta_file, label_file);
@@ -92,15 +92,15 @@ void PoseLandmarkAdapter::setModelInfo(const char *model_file, const char *meta_
                LOGW("A given model name is invalid so default task type will be used.");
        }
 
-       if (!model_file && !meta_file) {
+       if (model_file.empty() && meta_file.empty()) {
                LOGW("Given model info is invalid so default model info will be used instead.");
                return;
        }
 }
 
-void PoseLandmarkAdapter::setEngineInfo(const char *engine_type, const char *device_type)
+void PoseLandmarkAdapter::setEngineInfo(const string &engine_type, const string &device_type)
 {
-       _landmark_detection->setEngineInfo(string(engine_type), string(device_type));
+       _landmark_detection->setEngineInfo(engine_type, device_type);
 }
 
 void PoseLandmarkAdapter::configure()
@@ -108,24 +108,24 @@ void PoseLandmarkAdapter::configure()
        _landmark_detection->configure();
 }
 
-void PoseLandmarkAdapter::getNumberOfEngines(unsigned int *number_of_engines)
+unsigned int PoseLandmarkAdapter::getNumberOfEngines()
 {
-       _landmark_detection->getNumberOfEngines(number_of_engines);
+       return _landmark_detection->getNumberOfEngines();
 }
 
-void PoseLandmarkAdapter::getEngineType(unsigned int engine_index, char **engine_type)
+const string &PoseLandmarkAdapter::getEngineType(unsigned int engine_index)
 {
-       _landmark_detection->getEngineType(engine_index, engine_type);
+       return _landmark_detection->getEngineType(engine_index);
 }
 
-void PoseLandmarkAdapter::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+unsigned int PoseLandmarkAdapter::getNumberOfDevices(const string &engine_type)
 {
-       _landmark_detection->getNumberOfDevices(engine_type, number_of_devices);
+       return _landmark_detection->getNumberOfDevices(engine_type);
 }
 
-void PoseLandmarkAdapter::getDeviceType(const char *engine_type, unsigned int device_index, char **device_type)
+const string &PoseLandmarkAdapter::getDeviceType(const string &engine_type, unsigned int device_index)
 {
-       _landmark_detection->getDeviceType(engine_type, device_index, device_type);
+       return _landmark_detection->getDeviceType(engine_type, device_index);
 }
 
 void PoseLandmarkAdapter::prepare()

diff --git a/mv_machine_learning/object_detection/include/face_detection_adapter.h b/mv_machine_learning/object_detection/include/face_detection_adapter.h
index 85e1dc4..ae4cb68 100644 (file)
--- a/mv_machine_learning/object_detection/include/face_detection_adapter.h
+++ b/mv_machine_learning/object_detection/include/face_detection_adapter.h
@@ -44,14 +44,14 @@ public:
        FaceDetectionAdapter();
        ~FaceDetectionAdapter();
 
-       void setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                         const char *model_name) override;
-       void setEngineInfo(const char *engine_type, const char *device_type) override;
+       void setModelInfo(const std::string &model_file, const std::string &meta_file, const std::string &label_file,
+                                         const std::string &model_name) override;
+       void setEngineInfo(const std::string &engine_type, const std::string &device_type) override;
        void configure() override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) override;
        void prepare() override;
        void perform(InputBaseType &input) override;
        void performAsync(InputBaseType &input) override;

diff --git a/mv_machine_learning/object_detection/include/iobject_detection.h b/mv_machine_learning/object_detection/include/iobject_detection.h
index d05b53a..5a64ad1 100644 (file)
--- a/mv_machine_learning/object_detection/include/iobject_detection.h
+++ b/mv_machine_learning/object_detection/include/iobject_detection.h
@@ -33,10 +33,10 @@ public:
        virtual void preDestroy() = 0;
        virtual ObjectDetectionTaskType getTaskType() = 0;
        virtual void setEngineInfo(std::string engine_type, std::string device_type) = 0;
-       virtual void getNumberOfEngines(unsigned int *number_of_engines) = 0;
-       virtual void getEngineType(unsigned int engine_index, char **engine_type) = 0;
-       virtual void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) = 0;
-       virtual void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type) = 0;
+       virtual unsigned int getNumberOfEngines() = 0;
+       virtual const std::string &getEngineType(unsigned int engine_index) = 0;
+       virtual unsigned int getNumberOfDevices(const std::string &engine_type) = 0;
+       virtual const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) = 0;
        virtual void configure() = 0;
        virtual void prepare() = 0;
        virtual void perform(mv_source_h &mv_src) = 0;

diff --git a/mv_machine_learning/object_detection/include/object_detection.h b/mv_machine_learning/object_detection/include/object_detection.h
index 4669b89..a13acad 100644 (file)
--- a/mv_machine_learning/object_detection/include/object_detection.h
+++ b/mv_machine_learning/object_detection/include/object_detection.h
@@ -50,7 +50,7 @@ private:
 
        void loadLabel();
        void getEngineList();
-       void getDeviceList(const char *engine_type);
+       void getDeviceList(const std::string &engine_type);
        void preprocess(mv_source_h &mv_src, std::shared_ptr<MetaInfo> metaInfo, std::vector<T> &inputVector);
        std::shared_ptr<MetaInfo> getInputMetaInfo();
 
@@ -75,10 +75,10 @@ public:
        ObjectDetectionTaskType getTaskType() override;
        void setUserModel(std::string model_file, std::string meta_file, std::string label_file);
        void setEngineInfo(std::string engine_type_name, std::string device_type_name) override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) override;
        void configure() override;
        void prepare() override;
        void perform(mv_source_h &mv_src) override;

diff --git a/mv_machine_learning/object_detection/include/object_detection_adapter.h b/mv_machine_learning/object_detection/include/object_detection_adapter.h
index c825512..bec6c56 100644 (file)
--- a/mv_machine_learning/object_detection/include/object_detection_adapter.h
+++ b/mv_machine_learning/object_detection/include/object_detection_adapter.h
@@ -45,14 +45,14 @@ public:
        ObjectDetectionAdapter();
        ~ObjectDetectionAdapter();
 
-       void setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                         const char *model_name) override;
-       void setEngineInfo(const char *engine_type, const char *device_type) override;
+       void setModelInfo(const std::string &model_file, const std::string &meta_file, const std::string &label_file,
+                                         const std::string &model_name) override;
+       void setEngineInfo(const std::string &engine_type, const std::string &device_type) override;
        void configure() override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) override;
        void prepare() override;
        void perform(InputBaseType &input) override;
        void performAsync(InputBaseType &input) override;

diff --git a/mv_machine_learning/object_detection/include/object_detection_external.h b/mv_machine_learning/object_detection/include/object_detection_external.h
index 8a1ac4b..ff63117 100644 (file)
--- a/mv_machine_learning/object_detection/include/object_detection_external.h
+++ b/mv_machine_learning/object_detection/include/object_detection_external.h
@@ -39,16 +39,16 @@ private:
        ObjectDetectionResult _current_result;
 
 public:
-       ObjectDetectionExternal(ObjectDetectionTaskType task_type, const char *plugin_name);
+       ObjectDetectionExternal(ObjectDetectionTaskType task_type, const std::string &plugin_name);
        virtual ~ObjectDetectionExternal();
 
        void preDestroy() override;
        ObjectDetectionTaskType getTaskType() override;
        void setEngineInfo(std::string engine_type, std::string device_type) override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, const unsigned int device_index) override;
        void configure() override;
        void prepare() override;
        void perform(mv_source_h &mv_src) override;

diff --git a/mv_machine_learning/object_detection/src/face_detection_adapter.cpp b/mv_machine_learning/object_detection/src/face_detection_adapter.cpp
index 6d8e7ec..56ee5d9 100644 (file)
--- a/mv_machine_learning/object_detection/src/face_detection_adapter.cpp
+++ b/mv_machine_learning/object_detection/src/face_detection_adapter.cpp
@@ -105,8 +105,8 @@ ObjectDetectionTaskType FaceDetectionAdapter::convertToTaskType(string model_nam
        throw InvalidParameter("Invalid face detection model name.");
 }
 
-void FaceDetectionAdapter::setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                                                               const char *model_name)
+void FaceDetectionAdapter::setModelInfo(const string &model_file, const string &meta_file, const string &label_file,
+                                                                               const string &model_name)
 {
        try {
                _config->setUserModel(model_file, meta_file, label_file);
@@ -115,13 +115,13 @@ void FaceDetectionAdapter::setModelInfo(const char *model_file, const char *meta
                LOGW("A given model name is invalid so default task type will be used.");
        }
 
-       if (!model_file && !meta_file) {
+       if (model_file.empty() && meta_file.empty()) {
                LOGW("Given model info is invalid so default model info will be used instead.");
                return;
        }
 }
 
-void FaceDetectionAdapter::setEngineInfo(const char *engine_type, const char *device_type)
+void FaceDetectionAdapter::setEngineInfo(const string &engine_type, const string &device_type)
 {
        _object_detection->setEngineInfo(string(engine_type), string(device_type));
 }
@@ -131,24 +131,24 @@ void FaceDetectionAdapter::configure()
        _object_detection->configure();
 }
 
-void FaceDetectionAdapter::getNumberOfEngines(unsigned int *number_of_engines)
+unsigned int FaceDetectionAdapter::getNumberOfEngines()
 {
-       _object_detection->getNumberOfEngines(number_of_engines);
+       return _object_detection->getNumberOfEngines();
 }
 
-void FaceDetectionAdapter::getEngineType(unsigned int engine_index, char **engine_type)
+const string &FaceDetectionAdapter::getEngineType(unsigned int engine_index)
 {
-       _object_detection->getEngineType(engine_index, engine_type);
+       return _object_detection->getEngineType(engine_index);
 }
 
-void FaceDetectionAdapter::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+unsigned int FaceDetectionAdapter::getNumberOfDevices(const string &engine_type)
 {
-       _object_detection->getNumberOfDevices(engine_type, number_of_devices);
+       return _object_detection->getNumberOfDevices(engine_type);
 }
 
-void FaceDetectionAdapter::getDeviceType(const char *engine_type, unsigned int device_index, char **device_type)
+const string &FaceDetectionAdapter::getDeviceType(const string &engine_type, unsigned int device_index)
 {
-       _object_detection->getDeviceType(engine_type, device_index, device_type);
+       return _object_detection->getDeviceType(engine_type, device_index);
 }
 
 void FaceDetectionAdapter::prepare()

diff --git a/mv_machine_learning/object_detection/src/object_detection.cpp b/mv_machine_learning/object_detection/src/object_detection.cpp
index 5802070..73ddff7 100644 (file)
--- a/mv_machine_learning/object_detection/src/object_detection.cpp
+++ b/mv_machine_learning/object_detection/src/object_detection.cpp
@@ -66,7 +66,7 @@ template<typename T> void ObjectDetection<T>::getEngineList()
        }
 }
 
-template<typename T> void ObjectDetection<T>::getDeviceList(const char *engine_type)
+template<typename T> void ObjectDetection<T>::getDeviceList(const string &engine_type)
 {
        // TODO. add device types available for a given engine type later.
        //       In default, cpu and gpu only.
@@ -95,25 +95,23 @@ template<typename T> void ObjectDetection<T>::setEngineInfo(std::string engine_t
                 device_type_name.c_str(), device_type);
 }
 
-template<typename T> void ObjectDetection<T>::getNumberOfEngines(unsigned int *number_of_engines)
+template<typename T> unsigned int ObjectDetection<T>::getNumberOfEngines()
 {
        if (!_valid_backends.empty()) {
-               *number_of_engines = _valid_backends.size();
-               return;
+               return _valid_backends.size();
        }
 
        getEngineList();
-       *number_of_engines = _valid_backends.size();
+       return _valid_backends.size();
 }
 
-template<typename T> void ObjectDetection<T>::getEngineType(unsigned int engine_index, char **engine_type)
+template<typename T> const string &ObjectDetection<T>::getEngineType(unsigned int engine_index)
 {
        if (!_valid_backends.empty()) {
                if (_valid_backends.size() <= engine_index)
                        throw InvalidParameter("Invalid engine index.");
 
-               *engine_type = const_cast<char *>(_valid_backends[engine_index].data());
-               return;
+               return _valid_backends[engine_index];
        }
 
        getEngineList();
@@ -121,30 +119,27 @@ template<typename T> void ObjectDetection<T>::getEngineType(unsigned int engine_
        if (_valid_backends.size() <= engine_index)
                throw InvalidParameter("Invalid engine index.");
 
-       *engine_type = const_cast<char *>(_valid_backends[engine_index].data());
+       return _valid_backends[engine_index];
 }
 
-template<typename T>
-void ObjectDetection<T>::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+template<typename T> unsigned int ObjectDetection<T>::getNumberOfDevices(const string &engine_type)
 {
        if (!_valid_devices.empty()) {
-               *number_of_devices = _valid_devices.size();
-               return;
+               return _valid_devices.size();
        }
 
        getDeviceList(engine_type);
-       *number_of_devices = _valid_devices.size();
+       return _valid_devices.size();
 }
 
 template<typename T>
-void ObjectDetection<T>::getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type)
+const string &ObjectDetection<T>::getDeviceType(const string &engine_type, unsigned int device_index)
 {
        if (!_valid_devices.empty()) {
                if (_valid_devices.size() <= device_index)
                        throw InvalidParameter("Invalid device index.");
 
-               *device_type = const_cast<char *>(_valid_devices[device_index].data());
-               return;
+               return _valid_devices[device_index];
        }
 
        getDeviceList(engine_type);
@@ -152,7 +147,7 @@ void ObjectDetection<T>::getDeviceType(const char *engine_type, const unsigned i
        if (_valid_devices.size() <= device_index)
                throw InvalidParameter("Invalid device index.");
 
-       *device_type = const_cast<char *>(_valid_devices[device_index].data());
+       return _valid_devices[device_index];
 }
 
 template<typename T> void ObjectDetection<T>::loadLabel()

diff --git a/mv_machine_learning/object_detection/src/object_detection_adapter.cpp b/mv_machine_learning/object_detection/src/object_detection_adapter.cpp
index 13e13a3..5358929 100644 (file)
--- a/mv_machine_learning/object_detection/src/object_detection_adapter.cpp
+++ b/mv_machine_learning/object_detection/src/object_detection_adapter.cpp
@@ -110,8 +110,8 @@ ObjectDetectionTaskType ObjectDetectionAdapter::convertToTaskType(string model_n
        throw InvalidParameter("Invalid object detection model name.");
 }
 
-void ObjectDetectionAdapter::setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                                                                 const char *model_name)
+void ObjectDetectionAdapter::setModelInfo(const string &model_file, const string &meta_file, const string &label_file,
+                                                                                 const string &model_name)
 {
        try {
                _config->setUserModel(model_file, meta_file, label_file);
@@ -120,13 +120,13 @@ void ObjectDetectionAdapter::setModelInfo(const char *model_file, const char *me
                LOGW("A given model name is invalid so default task type will be used.");
        }
 
-       if (!model_file && !meta_file) {
+       if (model_file.empty() && meta_file.empty()) {
                LOGW("Given model info is invalid so default model info will be used instead.");
                return;
        }
 }
 
-void ObjectDetectionAdapter::setEngineInfo(const char *engine_type, const char *device_type)
+void ObjectDetectionAdapter::setEngineInfo(const string &engine_type, const string &device_type)
 {
        _object_detection->setEngineInfo(string(engine_type), string(device_type));
 }
@@ -136,24 +136,24 @@ void ObjectDetectionAdapter::configure()
        _object_detection->configure();
 }
 
-void ObjectDetectionAdapter::getNumberOfEngines(unsigned int *number_of_engines)
+unsigned int ObjectDetectionAdapter::getNumberOfEngines()
 {
-       _object_detection->getNumberOfEngines(number_of_engines);
+       return _object_detection->getNumberOfEngines();
 }
 
-void ObjectDetectionAdapter::getEngineType(unsigned int engine_index, char **engine_type)
+const string &ObjectDetectionAdapter::getEngineType(unsigned int engine_index)
 {
-       _object_detection->getEngineType(engine_index, engine_type);
+       return _object_detection->getEngineType(engine_index);
 }
 
-void ObjectDetectionAdapter::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+unsigned int ObjectDetectionAdapter::getNumberOfDevices(const string &engine_type)
 {
-       _object_detection->getNumberOfDevices(engine_type, number_of_devices);
+       return _object_detection->getNumberOfDevices(engine_type);
 }
 
-void ObjectDetectionAdapter::getDeviceType(const char *engine_type, unsigned int device_index, char **device_type)
+const string &ObjectDetectionAdapter::getDeviceType(const string &engine_type, unsigned int device_index)
 {
-       _object_detection->getDeviceType(engine_type, device_index, device_type);
+       return _object_detection->getDeviceType(engine_type, device_index);
 }
 
 void ObjectDetectionAdapter::prepare()

diff --git a/mv_machine_learning/object_detection/src/object_detection_external.cpp b/mv_machine_learning/object_detection/src/object_detection_external.cpp
index b9de6e0..1829cb7 100644 (file)
--- a/mv_machine_learning/object_detection/src/object_detection_external.cpp
+++ b/mv_machine_learning/object_detection/src/object_detection_external.cpp
@@ -32,12 +32,12 @@ namespace machine_learning
 typedef IObjectDetection *create_t(ObjectDetectionTaskType task_type);
 typedef void destroy_t(IObjectDetection *);
 
-ObjectDetectionExternal::ObjectDetectionExternal(ObjectDetectionTaskType task_type, const char *plugin_name)
+ObjectDetectionExternal::ObjectDetectionExternal(ObjectDetectionTaskType task_type, const string &plugin_name)
                : _plugin_handle(), _object_detection_plugin()
 {
        // Load external object detection library.
-       LOGI("lib: %s", plugin_name);
-       _plugin_handle = dlopen(plugin_name, RTLD_NOW);
+       LOGI("lib: %s", plugin_name.c_str());
+       _plugin_handle = dlopen(plugin_name.c_str(), RTLD_NOW);
 
        if (!_plugin_handle)
                throw InvalidOperation("Fail to open plugin library.");
@@ -79,30 +79,29 @@ ObjectDetectionTaskType ObjectDetectionExternal::getTaskType()
        return _object_detection_plugin->getTaskType();
 }
 
-void ObjectDetectionExternal::setEngineInfo(std::string engine_type, std::string device_type)
+void ObjectDetectionExternal::setEngineInfo(string engine_type, string device_type)
 {
        _object_detection_plugin->setEngineInfo(engine_type, device_type);
 }
 
-void ObjectDetectionExternal::getNumberOfEngines(unsigned int *number_of_engines)
+unsigned int ObjectDetectionExternal::getNumberOfEngines()
 {
-       _object_detection_plugin->getNumberOfEngines(number_of_engines);
+       return _object_detection_plugin->getNumberOfEngines();
 }
 
-void ObjectDetectionExternal::getEngineType(unsigned int engine_index, char **engine_type)
+const string &ObjectDetectionExternal::getEngineType(unsigned int engine_index)
 {
-       _object_detection_plugin->getEngineType(engine_index, engine_type);
+       return _object_detection_plugin->getEngineType(engine_index);
 }
 
-void ObjectDetectionExternal::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+unsigned int ObjectDetectionExternal::getNumberOfDevices(const string &engine_type)
 {
-       _object_detection_plugin->getNumberOfDevices(engine_type, number_of_devices);
+       return _object_detection_plugin->getNumberOfDevices(engine_type);
 }
 
-void ObjectDetectionExternal::getDeviceType(const char *engine_type, const unsigned int device_index,
-                                                                                       char **device_type)
+const string &ObjectDetectionExternal::getDeviceType(const string &engine_type, const unsigned int device_index)
 {
-       _object_detection_plugin->getDeviceType(engine_type, device_index, device_type);
+       return _object_detection_plugin->getDeviceType(engine_type, device_index);
 }
 
 void ObjectDetectionExternal::configure()

diff --git a/mv_machine_learning/object_detection_3d/include/iobject_detection_3d.h b/mv_machine_learning/object_detection_3d/include/iobject_detection_3d.h
index b1486e1..1f1fa05 100644 (file)
--- a/mv_machine_learning/object_detection_3d/include/iobject_detection_3d.h
+++ b/mv_machine_learning/object_detection_3d/include/iobject_detection_3d.h
@@ -32,10 +32,10 @@ public:
 
        virtual ObjectDetection3dTaskType getTaskType() = 0;
        virtual void setEngineInfo(std::string engine_type_name, std::string device_type_name) = 0;
-       virtual void getNumberOfEngines(unsigned int *number_of_engines) = 0;
-       virtual void getEngineType(unsigned int engine_index, char **engine_type) = 0;
-       virtual void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) = 0;
-       virtual void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type) = 0;
+       virtual unsigned int getNumberOfEngines() = 0;
+       virtual const std::string &getEngineType(unsigned int engine_index) = 0;
+       virtual unsigned int getNumberOfDevices(const std::string &engine_type) = 0;
+       virtual const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) = 0;
        virtual std::shared_ptr<MetaInfo> getInputMetaInfo() = 0;
        virtual void configure() = 0;
        virtual void prepare() = 0;

diff --git a/mv_machine_learning/object_detection_3d/include/object_detection_3d.h b/mv_machine_learning/object_detection_3d/include/object_detection_3d.h
index 64dd038..9fc7306 100644 (file)
--- a/mv_machine_learning/object_detection_3d/include/object_detection_3d.h
+++ b/mv_machine_learning/object_detection_3d/include/object_detection_3d.h
@@ -42,7 +42,7 @@ private:
 
        void loadLabel();
        void getEngineList();
-       void getDeviceList(const char *engine_type);
+       void getDeviceList(const std::string &engine_type);
 
 protected:
        std::unique_ptr<mediavision::inference::Inference> _inference;
@@ -63,10 +63,10 @@ public:
 
        ObjectDetection3dTaskType getTaskType();
        void setEngineInfo(std::string engine_type_name, std::string device_type_name);
-       void getNumberOfEngines(unsigned int *number_of_engines);
-       void getEngineType(unsigned int engine_index, char **engine_type);
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices);
-       void getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type);
+       unsigned int getNumberOfEngines();
+       const std::string &getEngineType(unsigned int engine_index);
+       unsigned int getNumberOfDevices(const std::string &engine_type);
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index);
        std::shared_ptr<MetaInfo> getInputMetaInfo();
        void configure();
        void prepare();

diff --git a/mv_machine_learning/object_detection_3d/include/object_detection_3d_adapter.h b/mv_machine_learning/object_detection_3d/include/object_detection_3d_adapter.h
index 0741ff0..b657b08 100644 (file)
--- a/mv_machine_learning/object_detection_3d/include/object_detection_3d_adapter.h
+++ b/mv_machine_learning/object_detection_3d/include/object_detection_3d_adapter.h
@@ -44,13 +44,13 @@ public:
        ObjectDetection3dAdapter();
        ~ObjectDetection3dAdapter();
 
-       void setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                         const char *model_name) override;
-       void setEngineInfo(const char *engine_type, const char *device_type) override;
-       void getNumberOfEngines(unsigned int *number_of_engines) override;
-       void getEngineType(unsigned int engine_index, char **engine_type) override;
-       void getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices) override;
-       void getDeviceType(const char *engine_type, unsigned int device_index, char **device_type) override;
+       void setModelInfo(const std::string &model_file, const std::string &meta_file, const std::string &label_file,
+                                         const std::string &model_name) override;
+       void setEngineInfo(const std::string &engine_type, const std::string &device_type) override;
+       unsigned int getNumberOfEngines() override;
+       const std::string &getEngineType(unsigned int engine_index) override;
+       unsigned int getNumberOfDevices(const std::string &engine_type) override;
+       const std::string &getDeviceType(const std::string &engine_type, unsigned int device_index) override;
        void configure() override;
        void prepare() override;
        void perform(InputBaseType &input) override;

diff --git a/mv_machine_learning/object_detection_3d/src/mv_object_detection_3d.cpp b/mv_machine_learning/object_detection_3d/src/mv_object_detection_3d.cpp
index 1d5164b..fe8ff55 100644 (file)
--- a/mv_machine_learning/object_detection_3d/src/mv_object_detection_3d.cpp
+++ b/mv_machine_learning/object_detection_3d/src/mv_object_detection_3d.cpp
@@ -163,7 +163,7 @@ int mv_object_detection_3d_get_engine_count(mv_object_detection_3d_h handle, uns
                auto context = static_cast<Context *>(handle);
                auto task = context->__tasks.at("object_detection_3d");
 
-               task->getNumberOfEngines(engine_count);
+               *engine_count = task->getNumberOfEngines();
                // TODO.
        } catch (const BaseException &e) {
                LOGE("%s", e.what());
@@ -191,7 +191,7 @@ int mv_object_detection_3d_get_engine_type(mv_object_detection_3d_h handle, cons
                auto context = static_cast<Context *>(handle);
                auto task = context->__tasks.at("object_detection_3d");
 
-               task->getEngineType(engine_index, engine_type);
+               *engine_type = (char *) task->getEngineType(engine_index).c_str();
                // TODO.
        } catch (const BaseException &e) {
                LOGE("%s", e.what());
@@ -219,7 +219,7 @@ int mv_object_detection_3d_get_device_count(mv_object_detection_3d_h handle, con
                auto context = static_cast<Context *>(handle);
                auto task = context->__tasks.at("object_detection_3d");
 
-               task->getNumberOfDevices(engine_type, device_count);
+               *device_count = task->getNumberOfDevices(engine_type);
                // TODO.
        } catch (const BaseException &e) {
                LOGE("%s", e.what());
@@ -232,7 +232,7 @@ int mv_object_detection_3d_get_device_count(mv_object_detection_3d_h handle, con
 }
 
 int mv_object_detection_3d_get_device_type(mv_object_detection_3d_h handle, const char *engine_type,
-                                                                                  const unsigned int device_index, char **device_type)
+                                                                                  unsigned int device_index, char **device_type)
 {
        lock_guard<mutex> lock(g_object_detection_3d_mutex);
 
@@ -249,7 +249,7 @@ int mv_object_detection_3d_get_device_type(mv_object_detection_3d_h handle, cons
                auto context = static_cast<Context *>(handle);
                auto task = context->__tasks.at("object_detection_3d");
 
-               task->getDeviceType(engine_type, device_index, device_type);
+               *device_type = (char *) task->getDeviceType(engine_type, device_index).c_str();
                // TODO.
        } catch (const BaseException &e) {
                LOGE("%s", e.what());

diff --git a/mv_machine_learning/object_detection_3d/src/object_detection_3d.cpp b/mv_machine_learning/object_detection_3d/src/object_detection_3d.cpp
index 82ef21e..46ade6d 100644 (file)
--- a/mv_machine_learning/object_detection_3d/src/object_detection_3d.cpp
+++ b/mv_machine_learning/object_detection_3d/src/object_detection_3d.cpp
@@ -59,7 +59,7 @@ template<typename T> void ObjectDetection3d<T>::getEngineList()
        }
 }
 
-template<typename T> void ObjectDetection3d<T>::getDeviceList(const char *engine_type)
+template<typename T> void ObjectDetection3d<T>::getDeviceList(const string &engine_type)
 {
        // TODO. add device types available for a given engine type later.
        //       In default, cpu and gpu only.
@@ -89,25 +89,23 @@ void ObjectDetection3d<T>::setEngineInfo(std::string engine_type_name, std::stri
                 device_type_name.c_str(), device_type);
 }
 
-template<typename T> void ObjectDetection3d<T>::getNumberOfEngines(unsigned int *number_of_engines)
+template<typename T> unsigned int ObjectDetection3d<T>::getNumberOfEngines()
 {
        if (!_valid_backends.empty()) {
-               *number_of_engines = _valid_backends.size();
-               return;
+               return _valid_backends.size();
        }
 
        getEngineList();
-       *number_of_engines = _valid_backends.size();
+       return _valid_backends.size();
 }
 
-template<typename T> void ObjectDetection3d<T>::getEngineType(unsigned int engine_index, char **engine_type)
+template<typename T> const string &ObjectDetection3d<T>::getEngineType(unsigned int engine_index)
 {
        if (!_valid_backends.empty()) {
                if (_valid_backends.size() <= engine_index)
                        throw InvalidParameter("Invalid engine index.");
 
-               *engine_type = const_cast<char *>(_valid_backends[engine_index].data());
-               return;
+               return _valid_backends[engine_index];
        }
 
        getEngineList();
@@ -115,30 +113,27 @@ template<typename T> void ObjectDetection3d<T>::getEngineType(unsigned int engin
        if (_valid_backends.size() <= engine_index)
                throw InvalidParameter("Invalid engine index.");
 
-       *engine_type = const_cast<char *>(_valid_backends[engine_index].data());
+       return _valid_backends[engine_index];
 }
 
-template<typename T>
-void ObjectDetection3d<T>::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+template<typename T> unsigned int ObjectDetection3d<T>::getNumberOfDevices(const string &engine_type)
 {
        if (!_valid_devices.empty()) {
-               *number_of_devices = _valid_devices.size();
-               return;
+               return _valid_devices.size();
        }
 
        getDeviceList(engine_type);
-       *number_of_devices = _valid_devices.size();
+       return _valid_devices.size();
 }
 
 template<typename T>
-void ObjectDetection3d<T>::getDeviceType(const char *engine_type, const unsigned int device_index, char **device_type)
+const string &ObjectDetection3d<T>::getDeviceType(const string &engine_type, const unsigned int device_index)
 {
        if (!_valid_devices.empty()) {
                if (_valid_devices.size() <= device_index)
                        throw InvalidParameter("Invalid device index.");
 
-               *device_type = const_cast<char *>(_valid_devices[device_index].data());
-               return;
+               return _valid_devices[device_index];
        }
 
        getDeviceList(engine_type);
@@ -146,7 +141,7 @@ void ObjectDetection3d<T>::getDeviceType(const char *engine_type, const unsigned
        if (_valid_devices.size() <= device_index)
                throw InvalidParameter("Invalid device index.");
 
-       *device_type = const_cast<char *>(_valid_devices[device_index].data());
+       return _valid_devices[device_index];
 }
 
 template<typename T> void ObjectDetection3d<T>::loadLabel()

diff --git a/mv_machine_learning/object_detection_3d/src/object_detection_3d_adapter.cpp b/mv_machine_learning/object_detection_3d/src/object_detection_3d_adapter.cpp
index 1651d02..44f441b 100644 (file)
--- a/mv_machine_learning/object_detection_3d/src/object_detection_3d_adapter.cpp
+++ b/mv_machine_learning/object_detection_3d/src/object_detection_3d_adapter.cpp
@@ -79,8 +79,8 @@ ObjectDetection3dTaskType ObjectDetection3dAdapter::convertToTaskType(string mod
        throw InvalidParameter("Invalid object detection 3d model name.");
 }
 
-void ObjectDetection3dAdapter::setModelInfo(const char *model_file, const char *meta_file, const char *label_file,
-                                                                                       const char *model_name)
+void ObjectDetection3dAdapter::setModelInfo(const string &model_file, const string &meta_file, const string &label_file,
+                                                                                       const string &model_name)
 {
        try {
                _config->setUserModel(model_file, meta_file, label_file);
@@ -89,11 +89,11 @@ void ObjectDetection3dAdapter::setModelInfo(const char *model_file, const char *
                LOGW("A given model name is invalid so default task type will be used.");
        }
 
-       if (!model_file && !meta_file)
+       if (model_file.empty() && meta_file.empty())
                throw InvalidParameter("Model info not invalid.");
 }
 
-void ObjectDetection3dAdapter::setEngineInfo(const char *engine_type, const char *device_type)
+void ObjectDetection3dAdapter::setEngineInfo(const string &engine_type, const string &device_type)
 {
        _object_detection_3d->setEngineInfo(string(engine_type), string(device_type));
 }
@@ -103,24 +103,24 @@ void ObjectDetection3dAdapter::configure()
        _object_detection_3d->configure();
 }
 
-void ObjectDetection3dAdapter::getNumberOfEngines(unsigned int *number_of_engines)
+unsigned int ObjectDetection3dAdapter::getNumberOfEngines()
 {
-       _object_detection_3d->getNumberOfEngines(number_of_engines);
+       return _object_detection_3d->getNumberOfEngines();
 }
 
-void ObjectDetection3dAdapter::getEngineType(unsigned int engine_index, char **engine_type)
+const string &ObjectDetection3dAdapter::getEngineType(unsigned int engine_index)
 {
-       _object_detection_3d->getEngineType(engine_index, engine_type);
+       return _object_detection_3d->getEngineType(engine_index);
 }
 
-void ObjectDetection3dAdapter::getNumberOfDevices(const char *engine_type, unsigned int *number_of_devices)
+unsigned int ObjectDetection3dAdapter::getNumberOfDevices(const string &engine_type)
 {
-       _object_detection_3d->getNumberOfDevices(engine_type, number_of_devices);
+       return _object_detection_3d->getNumberOfDevices(engine_type);
 }
 
-void ObjectDetection3dAdapter::getDeviceType(const char *engine_type, unsigned int device_index, char **device_type)
+const string &ObjectDetection3dAdapter::getDeviceType(const string &engine_type, unsigned int device_index)
 {
-       _object_detection_3d->getDeviceType(engine_type, device_index, device_type);
+       return _object_detection_3d->getDeviceType(engine_type, device_index);
 }
 
 void ObjectDetection3dAdapter::prepare()