Update inspireface to 1.2.0

cpp-package/inspireface/cpp/test/unit/base/test_face_session.cpp

@@ -0,0 +1,86 @@
+
+#include <iostream>
+#include "settings/test_settings.h"
+#include "unit/test_helper/help.h"
+#include "feature_hub/feature_hub_db.h"
+#include "middleware/costman.h"
+#include "inspireface/initialization_module/launch.h"
+#include "middleware/inspirecv_image_process.h"
+#include "inspireface/face_session.h"
+#include "inspireface/feature_hub/feature_hub_db.h"
+
+using namespace inspire;
+
+TEST_CASE("test_FaceSession", "[face_session") {
+    DRAW_SPLIT_LINE
+    TEST_PRINT_OUTPUT(true);
+
+    int32_t ret;
+    CustomPipelineParameter param;
+    param.enable_recognition = true;
+    param.enable_liveness = true;
+    param.enable_mask_detect = true;
+    param.enable_face_attribute = true;
+    param.enable_face_quality = true;
+
+    FaceSession session;
+    ret = session.Configuration(DetectModuleMode::DETECT_MODE_ALWAYS_DETECT, 1, param);
+    REQUIRE(ret == HSUCCEED);
+
+    inspirecv::Image kun1 = inspirecv::Image::Create(GET_DATA("data/bulk/kun.jpg"));
+    inspirecv::Image kun2 = inspirecv::Image::Create(GET_DATA("data/bulk/jntm.jpg"));
+    inspirecv::InspireImageProcess proc1 =
+      inspirecv::InspireImageProcess::Create(kun1.Data(), kun1.Height(), kun1.Width(), inspirecv::BGR, inspirecv::ROTATION_0);
+    inspirecv::InspireImageProcess proc2 =
+      inspirecv::InspireImageProcess::Create(kun2.Data(), kun2.Height(), kun2.Width(), inspirecv::BGR, inspirecv::ROTATION_0);
+    std::vector<std::vector<float>> features;
+    std::vector<inspirecv::InspireImageProcess> processes = {proc1, proc2};
+    for (auto &process : processes) {
+        ret = session.FaceDetectAndTrack(process);
+        REQUIRE(ret == HSUCCEED);
+        if (session.GetDetectCache().size() > 0) {
+            FaceBasicData data = session.GetFaceBasicDataCache()[0];
+            ret = session.FaceFeatureExtract(process, data);
+            REQUIRE(ret == HSUCCEED);
+            const auto &faces = session.GetTrackingFaceList();
+            REQUIRE(faces.size() > 0);
+            Embedded feature;
+            HyperFaceData hyper_face_data = FaceObjectInternalToHyperFaceData(faces[0]);
+            float norm;
+            ret = session.FaceRecognitionModule()->FaceExtract(process, hyper_face_data, feature, norm);
+            REQUIRE(ret == HSUCCEED);
+            features.push_back(feature);
+        }
+    }
+    REQUIRE(features.size() == 2);
+    float res;
+    ret = FeatureHubDB::CosineSimilarity(features[0].data(), features[1].data(), features[0].size(), res);
+    REQUIRE(ret == HSUCCEED);
+    REQUIRE(res > 0.5f);
+
+    inspirecv::Image other = inspirecv::Image::Create(GET_DATA("data/bulk/woman.png"));
+    inspirecv::InspireImageProcess proc3 =
+      inspirecv::InspireImageProcess::Create(other.Data(), other.Height(), other.Width(), inspirecv::BGR, inspirecv::ROTATION_0);
+    ret = session.FaceDetectAndTrack(proc3);
+    REQUIRE(ret == HSUCCEED);
+    if (session.GetDetectCache().size() > 0) {
+        FaceBasicData data = session.GetFaceBasicDataCache()[0];
+        ret = session.FaceFeatureExtract(proc3, data);
+        auto faces = session.GetTrackingFaceList();
+        REQUIRE(ret == HSUCCEED);
+        Embedded feature;
+        HyperFaceData hyper_face_data = FaceObjectInternalToHyperFaceData(faces[0]);
+        float norm;
+        ret = session.FaceRecognitionModule()->FaceExtract(proc3, hyper_face_data, feature, norm);
+        REQUIRE(ret == HSUCCEED);
+        features.push_back(feature);
+    }
+    REQUIRE(features.size() == 3);
+    float other_v_kun1, other_v_kun2;
+    ret = FeatureHubDB::CosineSimilarity(features[0].data(), features[2].data(), features[0].size(), other_v_kun1);
+    REQUIRE(ret == HSUCCEED);
+    REQUIRE(other_v_kun1 < 0.5f);
+    ret = FeatureHubDB::CosineSimilarity(features[1].data(), features[2].data(), features[0].size(), other_v_kun2);
+    REQUIRE(ret == HSUCCEED);
+    REQUIRE(other_v_kun2 < 0.5f);
+}

cpp-package/inspireface/cpp/test/unit/base/test_module_feature_hub.cpp

@@ -0,0 +1,198 @@
+#include <iostream>
+#include "settings/test_settings.h"
+#include "inspireface/c_api/inspireface.h"
+#include "unit/test_helper/help.h"
+#include "feature_hub/feature_hub_db.h"
+#include "middleware/costman.h"
+
+using namespace inspire;
+
+TEST_CASE("test_FeatureHubBasic", "[feature_hub") {
+    DRAW_SPLIT_LINE
+    TEST_PRINT_OUTPUT(true);
+
+    // Enable feature hub
+    DatabaseConfiguration config;
+    config.primary_key_mode = PrimaryKeyMode::AUTO_INCREMENT;
+    config.enable_persistence = false;  // memory mode
+    int32_t ret;
+    ret = FEATURE_HUB_DB->EnableHub(config);
+    REQUIRE(ret == HSUCCEED);
+
+    // Check if feature hub is enabled
+    ret = FEATURE_HUB_DB->EnableHub(config);
+    REQUIRE(ret == HSUCCEED);
+
+    // Check number of features
+    int32_t count = 1000;
+    std::vector<int64_t> ids;
+    std::vector<int64_t> expected_ids;
+    for (int32_t i = 0; i < count; i++) {
+        auto vec = GenerateRandomFeature(512, false);
+        int64_t alloc_id;
+        ret = FEATURE_HUB_DB->FaceFeatureInsert(vec, -1, alloc_id);
+        REQUIRE(ret == HSUCCEED);
+        ids.push_back(alloc_id);
+        expected_ids.push_back(i + 1);
+    }
+    REQUIRE(FEATURE_HUB_DB->GetFaceFeatureCount() == ids.size());
+    REQUIRE(ids == expected_ids);
+
+    // Delete data
+    std::vector<int64_t> delete_ids = {5, 20, 100};
+    for (auto id : delete_ids) {
+        FEATURE_HUB_DB->FaceFeatureRemove(id);
+    }
+    REQUIRE(FEATURE_HUB_DB->GetFaceFeatureCount() == ids.size() - delete_ids.size());
+
+    // Check if the deleted data can be found
+    std::vector<float> feature;
+    ret = FEATURE_HUB_DB->GetFaceFeature(5, feature);
+    REQUIRE(ret == HERR_FT_HUB_NOT_FOUND_FEATURE);
+
+    // Check if the data can be found
+    ret = FEATURE_HUB_DB->GetFaceFeature(1, feature);
+    REQUIRE(ret == HSUCCEED);
+    REQUIRE(feature.size() == 512);
+
+    // Check if the cached data is correct
+    ret = FEATURE_HUB_DB->GetFaceFeature(1);
+    REQUIRE(ret == HSUCCEED);
+    auto cached_feature = FEATURE_HUB_DB->GetFaceFeaturePtrCache();
+    for (size_t i = 0; i < cached_feature->dataSize; i++) {
+        REQUIRE(feature[i] == cached_feature->data[i]);
+    }
+
+    // Update data
+    auto update_feature = GenerateRandomFeature(512, false);
+    ret = FEATURE_HUB_DB->FaceFeatureUpdate(update_feature, 1);
+    REQUIRE(ret == HSUCCEED);
+
+    // Check if the updated data is correct
+    ret = FEATURE_HUB_DB->GetFaceFeature(1, feature);
+    REQUIRE(ret == HSUCCEED);
+    for (size_t i = 0; i < feature.size(); i++) {
+        REQUIRE(feature[i] == Approx(update_feature[i]).epsilon(0.0001));
+    }
+
+    // Update removed data
+    ret = FEATURE_HUB_DB->FaceFeatureUpdate(update_feature, 5);
+    REQUIRE(ret == HERR_FT_HUB_NOT_FOUND_FEATURE);
+
+    // Disable feature hub
+    FEATURE_HUB_DB->DisableHub();
+    REQUIRE(FEATURE_HUB_DB->GetFaceFeatureCount() == 0);
+
+    // Check if the data can be found
+    ret = FEATURE_HUB_DB->GetFaceFeature(1, feature);
+    REQUIRE(ret == HERR_FT_HUB_DISABLE);
+
+    ret = FEATURE_HUB_DB->EnableHub(config);
+    REQUIRE(ret == HSUCCEED);
+    // Because the memory mode is turned on, once the data is turned off, it goes back to empty
+    REQUIRE(FEATURE_HUB_DB->GetFaceFeatureCount() == 0);
+
+    ret = FEATURE_HUB_DB->DisableHub();
+    REQUIRE(ret == HSUCCEED);
+}
+
+TEST_CASE("test_PerformanceMemoryMode", "[feature_hub") {
+    DRAW_SPLIT_LINE
+    TEST_PRINT_OUTPUT(true);
+
+    DatabaseConfiguration config;
+    config.primary_key_mode = PrimaryKeyMode::AUTO_INCREMENT;
+    config.enable_persistence = false;  // memory mode
+    int32_t ret;
+    ret = FEATURE_HUB_DB->EnableHub(config);
+    REQUIRE(ret == HSUCCEED);
+
+    Timer t1;
+    int num = 10000;
+    for (int i = 0; i < num; i++) {
+        auto vec = GenerateRandomFeature(512, false);
+        int64_t alloc_id;
+        ret = FEATURE_HUB_DB->FaceFeatureInsert(vec, -1, alloc_id);
+        REQUIRE(ret == HSUCCEED);
+    }
+    TEST_PRINT("[Memory Mode]Insert 10000 features cost: {:.2f} ms", t1.GetCostTime());
+
+    Timer t2;
+    std::vector<float> feature;
+    ret = FEATURE_HUB_DB->GetFaceFeature(1, feature);
+    TEST_PRINT("[Memory Mode]Get feature from id cost: {:.2f} ms", t2.GetCostTime());
+    REQUIRE(ret == HSUCCEED);
+
+    Timer t3;
+    ret = FEATURE_HUB_DB->GetFaceFeature(9998, feature);
+    TEST_PRINT("[Memory Mode]Get feature from id cost: {:.2f} ms", t3.GetCostTime());
+    REQUIRE(ret == HSUCCEED);
+    auto sim_vec = SimulateSimilarVector(feature, false);
+    FaceSearchResult search_result;
+    Timer t4;
+    FEATURE_HUB_DB->SearchFaceFeature(sim_vec, search_result, true);
+    TEST_PRINT("[Memory Mode]Search feature cost: {:.2f} ms", t4.GetCostTime());
+    REQUIRE(search_result.id == 9998);
+
+    ret = FEATURE_HUB_DB->FaceFeatureRemove(9998);
+    REQUIRE(ret == HSUCCEED);
+
+    FEATURE_HUB_DB->DisableHub();
+}
+
+TEST_CASE("test_PerformancePersistentMode", "[feature_hub") {
+    DRAW_SPLIT_LINE
+    TEST_PRINT_OUTPUT(true);
+
+    std::string db_path = ".test_db";
+    std::remove(db_path.c_str());
+
+    DatabaseConfiguration config;
+    config.primary_key_mode = PrimaryKeyMode::AUTO_INCREMENT;
+    config.enable_persistence = true;  // persistent mode
+    config.persistence_db_path = db_path;
+
+    int32_t ret;
+    ret = FEATURE_HUB_DB->EnableHub(config);
+    REQUIRE(ret == HSUCCEED);
+
+    Timer t1;
+    int num = 10000;
+    for (int i = 0; i < num; i++) {
+        auto vec = GenerateRandomFeature(512, false);
+        int64_t alloc_id;
+        ret = FEATURE_HUB_DB->FaceFeatureInsert(vec, -1, alloc_id);
+        REQUIRE(ret == HSUCCEED);
+    }
+    TEST_PRINT("[Persistent Mode]Insert 10000 features cost: {:.2f} ms", t1.GetCostTime());
+
+    Timer t2;
+    std::vector<float> feature;
+    ret = FEATURE_HUB_DB->GetFaceFeature(1, feature);
+    TEST_PRINT("[Persistent Mode]Get feature from id cost: {:.2f} ms", t2.GetCostTime());
+    REQUIRE(ret == HSUCCEED);
+
+    Timer t3;
+    ret = FEATURE_HUB_DB->GetFaceFeature(9998, feature);
+    TEST_PRINT("[Persistent Mode]Get feature from id cost: {:.2f} ms", t3.GetCostTime());
+    REQUIRE(ret == HSUCCEED);
+    auto sim_vec = SimulateSimilarVector(feature, false);
+    FaceSearchResult search_result;
+    Timer t4;
+    FEATURE_HUB_DB->SearchFaceFeature(sim_vec, search_result, true);
+    TEST_PRINT("[Persistent Mode]Search feature cost: {:.2f} ms", t4.GetCostTime());
+    REQUIRE(search_result.id == 9998);
+
+    ret = FEATURE_HUB_DB->FaceFeatureRemove(9998);
+    REQUIRE(ret == HSUCCEED);
+
+    auto remark_num = FEATURE_HUB_DB->GetFaceFeatureCount();
+    REQUIRE(remark_num == num - 1);
+
+    // Verify important of persistence test
+    ret = FEATURE_HUB_DB->EnableHub(config);
+    REQUIRE(ret == HSUCCEED);
+    REQUIRE(FEATURE_HUB_DB->GetFaceFeatureCount() == remark_num);
+
+    FEATURE_HUB_DB->DisableHub();
+}

cpp-package/inspireface/cpp/test/unit/base/test_module_track.cpp

@@ -0,0 +1,112 @@
+
+#include <iostream>
+#include "settings/test_settings.h"
+#include "unit/test_helper/help.h"
+#include "feature_hub/feature_hub_db.h"
+#include "middleware/costman.h"
+#include "track_module/face_detect/all.h"
+#include "inspireface/initialization_module/launch.h"
+#include "track_module/face_track_module.h"
+#include "middleware/inspirecv_image_process.h"
+
+using namespace inspire;
+
+TEST_CASE("test_FaceDetect", "[track_module") {
+    DRAW_SPLIT_LINE
+    TEST_PRINT_OUTPUT(true);
+    auto archive = INSPIRE_LAUNCH->getMArchive();
+    const std::vector<int32_t> supported_sizes = {160, 320, 640};
+    const std::vector<std::string> scheme_names = {"face_detect_160", "face_detect_320", "face_detect_640"};
+    for (size_t i = 0; i < scheme_names.size(); i++) {
+        InspireModel model;
+        auto ret = archive.LoadModel(scheme_names[i], model);
+        REQUIRE(ret == 0);
+        FaceDetectAdapt face_detector(supported_sizes[i]);
+        face_detector.loadData(model, model.modelType, false);
+
+        inspirecv::Image img = inspirecv::Image::Create(GET_DATA("data/bulk/kun.jpg"));
+        auto result = face_detector(img);
+        REQUIRE(result.size() == 1);
+    }
+}
+
+TEST_CASE("test_RefineNet", "[track_module") {
+    DRAW_SPLIT_LINE
+    TEST_PRINT_OUTPUT(true);
+    auto archive = INSPIRE_LAUNCH->getMArchive();
+    InspireModel model;
+    auto ret = archive.LoadModel("refine_net", model);
+    REQUIRE(ret == 0);
+    RNetAdapt rnet;
+    rnet.loadData(model, model.modelType, false);
+
+    inspirecv::Image face = inspirecv::Image::Create(GET_DATA("data/crop/crop.png"));
+    auto result1 = rnet(face);
+    REQUIRE(result1 > 0.5f);
+
+    inspirecv::Image no_face = inspirecv::Image::Create(GET_DATA("data/crop/no_face.png"));
+    auto result2 = rnet(no_face);
+    REQUIRE(result2 < 0.5f);
+}
+
+TEST_CASE("test_Landmark", "[track_module") {
+    DRAW_SPLIT_LINE
+    TEST_PRINT_OUTPUT(true);
+    auto archive = INSPIRE_LAUNCH->getMArchive();
+    InspireModel model;
+    auto ret = archive.LoadModel("landmark", model);
+    REQUIRE(ret == 0);
+
+    FaceLandmarkAdapt face_landmark(112);
+    face_landmark.loadData(model, model.modelType);
+
+    inspirecv::Image img = inspirecv::Image::Create(GET_DATA("data/crop/crop.png"));
+    auto result = face_landmark(img);
+    REQUIRE(result.size() == 106 * 2);
+}
+
+TEST_CASE("test_Quality", "[track_module") {
+    DRAW_SPLIT_LINE
+    TEST_PRINT_OUTPUT(true);
+    auto archive = INSPIRE_LAUNCH->getMArchive();
+    InspireModel model;
+    auto ret = archive.LoadModel("pose_quality", model);
+    REQUIRE(ret == 0);
+    FacePoseQualityAdapt quality;
+    ret = quality.loadData(model, model.modelType);
+    REQUIRE(ret == 0);
+
+    inspirecv::Image img = inspirecv::Image::Create(GET_DATA("data/crop/crop.png"));
+    auto result = quality(img);
+    REQUIRE(result.lmk.size() == 5);
+    REQUIRE(result.lmk_quality.size() == 5);
+}
+
+TEST_CASE("test_FaceTrackModule", "[track_module") {
+    DRAW_SPLIT_LINE
+    TEST_PRINT_OUTPUT(true);
+    auto archive = INSPIRE_LAUNCH->getMArchive();
+
+    SECTION("Test face detect rotate 0") {
+        auto mode = DetectModuleMode::DETECT_MODE_ALWAYS_DETECT;
+        int max_detected_faces = 10;
+        FaceTrackModule face_track(mode, max_detected_faces);
+        face_track.Configuration(archive);
+        inspirecv::Image img = inspirecv::Image::Create(GET_DATA("data/bulk/kun.jpg"));
+        inspirecv::InspireImageProcess image = inspirecv::InspireImageProcess::Create(img.Data(), img.Height(), img.Width(), inspirecv::BGR);
+        face_track.UpdateStream(image);
+        REQUIRE(face_track.trackingFace.size() == 1);
+    }
+
+    SECTION("Test face detect rotate 90") {
+        auto mode = DetectModuleMode::DETECT_MODE_ALWAYS_DETECT;
+        int max_detected_faces = 10;
+        FaceTrackModule face_track(mode, max_detected_faces);
+        face_track.Configuration(archive);
+        inspirecv::Image img = inspirecv::Image::Create(GET_DATA("data/bulk/r90.jpg"));
+        inspirecv::InspireImageProcess image =
+          inspirecv::InspireImageProcess::Create(img.Data(), img.Height(), img.Width(), inspirecv::BGR, inspirecv::ROTATION_90);
+        face_track.UpdateStream(image);
+        REQUIRE(face_track.trackingFace.size() == 1);
+    }
+}