test: add test case for hand landmark task group

Change-Id: I5ce95733d005e07dac3ae31a47d25680a957bda6
Signed-off-by: Inki Dae <inki.dae@samsung.com>

diff --git a/test/testsuites/machine_learning/landmark_detection/test_landmark_detection.cpp b/test/testsuites/machine_learning/landmark_detection/test_landmark_detection.cpp
index 724c9971953deef890223c8697c143cf41101069..50ffb1f4aa8bcc9328b73caccae41de41b6f894d 100644 (file)
--- a/test/testsuites/machine_learning/landmark_detection/test_landmark_detection.cpp
+++ b/test/testsuites/machine_learning/landmark_detection/test_landmark_detection.cpp
@@ -24,11 +24,14 @@
 #include "ImageHelper.h"
 #include "mv_facial_landmark.h"
 #include "mv_facial_landmark_internal.h"
+#include "mv_hand_landmark.h"
+#include "mv_hand_landmark_internal.h"
 #include "mv_pose_landmark.h"
 #include "mv_pose_landmark_internal.h"
 
 #define IMG_FACE TEST_RES_PATH "/res/inference/images/faceLandmark.jpg"
 #define IMG_POSE TEST_RES_PATH "/res/inference/images/poseLandmark.jpg"
+#define IMG_HAND TEST_RES_PATH "/res/inference/images/handLandmark.jpg"
 
 using namespace testing;
 using namespace std;
@@ -242,3 +245,105 @@ TEST(PoseLandmarkTest, InferenceShouldBeOk)
        ret = mv_destroy_source(mv_source);
        ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
 }
+
+TEST(HandLandmarkTest, GettingAvailableInferenceEnginesInfoShouldBeOk)
+{
+       mv_hand_landmark_h handle;
+
+       int ret = mv_hand_landmark_create(&handle);
+       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+       unsigned int engine_count = 0;
+
+       ret = mv_hand_landmark_get_engine_count(handle, &engine_count);
+       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+       ASSERT_GE(engine_count, 1);
+
+       for (unsigned int engine_idx = 0; engine_idx < engine_count; ++engine_idx) {
+               char *engine_type = nullptr;
+
+               ret = mv_hand_landmark_get_engine_type(handle, engine_idx, &engine_type);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               unsigned int device_count = 0;
+
+               ret = mv_hand_landmark_get_device_count(handle, engine_type, &device_count);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+               ASSERT_GE(device_count, 1);
+
+               for (unsigned int device_idx = 0; device_idx < device_count; ++device_idx) {
+                       char *device_type = nullptr;
+
+                       ret = mv_hand_landmark_get_device_type(handle, engine_type, device_idx, &device_type);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+               }
+       }
+
+       ret = mv_hand_landmark_destroy(handle);
+       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+}
+
+TEST(HandLandmarkTest, InferenceShouldBeOk)
+{
+       mv_hand_landmark_h handle;
+       vector<test_model_input> test_models {
+               {} // If empty then default model will be used.
+               // TODO.
+       };
+       const unsigned int coordinate_answers[][21] = { { 638, 833, 1003, 1148, 1267, 808, 884, 927, 952, 663, 689,
+                                                                                                         689, 680, 535,  518,  501,  467, 416, 365, 314, 289 },
+                                                                                                       { 1710, 1608, 1417, 1251, 1123, 995, 753,  561, 408, 957, 676,
+                                                                                                         459,  306,  995,      727,  485,      306, 1097, 880, 689, 510 } };
+
+       mv_source_h mv_source = NULL;
+       int ret = mv_create_source(&mv_source);
+       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+       ret = ImageHelper::loadImageToSource(IMG_HAND, mv_source);
+       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+       for (auto &model : test_models) {
+               ret = mv_hand_landmark_create(&handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_set_model(handle, model.model_file.c_str(), model.meta_file.c_str(),
+                                                                                model.label_file.c_str(), model.model_name.c_str());
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_set_engine(handle, "tflite", "cpu");
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_configure(handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_prepare(handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_inference(handle, mv_source);
+               ASSERT_EQ(ret, 0);
+
+               unsigned long frame_number;
+               unsigned int number_of_landmarks;
+
+               ret = mv_hand_landmark_get_result_count(handle, &frame_number, &number_of_landmarks);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               for (unsigned int idx = 0; idx < number_of_landmarks; ++idx) {
+                       unsigned int pos_x, pos_y;
+
+                       ret = mv_hand_landmark_get_position(handle, idx, &pos_x, &pos_y);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+                       unsigned int answer_x = coordinate_answers[0][idx];
+                       unsigned int answer_y = coordinate_answers[1][idx];
+
+                       ASSERT_TRUE(pos_x == answer_x && pos_y == answer_y);
+               }
+
+               ret = mv_hand_landmark_destroy(handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+       }
+
+       ret = mv_destroy_source(mv_source);
+       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+}

diff --git a/test/testsuites/machine_learning/landmark_detection/test_landmark_detection_async.cpp b/test/testsuites/machine_learning/landmark_detection/test_landmark_detection_async.cpp
index 5090d5331d91c3371ab9f76dc994a84e2e934de1..8a68034d28da1c742583d5640a86f3643c8a9e82 100644 (file)
--- a/test/testsuites/machine_learning/landmark_detection/test_landmark_detection_async.cpp
+++ b/test/testsuites/machine_learning/landmark_detection/test_landmark_detection_async.cpp
@@ -25,11 +25,14 @@
 #include "ImageHelper.h"
 #include "mv_facial_landmark.h"
 #include "mv_facial_landmark_internal.h"
+#include "mv_hand_landmark.h"
+#include "mv_hand_landmark_internal.h"
 #include "mv_pose_landmark.h"
 #include "mv_pose_landmark_internal.h"
 
 #define IMG_FACE TEST_RES_PATH "/res/inference/images/faceLandmark.jpg"
 #define IMG_POSE TEST_RES_PATH "/res/inference/images/poseLandmark.jpg"
+#define IMG_HAND TEST_RES_PATH "/res/inference/images/handLandmark.jpg"
 
 #define MAX_INFERENCE_ITERATION 50
 
@@ -320,6 +323,143 @@ TEST(FacialLandmarkAsyncTest, InferenceShouldBeOkWithDestroyFirst)
                ret = mv_facial_landmark_destroy(handle);
                ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
 
+               thread_handle->join();
+       }
+}
+
+void hand_landmark_callback(void *user_data)
+{
+       mv_hand_landmark_h handle = static_cast<mv_hand_landmark_h>(user_data);
+       bool is_loop_exit = false;
+       const unsigned int coordinate_answers[][21] = { { 638, 833, 1003, 1148, 1267, 808, 884, 927, 952, 663, 689,
+                                                                                                         689, 680, 535,  518,  501,  467, 416, 365, 314, 289 },
+                                                                                                       { 1710, 1608, 1417, 1251, 1123, 995, 753,  561, 408, 957, 676,
+                                                                                                         459,  306,  995,      727,  485,      306, 1097, 880, 689, 510 } };
+
+       while (!is_loop_exit) {
+               unsigned long frame_number;
+               unsigned int number_of_landmarks;
+
+               int ret = mv_hand_landmark_get_result_count(handle, &frame_number, &number_of_landmarks);
+               if (ret == MEDIA_VISION_ERROR_INVALID_OPERATION)
+                       break;
+
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               for (unsigned int idx = 0; idx < number_of_landmarks; ++idx) {
+                       unsigned int pos_x, pos_y;
+
+                       ret = mv_hand_landmark_get_position(handle, idx, &pos_x, &pos_y);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+                       unsigned int answer_x = coordinate_answers[0][idx];
+                       unsigned int answer_y = coordinate_answers[1][idx];
+
+                       ASSERT_TRUE(pos_x == answer_x && pos_y == answer_y);
+               }
+       }
+}
+
+TEST(HandLandmarkAsyncTest, InferenceShouldBeOk)
+{
+       mv_hand_landmark_h handle;
+       vector<test_model_input> test_models {
+               {} // If empty then default model will be used.
+               // TODO.
+       };
+
+       for (auto &model : test_models) {
+               int ret = mv_hand_landmark_create(&handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_set_model(handle, model.model_file.c_str(), model.meta_file.c_str(),
+                                                                                model.label_file.c_str(), model.model_name.c_str());
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_set_engine(handle, "tflite", "cpu");
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_configure(handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_prepare(handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               unique_ptr<thread> thread_handle;
+
+               for (unsigned int iter = 0; iter < MAX_INFERENCE_ITERATION; ++iter) {
+                       mv_source_h mv_source = NULL;
+                       ret = mv_create_source(&mv_source);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+                       ret = ImageHelper::loadImageToSource(IMG_HAND, mv_source);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+                       ret = mv_hand_landmark_inference_async(handle, mv_source);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+                       if (iter == 0)
+                               thread_handle = make_unique<thread>(&hand_landmark_callback, static_cast<void *>(handle));
+
+                       ret = mv_destroy_source(mv_source);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+               }
+
+               thread_handle->join();
+
+               ret = mv_hand_landmark_destroy(handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+       }
+}
+
+TEST(HandLandmarkAsyncTest, InferenceShouldBeOkWithDestroyFirst)
+{
+       mv_hand_landmark_h handle;
+       vector<test_model_input> test_models {
+               { "", "", "", "" } // If empty then default model will be used.
+               // TODO.
+       };
+
+       for (auto &model : test_models) {
+               int ret = mv_hand_landmark_create(&handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_set_model(handle, model.model_file.c_str(), model.meta_file.c_str(),
+                                                                                model.label_file.c_str(), model.model_name.c_str());
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_set_engine(handle, "tflite", "cpu");
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_configure(handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               ret = mv_hand_landmark_prepare(handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+               unique_ptr<thread> thread_handle;
+
+               for (unsigned int iter = 0; iter < MAX_INFERENCE_ITERATION; ++iter) {
+                       mv_source_h mv_source = NULL;
+                       ret = mv_create_source(&mv_source);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+                       ret = ImageHelper::loadImageToSource(IMG_HAND, mv_source);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+                       ret = mv_hand_landmark_inference_async(handle, mv_source);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
+                       if (iter == 0)
+                               thread_handle = make_unique<thread>(&hand_landmark_callback, static_cast<void *>(handle));
+
+                       ret = mv_destroy_source(mv_source);
+                       ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+               }
+
+               ret = mv_hand_landmark_destroy(handle);
+               ASSERT_EQ(ret, MEDIA_VISION_ERROR_NONE);
+
                thread_handle->join();
        }
 }
\ No newline at end of file