diff --git a/CMakeLists.txt b/CMakeLists.txt
index bf9bdb43..0525cbb6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,7 +10,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
 # Current version
 set(INSPIRE_FACE_VERSION_MAJOR 1)
 set(INSPIRE_FACE_VERSION_MINOR 1)
-set(INSPIRE_FACE_VERSION_PATCH 11)
+set(INSPIRE_FACE_VERSION_PATCH 12)
 
 # Converts the version number to a string
 string(CONCAT INSPIRE_FACE_VERSION_MAJOR_STR ${INSPIRE_FACE_VERSION_MAJOR})
diff --git a/README.md b/README.md
index 02a5f05c..17834b94 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,8 @@ Please contact [contact@insightface.ai](mailto:contact@insightface.ai?subject=In
 
 ## Change Logs
 
+**`2025-01-21`** Update all models to t3 and add tool to convert cosine similarity to percentage.
+
 **`2025-01-08`** Support inference on Rockchip devices **RK3566/RK3568** NPU.
 
 **`2024-12-25`** Add support for optional **RKRGA** image acceleration processing on Rockchip devices.
diff --git a/android/InspireFaceExample/inspireface/src/main/java/com/insightface/sdk/inspireface/InspireFace.java b/android/InspireFaceExample/inspireface/src/main/java/com/insightface/sdk/inspireface/InspireFace.java
index 7ed91cdc..77eba29e 100644
--- a/android/InspireFaceExample/inspireface/src/main/java/com/insightface/sdk/inspireface/InspireFace.java
+++ b/android/InspireFaceExample/inspireface/src/main/java/com/insightface/sdk/inspireface/InspireFace.java
@@ -20,6 +20,7 @@
 import com.insightface.sdk.inspireface.base.RGBLivenessConfidence;
 import com.insightface.sdk.inspireface.base.SearchTopKResults;
 import com.insightface.sdk.inspireface.base.Session;
+import com.insightface.sdk.inspireface.base.SimilarityConverterConfig;
 import com.insightface.sdk.inspireface.base.TypeDefine;
 import com.insightface.sdk.inspireface.utils.SDKUtils;
 
@@ -214,6 +215,27 @@ public static CustomParameter CreateCustomParameter(boolean enableRecognition, b
      */
     public static native void SetFaceDetectThreshold(Session session, float threshold);
 
+    /**
+     * Set track mode smooth ratio, default value is 0.025
+     * @param session Session object
+     * @param ratio Smooth ratio
+     */
+    public static native void SetTrackModeSmoothRatio(Session session, float ratio);
+
+    /**
+     * Set track mode num smooth cache frame, default value is 15
+     * @param session Session object
+     * @param num Num smooth cache frame
+     */
+    public static native void SetTrackModeNumSmoothCacheFrame(Session session, int num);
+
+    /**
+     * Set track mode detect interval, default value is 20
+     * @param session Session object
+     * @param interval Detect interval
+     */
+    public static native void SetTrackModeDetectInterval(Session session, int interval);
+
     /**
      * Enable feature hub data
      * @param configuration FeatureHubConfiguration object
@@ -288,6 +310,26 @@ public static CustomParameter CreateCustomParameter(boolean enableRecognition, b
      */
     public static native int GetFeatureLength();
 
+
+    /**
+     * Get cosine similarity converter
+     * @return SimilarityConverterConfig object
+     */
+    public static native SimilarityConverterConfig GetCosineSimilarityConverter();
+
+    /**
+     * Update cosine similarity converter
+     * @param config SimilarityConverterConfig object
+     */
+    public static native void UpdateCosineSimilarityConverter(SimilarityConverterConfig config);
+
+    /**
+     * Convert cosine similarity to percentage
+     * @param similarity Cosine similarity
+     * @return Percentage similarity
+     */
+    public static native float CosineSimilarityConvertToPercentage(float similarity);
+
     /**
      * Face comparison
      * @param feature1 FaceFeature object
diff --git a/android/InspireFaceExample/inspireface/src/main/java/com/insightface/sdk/inspireface/base/SimilarityConverterConfig.java b/android/InspireFaceExample/inspireface/src/main/java/com/insightface/sdk/inspireface/base/SimilarityConverterConfig.java
new file mode 100644
index 00000000..d4517d72
--- /dev/null
+++ b/android/InspireFaceExample/inspireface/src/main/java/com/insightface/sdk/inspireface/base/SimilarityConverterConfig.java
@@ -0,0 +1,9 @@
+package com.insightface.sdk.inspireface.base;
+
+public class SimilarityConverterConfig {
+    public float threshold;
+    public float middleScore;
+    public float steepness;
+    public float outputMin;
+    public float outputMax;
+}
diff --git a/cpp/inspireface/CMakeLists.txt b/cpp/inspireface/CMakeLists.txt
index e8c52f2a..e56a6683 100644
--- a/cpp/inspireface/CMakeLists.txt
+++ b/cpp/inspireface/CMakeLists.txt
@@ -40,6 +40,7 @@ if (ISF_ENABLE_RKNN)
             # For rknpu2 with armv7, we recommend linking static libraries by default
             set(ISF_RKNN_API_LIB ${ISF_THIRD_PARTY_DIR}/inspireface-precompile-lite/rknn/${ISF_RKNPU_MAJOR}/runtime/${RK_PLATFORM}/librknn_api/${ISF_RK_COMPILER_TYPE}/librknnmrt.a)
             set(RKNN_LINKED ${ISF_RKNN_API_LIB})
+            set(RKNN_USE_STATIC_LIBS TRUE)
         endif()
     endif()
 
@@ -206,3 +207,17 @@ endif ()
 if (ISF_RK_COMPILER_TYPE STREQUAL "aarch64")
     install(FILES ${ISF_RKNN_API_LIB}/librknnrt.so DESTINATION ${CMAKE_INSTALL_PREFIX}/InspireFace/lib)
 endif()
+
+if (NOT ISF_BUILD_SHARED_LIBS)
+    if(MNN_BUILD_SHARED_LIBS)
+        install(FILES ${CMAKE_BINARY_DIR}/3rdparty/MNN/libMNN.so DESTINATION ${CMAKE_INSTALL_PREFIX}/InspireFace/lib)
+    else()
+        install(FILES ${CMAKE_BINARY_DIR}/3rdparty/MNN/libMNN.a DESTINATION ${CMAKE_INSTALL_PREFIX}/InspireFace/lib)
+    endif()
+    if(RKNN_USE_STATIC_LIBS)
+        # To be added: The compilation of the RK series needs to be added
+        install(FILES ${ISF_RKNN_API_LIB} DESTINATION ${CMAKE_INSTALL_PREFIX}/InspireFace/lib)
+    endif()
+    
+endif()
+
diff --git a/cpp/inspireface/c_api/inspireface.cc b/cpp/inspireface/c_api/inspireface.cc
index 0b71ae8e..21dc766f 100644
--- a/cpp/inspireface/c_api/inspireface.cc
+++ b/cpp/inspireface/c_api/inspireface.cc
@@ -10,6 +10,7 @@
 #include "feature_hub/feature_hub_db.h"
 #include "initialization_module/launch.h"
 #include "initialization_module/resource_manage.h"
+#include "recognition_module/similarity_converter.h"
 
 using namespace inspire;
 
@@ -66,6 +67,74 @@ HYPER_CAPI_EXPORT extern HResult HFCreateImageStream(PHFImageData data, HFImageS
     return HSUCCEED;
 }
 
+HYPER_CAPI_EXPORT extern HResult HFCreateImageStreamEmpty(HFImageStream *handle) {
+    if (handle == nullptr) {
+        return HERR_INVALID_IMAGE_STREAM_HANDLE;
+    }
+    auto stream = new HF_CameraStream();
+    *handle = (HFImageStream)stream;
+    return HSUCCEED;
+}
+
+HYPER_CAPI_EXPORT extern HResult HFImageStreamSetBuffer(HFImageStream handle, HPUInt8 buffer, HInt32 width, HInt32 height) {
+    if (handle == nullptr) {
+        return HERR_INVALID_IMAGE_STREAM_HANDLE;
+    }
+    ((HF_CameraStream *)handle)->impl.SetDataBuffer(buffer, width, height);
+    return HSUCCEED;
+}
+
+HYPER_CAPI_EXPORT extern HResult HFImageStreamSetRotation(HFImageStream handle, HFRotation rotation) {
+    if (handle == nullptr) {
+        return HERR_INVALID_IMAGE_STREAM_HANDLE;
+    }
+    switch (rotation) {
+        case HF_CAMERA_ROTATION_90:
+            ((HF_CameraStream *)handle)->impl.SetRotationMode(inspirecv::ROTATION_90);
+            break;
+        case HF_CAMERA_ROTATION_180:
+            ((HF_CameraStream *)handle)->impl.SetRotationMode(inspirecv::ROTATION_180);
+            break;
+        case HF_CAMERA_ROTATION_270:
+            ((HF_CameraStream *)handle)->impl.SetRotationMode(inspirecv::ROTATION_270);
+            break;
+        default:
+            ((HF_CameraStream *)handle)->impl.SetRotationMode(inspirecv::ROTATION_0);
+            break;
+    }
+    return HSUCCEED;
+}
+
+HYPER_CAPI_EXPORT extern HResult HFImageStreamSetFormat(HFImageStream handle, HFImageFormat format) {
+    if (handle == nullptr) {
+        return HERR_INVALID_IMAGE_STREAM_HANDLE;
+    }
+    switch (format) {
+        case HF_STREAM_RGB:
+            ((HF_CameraStream *)handle)->impl.SetDataFormat(inspirecv::RGB);
+            break;
+        case HF_STREAM_BGR:
+            ((HF_CameraStream *)handle)->impl.SetDataFormat(inspirecv::BGR);
+            break;
+        case HF_STREAM_RGBA:
+            ((HF_CameraStream *)handle)->impl.SetDataFormat(inspirecv::RGBA);
+            break;
+        case HF_STREAM_BGRA:
+            ((HF_CameraStream *)handle)->impl.SetDataFormat(inspirecv::BGRA);
+            break;
+        case HF_STREAM_YUV_NV12:
+            ((HF_CameraStream *)handle)->impl.SetDataFormat(inspirecv::NV12);
+            break;
+        case HF_STREAM_YUV_NV21:
+            ((HF_CameraStream *)handle)->impl.SetDataFormat(inspirecv::NV21);
+            break;
+        default:
+            return HERR_INVALID_IMAGE_STREAM_PARAM;  // Assume there's a return code for unsupported
+                                                     // formats
+    }
+    return HSUCCEED;
+}
+
 HYPER_CAPI_EXPORT extern HResult HFReleaseImageStream(HFImageStream streamHandle) {
     if (streamHandle == nullptr) {
         return HERR_INVALID_IMAGE_STREAM_HANDLE;
@@ -372,6 +441,16 @@ HResult HFQueryExpansiveHardwareRockchipDmaHeapPath(HString path) {
     return HSUCCEED;
 }
 
+HResult HFSetExpansiveHardwareAppleCoreMLModelPath(HString path) {
+    // TODO: Implement this function
+    return HSUCCEED;
+}
+
+HResult HFQueryExpansiveHardwareAppleCoreMLModelPath(HString path) {
+    // TODO: Implement this function
+    return HSUCCEED;
+}
+
 HResult HFFeatureHubDataEnable(HFFeatureHubConfiguration configuration) {
     inspire::DatabaseConfiguration param;
     if (configuration.primaryKeyMode != HF_PK_AUTO_INCREMENT && configuration.primaryKeyMode != HF_PK_MANUAL_INPUT) {
@@ -447,6 +526,39 @@ HResult HFSessionSetFaceDetectThreshold(HFSession session, HFloat threshold) {
     return ctx->impl.SetFaceDetectThreshold(threshold);
 }
 
+HResult HFSessionSetTrackModeSmoothRatio(HFSession session, HFloat ratio) {
+    if (session == nullptr) {
+        return HERR_INVALID_CONTEXT_HANDLE;
+    }
+    HF_FaceAlgorithmSession *ctx = (HF_FaceAlgorithmSession *)session;
+    if (ctx == nullptr) {
+        return HERR_INVALID_CONTEXT_HANDLE;
+    }
+    return ctx->impl.SetTrackModeSmoothRatio(ratio);
+}
+
+HResult HFSessionSetTrackModeNumSmoothCacheFrame(HFSession session, HInt32 num) {
+    if (session == nullptr) {
+        return HERR_INVALID_CONTEXT_HANDLE;
+    }
+    HF_FaceAlgorithmSession *ctx = (HF_FaceAlgorithmSession *)session;
+    if (ctx == nullptr) {
+        return HERR_INVALID_CONTEXT_HANDLE;
+    }
+    return ctx->impl.SetTrackModeNumSmoothCacheFrame(num);
+}
+
+HResult HFSessionSetTrackModeDetectInterval(HFSession session, HInt32 num) {
+    if (session == nullptr) {
+        return HERR_INVALID_CONTEXT_HANDLE;
+    }
+    HF_FaceAlgorithmSession *ctx = (HF_FaceAlgorithmSession *)session;
+    if (ctx == nullptr) {
+        return HERR_INVALID_CONTEXT_HANDLE;
+    }
+    return ctx->impl.SetTrackModeDetectInterval(num);
+}
+
 HResult HFExecuteFaceTrack(HFSession session, HFImageStream streamHandle, PHFMultipleFaceData results) {
     if (session == nullptr) {
         return HERR_INVALID_CONTEXT_HANDLE;
@@ -648,6 +760,49 @@ HResult HFFaceComparison(HFFaceFeature feature1, HFFaceFeature feature2, HPFloat
     return ret;
 }
 
+HResult HFGetRecommendedCosineThreshold(HPFloat threshold) {
+    if (!INSPIRE_LAUNCH->isMLoad()) {
+        INSPIRE_LOGW("Inspireface is not launched, using default threshold 0.48");
+    }
+    *threshold = SIMILARITY_CONVERTER_GET_RECOMMENDED_COSINE_THRESHOLD();
+    return HSUCCEED;
+}
+
+HResult HFCosineSimilarityConvertToPercentage(HFloat similarity, HPFloat result) {
+    if (!INSPIRE_LAUNCH->isMLoad()) {
+        INSPIRE_LOGW("Inspireface is not launched.");
+    }
+    *result = SIMILARITY_CONVERTER_RUN(similarity);
+    return HSUCCEED;
+}
+
+HResult HFUpdateCosineSimilarityConverter(HFSimilarityConverterConfig config) {
+    if (!INSPIRE_LAUNCH->isMLoad()) {
+        INSPIRE_LOGW("Inspireface is not launched.");
+    }
+    inspire::SimilarityConverterConfig cfg;
+    cfg.threshold = config.threshold;
+    cfg.middleScore = config.middleScore;
+    cfg.steepness = config.steepness;
+    cfg.outputMin = config.outputMin;
+    cfg.outputMax = config.outputMax;
+    SIMILARITY_CONVERTER_UPDATE_CONFIG(cfg);
+    return HSUCCEED;
+}
+
+HResult HFGetCosineSimilarityConverter(PHFSimilarityConverterConfig config) {
+    if (!INSPIRE_LAUNCH->isMLoad()) {
+        INSPIRE_LOGW("Inspireface is not launched.");
+    }
+    inspire::SimilarityConverterConfig cfg = SIMILARITY_CONVERTER_GET_CONFIG();
+    config->threshold = cfg.threshold;
+    config->middleScore = cfg.middleScore;
+    config->steepness = cfg.steepness;
+    config->outputMin = cfg.outputMin;
+    config->outputMax = cfg.outputMax;
+    return HSUCCEED;
+}
+
 HResult HFGetFeatureLength(HPInt32 num) {
     *num = 512;
 
diff --git a/cpp/inspireface/c_api/inspireface.h b/cpp/inspireface/c_api/inspireface.h
index 2da60dc6..3135488d 100644
--- a/cpp/inspireface/c_api/inspireface.h
+++ b/cpp/inspireface/c_api/inspireface.h
@@ -64,7 +64,7 @@ typedef enum HFRotation {
  * Defines the structure for image data stream.
  */
 typedef struct HFImageData {
-    uint8_t *data;         ///< Pointer to the image data stream.
+    HPUInt8 data;          ///< Pointer to the image data stream.
     HInt32 width;          ///< Width of the image.
     HInt32 height;         ///< Height of the image.
     HFImageFormat format;  ///< Format of the image, indicating the data stream format to be parsed.
@@ -82,6 +82,45 @@ typedef struct HFImageData {
  */
 HYPER_CAPI_EXPORT extern HResult HFCreateImageStream(PHFImageData data, HFImageStream *handle);
 
+/**
+ * @brief Create an empty image stream instance.
+ *
+ * This function is used to create an instance of a data buffer stream with the given image data.
+ *
+ * @param handle Pointer to the stream handle that will be returned.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFCreateImageStreamEmpty(HFImageStream *handle);
+
+/**
+ * @brief Set the buffer of the image stream.
+ *
+ * @param handle Pointer to the stream handle.
+ * @param buffer Pointer to the buffer.
+ * @param width Width of the image.
+ * @param height Height of the image.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFImageStreamSetBuffer(HFImageStream handle, HPUInt8 buffer, HInt32 width, HInt32 height);
+
+/**
+ * @brief Set the rotation of the image stream.
+ *
+ * @param handle Pointer to the stream handle.
+ * @param rotation Rotation angle of the image.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFImageStreamSetRotation(HFImageStream handle, HFRotation rotation);
+
+/**
+ * @brief Set the format of the image stream.
+ *
+ * @param handle Pointer to the stream handle.
+ * @param format Format of the image.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFImageStreamSetFormat(HFImageStream handle, HFImageFormat format);
+
 /**
  * @brief Release the instantiated DataBuffer object.
  *
@@ -238,6 +277,15 @@ HYPER_CAPI_EXPORT extern HResult HFTerminateInspireFace();
  * */
 HYPER_CAPI_EXPORT extern HResult HFQueryInspireFaceLaunchStatus(HInt32 *status);
 
+/************************************************************************
+ * Extended Interface Based on Third-party Hardware Devices
+ *
+ * According to different manufacturers' devices, manufacturers typically perform deep customization and optimization, such as neural network
+ * inference computation, geometric image acceleration computation, and deeply customized device interfaces, etc. These types of functionalities are
+ * usually difficult to abstract, so they are placed in extension module APIs, involving hybrid computing, heterogeneous computing, multi-device
+ * computing, and other features.
+ ************************************************************************/
+
 /**
  * @brief Set the rockchip dma heap path
  * By default, we have already configured the DMA Heap address used by RGA on RK devices.
@@ -255,6 +303,21 @@ HYPER_CAPI_EXPORT extern HResult HFSetExpansiveHardwareRockchipDmaHeapPath(HPath
  * */
 HYPER_CAPI_EXPORT extern HResult HFQueryExpansiveHardwareRockchipDmaHeapPath(HString path);
 
+/**
+ * @brief Set the Apple CoreML model path. In normal circumstances, manual modification is not needed.
+ * @param path The path to the apple coreml model
+ * @return HResult indicating the success or failure of the operation.
+ * */
+HYPER_CAPI_EXPORT extern HResult HFSetExpansiveHardwareAppleCoreMLModelPath(HString path);
+
+/**
+ * @brief Query the Apple CoreML model path. After executing HFLaunchInspireFace, it's typically your input filename plus the suffix '.mlmodelc', for
+ * example: Pikachu and Pikachu.mlmodelc
+ * @param path Query the apple coreml model path
+ * @return HResult indicating the success or failure of the operation.
+ * */
+HYPER_CAPI_EXPORT extern HResult HFQueryExpansiveHardwareAppleCoreMLModelPath(HString path);
+
 /************************************************************************
  * FaceSession
  ************************************************************************/
@@ -397,6 +460,33 @@ HYPER_CAPI_EXPORT extern HResult HFSessionSetFilterMinimumFacePixelSize(HFSessio
  */
 HYPER_CAPI_EXPORT extern HResult HFSessionSetFaceDetectThreshold(HFSession session, HFloat threshold);
 
+/**
+ * @brief Set the track mode smooth ratio in the session. default value is  0.025
+ *
+ * @param session Handle to the session.
+ * @param ratio The smooth ratio value.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFSessionSetTrackModeSmoothRatio(HFSession session, HFloat ratio);
+
+/**
+ * @brief Set the track mode num smooth cache frame in the session. default value is 15
+ *
+ * @param session Handle to the session.
+ * @param num The num smooth cache frame value.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFSessionSetTrackModeNumSmoothCacheFrame(HFSession session, HInt32 num);
+
+/**
+ * @brief Set the track model detect interval in the session. default value is 20
+ *
+ * @param session Handle to the session.
+ * @param num The detect interval value.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFSessionSetTrackModeDetectInterval(HFSession session, HInt32 num);
+
 /**
  * @brief Run face tracking in the session.
  *
@@ -598,15 +688,68 @@ HYPER_CAPI_EXPORT extern HResult HFFeatureHubFaceSearchThresholdSetting(float th
 
 /**
  * @brief Perform a one-to-one comparison of two face features.
+ *  Result is a cosine similarity score, not a percentage similarity.
  *
  * @param session Handle to the session.
  * @param feature1 The first face feature for comparison.
  * @param feature2 The second face feature for comparison.
  * @param result Pointer to the floating-point value where the comparison result will be stored.
+ *               The result is a cosine similarity score, not a percentage similarity.
+ *               The score ranges from -1 to 1, where 1 indicates identical features,
+ *               0 indicates orthogonal features, and -1 indicates opposite features.
  * @return HResult indicating the success or failure of the operation.
  */
 HYPER_CAPI_EXPORT extern HResult HFFaceComparison(HFFaceFeature feature1, HFFaceFeature feature2, HPFloat result);
 
+/**
+ * @brief Get recommended cosine threshold from loaded resource.
+ *  Use it to determine face similarity. Note: it's just a reference and may not be optimal for your task.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFGetRecommendedCosineThreshold(HPFloat threshold);
+
+/**
+ * @brief Convert cosine similarity to percentage similarity.
+ *  This is a nonlinear transformation function. You can adjust curve parameters to map the similarity distribution you need.
+ * @note The conversion parameters are primarily read from the Resource file configuration, as different models
+ *       have different conversion parameters. The parameters provided in the Resource file are only reference
+ *       values. If they do not meet your specific use case requirements, you can implement your own conversion
+ *       function.
+ * @param similarity The cosine similarity score.
+ * @param result Pointer to the floating-point value where the percentage similarity will be stored.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFCosineSimilarityConvertToPercentage(HFloat similarity, HPFloat result);
+
+/**
+ * @brief Similarity converter configuration.
+ */
+typedef struct HFSimilarityConverterConfig {
+    HFloat threshold;    ///< If you think that the threshold for judging the same person using cosine is some value such as 0.42,
+                         // you need to convert him to a percentage of 0.6(pass), you can modify it.
+    HFloat middleScore;  ///< Cosine threshold converted to a percentage reference value,
+                         // usually set 0.6 or 0.5, greater than it indicates similar, pass
+    HFloat steepness;    ///< Steepness of the curve, usually set 8.0
+    HFloat outputMin;    ///< Minimum value of output range, usually set 0.01
+    HFloat outputMax;    ///< Maximum value of output range, usually set 1.0
+} HFSimilarityConverterConfig, *PHFSimilarityConverterConfig;
+
+/**
+ * @brief Update the similarity converter configuration.
+ * @note The default configuration is loaded from the resource file during initialization.
+ *       This function allows you to override those default settings if needed.
+ * @param config The new similarity converter configuration to apply.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFUpdateCosineSimilarityConverter(HFSimilarityConverterConfig config);
+
+/**
+ * @brief Get the similarity converter configuration.
+ * @param config Pointer to the similarity converter configuration to be filled.
+ * @return HResult indicating the success or failure of the operation.
+ */
+HYPER_CAPI_EXPORT extern HResult HFGetCosineSimilarityConverter(PHFSimilarityConverterConfig config);
+
 /**
  * @brief Get the length of the face feature.
  *
diff --git a/cpp/inspireface/c_api/intypedef.h b/cpp/inspireface/c_api/intypedef.h
index d7a1525c..66ca0b01 100644
--- a/cpp/inspireface/c_api/intypedef.h
+++ b/cpp/inspireface/c_api/intypedef.h
@@ -17,6 +17,7 @@ typedef float               HFloat;                          ///< Single-precisi
 typedef float*              HPFloat;                         ///< Pointer to Single-precision floating point.
 typedef double              HDouble;                          ///< Double-precision floating point.
 typedef	unsigned char		HUInt8;                           ///< Unsigned 8-bit integer.
+typedef unsigned char*      HPUInt8;                          ///< Pointer to unsigned 8-bit integer.
 typedef signed int			HInt32;                           ///< Signed 32-bit integer.
 typedef signed int			HOption;                          ///< Signed 32-bit integer option.
 typedef signed int*			HPInt32;                          ///< Pointer to signed 32-bit integer.
diff --git a/cpp/inspireface/common/face_info/face_object_internal.h b/cpp/inspireface/common/face_info/face_object_internal.h
index fc4a3668..cf3cc627 100755
--- a/cpp/inspireface/common/face_info/face_object_internal.h
+++ b/cpp/inspireface/common/face_info/face_object_internal.h
@@ -28,13 +28,14 @@ class INSPIRE_API FaceObjectInternal {
         face_action_ = std::make_shared<FaceActionPredictor>(10);
     }
 
-    void SetLandmark(const std::vector<inspirecv::Point2f> &lmk, bool update_rect = true, bool update_matrix = true) {
+    void SetLandmark(const std::vector<inspirecv::Point2f> &lmk, bool update_rect = true, bool update_matrix = true, float h = 0.06f, int n = 5) {
         if (lmk.size() != landmark_.size()) {
             INSPIRE_LOGW("The SetLandmark function displays an exception indicating that the lmk number does not match");
             return;
         }
         std::copy(lmk.begin(), lmk.end(), landmark_.begin());
-        DynamicSmoothParamUpdate(landmark_, landmark_smooth_aux_, 106 * 2, 0.06);
+        DynamicSmoothParamUpdate(landmark_, landmark_smooth_aux_, 106 * 2, h, n);
+        // std::cout << "smooth ratio: " << h << " num smooth cache frame: " << n << std::endl;
 
         // cv::Vec3d euler_angle;
         // EstimateHeadPose(landmark_, euler_angle_);
@@ -162,8 +163,7 @@ class INSPIRE_API FaceObjectInternal {
     }
 
     void DynamicSmoothParamUpdate(std::vector<inspirecv::Point2f> &landmarks, std::vector<std::vector<inspirecv::Point2f>> &landmarks_lastNframes,
-                                  int lm_length, float h) {
-        int n = 5;
+                                  int lm_length, float h = 0.06f, int n = 5) {
         std::vector<inspirecv::Point2f> landmarks_temp;
         landmarks_temp.assign(landmarks.begin(), landmarks.end());
         if (landmarks_lastNframes.size() == n) {
@@ -191,7 +191,7 @@ class INSPIRE_API FaceObjectInternal {
             landmarks_frame.push_back(inspirecv::Point2f(landmarks[i].GetX(), landmarks[i].GetY()));
         }
         landmarks_lastNframes.push_back(landmarks_frame);
-        if (landmarks_lastNframes.size() > 5)
+        if (landmarks_lastNframes.size() > n)
             landmarks_lastNframes.erase(landmarks_lastNframes.begin());
     }
 
@@ -230,7 +230,6 @@ class INSPIRE_API FaceObjectInternal {
         return bbox_;
     }
 
-
     void setBbox(const inspirecv::Rect2i &bbox) {
         bbox_ = bbox;
     }
diff --git a/cpp/inspireface/face_session.cpp b/cpp/inspireface/face_session.cpp
index a2b07467..ccda723c 100644
--- a/cpp/inspireface/face_session.cpp
+++ b/cpp/inspireface/face_session.cpp
@@ -395,4 +395,19 @@ int32_t FaceSession::SetTrackFaceMinimumSize(int32_t minSize) {
     return HSUCCEED;
 }
 
+int32_t FaceSession::SetTrackModeSmoothRatio(float value) {
+    m_face_track_->SetTrackModeSmoothRatio(value);
+    return HSUCCEED;
+}
+
+int32_t FaceSession::SetTrackModeNumSmoothCacheFrame(int value) {
+    m_face_track_->SetTrackModeNumSmoothCacheFrame(value);
+    return HSUCCEED;
+}
+
+int32_t FaceSession::SetTrackModeDetectInterval(int value) {
+    m_face_track_->SetTrackModeDetectInterval(value);
+    return HSUCCEED;
+}
+
 }  // namespace inspire
\ No newline at end of file
diff --git a/cpp/inspireface/face_session.h b/cpp/inspireface/face_session.h
index 0b73428a..5b3d8c84 100644
--- a/cpp/inspireface/face_session.h
+++ b/cpp/inspireface/face_session.h
@@ -313,6 +313,27 @@ class INSPIRE_API FaceSession {
      */
     const float GetFaceFeatureNormCache() const;
 
+    /**
+     * @brief Set the track mode smooth ratio
+     * @param value The smooth ratio value
+     * @return int32_t Status code of the operation.
+     * */
+    int32_t SetTrackModeSmoothRatio(float value);
+
+    /**
+     * @brief Set the track mode num smooth cache frame
+     * @param value The num smooth cache frame value
+     * @return int32_t Status code of the operation.
+     * */
+    int32_t SetTrackModeNumSmoothCacheFrame(int value);
+
+    /**
+     * @brief Set the track model detect interval
+     * @param value The detect interval value
+     * @return int32_t Status code of the operation.
+     * */
+    int32_t SetTrackModeDetectInterval(int value);
+
 private:
     // Private member variables
     CustomPipelineParameter m_parameter_;  ///< Stores custom parameters for the pipeline
diff --git a/cpp/inspireface/feature_hub/feature_hub_db.h b/cpp/inspireface/feature_hub/feature_hub_db.h
index 8e6c74e4..102d5b6b 100644
--- a/cpp/inspireface/feature_hub/feature_hub_db.h
+++ b/cpp/inspireface/feature_hub/feature_hub_db.h
@@ -255,11 +255,11 @@ class INSPIRE_API FeatureHubDB {
     Embedded m_getter_face_feature_cache_;                      ///< Cache for face feature data used in search operations
     std::shared_ptr<FaceFeaturePtr> m_face_feature_ptr_cache_;  ///< Shared pointer to cache of face feature pointers
 
-    std::vector<FaceSearchResult> m_search_top_k_cache_;
-    std::vector<float> m_top_k_confidence_;
-    std::vector<int64_t> m_top_k_custom_ids_cache_;
+    std::vector<FaceSearchResult> m_search_top_k_cache_;  ///< Cache for top k search results
+    std::vector<float> m_top_k_confidence_;               ///< Cache for top k confidence scores
+    std::vector<int64_t> m_top_k_custom_ids_cache_;       ///< Cache for top k custom ids
 
-    std::vector<int64_t> m_all_ids_;
+    std::vector<int64_t> m_all_ids_;  ///< Cache for all ids
 
 private:
     DatabaseConfiguration m_db_configuration_;     ///< Configuration settings for the database
diff --git a/cpp/inspireface/middleware/model_archive/inspire_archive.h b/cpp/inspireface/middleware/model_archive/inspire_archive.h
index 64b20aea..c065c1f9 100644
--- a/cpp/inspireface/middleware/model_archive/inspire_archive.h
+++ b/cpp/inspireface/middleware/model_archive/inspire_archive.h
@@ -9,6 +9,7 @@
 #include "inspire_model/inspire_model.h"
 #include "yaml-cpp/yaml.h"
 #include "fstream"
+#include "recognition_module/similarity_converter.h"
 
 namespace inspire {
 
@@ -88,7 +89,38 @@ class INSPIRE_API InspireArchive : SimpleArchive {
             }
             m_tag_ = m_config_["tag"].as<std::string>();
             m_version_ = m_config_["version"].as<std::string>();
-            INSPIRE_LOGI("== %s %s ==", m_tag_.c_str(), m_version_.c_str());
+            if (m_config_["major"]) {
+                m_major_ = m_config_["major"].as<std::string>();
+            } else {
+                m_major_ = "unknown";
+            }
+            if (m_config_["release"]) {
+                m_release_time_ = m_config_["release"].as<std::string>();
+            } else {
+                m_release_time_ = "unknown";
+            }
+            INSPIRE_LOGI("== Load %s-%s, Version: %s, Release: %s ==", m_tag_.c_str(), m_major_.c_str(), m_version_.c_str(), m_release_time_.c_str());
+            // Load similarity converter config
+            if (m_config_["similarity_converter"]) {
+                SimilarityConverterConfig config;
+                config.threshold = m_config_["similarity_converter"]["threshold"].as<double>();
+                config.middleScore = m_config_["similarity_converter"]["middle_score"].as<double>();
+                config.steepness = m_config_["similarity_converter"]["steepness"].as<double>();
+                config.outputMin = m_config_["similarity_converter"]["output_min"].as<double>();
+                config.outputMax = m_config_["similarity_converter"]["output_max"].as<double>();
+                SIMILARITY_CONVERTER_UPDATE_CONFIG(config);
+                INSPIRE_LOGI(
+                  "Successfully loaded similarity converter config: \n \t threshold: %f \n \t middle_score: %f \n \t steepness: %f \n \t output_min: "
+                  "%f \n \t output_max: %f",
+                  config.threshold, config.middleScore, config.steepness, config.outputMin, config.outputMax);
+                SIMILARITY_CONVERTER_SET_RECOMMENDED_COSINE_THRESHOLD(config.threshold);
+            } else {
+                INSPIRE_LOGW("No similarity converter config found, use default config: ");
+                auto config = SIMILARITY_CONVERTER_GET_CONFIG();
+                INSPIRE_LOGI("threshold: %f \n \t middle_score: %f \n \t steepness: %f \n \t output_min: %f \n \t output_max: %f", config.threshold,
+                             config.middleScore, config.steepness, config.outputMin, config.outputMax);
+                SIMILARITY_CONVERTER_SET_RECOMMENDED_COSINE_THRESHOLD(config.threshold);
+            }
         }
         return 0;
     }
@@ -102,6 +134,8 @@ class INSPIRE_API InspireArchive : SimpleArchive {
 
     std::string m_tag_;
     std::string m_version_;
+    std::string m_major_;
+    std::string m_release_time_;
 };
 
 }  // namespace inspire
diff --git a/cpp/inspireface/pipeline_module/face_pipeline_module.cpp b/cpp/inspireface/pipeline_module/face_pipeline_module.cpp
index 19f9f0fe..db781c73 100644
--- a/cpp/inspireface/pipeline_module/face_pipeline_module.cpp
+++ b/cpp/inspireface/pipeline_module/face_pipeline_module.cpp
@@ -137,18 +137,33 @@ int32_t FacePipelineModule::Process(inspirecv::InspireImageProcess &processor, c
                 new_rect.SetX(cx - new_rect.GetWidth() / 2);
                 new_rect.SetY(cy - new_rect.GetHeight() / 2);
 
-                // Ensure rect stays within image bounds
+                // Ensure rect stays within image bounds while maintaining aspect ratio
+                float originalAspectRatio = new_rect.GetWidth() / new_rect.GetHeight();
+
+                // Adjust position and size to fit within image bounds
                 if (new_rect.GetX() < 0) {
+                    new_rect.SetWidth(new_rect.GetWidth() + new_rect.GetX());  // Reduce width by overflow amount
                     new_rect.SetX(0);
                 }
                 if (new_rect.GetY() < 0) {
+                    new_rect.SetHeight(new_rect.GetHeight() + new_rect.GetY());  // Reduce height by overflow amount
                     new_rect.SetY(0);
                 }
-                if (new_rect.GetX() + new_rect.GetWidth() > originImage.Width()) {
-                    new_rect.SetWidth(originImage.Width() - new_rect.GetX());
+
+                float rightOverflow = (new_rect.GetX() + new_rect.GetWidth()) - originImage.Width();
+                if (rightOverflow > 0) {
+                    new_rect.SetWidth(new_rect.GetWidth() - rightOverflow);
                 }
-                if (new_rect.GetY() + new_rect.GetHeight() > originImage.Height()) {
-                    new_rect.SetHeight(originImage.Height() - new_rect.GetY());
+
+                float bottomOverflow = (new_rect.GetY() + new_rect.GetHeight()) - originImage.Height();
+                if (bottomOverflow > 0) {
+                    new_rect.SetHeight(new_rect.GetHeight() - bottomOverflow);
+                }
+
+                // Maintain minimum size (e.g., 20x20 ixels)
+                const float minSize = 20.0f;
+                if (new_rect.GetWidth() < minSize || new_rect.GetHeight() < minSize) {
+                    continue;  // Skip this eye if the crop region is too small
                 }
 
                 auto crop = originImage.Crop(new_rect);
diff --git a/cpp/inspireface/platform/jni/android/inspireface_jni.cpp b/cpp/inspireface/platform/jni/android/inspireface_jni.cpp
index b02b86c0..2c1eec0d 100644
--- a/cpp/inspireface/platform/jni/android/inspireface_jni.cpp
+++ b/cpp/inspireface/platform/jni/android/inspireface_jni.cpp
@@ -492,6 +492,37 @@ JNIEXPORT void INSPIRE_FACE_JNI(InspireFace_SetFaceDetectThreshold)(JNIEnv *env,
         INSPIRE_LOGE("Failed to set face detect threshold, error code: %d", result);
     }
 }
+
+JNIEXPORT void INSPIRE_FACE_JNI(InspireFace_SetTrackModeSmoothRatio)(JNIEnv *env, jobject thiz, jobject session, jfloat ratio) {
+    jclass sessionClass = env->GetObjectClass(session);
+    jfieldID sessionHandleField = env->GetFieldID(sessionClass, "handle", "J");
+    jlong sessionHandle = env->GetLongField(session, sessionHandleField);
+    auto result = HFSessionSetTrackModeSmoothRatio((HFSession)sessionHandle, ratio);
+    if (result != HSUCCEED) {
+        INSPIRE_LOGE("Failed to set track mode smooth ratio, error code: %d", result);
+    }
+}
+
+JNIEXPORT void INSPIRE_FACE_JNI(InspireFace_SetTrackModeNumSmoothCacheFrame)(JNIEnv *env, jobject thiz, jobject session, jint num) {
+    jclass sessionClass = env->GetObjectClass(session);
+    jfieldID sessionHandleField = env->GetFieldID(sessionClass, "handle", "J");
+    jlong sessionHandle = env->GetLongField(session, sessionHandleField);
+    auto result = HFSessionSetTrackModeNumSmoothCacheFrame((HFSession)sessionHandle, num);
+    if (result != HSUCCEED) {
+        INSPIRE_LOGE("Failed to set track mode num smooth cache frame, error code: %d", result);
+    }
+}
+
+JNIEXPORT void INSPIRE_FACE_JNI(InspireFace_SetTrackModeDetectInterval)(JNIEnv *env, jobject thiz, jobject session, jint interval) {
+    jclass sessionClass = env->GetObjectClass(session);
+    jfieldID sessionHandleField = env->GetFieldID(sessionClass, "handle", "J");
+    jlong sessionHandle = env->GetLongField(session, sessionHandleField);
+    auto result = HFSessionSetTrackModeDetectInterval((HFSession)sessionHandle, interval);
+    if (result != HSUCCEED) {
+        INSPIRE_LOGE("Failed to set track mode detect interval, error code: %d", result);
+    }
+}
+
 JNIEXPORT jboolean INSPIRE_FACE_JNI(InspireFace_FeatureHubDataEnable)(JNIEnv *env, jobject thiz, jobject configuration) {
     jclass configClass = env->GetObjectClass(configuration);
 
@@ -816,6 +847,53 @@ JNIEXPORT jint INSPIRE_FACE_JNI(InspireFace_GetFeatureLength)(JNIEnv *env, jobje
     return length;
 }
 
+JNIEXPORT void INSPIRE_FACE_JNI(InspireFace_UpdateCosineSimilarityConverter)(JNIEnv *env, jobject thiz, jobject config) {
+    jclass configClass = env->GetObjectClass(config);
+    jfieldID thresholdField = env->GetFieldID(configClass, "threshold", "F");
+    jfieldID middleScoreField = env->GetFieldID(configClass, "middleScore", "F");
+    jfieldID steepnessField = env->GetFieldID(configClass, "steepness", "F");
+    jfieldID outputMinField = env->GetFieldID(configClass, "outputMin", "F");
+    jfieldID outputMaxField = env->GetFieldID(configClass, "outputMax", "F");
+
+    HFSimilarityConverterConfig converterConfig;
+    converterConfig.threshold = env->GetFloatField(config, thresholdField);
+    converterConfig.middleScore = env->GetFloatField(config, middleScoreField);
+    converterConfig.steepness = env->GetFloatField(config, steepnessField);
+    converterConfig.outputMin = env->GetFloatField(config, outputMinField);
+    converterConfig.outputMax = env->GetFloatField(config, outputMaxField);
+    HFUpdateCosineSimilarityConverter(converterConfig);
+}
+
+JNIEXPORT jobject INSPIRE_FACE_JNI(InspireFace_GetCosineSimilarityConverter)(JNIEnv *env, jobject thiz) {
+    HFSimilarityConverterConfig converterConfig;
+    HFGetCosineSimilarityConverter(&converterConfig);
+    jclass configClass = env->FindClass("com/insightface/sdk/inspireface/base/SimilarityConverterConfig");
+    jmethodID constructor = env->GetMethodID(configClass, "<init>", "()V");
+    jobject configObj = env->NewObject(configClass, constructor);
+
+    // Get field IDs
+    jfieldID thresholdField = env->GetFieldID(configClass, "threshold", "F");
+    jfieldID middleScoreField = env->GetFieldID(configClass, "middleScore", "F");
+    jfieldID steepnessField = env->GetFieldID(configClass, "steepness", "F");
+    jfieldID outputMinField = env->GetFieldID(configClass, "outputMin", "F");
+    jfieldID outputMaxField = env->GetFieldID(configClass, "outputMax", "F");
+
+    // Set fields
+    env->SetFloatField(configObj, thresholdField, converterConfig.threshold);
+    env->SetFloatField(configObj, middleScoreField, converterConfig.middleScore);
+    env->SetFloatField(configObj, steepnessField, converterConfig.steepness);
+    env->SetFloatField(configObj, outputMinField, converterConfig.outputMin);
+    env->SetFloatField(configObj, outputMaxField, converterConfig.outputMax);
+
+    return configObj;
+}
+
+JNIEXPORT jfloat INSPIRE_FACE_JNI(InspireFace_CosineSimilarityConvertToPercentage)(JNIEnv *env, jobject thiz, jfloat similarity) {
+    HFloat result;
+    HFCosineSimilarityConvertToPercentage(similarity, &result);
+    return result;
+}
+
 JNIEXPORT jfloat INSPIRE_FACE_JNI(InspireFace_FaceComparison)(JNIEnv *env, jobject thiz, jobject feature1, jobject feature2) {
     if (feature1 == nullptr || feature2 == nullptr) {
         return -1.0f;
diff --git a/cpp/inspireface/recognition_module/similarity_converter.cpp b/cpp/inspireface/recognition_module/similarity_converter.cpp
new file mode 100644
index 00000000..d1f972ee
--- /dev/null
+++ b/cpp/inspireface/recognition_module/similarity_converter.cpp
@@ -0,0 +1,9 @@
+#include <mutex>
+#include "similarity_converter.h"
+
+namespace inspire {
+
+SimilarityConverter* SimilarityConverter::instance = nullptr;
+std::mutex SimilarityConverter::instanceMutex;
+
+}  // namespace inspire
diff --git a/cpp/inspireface/recognition_module/similarity_converter.h b/cpp/inspireface/recognition_module/similarity_converter.h
new file mode 100644
index 00000000..7f9c853d
--- /dev/null
+++ b/cpp/inspireface/recognition_module/similarity_converter.h
@@ -0,0 +1,112 @@
+#ifndef SIMILARITY_CONVERTER_H
+#define SIMILARITY_CONVERTER_H
+
+#include <iostream>
+#include <cmath>
+#include <mutex>
+
+#define SIMILARITY_CONVERTER_UPDATE_CONFIG(config) inspire::SimilarityConverter::getInstance().updateConfig(config)
+#define SIMILARITY_CONVERTER_RUN(cosine) inspire::SimilarityConverter::getInstance().convert(cosine)
+#define SIMILARITY_CONVERTER_GET_CONFIG() inspire::SimilarityConverter::getInstance().getConfig()
+#define SIMILARITY_CONVERTER_GET_RECOMMENDED_COSINE_THRESHOLD() inspire::SimilarityConverter::getInstance().getRecommendedCosineThreshold()
+#define SIMILARITY_CONVERTER_SET_RECOMMENDED_COSINE_THRESHOLD(threshold) \
+    inspire::SimilarityConverter::getInstance().setRecommendedCosineThreshold(threshold)
+
+namespace inspire {
+
+struct SimilarityConverterConfig {
+    double threshold = 0.48;   // Similarity threshold (e.g. 0.48 or 0.32)
+    double middleScore = 0.6;  // Target score at threshold (e.g. 0.6)
+    double steepness = 8.0;    // Steepness of the curve
+    double outputMin = 0.01;   // Minimum value of output range
+    double outputMax = 1.0;    // Maximum value of output range
+};
+
+class SimilarityConverter {
+private:
+    SimilarityConverterConfig config;
+    double outputScale;              // Scale of output range
+    double bias;                     // Sigmoid bias
+    mutable std::mutex configMutex;  // Mutex for protecting config updates
+
+    // Recommended cosine threshold
+    float recommendedCosineThreshold = 0.48;
+
+    static SimilarityConverter* instance;
+    static std::mutex instanceMutex;
+
+    // Update internal calculation parameters
+    void updateParameters() {
+        outputScale = config.outputMax - config.outputMin;
+        bias = -std::log((config.outputMax - config.middleScore) / (config.middleScore - config.outputMin));
+    }
+
+public:
+    // Get global singleton instance
+    static SimilarityConverter& getInstance() {
+        std::lock_guard<std::mutex> lock(instanceMutex);
+        if (instance == nullptr) {
+            instance = new SimilarityConverter();
+        }
+        return *instance;
+    }
+
+    // Allow external creation of new instances
+    explicit SimilarityConverter(const SimilarityConverterConfig& config = SimilarityConverterConfig()) : config(config) {
+        updateParameters();
+    }
+
+    // Prevent copying
+    SimilarityConverter(const SimilarityConverter&) = delete;
+    SimilarityConverter& operator=(const SimilarityConverter&) = delete;
+
+    // Update configuration (thread-safe)
+    void updateConfig(const SimilarityConverterConfig& newConfig) {
+        std::lock_guard<std::mutex> lock(configMutex);
+        config = newConfig;
+        updateParameters();
+    }
+
+    // Get current configuration (thread-safe)
+    SimilarityConverterConfig getConfig() const {
+        std::lock_guard<std::mutex> lock(configMutex);
+        return config;
+    }
+
+    // Convert similarity (thread-safe)
+    template <typename T>
+    double convert(T cosine) {
+        std::lock_guard<std::mutex> lock(configMutex);
+        // Calculate shifted input
+        double shiftedInput = config.steepness * (static_cast<double>(cosine) - config.threshold);
+        // Apply sigmoid function
+        double sigmoid = 1.0 / (1.0 + std::exp(-shiftedInput - bias));
+        // Map to output range
+        return sigmoid * outputScale + config.outputMin;
+    }
+
+    // Clean up singleton instance
+    static void destroyInstance() {
+        std::lock_guard<std::mutex> lock(instanceMutex);
+        if (instance != nullptr) {
+            delete instance;
+            instance = nullptr;
+        }
+    }
+
+    // Get recommended cosine threshold
+    float getRecommendedCosineThreshold() const {
+        return recommendedCosineThreshold;
+    }
+
+    // Set recommended cosine threshold
+    void setRecommendedCosineThreshold(float threshold) {
+        recommendedCosineThreshold = threshold;
+    }
+
+    ~SimilarityConverter() = default;
+};  // class SimilarityConverter
+
+}  // namespace inspire
+
+#endif  // SIMILARITY_CONVERTER_H
\ No newline at end of file
diff --git a/cpp/inspireface/track_module/face_track_module.cpp b/cpp/inspireface/track_module/face_track_module.cpp
index fb4c7ca4..a590bf44 100644
--- a/cpp/inspireface/track_module/face_track_module.cpp
+++ b/cpp/inspireface/track_module/face_track_module.cpp
@@ -186,8 +186,22 @@ bool FaceTrackModule::TrackFace(inspirecv::InspireImageProcess &image, FaceObjec
                 // INSPIRE_LOGD("Extensive Affine Cost %f", extensive_cost_time.GetCostTimeUpdate());
             }
         }
+        // Replace the landmark with the high-quality landmark
+        landmark_back[FaceLandmarkAdapt::LEFT_EYE_CENTER] = face.high_result.lmk[0];
+        landmark_back[FaceLandmarkAdapt::RIGHT_EYE_CENTER] = face.high_result.lmk[1];
+        landmark_back[FaceLandmarkAdapt::NOSE_CORNER] = face.high_result.lmk[2];
+        landmark_back[FaceLandmarkAdapt::MOUTH_LEFT_CORNER] = face.high_result.lmk[3];
+        landmark_back[FaceLandmarkAdapt::MOUTH_RIGHT_CORNER] = face.high_result.lmk[4];
         // Update face key points
-        face.SetLandmark(landmark_back, true);
+        face.SetLandmark(landmark_back, true, true, m_track_mode_smooth_ratio_, m_track_mode_num_smooth_cache_frame_);
+        // Get the smoothed landmark
+        auto &landmark_smooth = face.landmark_smooth_aux_.back();
+        // Update the face key points
+        face.high_result.lmk[0] = landmark_smooth[FaceLandmarkAdapt::LEFT_EYE_CENTER];
+        face.high_result.lmk[1] = landmark_smooth[FaceLandmarkAdapt::RIGHT_EYE_CENTER];
+        face.high_result.lmk[2] = landmark_smooth[FaceLandmarkAdapt::NOSE_CORNER];
+        face.high_result.lmk[3] = landmark_smooth[FaceLandmarkAdapt::MOUTH_LEFT_CORNER];
+        face.high_result.lmk[4] = landmark_smooth[FaceLandmarkAdapt::MOUTH_RIGHT_CORNER];
     }
 
     // If tracking status, update the confidence level
@@ -205,7 +219,8 @@ void FaceTrackModule::UpdateStream(inspirecv::InspireImageProcess &image) {
     detection_index_ += 1;
     if (m_mode_ == DETECT_MODE_ALWAYS_DETECT || m_mode_ == DETECT_MODE_TRACK_BY_DETECT)
         trackingFace.clear();
-    if (detection_index_ % detection_interval_ == 0 || m_mode_ == DETECT_MODE_ALWAYS_DETECT || m_mode_ == DETECT_MODE_TRACK_BY_DETECT) {
+    if (trackingFace.empty() || detection_index_ % detection_interval_ == 0 || m_mode_ == DETECT_MODE_ALWAYS_DETECT ||
+        m_mode_ == DETECT_MODE_TRACK_BY_DETECT) {
         image.SetPreviewSize(track_preview_size_);
         inspirecv::Image image_detect = image.ExecutePreviewImageProcessing(true);
 
@@ -469,4 +484,17 @@ std::string FaceTrackModule::ChoiceMultiLevelDetectModel(const int32_t pixel_siz
 bool FaceTrackModule::IsDetectModeLandmark() const {
     return m_detect_mode_landmark_;
 }
+
+void FaceTrackModule::SetTrackModeSmoothRatio(float value) {
+    m_track_mode_smooth_ratio_ = value;
+}
+
+void FaceTrackModule::SetTrackModeNumSmoothCacheFrame(int value) {
+    m_track_mode_num_smooth_cache_frame_ = value;
+}
+
+void FaceTrackModule::SetTrackModeDetectInterval(int value) {
+    detection_interval_ = value;
+}
+
 }  // namespace inspire
diff --git a/cpp/inspireface/track_module/face_track_module.h b/cpp/inspireface/track_module/face_track_module.h
index 2cb86f1a..6fdee1f9 100644
--- a/cpp/inspireface/track_module/face_track_module.h
+++ b/cpp/inspireface/track_module/face_track_module.h
@@ -144,12 +144,12 @@ class INSPIRE_API FaceTrackModule {
 
 public:
     /**
-     * @brief Fix detect threshold
+     * @brief Set the detect threshold
      * */
     void SetDetectThreshold(float value);
 
     /**
-     * @brief Fix detect threshold
+     * @brief Set the minimum face size
      * */
     void SetMinimumFacePxSize(float value);
 
@@ -159,6 +159,24 @@ class INSPIRE_API FaceTrackModule {
      */
     bool IsDetectModeLandmark() const;
 
+    /**
+     * @brief Sets the smoothing ratio for landmark tracking
+     * @param value Smoothing ratio between 0 and 1, smaller values mean stronger smoothing
+     */
+    void SetTrackModeSmoothRatio(float value);
+
+    /**
+     * @brief Set the number of smooth cache frame
+     * @param value Number of frames to cache for smoothing
+     */
+    void SetTrackModeNumSmoothCacheFrame(int value);
+
+    /**
+     * @brief Set the detect interval
+     * @param value Interval between detections
+     */
+    void SetTrackModeDetectInterval(int value);
+
 public:
     std::vector<FaceObjectInternal> trackingFace;  ///< Vector of FaceObjects currently being tracked.
 
@@ -181,14 +199,18 @@ class INSPIRE_API FaceTrackModule {
     std::shared_ptr<BYTETracker> m_TbD_tracker_;  ///< Shared pointer to the Bytetrack.
     int m_dynamic_detection_input_level_ = -1;    ///< Detector size class for dynamic input.
 
-    float m_crop_extensive_ratio_ = 1.8f;
-    int m_crop_extensive_size_ = 96;
+    float m_crop_extensive_ratio_ = 1.8f;  ///< Crop extensive ratio
+    int m_crop_extensive_size_ = 96;       ///< Crop extensive size
 
     DetectModuleMode m_mode_;  ///< Detect mode
 
-    std::string m_expansion_path_{""};
+    std::string m_expansion_path_{""};  ///< Expand the path if you need it.
+
+    bool m_detect_mode_landmark_{true};  ///< Detect mode landmark
+
+    int m_track_mode_num_smooth_cache_frame_ = 15;  ///< Track mode number of smooth cache frame
 
-    bool m_detect_mode_landmark_{true};
+    float m_track_mode_smooth_ratio_ = 0.025;  ///< Track mode smooth ratio
 };
 
 }  // namespace inspire
diff --git a/cpp/sample/CMakeLists.txt b/cpp/sample/CMakeLists.txt
index a97d04a9..e9d23ec0 100644
--- a/cpp/sample/CMakeLists.txt
+++ b/cpp/sample/CMakeLists.txt
@@ -4,6 +4,7 @@ project(InspireFaceSample)
 option(ISF_BUILD_SAMPLE_CLUTTERED "Whether to compile the cluttered sample program (debug code during development)" OFF)
 
 include_directories(${SRC_DIR})
+include_directories(${SRC_DIR}/inspireface/c_api)
 
 if (ISF_ENABLE_RKNN AND ISF_RKNPU_MAJOR STREQUAL "rknpu1")
         set(ISF_RKNN_API_LIB ${ISF_THIRD_PARTY_DIR}/inspireface-precompile-lite/rknn/${ISF_RKNPU_MAJOR}/runtime/${ISF_RK_DEVICE_TYPE}/Linux/librknn_api/${CPU_ARCH}/)
diff --git a/cpp/sample/api/sample_face_comparison.cpp b/cpp/sample/api/sample_face_comparison.cpp
index 55aeed9a..ce835198 100644
--- a/cpp/sample/api/sample_face_comparison.cpp
+++ b/cpp/sample/api/sample_face_comparison.cpp
@@ -4,7 +4,7 @@
  */
 #include <iostream>
 #include <vector>
-#include "inspireface/c_api/inspireface.h"
+#include <inspireface.h>
 
 int main(int argc, char* argv[]) {
     // Check whether the number of parameters is correct
@@ -104,7 +104,29 @@ int main(int argc, char* argv[]) {
         return ret;
     }
 
-    HFLogPrint(HF_LOG_INFO, "Similarity: %f", similarity);
+    HFloat recommended_cosine_threshold;
+    ret = HFGetRecommendedCosineThreshold(&recommended_cosine_threshold);
+    if (ret != HSUCCEED) {
+        HFLogPrint(HF_LOG_ERROR, "Get recommended cosine threshold error: %d", ret);
+        return ret;
+    }
+
+    if (similarity > recommended_cosine_threshold) {
+        HFLogPrint(HF_LOG_INFO, "%.3f > %.3f ✓ Same face", similarity, recommended_cosine_threshold);
+    } else {
+        HFLogPrint(HF_LOG_WARN, "%.3f < %.3f ✗ Different face", similarity, recommended_cosine_threshold);
+    }
+    HFLogPrint(HF_LOG_INFO, "Similarity score: %.3f", similarity);
+
+    // Convert cosine similarity to percentage similarity.
+    // Note: conversion parameters are not optimal and should be adjusted based on your specific use case.
+    HFloat percentage;
+    ret = HFCosineSimilarityConvertToPercentage(similarity, &percentage);
+    if (ret != HSUCCEED) {
+        HFLogPrint(HF_LOG_ERROR, "Convert similarity to percentage error: %d", ret);
+        return ret;
+    }
+    HFLogPrint(HF_LOG_INFO, "Percentage similarity: %f", percentage);
 
     // The memory must be freed at the end of the program
     ret = HFReleaseInspireFaceSession(session);
diff --git a/cpp/sample/api/sample_face_track.cpp b/cpp/sample/api/sample_face_track.cpp
index 85eabc1f..ee4650e1 100644
--- a/cpp/sample/api/sample_face_track.cpp
+++ b/cpp/sample/api/sample_face_track.cpp
@@ -3,7 +3,7 @@
  * @date 2024-10-01
  */
 #include <iostream>
-#include "inspireface/c_api/inspireface.h"
+#include <inspireface.h>
 
 int main(int argc, char* argv[]) {
     // Check whether the number of parameters is correct
diff --git a/cpp/sample/api/sample_feature_hub.cpp b/cpp/sample/api/sample_feature_hub.cpp
index 90ff257b..72f8f9e9 100644
--- a/cpp/sample/api/sample_feature_hub.cpp
+++ b/cpp/sample/api/sample_feature_hub.cpp
@@ -1,5 +1,5 @@
 #include <iostream>
-#include "inspireface/c_api/inspireface.h"
+#include <inspireface.h>
 #include <vector>
 
 static std::vector<float> FT = {
diff --git a/cpp/sample/api/sample_load_reload.cpp b/cpp/sample/api/sample_load_reload.cpp
index a4815f09..c62a1745 100644
--- a/cpp/sample/api/sample_load_reload.cpp
+++ b/cpp/sample/api/sample_load_reload.cpp
@@ -1,5 +1,5 @@
 #include <iostream>
-#include "inspireface/c_api/inspireface.h"
+#include <inspireface.h>
 
 int main() {
     std::string resourcePath = "test_res/pack/Pikachu";
diff --git a/cpp/test/unit/api/test_similarity_converter.cpp b/cpp/test/unit/api/test_similarity_converter.cpp
new file mode 100644
index 00000000..f83d01a2
--- /dev/null
+++ b/cpp/test/unit/api/test_similarity_converter.cpp
@@ -0,0 +1,51 @@
+/**
+ * Created by Jingyu Yan
+ * @date 2025-01-20
+ */
+#include <iostream>
+#include "settings/test_settings.h"
+#include "unit/test_helper/test_help.h"
+#include "inspireface/recognition_module/similarity_converter.h"
+
+TEST_CASE("test_similarity_converter", "[similarity_converter]") {
+    DRAW_SPLIT_LINE
+    TEST_PRINT_OUTPUT(true);
+
+    SECTION("test_similarity_converter_0.42") {
+        inspire::SimilarityConverterConfig config;
+        config.threshold = 0.42;
+        config.middleScore = 0.6;
+        config.steepness = 8.0;
+        config.outputMin = 0.01;
+        config.outputMax = 1.0;
+        inspire::SimilarityConverter similarity_converter(config);
+        std::vector<double> test_points = {-0.80, -0.20, 0.02, 0.10, 0.25, 0.30, 0.48, 0.70, 0.80, 0.90, 1.00};
+        std::vector<double> expected_scores = {0.0101, 0.0201, 0.0661, 0.1113, 0.2819, 0.3673, 0.7074, 0.9334, 0.9689, 0.9858, 0.9936};
+        REQUIRE(test_points.size() == expected_scores.size());
+
+        for (size_t i = 0; i < test_points.size(); ++i) {
+            double cosine = test_points[i];
+            double similarity = similarity_converter.convert(cosine);
+            REQUIRE(similarity == Approx(expected_scores[i]).epsilon(0.01));
+        }
+    }
+
+    SECTION("test_similarity_converter_0.32") {
+        inspire::SimilarityConverterConfig config;
+        config.threshold = 0.32;
+        config.middleScore = 0.6;
+        config.steepness = 10.0;
+        config.outputMin = 0.02;
+        config.outputMax = 1.0;
+        inspire::SimilarityConverter similarity_converter(config);
+        std::vector<double> test_points = {-0.80, -0.20, 0.02, 0.10, 0.25, 0.32, 0.50, 0.70, 0.80, 0.90, 1.00};
+        std::vector<double> expected_scores = {0.0200, 0.0278, 0.0860, 0.1557, 0.4302, 0.6000, 0.8997, 0.9851, 0.9945, 0.9980, 0.9992};
+        REQUIRE(test_points.size() == expected_scores.size());
+
+        for (size_t i = 0; i < test_points.size(); ++i) {
+            double cosine = test_points[i];
+            double similarity = similarity_converter.convert(cosine);
+            REQUIRE(similarity == Approx(expected_scores[i]).epsilon(0.01));
+        }
+    }
+}
\ No newline at end of file
diff --git a/python/inspireface/modules/__init__.py b/python/inspireface/modules/__init__.py
index a0848f55..c1f57a99 100644
--- a/python/inspireface/modules/__init__.py
+++ b/python/inspireface/modules/__init__.py
@@ -3,4 +3,6 @@
     FaceIdentity, feature_hub_set_search_threshold, feature_hub_face_insert, SearchResult, \
     feature_hub_face_search, feature_hub_face_search_top_k, feature_hub_face_update, feature_hub_face_remove, \
     feature_hub_get_face_identity, feature_hub_get_face_count, view_table_in_terminal, version, query_launch_status, reload, \
-    set_logging_level, disable_logging, show_system_resource_statistics, HF_PK_AUTO_INCREMENT, HF_PK_MANUAL_INPUT, HF_SEARCH_MODE_EAGER, HF_SEARCH_MODE_EXHAUSTIVE
\ No newline at end of file
+    set_logging_level, disable_logging, show_system_resource_statistics, get_recommended_cosine_threshold, cosine_similarity_convert_to_percentage, \
+    get_similarity_converter_config, set_similarity_converter_config, pull_latest_model, \
+          HF_PK_AUTO_INCREMENT, HF_PK_MANUAL_INPUT, HF_SEARCH_MODE_EAGER, HF_SEARCH_MODE_EXHAUSTIVE
\ No newline at end of file
diff --git a/python/inspireface/modules/core/native.py b/python/inspireface/modules/core/native.py
index cd8d777a..86e6d356 100644
--- a/python/inspireface/modules/core/native.py
+++ b/python/inspireface/modules/core/native.py
@@ -937,7 +937,6 @@ def add_library_search_dirs(other_dirs):
 
 # Begin libraries
 _libs[_LIBRARY_FILENAME] = load_library(_LIBRARY_FILENAME)
-
 # 1 libraries
 # End libraries
 
@@ -945,39 +944,43 @@ def add_library_search_dirs(other_dirs):
 
 uint8_t = c_ubyte# /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/_types/_uint8_t.h: 31
 
-HPVoid = POINTER(None)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 10
+HPVoid = POINTER(None)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 11
+
+HFImageStream = POINTER(None)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 12
+
+HFSession = POINTER(None)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 13
 
-HFImageStream = POINTER(None)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 11
+HFImageBitmap = POINTER(None)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 14
 
-HFSession = POINTER(None)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 12
+HFloat = c_float# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 16
 
-HFImageBitmap = POINTER(None)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 13
+HPFloat = POINTER(c_float)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 17
 
-HFloat = c_float# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 15
+HPUInt8 = POINTER(c_ubyte)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 20
 
-HPFloat = POINTER(c_float)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 16
+HInt32 = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 21
 
-HInt32 = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 19
+HOption = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 22
 
-HOption = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 20
+HPInt32 = POINTER(c_int)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 23
 
-HPInt32 = POINTER(c_int)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 21
+HFaceId = c_int64# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 24
 
-HFaceId = c_int64# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 22
+HPFaceId = POINTER(c_int64)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 25
 
-HPFaceId = POINTER(c_int64)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 23
+HResult = c_long# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 26
 
-HResult = c_long# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 24
+HString = String# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 27
 
-HString = String# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 25
+HPath = String# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 28
 
-HPath = String# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 26
+HFormat = String# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 29
 
-HChar = c_char# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 28
+HChar = c_char# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 31
 
-HPBuffer = String# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 29
+HPBuffer = String# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 32
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 39
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 42
 class struct_HFaceRect(Structure):
     pass
 
@@ -994,9 +997,9 @@ class struct_HFaceRect(Structure):
     ('height', HInt32),
 ]
 
-HFaceRect = struct_HFaceRect# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 39
+HFaceRect = struct_HFaceRect# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 42
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 44
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 47
 class struct_HPoint2f(Structure):
     pass
 
@@ -1009,9 +1012,9 @@ class struct_HPoint2f(Structure):
     ('y', HFloat),
 ]
 
-HPoint2f = struct_HPoint2f# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 44
+HPoint2f = struct_HPoint2f# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 47
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 49
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 52
 class struct_HPoint2i(Structure):
     pass
 
@@ -1024,9 +1027,9 @@ class struct_HPoint2i(Structure):
     ('y', HInt32),
 ]
 
-HPoint2i = struct_HPoint2i# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 49
+HPoint2i = struct_HPoint2i# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 52
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 55
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 58
 class struct_HColor(Structure):
     pass
 
@@ -1041,37 +1044,37 @@ class struct_HColor(Structure):
     ('b', HFloat),
 ]
 
-HColor = struct_HColor# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 55
+HColor = struct_HColor# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/intypedef.h: 58
 
-enum_HFImageFormat = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 48
+enum_HFImageFormat = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 49
 
-HF_STREAM_RGB = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 48
+HF_STREAM_RGB = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 49
 
-HF_STREAM_BGR = 1# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 48
+HF_STREAM_BGR = 1# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 49
 
-HF_STREAM_RGBA = 2# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 48
+HF_STREAM_RGBA = 2# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 49
 
-HF_STREAM_BGRA = 3# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 48
+HF_STREAM_BGRA = 3# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 49
 
-HF_STREAM_YUV_NV12 = 4# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 48
+HF_STREAM_YUV_NV12 = 4# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 49
 
-HF_STREAM_YUV_NV21 = 5# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 48
+HF_STREAM_YUV_NV21 = 5# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 49
 
-HFImageFormat = enum_HFImageFormat# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 48
+HFImageFormat = enum_HFImageFormat# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 49
 
-enum_HFRotation = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 59
+enum_HFRotation = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 60
 
-HF_CAMERA_ROTATION_0 = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 59
+HF_CAMERA_ROTATION_0 = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 60
 
-HF_CAMERA_ROTATION_90 = 1# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 59
+HF_CAMERA_ROTATION_90 = 1# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 60
 
-HF_CAMERA_ROTATION_180 = 2# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 59
+HF_CAMERA_ROTATION_180 = 2# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 60
 
-HF_CAMERA_ROTATION_270 = 3# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 59
+HF_CAMERA_ROTATION_270 = 3# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 60
 
-HFRotation = enum_HFRotation# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 59
+HFRotation = enum_HFRotation# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 60
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 71
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 72
 class struct_HFImageData(Structure):
     pass
 
@@ -1083,30 +1086,54 @@ class struct_HFImageData(Structure):
     'rotation',
 ]
 struct_HFImageData._fields_ = [
-    ('data', POINTER(uint8_t)),
+    ('data', HPUInt8),
     ('width', HInt32),
     ('height', HInt32),
     ('format', HFImageFormat),
     ('rotation', HFRotation),
 ]
 
-HFImageData = struct_HFImageData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 71
+HFImageData = struct_HFImageData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 72
 
-PHFImageData = POINTER(struct_HFImageData)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 71
+PHFImageData = POINTER(struct_HFImageData)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 72
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 82
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 83
 if _libs[_LIBRARY_FILENAME].has("HFCreateImageStream", "cdecl"):
     HFCreateImageStream = _libs[_LIBRARY_FILENAME].get("HFCreateImageStream", "cdecl")
     HFCreateImageStream.argtypes = [PHFImageData, POINTER(HFImageStream)]
     HFCreateImageStream.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 92
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 93
+if _libs[_LIBRARY_FILENAME].has("HFCreateImageStreamEmpty", "cdecl"):
+    HFCreateImageStreamEmpty = _libs[_LIBRARY_FILENAME].get("HFCreateImageStreamEmpty", "cdecl")
+    HFCreateImageStreamEmpty.argtypes = [POINTER(HFImageStream)]
+    HFCreateImageStreamEmpty.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 104
+if _libs[_LIBRARY_FILENAME].has("HFImageStreamSetBuffer", "cdecl"):
+    HFImageStreamSetBuffer = _libs[_LIBRARY_FILENAME].get("HFImageStreamSetBuffer", "cdecl")
+    HFImageStreamSetBuffer.argtypes = [HFImageStream, HPUInt8, HInt32, HInt32]
+    HFImageStreamSetBuffer.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 113
+if _libs[_LIBRARY_FILENAME].has("HFImageStreamSetRotation", "cdecl"):
+    HFImageStreamSetRotation = _libs[_LIBRARY_FILENAME].get("HFImageStreamSetRotation", "cdecl")
+    HFImageStreamSetRotation.argtypes = [HFImageStream, HFRotation]
+    HFImageStreamSetRotation.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 122
+if _libs[_LIBRARY_FILENAME].has("HFImageStreamSetFormat", "cdecl"):
+    HFImageStreamSetFormat = _libs[_LIBRARY_FILENAME].get("HFImageStreamSetFormat", "cdecl")
+    HFImageStreamSetFormat.argtypes = [HFImageStream, HFImageFormat]
+    HFImageStreamSetFormat.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 132
 if _libs[_LIBRARY_FILENAME].has("HFReleaseImageStream", "cdecl"):
     HFReleaseImageStream = _libs[_LIBRARY_FILENAME].get("HFReleaseImageStream", "cdecl")
     HFReleaseImageStream.argtypes = [HFImageStream]
     HFReleaseImageStream.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 102
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 142
 class struct_HFImageBitmapData(Structure):
     pass
 
@@ -1123,101 +1150,125 @@ class struct_HFImageBitmapData(Structure):
     ('channels', HInt32),
 ]
 
-HFImageBitmapData = struct_HFImageBitmapData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 102
+HFImageBitmapData = struct_HFImageBitmapData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 142
 
-PHFImageBitmapData = POINTER(struct_HFImageBitmapData)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 102
+PHFImageBitmapData = POINTER(struct_HFImageBitmapData)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 142
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 111
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 151
 if _libs[_LIBRARY_FILENAME].has("HFCreateImageBitmap", "cdecl"):
     HFCreateImageBitmap = _libs[_LIBRARY_FILENAME].get("HFCreateImageBitmap", "cdecl")
     HFCreateImageBitmap.argtypes = [PHFImageBitmapData, POINTER(HFImageBitmap)]
     HFCreateImageBitmap.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 121
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 161
 if _libs[_LIBRARY_FILENAME].has("HFCreateImageBitmapFromFilePath", "cdecl"):
     HFCreateImageBitmapFromFilePath = _libs[_LIBRARY_FILENAME].get("HFCreateImageBitmapFromFilePath", "cdecl")
     HFCreateImageBitmapFromFilePath.argtypes = [HPath, HInt32, POINTER(HFImageBitmap)]
     HFCreateImageBitmapFromFilePath.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 130
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 170
 if _libs[_LIBRARY_FILENAME].has("HFImageBitmapCopy", "cdecl"):
     HFImageBitmapCopy = _libs[_LIBRARY_FILENAME].get("HFImageBitmapCopy", "cdecl")
     HFImageBitmapCopy.argtypes = [HFImageBitmap, POINTER(HFImageBitmap)]
     HFImageBitmapCopy.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 138
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 178
 if _libs[_LIBRARY_FILENAME].has("HFReleaseImageBitmap", "cdecl"):
     HFReleaseImageBitmap = _libs[_LIBRARY_FILENAME].get("HFReleaseImageBitmap", "cdecl")
     HFReleaseImageBitmap.argtypes = [HFImageBitmap]
     HFReleaseImageBitmap.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 148
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 188
 if _libs[_LIBRARY_FILENAME].has("HFCreateImageStreamFromImageBitmap", "cdecl"):
     HFCreateImageStreamFromImageBitmap = _libs[_LIBRARY_FILENAME].get("HFCreateImageStreamFromImageBitmap", "cdecl")
     HFCreateImageStreamFromImageBitmap.argtypes = [HFImageBitmap, HFRotation, POINTER(HFImageStream)]
     HFCreateImageStreamFromImageBitmap.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 157
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 197
 if _libs[_LIBRARY_FILENAME].has("HFImageBitmapWriteToFile", "cdecl"):
     HFImageBitmapWriteToFile = _libs[_LIBRARY_FILENAME].get("HFImageBitmapWriteToFile", "cdecl")
     HFImageBitmapWriteToFile.argtypes = [HFImageBitmap, HPath]
     HFImageBitmapWriteToFile.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 168
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 208
 if _libs[_LIBRARY_FILENAME].has("HFImageBitmapDrawRect", "cdecl"):
     HFImageBitmapDrawRect = _libs[_LIBRARY_FILENAME].get("HFImageBitmapDrawRect", "cdecl")
     HFImageBitmapDrawRect.argtypes = [HFImageBitmap, HFaceRect, HColor, HInt32]
     HFImageBitmapDrawRect.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 180
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 220
 if _libs[_LIBRARY_FILENAME].has("HFImageBitmapDrawCircleF", "cdecl"):
     HFImageBitmapDrawCircleF = _libs[_LIBRARY_FILENAME].get("HFImageBitmapDrawCircleF", "cdecl")
     HFImageBitmapDrawCircleF.argtypes = [HFImageBitmap, HPoint2f, HInt32, HColor, HInt32]
     HFImageBitmapDrawCircleF.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 181
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 221
 if _libs[_LIBRARY_FILENAME].has("HFImageBitmapDrawCircle", "cdecl"):
     HFImageBitmapDrawCircle = _libs[_LIBRARY_FILENAME].get("HFImageBitmapDrawCircle", "cdecl")
     HFImageBitmapDrawCircle.argtypes = [HFImageBitmap, HPoint2i, HInt32, HColor, HInt32]
     HFImageBitmapDrawCircle.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 190
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 230
 if _libs[_LIBRARY_FILENAME].has("HFImageBitmapGetData", "cdecl"):
     HFImageBitmapGetData = _libs[_LIBRARY_FILENAME].get("HFImageBitmapGetData", "cdecl")
     HFImageBitmapGetData.argtypes = [HFImageBitmap, PHFImageBitmapData]
     HFImageBitmapGetData.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 200
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 240
 if _libs[_LIBRARY_FILENAME].has("HFImageBitmapShow", "cdecl"):
     HFImageBitmapShow = _libs[_LIBRARY_FILENAME].get("HFImageBitmapShow", "cdecl")
     HFImageBitmapShow.argtypes = [HFImageBitmap, HString, HInt32]
     HFImageBitmapShow.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 214
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 254
 if _libs[_LIBRARY_FILENAME].has("HFLaunchInspireFace", "cdecl"):
     HFLaunchInspireFace = _libs[_LIBRARY_FILENAME].get("HFLaunchInspireFace", "cdecl")
     HFLaunchInspireFace.argtypes = [HPath]
     HFLaunchInspireFace.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 222
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 262
 if _libs[_LIBRARY_FILENAME].has("HFReloadInspireFace", "cdecl"):
     HFReloadInspireFace = _libs[_LIBRARY_FILENAME].get("HFReloadInspireFace", "cdecl")
     HFReloadInspireFace.argtypes = [HPath]
     HFReloadInspireFace.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 230
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 270
 if _libs[_LIBRARY_FILENAME].has("HFTerminateInspireFace", "cdecl"):
     HFTerminateInspireFace = _libs[_LIBRARY_FILENAME].get("HFTerminateInspireFace", "cdecl")
     HFTerminateInspireFace.argtypes = []
     HFTerminateInspireFace.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 238
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 278
 if _libs[_LIBRARY_FILENAME].has("HFQueryInspireFaceLaunchStatus", "cdecl"):
     HFQueryInspireFaceLaunchStatus = _libs[_LIBRARY_FILENAME].get("HFQueryInspireFaceLaunchStatus", "cdecl")
     HFQueryInspireFaceLaunchStatus.argtypes = [POINTER(HInt32)]
     HFQueryInspireFaceLaunchStatus.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 259
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 296
+if _libs[_LIBRARY_FILENAME].has("HFSetExpansiveHardwareRockchipDmaHeapPath", "cdecl"):
+    HFSetExpansiveHardwareRockchipDmaHeapPath = _libs[_LIBRARY_FILENAME].get("HFSetExpansiveHardwareRockchipDmaHeapPath", "cdecl")
+    HFSetExpansiveHardwareRockchipDmaHeapPath.argtypes = [HPath]
+    HFSetExpansiveHardwareRockchipDmaHeapPath.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 304
+if _libs[_LIBRARY_FILENAME].has("HFQueryExpansiveHardwareRockchipDmaHeapPath", "cdecl"):
+    HFQueryExpansiveHardwareRockchipDmaHeapPath = _libs[_LIBRARY_FILENAME].get("HFQueryExpansiveHardwareRockchipDmaHeapPath", "cdecl")
+    HFQueryExpansiveHardwareRockchipDmaHeapPath.argtypes = [HString]
+    HFQueryExpansiveHardwareRockchipDmaHeapPath.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 311
+if _libs[_LIBRARY_FILENAME].has("HFSetExpansiveHardwareAppleCoreMLModelPath", "cdecl"):
+    HFSetExpansiveHardwareAppleCoreMLModelPath = _libs[_LIBRARY_FILENAME].get("HFSetExpansiveHardwareAppleCoreMLModelPath", "cdecl")
+    HFSetExpansiveHardwareAppleCoreMLModelPath.argtypes = [HString]
+    HFSetExpansiveHardwareAppleCoreMLModelPath.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 319
+if _libs[_LIBRARY_FILENAME].has("HFQueryExpansiveHardwareAppleCoreMLModelPath", "cdecl"):
+    HFQueryExpansiveHardwareAppleCoreMLModelPath = _libs[_LIBRARY_FILENAME].get("HFQueryExpansiveHardwareAppleCoreMLModelPath", "cdecl")
+    HFQueryExpansiveHardwareAppleCoreMLModelPath.argtypes = [HString]
+    HFQueryExpansiveHardwareAppleCoreMLModelPath.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 341
 class struct_HFSessionCustomParameter(Structure):
     pass
 
@@ -1229,6 +1280,7 @@ class struct_HFSessionCustomParameter(Structure):
     'enable_face_quality',
     'enable_face_attribute',
     'enable_interaction_liveness',
+    'enable_detect_mode_landmark',
 ]
 struct_HFSessionCustomParameter._fields_ = [
     ('enable_recognition', HInt32),
@@ -1238,41 +1290,42 @@ class struct_HFSessionCustomParameter(Structure):
     ('enable_face_quality', HInt32),
     ('enable_face_attribute', HInt32),
     ('enable_interaction_liveness', HInt32),
+    ('enable_detect_mode_landmark', HInt32),
 ]
 
-HFSessionCustomParameter = struct_HFSessionCustomParameter# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 259
+HFSessionCustomParameter = struct_HFSessionCustomParameter# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 341
 
-PHFSessionCustomParameter = POINTER(struct_HFSessionCustomParameter)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 259
+PHFSessionCustomParameter = POINTER(struct_HFSessionCustomParameter)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 341
 
-enum_HFDetectMode = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 272
+enum_HFDetectMode = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 354
 
-HF_DETECT_MODE_ALWAYS_DETECT = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 272
+HF_DETECT_MODE_ALWAYS_DETECT = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 354
 
-HF_DETECT_MODE_LIGHT_TRACK = (HF_DETECT_MODE_ALWAYS_DETECT + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 272
+HF_DETECT_MODE_LIGHT_TRACK = (HF_DETECT_MODE_ALWAYS_DETECT + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 354
 
-HF_DETECT_MODE_TRACK_BY_DETECTION = (HF_DETECT_MODE_LIGHT_TRACK + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 272
+HF_DETECT_MODE_TRACK_BY_DETECTION = (HF_DETECT_MODE_LIGHT_TRACK + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 354
 
-HFDetectMode = enum_HFDetectMode# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 272
+HFDetectMode = enum_HFDetectMode# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 354
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 288
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 370
 if _libs[_LIBRARY_FILENAME].has("HFCreateInspireFaceSession", "cdecl"):
     HFCreateInspireFaceSession = _libs[_LIBRARY_FILENAME].get("HFCreateInspireFaceSession", "cdecl")
     HFCreateInspireFaceSession.argtypes = [HFSessionCustomParameter, HFDetectMode, HInt32, HInt32, HInt32, POINTER(HFSession)]
     HFCreateInspireFaceSession.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 305
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 387
 if _libs[_LIBRARY_FILENAME].has("HFCreateInspireFaceSessionOptional", "cdecl"):
     HFCreateInspireFaceSessionOptional = _libs[_LIBRARY_FILENAME].get("HFCreateInspireFaceSessionOptional", "cdecl")
     HFCreateInspireFaceSessionOptional.argtypes = [HOption, HFDetectMode, HInt32, HInt32, HInt32, POINTER(HFSession)]
     HFCreateInspireFaceSessionOptional.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 314
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 396
 if _libs[_LIBRARY_FILENAME].has("HFReleaseInspireFaceSession", "cdecl"):
     HFReleaseInspireFaceSession = _libs[_LIBRARY_FILENAME].get("HFReleaseInspireFaceSession", "cdecl")
     HFReleaseInspireFaceSession.argtypes = [HFSession]
     HFReleaseInspireFaceSession.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 324
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 406
 class struct_HFFaceBasicToken(Structure):
     pass
 
@@ -1285,11 +1338,11 @@ class struct_HFFaceBasicToken(Structure):
     ('data', HPVoid),
 ]
 
-HFFaceBasicToken = struct_HFFaceBasicToken# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 324
+HFFaceBasicToken = struct_HFFaceBasicToken# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 406
 
-PHFFaceBasicToken = POINTER(struct_HFFaceBasicToken)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 324
+PHFFaceBasicToken = POINTER(struct_HFFaceBasicToken)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 406
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 335
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 417
 class struct_HFFaceEulerAngle(Structure):
     pass
 
@@ -1304,9 +1357,9 @@ class struct_HFFaceEulerAngle(Structure):
     ('pitch', POINTER(HFloat)),
 ]
 
-HFFaceEulerAngle = struct_HFFaceEulerAngle# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 335
+HFFaceEulerAngle = struct_HFFaceEulerAngle# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 417
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 350
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 432
 class struct_HFMultipleFaceData(Structure):
     pass
 
@@ -1327,59 +1380,83 @@ class struct_HFMultipleFaceData(Structure):
     ('tokens', PHFFaceBasicToken),
 ]
 
-HFMultipleFaceData = struct_HFMultipleFaceData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 350
+HFMultipleFaceData = struct_HFMultipleFaceData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 432
 
-PHFMultipleFaceData = POINTER(struct_HFMultipleFaceData)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 350
+PHFMultipleFaceData = POINTER(struct_HFMultipleFaceData)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 432
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 360
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 442
 if _libs[_LIBRARY_FILENAME].has("HFSessionSetTrackPreviewSize", "cdecl"):
     HFSessionSetTrackPreviewSize = _libs[_LIBRARY_FILENAME].get("HFSessionSetTrackPreviewSize", "cdecl")
     HFSessionSetTrackPreviewSize.argtypes = [HFSession, HInt32]
     HFSessionSetTrackPreviewSize.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 370
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 452
 if _libs[_LIBRARY_FILENAME].has("HFSessionSetFilterMinimumFacePixelSize", "cdecl"):
     HFSessionSetFilterMinimumFacePixelSize = _libs[_LIBRARY_FILENAME].get("HFSessionSetFilterMinimumFacePixelSize", "cdecl")
     HFSessionSetFilterMinimumFacePixelSize.argtypes = [HFSession, HInt32]
     HFSessionSetFilterMinimumFacePixelSize.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 379
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 461
 if _libs[_LIBRARY_FILENAME].has("HFSessionSetFaceDetectThreshold", "cdecl"):
     HFSessionSetFaceDetectThreshold = _libs[_LIBRARY_FILENAME].get("HFSessionSetFaceDetectThreshold", "cdecl")
     HFSessionSetFaceDetectThreshold.argtypes = [HFSession, HFloat]
     HFSessionSetFaceDetectThreshold.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 389
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 470
+if _libs[_LIBRARY_FILENAME].has("HFSessionSetTrackModeSmoothRatio", "cdecl"):
+    HFSessionSetTrackModeSmoothRatio = _libs[_LIBRARY_FILENAME].get("HFSessionSetTrackModeSmoothRatio", "cdecl")
+    HFSessionSetTrackModeSmoothRatio.argtypes = [HFSession, HFloat]
+    HFSessionSetTrackModeSmoothRatio.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 479
+if _libs[_LIBRARY_FILENAME].has("HFSessionSetTrackModeNumSmoothCacheFrame", "cdecl"):
+    HFSessionSetTrackModeNumSmoothCacheFrame = _libs[_LIBRARY_FILENAME].get("HFSessionSetTrackModeNumSmoothCacheFrame", "cdecl")
+    HFSessionSetTrackModeNumSmoothCacheFrame.argtypes = [HFSession, HInt32]
+    HFSessionSetTrackModeNumSmoothCacheFrame.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 488
+if _libs[_LIBRARY_FILENAME].has("HFSessionSetTrackModeDetectInterval", "cdecl"):
+    HFSessionSetTrackModeDetectInterval = _libs[_LIBRARY_FILENAME].get("HFSessionSetTrackModeDetectInterval", "cdecl")
+    HFSessionSetTrackModeDetectInterval.argtypes = [HFSession, HInt32]
+    HFSessionSetTrackModeDetectInterval.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 498
 if _libs[_LIBRARY_FILENAME].has("HFExecuteFaceTrack", "cdecl"):
     HFExecuteFaceTrack = _libs[_LIBRARY_FILENAME].get("HFExecuteFaceTrack", "cdecl")
     HFExecuteFaceTrack.argtypes = [HFSession, HFImageStream, PHFMultipleFaceData]
     HFExecuteFaceTrack.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 406
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 515
 if _libs[_LIBRARY_FILENAME].has("HFCopyFaceBasicToken", "cdecl"):
     HFCopyFaceBasicToken = _libs[_LIBRARY_FILENAME].get("HFCopyFaceBasicToken", "cdecl")
     HFCopyFaceBasicToken.argtypes = [HFFaceBasicToken, HPBuffer, HInt32]
     HFCopyFaceBasicToken.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 420
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 529
 if _libs[_LIBRARY_FILENAME].has("HFGetFaceBasicTokenSize", "cdecl"):
     HFGetFaceBasicTokenSize = _libs[_LIBRARY_FILENAME].get("HFGetFaceBasicTokenSize", "cdecl")
     HFGetFaceBasicTokenSize.argtypes = [HPInt32]
     HFGetFaceBasicTokenSize.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 427
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 536
 if _libs[_LIBRARY_FILENAME].has("HFGetNumOfFaceDenseLandmark", "cdecl"):
     HFGetNumOfFaceDenseLandmark = _libs[_LIBRARY_FILENAME].get("HFGetNumOfFaceDenseLandmark", "cdecl")
     HFGetNumOfFaceDenseLandmark.argtypes = [HPInt32]
     HFGetNumOfFaceDenseLandmark.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 437
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 546
 if _libs[_LIBRARY_FILENAME].has("HFGetFaceDenseLandmarkFromFaceToken", "cdecl"):
     HFGetFaceDenseLandmarkFromFaceToken = _libs[_LIBRARY_FILENAME].get("HFGetFaceDenseLandmarkFromFaceToken", "cdecl")
     HFGetFaceDenseLandmarkFromFaceToken.argtypes = [HFFaceBasicToken, POINTER(HPoint2f), HInt32]
     HFGetFaceDenseLandmarkFromFaceToken.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 451
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 555
+if _libs[_LIBRARY_FILENAME].has("HFGetFaceFiveKeyPointsFromFaceToken", "cdecl"):
+    HFGetFaceFiveKeyPointsFromFaceToken = _libs[_LIBRARY_FILENAME].get("HFGetFaceFiveKeyPointsFromFaceToken", "cdecl")
+    HFGetFaceFiveKeyPointsFromFaceToken.argtypes = [HFFaceBasicToken, POINTER(HPoint2f), HInt32]
+    HFGetFaceFiveKeyPointsFromFaceToken.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 569
 class struct_HFFaceFeature(Structure):
     pass
 
@@ -1392,45 +1469,45 @@ class struct_HFFaceFeature(Structure):
     ('data', HPFloat),
 ]
 
-HFFaceFeature = struct_HFFaceFeature# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 451
+HFFaceFeature = struct_HFFaceFeature# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 569
 
-PHFFaceFeature = POINTER(struct_HFFaceFeature)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 451
+PHFFaceFeature = POINTER(struct_HFFaceFeature)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 569
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 462
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 580
 if _libs[_LIBRARY_FILENAME].has("HFFaceFeatureExtract", "cdecl"):
     HFFaceFeatureExtract = _libs[_LIBRARY_FILENAME].get("HFFaceFeatureExtract", "cdecl")
     HFFaceFeatureExtract.argtypes = [HFSession, HFImageStream, HFFaceBasicToken, PHFFaceFeature]
     HFFaceFeatureExtract.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 474
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 592
 if _libs[_LIBRARY_FILENAME].has("HFFaceFeatureExtractCpy", "cdecl"):
     HFFaceFeatureExtractCpy = _libs[_LIBRARY_FILENAME].get("HFFaceFeatureExtractCpy", "cdecl")
     HFFaceFeatureExtractCpy.argtypes = [HFSession, HFImageStream, HFFaceBasicToken, HPFloat]
     HFFaceFeatureExtractCpy.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 484
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 602
 if _libs[_LIBRARY_FILENAME].has("HFFaceGetFaceAlignmentImage", "cdecl"):
     HFFaceGetFaceAlignmentImage = _libs[_LIBRARY_FILENAME].get("HFFaceGetFaceAlignmentImage", "cdecl")
     HFFaceGetFaceAlignmentImage.argtypes = [HFSession, HFImageStream, HFFaceBasicToken, POINTER(HFImageBitmap)]
     HFFaceGetFaceAlignmentImage.restype = HResult
 
-enum_HFSearchMode = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 498
+enum_HFSearchMode = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 616
 
-HF_SEARCH_MODE_EAGER = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 498
+HF_SEARCH_MODE_EAGER = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 616
 
-HF_SEARCH_MODE_EXHAUSTIVE = (HF_SEARCH_MODE_EAGER + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 498
+HF_SEARCH_MODE_EXHAUSTIVE = (HF_SEARCH_MODE_EAGER + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 616
 
-HFSearchMode = enum_HFSearchMode# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 498
+HFSearchMode = enum_HFSearchMode# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 616
 
-enum_HFPKMode = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 506
+enum_HFPKMode = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 624
 
-HF_PK_AUTO_INCREMENT = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 506
+HF_PK_AUTO_INCREMENT = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 624
 
-HF_PK_MANUAL_INPUT = (HF_PK_AUTO_INCREMENT + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 506
+HF_PK_MANUAL_INPUT = (HF_PK_AUTO_INCREMENT + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 624
 
-HFPKMode = enum_HFPKMode# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 506
+HFPKMode = enum_HFPKMode# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 624
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 519
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 637
 class struct_HFFeatureHubConfiguration(Structure):
     pass
 
@@ -1449,21 +1526,21 @@ class struct_HFFeatureHubConfiguration(Structure):
     ('searchMode', HFSearchMode),
 ]
 
-HFFeatureHubConfiguration = struct_HFFeatureHubConfiguration# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 519
+HFFeatureHubConfiguration = struct_HFFeatureHubConfiguration# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 637
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 531
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 649
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubDataEnable", "cdecl"):
     HFFeatureHubDataEnable = _libs[_LIBRARY_FILENAME].get("HFFeatureHubDataEnable", "cdecl")
     HFFeatureHubDataEnable.argtypes = [HFFeatureHubConfiguration]
     HFFeatureHubDataEnable.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 537
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 655
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubDataDisable", "cdecl"):
     HFFeatureHubDataDisable = _libs[_LIBRARY_FILENAME].get("HFFeatureHubDataDisable", "cdecl")
     HFFeatureHubDataDisable.argtypes = []
     HFFeatureHubDataDisable.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 548
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 666
 class struct_HFFaceFeatureIdentity(Structure):
     pass
 
@@ -1476,11 +1553,11 @@ class struct_HFFaceFeatureIdentity(Structure):
     ('feature', PHFFaceFeature),
 ]
 
-HFFaceFeatureIdentity = struct_HFFaceFeatureIdentity# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 548
+HFFaceFeatureIdentity = struct_HFFaceFeatureIdentity# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 666
 
-PHFFaceFeatureIdentity = POINTER(struct_HFFaceFeatureIdentity)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 548
+PHFFaceFeatureIdentity = POINTER(struct_HFFaceFeatureIdentity)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 666
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 557
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 675
 class struct_HFSearchTopKResults(Structure):
     pass
 
@@ -1495,77 +1572,124 @@ class struct_HFSearchTopKResults(Structure):
     ('ids', HPFaceId),
 ]
 
-HFSearchTopKResults = struct_HFSearchTopKResults# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 557
+HFSearchTopKResults = struct_HFSearchTopKResults# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 675
 
-PHFSearchTopKResults = POINTER(struct_HFSearchTopKResults)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 557
+PHFSearchTopKResults = POINTER(struct_HFSearchTopKResults)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 675
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 569
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 687
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubFaceSearchThresholdSetting", "cdecl"):
     HFFeatureHubFaceSearchThresholdSetting = _libs[_LIBRARY_FILENAME].get("HFFeatureHubFaceSearchThresholdSetting", "cdecl")
     HFFeatureHubFaceSearchThresholdSetting.argtypes = [c_float]
     HFFeatureHubFaceSearchThresholdSetting.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 580
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 702
 if _libs[_LIBRARY_FILENAME].has("HFFaceComparison", "cdecl"):
     HFFaceComparison = _libs[_LIBRARY_FILENAME].get("HFFaceComparison", "cdecl")
     HFFaceComparison.argtypes = [HFFaceFeature, HFFaceFeature, HPFloat]
     HFFaceComparison.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 588
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 708
+if _libs[_LIBRARY_FILENAME].has("HFGetRecommendedCosineThreshold", "cdecl"):
+    HFGetRecommendedCosineThreshold = _libs[_LIBRARY_FILENAME].get("HFGetRecommendedCosineThreshold", "cdecl")
+    HFGetRecommendedCosineThreshold.argtypes = [HPFloat]
+    HFGetRecommendedCosineThreshold.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 720
+if _libs[_LIBRARY_FILENAME].has("HFCosineSimilarityConvertToPercentage", "cdecl"):
+    HFCosineSimilarityConvertToPercentage = _libs[_LIBRARY_FILENAME].get("HFCosineSimilarityConvertToPercentage", "cdecl")
+    HFCosineSimilarityConvertToPercentage.argtypes = [HFloat, HPFloat]
+    HFCosineSimilarityConvertToPercentage.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 733
+class struct_HFSimilarityConverterConfig(Structure):
+    pass
+
+struct_HFSimilarityConverterConfig.__slots__ = [
+    'threshold',
+    'middleScore',
+    'steepness',
+    'outputMin',
+    'outputMax',
+]
+struct_HFSimilarityConverterConfig._fields_ = [
+    ('threshold', HFloat),
+    ('middleScore', HFloat),
+    ('steepness', HFloat),
+    ('outputMin', HFloat),
+    ('outputMax', HFloat),
+]
+
+HFSimilarityConverterConfig = struct_HFSimilarityConverterConfig# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 733
+
+PHFSimilarityConverterConfig = POINTER(struct_HFSimilarityConverterConfig)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 733
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 742
+if _libs[_LIBRARY_FILENAME].has("HFUpdateCosineSimilarityConverter", "cdecl"):
+    HFUpdateCosineSimilarityConverter = _libs[_LIBRARY_FILENAME].get("HFUpdateCosineSimilarityConverter", "cdecl")
+    HFUpdateCosineSimilarityConverter.argtypes = [HFSimilarityConverterConfig]
+    HFUpdateCosineSimilarityConverter.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 749
+if _libs[_LIBRARY_FILENAME].has("HFGetCosineSimilarityConverter", "cdecl"):
+    HFGetCosineSimilarityConverter = _libs[_LIBRARY_FILENAME].get("HFGetCosineSimilarityConverter", "cdecl")
+    HFGetCosineSimilarityConverter.argtypes = [PHFSimilarityConverterConfig]
+    HFGetCosineSimilarityConverter.restype = HResult
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 757
 if _libs[_LIBRARY_FILENAME].has("HFGetFeatureLength", "cdecl"):
     HFGetFeatureLength = _libs[_LIBRARY_FILENAME].get("HFGetFeatureLength", "cdecl")
     HFGetFeatureLength.argtypes = [HPInt32]
     HFGetFeatureLength.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 596
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 765
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubInsertFeature", "cdecl"):
     HFFeatureHubInsertFeature = _libs[_LIBRARY_FILENAME].get("HFFeatureHubInsertFeature", "cdecl")
     HFFeatureHubInsertFeature.argtypes = [HFFaceFeatureIdentity, HPFaceId]
     HFFeatureHubInsertFeature.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 607
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 776
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubFaceSearch", "cdecl"):
     HFFeatureHubFaceSearch = _libs[_LIBRARY_FILENAME].get("HFFeatureHubFaceSearch", "cdecl")
     HFFeatureHubFaceSearch.argtypes = [HFFaceFeature, HPFloat, PHFFaceFeatureIdentity]
     HFFeatureHubFaceSearch.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 617
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 786
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubFaceSearchTopK", "cdecl"):
     HFFeatureHubFaceSearchTopK = _libs[_LIBRARY_FILENAME].get("HFFeatureHubFaceSearchTopK", "cdecl")
     HFFeatureHubFaceSearchTopK.argtypes = [HFFaceFeature, HInt32, PHFSearchTopKResults]
     HFFeatureHubFaceSearchTopK.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 625
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 794
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubFaceRemove", "cdecl"):
     HFFeatureHubFaceRemove = _libs[_LIBRARY_FILENAME].get("HFFeatureHubFaceRemove", "cdecl")
     HFFeatureHubFaceRemove.argtypes = [HFaceId]
     HFFeatureHubFaceRemove.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 633
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 802
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubFaceUpdate", "cdecl"):
     HFFeatureHubFaceUpdate = _libs[_LIBRARY_FILENAME].get("HFFeatureHubFaceUpdate", "cdecl")
     HFFeatureHubFaceUpdate.argtypes = [HFFaceFeatureIdentity]
     HFFeatureHubFaceUpdate.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 642
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 811
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubGetFaceIdentity", "cdecl"):
     HFFeatureHubGetFaceIdentity = _libs[_LIBRARY_FILENAME].get("HFFeatureHubGetFaceIdentity", "cdecl")
     HFFeatureHubGetFaceIdentity.argtypes = [HFaceId, PHFFaceFeatureIdentity]
     HFFeatureHubGetFaceIdentity.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 650
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 819
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubGetFaceCount", "cdecl"):
     HFFeatureHubGetFaceCount = _libs[_LIBRARY_FILENAME].get("HFFeatureHubGetFaceCount", "cdecl")
     HFFeatureHubGetFaceCount.argtypes = [POINTER(HInt32)]
     HFFeatureHubGetFaceCount.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 657
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 826
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubViewDBTable", "cdecl"):
     HFFeatureHubViewDBTable = _libs[_LIBRARY_FILENAME].get("HFFeatureHubViewDBTable", "cdecl")
     HFFeatureHubViewDBTable.argtypes = []
     HFFeatureHubViewDBTable.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 665
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 834
 class struct_HFFeatureHubExistingIds(Structure):
     pass
 
@@ -1578,29 +1702,29 @@ class struct_HFFeatureHubExistingIds(Structure):
     ('ids', HPFaceId),
 ]
 
-HFFeatureHubExistingIds = struct_HFFeatureHubExistingIds# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 665
+HFFeatureHubExistingIds = struct_HFFeatureHubExistingIds# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 834
 
-PHFFeatureHubExistingIds = POINTER(struct_HFFeatureHubExistingIds)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 665
+PHFFeatureHubExistingIds = POINTER(struct_HFFeatureHubExistingIds)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 834
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 672
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 841
 if _libs[_LIBRARY_FILENAME].has("HFFeatureHubGetExistingIds", "cdecl"):
     HFFeatureHubGetExistingIds = _libs[_LIBRARY_FILENAME].get("HFFeatureHubGetExistingIds", "cdecl")
     HFFeatureHubGetExistingIds.argtypes = [PHFFeatureHubExistingIds]
     HFFeatureHubGetExistingIds.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 690
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 859
 if _libs[_LIBRARY_FILENAME].has("HFMultipleFacePipelineProcess", "cdecl"):
     HFMultipleFacePipelineProcess = _libs[_LIBRARY_FILENAME].get("HFMultipleFacePipelineProcess", "cdecl")
     HFMultipleFacePipelineProcess.argtypes = [HFSession, HFImageStream, PHFMultipleFaceData, HFSessionCustomParameter]
     HFMultipleFacePipelineProcess.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 705
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 874
 if _libs[_LIBRARY_FILENAME].has("HFMultipleFacePipelineProcessOptional", "cdecl"):
     HFMultipleFacePipelineProcessOptional = _libs[_LIBRARY_FILENAME].get("HFMultipleFacePipelineProcessOptional", "cdecl")
     HFMultipleFacePipelineProcessOptional.argtypes = [HFSession, HFImageStream, PHFMultipleFaceData, HInt32]
     HFMultipleFacePipelineProcessOptional.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 717
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 886
 class struct_HFRGBLivenessConfidence(Structure):
     pass
 
@@ -1613,17 +1737,17 @@ class struct_HFRGBLivenessConfidence(Structure):
     ('confidence', HPFloat),
 ]
 
-HFRGBLivenessConfidence = struct_HFRGBLivenessConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 717
+HFRGBLivenessConfidence = struct_HFRGBLivenessConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 886
 
-PHFRGBLivenessConfidence = POINTER(struct_HFRGBLivenessConfidence)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 717
+PHFRGBLivenessConfidence = POINTER(struct_HFRGBLivenessConfidence)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 886
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 729
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 898
 if _libs[_LIBRARY_FILENAME].has("HFGetRGBLivenessConfidence", "cdecl"):
     HFGetRGBLivenessConfidence = _libs[_LIBRARY_FILENAME].get("HFGetRGBLivenessConfidence", "cdecl")
     HFGetRGBLivenessConfidence.argtypes = [HFSession, PHFRGBLivenessConfidence]
     HFGetRGBLivenessConfidence.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 740
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 909
 class struct_HFFaceMaskConfidence(Structure):
     pass
 
@@ -1636,17 +1760,17 @@ class struct_HFFaceMaskConfidence(Structure):
     ('confidence', HPFloat),
 ]
 
-HFFaceMaskConfidence = struct_HFFaceMaskConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 740
+HFFaceMaskConfidence = struct_HFFaceMaskConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 909
 
-PHFFaceMaskConfidence = POINTER(struct_HFFaceMaskConfidence)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 740
+PHFFaceMaskConfidence = POINTER(struct_HFFaceMaskConfidence)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 909
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 752
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 921
 if _libs[_LIBRARY_FILENAME].has("HFGetFaceMaskConfidence", "cdecl"):
     HFGetFaceMaskConfidence = _libs[_LIBRARY_FILENAME].get("HFGetFaceMaskConfidence", "cdecl")
     HFGetFaceMaskConfidence.argtypes = [HFSession, PHFFaceMaskConfidence]
     HFGetFaceMaskConfidence.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 763
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 932
 class struct_HFFaceQualityConfidence(Structure):
     pass
 
@@ -1659,23 +1783,23 @@ class struct_HFFaceQualityConfidence(Structure):
     ('confidence', HPFloat),
 ]
 
-HFFaceQualityConfidence = struct_HFFaceQualityConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 763
+HFFaceQualityConfidence = struct_HFFaceQualityConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 932
 
-PHFFaceQualityConfidence = POINTER(struct_HFFaceQualityConfidence)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 763
+PHFFaceQualityConfidence = POINTER(struct_HFFaceQualityConfidence)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 932
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 775
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 944
 if _libs[_LIBRARY_FILENAME].has("HFGetFaceQualityConfidence", "cdecl"):
     HFGetFaceQualityConfidence = _libs[_LIBRARY_FILENAME].get("HFGetFaceQualityConfidence", "cdecl")
     HFGetFaceQualityConfidence.argtypes = [HFSession, PHFFaceQualityConfidence]
     HFGetFaceQualityConfidence.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 787
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 956
 if _libs[_LIBRARY_FILENAME].has("HFFaceQualityDetect", "cdecl"):
     HFFaceQualityDetect = _libs[_LIBRARY_FILENAME].get("HFFaceQualityDetect", "cdecl")
     HFFaceQualityDetect.argtypes = [HFSession, HFFaceBasicToken, POINTER(HFloat)]
     HFFaceQualityDetect.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 798
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 967
 class struct_HFFaceInteractionState(Structure):
     pass
 
@@ -1690,17 +1814,17 @@ class struct_HFFaceInteractionState(Structure):
     ('rightEyeStatusConfidence', HPFloat),
 ]
 
-HFFaceInteractionState = struct_HFFaceInteractionState# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 798
+HFFaceInteractionState = struct_HFFaceInteractionState# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 967
 
-PHFFaceInteractionState = POINTER(struct_HFFaceInteractionState)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 798
+PHFFaceInteractionState = POINTER(struct_HFFaceInteractionState)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 967
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 805
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 974
 if _libs[_LIBRARY_FILENAME].has("HFGetFaceInteractionStateResult", "cdecl"):
     HFGetFaceInteractionStateResult = _libs[_LIBRARY_FILENAME].get("HFGetFaceInteractionStateResult", "cdecl")
     HFGetFaceInteractionStateResult.argtypes = [HFSession, PHFFaceInteractionState]
     HFGetFaceInteractionStateResult.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 817
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 986
 class struct_HFFaceInteractionsActions(Structure):
     pass
 
@@ -1721,17 +1845,17 @@ class struct_HFFaceInteractionsActions(Structure):
     ('blink', HPInt32),
 ]
 
-HFFaceInteractionsActions = struct_HFFaceInteractionsActions# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 817
+HFFaceInteractionsActions = struct_HFFaceInteractionsActions# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 986
 
-PHFFaceInteractionsActions = POINTER(struct_HFFaceInteractionsActions)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 817
+PHFFaceInteractionsActions = POINTER(struct_HFFaceInteractionsActions)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 986
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 825
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 994
 if _libs[_LIBRARY_FILENAME].has("HFGetFaceInteractionActionsResult", "cdecl"):
     HFGetFaceInteractionActionsResult = _libs[_LIBRARY_FILENAME].get("HFGetFaceInteractionActionsResult", "cdecl")
     HFGetFaceInteractionActionsResult.argtypes = [HFSession, PHFFaceInteractionsActions]
     HFGetFaceInteractionActionsResult.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 852
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1021
 class struct_HFFaceAttributeResult(Structure):
     pass
 
@@ -1748,17 +1872,17 @@ class struct_HFFaceAttributeResult(Structure):
     ('ageBracket', HPInt32),
 ]
 
-HFFaceAttributeResult = struct_HFFaceAttributeResult# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 852
+HFFaceAttributeResult = struct_HFFaceAttributeResult# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1021
 
-PHFFaceAttributeResult = POINTER(struct_HFFaceAttributeResult)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 852
+PHFFaceAttributeResult = POINTER(struct_HFFaceAttributeResult)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1021
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 864
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1033
 if _libs[_LIBRARY_FILENAME].has("HFGetFaceAttributeResult", "cdecl"):
     HFGetFaceAttributeResult = _libs[_LIBRARY_FILENAME].get("HFGetFaceAttributeResult", "cdecl")
     HFGetFaceAttributeResult.argtypes = [HFSession, PHFFaceAttributeResult]
     HFGetFaceAttributeResult.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 877
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1046
 class struct_HFInspireFaceVersion(Structure):
     pass
 
@@ -1773,17 +1897,17 @@ class struct_HFInspireFaceVersion(Structure):
     ('patch', c_int),
 ]
 
-HFInspireFaceVersion = struct_HFInspireFaceVersion# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 877
+HFInspireFaceVersion = struct_HFInspireFaceVersion# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1046
 
-PHFInspireFaceVersion = POINTER(struct_HFInspireFaceVersion)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 877
+PHFInspireFaceVersion = POINTER(struct_HFInspireFaceVersion)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1046
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 887
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1056
 if _libs[_LIBRARY_FILENAME].has("HFQueryInspireFaceVersion", "cdecl"):
     HFQueryInspireFaceVersion = _libs[_LIBRARY_FILENAME].get("HFQueryInspireFaceVersion", "cdecl")
     HFQueryInspireFaceVersion.argtypes = [PHFInspireFaceVersion]
     HFQueryInspireFaceVersion.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 895
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1064
 class struct_HFInspireFaceExtendedInformation(Structure):
     pass
 
@@ -1794,81 +1918,89 @@ class struct_HFInspireFaceExtendedInformation(Structure):
     ('information', HChar * int(256)),
 ]
 
-HFInspireFaceExtendedInformation = struct_HFInspireFaceExtendedInformation# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 895
+HFInspireFaceExtendedInformation = struct_HFInspireFaceExtendedInformation# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1064
 
-PHFInspireFaceExtendedInformation = POINTER(struct_HFInspireFaceExtendedInformation)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 895
+PHFInspireFaceExtendedInformation = POINTER(struct_HFInspireFaceExtendedInformation)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1064
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 902
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1071
 if _libs[_LIBRARY_FILENAME].has("HFQueryInspireFaceExtendedInformation", "cdecl"):
     HFQueryInspireFaceExtendedInformation = _libs[_LIBRARY_FILENAME].get("HFQueryInspireFaceExtendedInformation", "cdecl")
     HFQueryInspireFaceExtendedInformation.argtypes = [PHFInspireFaceExtendedInformation]
     HFQueryInspireFaceExtendedInformation.restype = HResult
 
-enum_HFLogLevel = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 914
+enum_HFLogLevel = c_int# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1083
 
-HF_LOG_NONE = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 914
+HF_LOG_NONE = 0# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1083
 
-HF_LOG_DEBUG = (HF_LOG_NONE + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 914
+HF_LOG_DEBUG = (HF_LOG_NONE + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1083
 
-HF_LOG_INFO = (HF_LOG_DEBUG + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 914
+HF_LOG_INFO = (HF_LOG_DEBUG + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1083
 
-HF_LOG_WARN = (HF_LOG_INFO + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 914
+HF_LOG_WARN = (HF_LOG_INFO + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1083
 
-HF_LOG_ERROR = (HF_LOG_WARN + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 914
+HF_LOG_ERROR = (HF_LOG_WARN + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1083
 
-HF_LOG_FATAL = (HF_LOG_ERROR + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 914
+HF_LOG_FATAL = (HF_LOG_ERROR + 1)# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1083
 
-HFLogLevel = enum_HFLogLevel# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 914
+HFLogLevel = enum_HFLogLevel# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1083
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 919
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1088
 if _libs[_LIBRARY_FILENAME].has("HFSetLogLevel", "cdecl"):
     HFSetLogLevel = _libs[_LIBRARY_FILENAME].get("HFSetLogLevel", "cdecl")
     HFSetLogLevel.argtypes = [HFLogLevel]
     HFSetLogLevel.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 924
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1093
 if _libs[_LIBRARY_FILENAME].has("HFLogDisable", "cdecl"):
     HFLogDisable = _libs[_LIBRARY_FILENAME].get("HFLogDisable", "cdecl")
     HFLogDisable.argtypes = []
     HFLogDisable.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 937
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1103
+if _libs[_LIBRARY_FILENAME].has("HFLogPrint", "cdecl"):
+    _func = _libs[_LIBRARY_FILENAME].get("HFLogPrint", "cdecl")
+    _restype = HResult
+    _errcheck = None
+    _argtypes = [HFLogLevel, HFormat]
+    HFLogPrint = _variadic_function(_func,_restype,_argtypes,_errcheck)
+
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1116
 if _libs[_LIBRARY_FILENAME].has("HFDeBugImageStreamImShow", "cdecl"):
     HFDeBugImageStreamImShow = _libs[_LIBRARY_FILENAME].get("HFDeBugImageStreamImShow", "cdecl")
     HFDeBugImageStreamImShow.argtypes = [HFImageStream]
     HFDeBugImageStreamImShow.restype = None
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 949
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1128
 if _libs[_LIBRARY_FILENAME].has("HFDeBugImageStreamDecodeSave", "cdecl"):
     HFDeBugImageStreamDecodeSave = _libs[_LIBRARY_FILENAME].get("HFDeBugImageStreamDecodeSave", "cdecl")
     HFDeBugImageStreamDecodeSave.argtypes = [HFImageStream, HPath]
     HFDeBugImageStreamDecodeSave.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 964
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1143
 if _libs[_LIBRARY_FILENAME].has("HFDeBugShowResourceStatistics", "cdecl"):
     HFDeBugShowResourceStatistics = _libs[_LIBRARY_FILENAME].get("HFDeBugShowResourceStatistics", "cdecl")
     HFDeBugShowResourceStatistics.argtypes = []
     HFDeBugShowResourceStatistics.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 974
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1153
 if _libs[_LIBRARY_FILENAME].has("HFDeBugGetUnreleasedSessionsCount", "cdecl"):
     HFDeBugGetUnreleasedSessionsCount = _libs[_LIBRARY_FILENAME].get("HFDeBugGetUnreleasedSessionsCount", "cdecl")
     HFDeBugGetUnreleasedSessionsCount.argtypes = [POINTER(HInt32)]
     HFDeBugGetUnreleasedSessionsCount.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 985
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1164
 if _libs[_LIBRARY_FILENAME].has("HFDeBugGetUnreleasedSessions", "cdecl"):
     HFDeBugGetUnreleasedSessions = _libs[_LIBRARY_FILENAME].get("HFDeBugGetUnreleasedSessions", "cdecl")
     HFDeBugGetUnreleasedSessions.argtypes = [POINTER(HFSession), HInt32]
     HFDeBugGetUnreleasedSessions.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 995
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1174
 if _libs[_LIBRARY_FILENAME].has("HFDeBugGetUnreleasedStreamsCount", "cdecl"):
     HFDeBugGetUnreleasedStreamsCount = _libs[_LIBRARY_FILENAME].get("HFDeBugGetUnreleasedStreamsCount", "cdecl")
     HFDeBugGetUnreleasedStreamsCount.argtypes = [POINTER(HInt32)]
     HFDeBugGetUnreleasedStreamsCount.restype = HResult
 
-# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1006
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1185
 if _libs[_LIBRARY_FILENAME].has("HFDeBugGetUnreleasedStreams", "cdecl"):
     HFDeBugGetUnreleasedStreams = _libs[_LIBRARY_FILENAME].get("HFDeBugGetUnreleasedStreams", "cdecl")
     HFDeBugGetUnreleasedStreams.argtypes = [POINTER(HFImageStream), HInt32]
@@ -1928,43 +2060,51 @@ class struct_HFInspireFaceExtendedInformation(Structure):
 except:
     pass
 
-HFImageData = struct_HFImageData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 71
+# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 36
+try:
+    HF_ENABLE_DETECT_MODE_LANDMARK = 0x00000200
+except:
+    pass
+
+HFImageData = struct_HFImageData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 72
+
+HFImageBitmapData = struct_HFImageBitmapData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 142
 
-HFImageBitmapData = struct_HFImageBitmapData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 102
+HFSessionCustomParameter = struct_HFSessionCustomParameter# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 341
 
-HFSessionCustomParameter = struct_HFSessionCustomParameter# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 259
+HFFaceBasicToken = struct_HFFaceBasicToken# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 406
 
-HFFaceBasicToken = struct_HFFaceBasicToken# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 324
+HFFaceEulerAngle = struct_HFFaceEulerAngle# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 417
 
-HFFaceEulerAngle = struct_HFFaceEulerAngle# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 335
+HFMultipleFaceData = struct_HFMultipleFaceData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 432
 
-HFMultipleFaceData = struct_HFMultipleFaceData# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 350
+HFFaceFeature = struct_HFFaceFeature# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 569
 
-HFFaceFeature = struct_HFFaceFeature# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 451
+HFFeatureHubConfiguration = struct_HFFeatureHubConfiguration# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 637
 
-HFFeatureHubConfiguration = struct_HFFeatureHubConfiguration# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 519
+HFFaceFeatureIdentity = struct_HFFaceFeatureIdentity# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 666
 
-HFFaceFeatureIdentity = struct_HFFaceFeatureIdentity# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 548
+HFSearchTopKResults = struct_HFSearchTopKResults# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 675
 
-HFSearchTopKResults = struct_HFSearchTopKResults# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 557
+HFSimilarityConverterConfig = struct_HFSimilarityConverterConfig# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 733
 
-HFFeatureHubExistingIds = struct_HFFeatureHubExistingIds# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 665
+HFFeatureHubExistingIds = struct_HFFeatureHubExistingIds# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 834
 
-HFRGBLivenessConfidence = struct_HFRGBLivenessConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 717
+HFRGBLivenessConfidence = struct_HFRGBLivenessConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 886
 
-HFFaceMaskConfidence = struct_HFFaceMaskConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 740
+HFFaceMaskConfidence = struct_HFFaceMaskConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 909
 
-HFFaceQualityConfidence = struct_HFFaceQualityConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 763
+HFFaceQualityConfidence = struct_HFFaceQualityConfidence# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 932
 
-HFFaceInteractionState = struct_HFFaceInteractionState# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 798
+HFFaceInteractionState = struct_HFFaceInteractionState# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 967
 
-HFFaceInteractionsActions = struct_HFFaceInteractionsActions# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 817
+HFFaceInteractionsActions = struct_HFFaceInteractionsActions# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 986
 
-HFFaceAttributeResult = struct_HFFaceAttributeResult# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 852
+HFFaceAttributeResult = struct_HFFaceAttributeResult# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1021
 
-HFInspireFaceVersion = struct_HFInspireFaceVersion# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 877
+HFInspireFaceVersion = struct_HFInspireFaceVersion# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1046
 
-HFInspireFaceExtendedInformation = struct_HFInspireFaceExtendedInformation# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 895
+HFInspireFaceExtendedInformation = struct_HFInspireFaceExtendedInformation# /Users/tunm/work/InspireFace/cpp/inspireface/c_api/inspireface.h: 1064
 
 # No inserted files
 
diff --git a/python/inspireface/modules/inspireface.py b/python/inspireface/modules/inspireface.py
index 12a63858..cd3c835d 100644
--- a/python/inspireface/modules/inspireface.py
+++ b/python/inspireface/modules/inspireface.py
@@ -384,6 +384,21 @@ def set_filter_minimum_face_pixel_size(self, min_size=32):
         if ret != 0:
             logger.error(f"Set filter minimum face pixel size error: {ret}")
 
+    def set_track_mode_smooth_ratio(self, ratio=0.025):
+        ret = HFSessionSetTrackModeSmoothRatio(self._sess, ratio)
+        if ret != 0:
+            logger.error(f"Set track mode smooth ratio error: {ret}")
+
+    def set_track_mode_num_smooth_cache_frame(self, num=15):
+        ret = HFSessionSetTrackModeNumSmoothCacheFrame(self._sess, num)
+        if ret != 0:
+            logger.error(f"Set track mode num smooth cache frame error: {ret}")
+
+    def set_track_model_detect_interval(self, num=20):
+        ret = HFSessionSetTrackModeDetectInterval(self._sess, num)
+        if ret != 0:
+            logger.error(f"Set track model detect interval error: {ret}")
+
     def face_pipeline(self, image, faces: List[FaceInformation], exec_param) -> List[FaceExtended]:
         """
         Processes detected faces to extract additional attributes based on the provided execution parameters.
@@ -604,6 +619,11 @@ def launch(model_name: str = "Pikachu", resource_path: str = None) -> bool:
             return False
     return True
 
+def pull_latest_model(model_name: str = "Pikachu") -> str:
+    sm = ResourceManager()
+    resource_path = sm.get_model(model_name, re_download=True)
+    return resource_path
+
 def reload(model_name: str = "Pikachu", resource_path: str = None) -> bool:
     if resource_path is None:
         sm = ResourceManager()
@@ -999,6 +1019,52 @@ def view_table_in_terminal():
     if ret != 0:
         logger.error(f"Failed to view DB: {ret}")
 
+def get_recommended_cosine_threshold() -> float:
+    """
+    Retrieves the recommended cosine threshold.
+    """
+    threshold = HFloat()
+    HFGetRecommendedCosineThreshold(threshold)
+    return float(threshold.value)
+
+def get_similarity_converter_config() -> dict:
+    """
+    Retrieves the similarity converter configuration.
+    """
+    config = HFSimilarityConverterConfig()
+    ret = HFGetCosineSimilarityConverter(PHFSimilarityConverterConfig(config))
+    if ret != 0:
+        logger.error(f"Failed to get cosine similarity converter config: {ret}")
+    cfg = { 
+        "threshold": config.threshold,
+        "middleScore": config.middleScore,
+        "steepness": config.steepness,
+        "outputMin": config.outputMin,
+        "outputMax": config.outputMax
+    }
+    return cfg
+
+def set_similarity_converter_config(cfg: dict):
+    """
+    Sets the similarity converter configuration.
+    """
+    config = HFSimilarityConverterConfig()
+    config.threshold = cfg["threshold"]
+    config.middleScore = cfg["middleScore"]
+    config.steepness = cfg["steepness"]
+    config.outputMin = cfg["outputMin"]
+    config.outputMax = cfg["outputMax"]
+    HFUpdateCosineSimilarityConverter(config)
+
+def cosine_similarity_convert_to_percentage(similarity: float) -> float:
+    """
+    Converts a cosine similarity score to a percentage similarity score.
+    """
+    result = HFloat()
+    ret = HFCosineSimilarityConvertToPercentage(HFloat(similarity), HPFloat(result))
+    if ret != 0:
+        logger.error(f"Failed to convert cosine similarity to percentage: {ret}")
+    return float(result.value)
 
 def version() -> str:
     """
@@ -1033,3 +1099,4 @@ def show_system_resource_statistics():
     Displays the system resource information.
     """
     HFDeBugShowResourceStatistics()
+
diff --git a/python/pull_models.py b/python/pull_models.py
new file mode 100644
index 00000000..5e9e4e68
--- /dev/null
+++ b/python/pull_models.py
@@ -0,0 +1,4 @@
+import inspireface
+
+for model in ["Pikachu", "Megatron"]:
+    inspireface.pull_latest_model(model)
diff --git a/python/sample_face_comparison.py b/python/sample_face_comparison.py
new file mode 100644
index 00000000..b7c1f9dd
--- /dev/null
+++ b/python/sample_face_comparison.py
@@ -0,0 +1,52 @@
+import cv2
+import inspireface as isf
+import click
+
+@click.command()
+@click.argument('image_path1')
+@click.argument('image_path2') 
+def case_face_comparison(image_path1, image_path2):
+    """
+    This is a sample application for comparing two face images.
+    Args:
+        image_path1 (str): Path to the first face image
+        image_path2 (str): Path to the second face image
+    """
+    # Enable face recognition features
+    opt = isf.HF_ENABLE_FACE_RECOGNITION
+    session = isf.InspireFaceSession(opt, isf.HF_DETECT_MODE_ALWAYS_DETECT)
+
+    # Load and check the first image
+    image1 = cv2.imread(image_path1)
+    assert image1 is not None, "Failed to load first image"
+    
+    # Load and check the second image  
+    image2 = cv2.imread(image_path2)
+    assert image2 is not None, "Failed to load second image"
+
+    # Detect faces in first image
+    faces1 = session.face_detection(image1)
+    assert faces1, "No face detected in first image"
+    face1 = faces1[0]  # Use the first detected face
+
+    # Detect faces in second image
+    faces2 = session.face_detection(image2)
+    assert faces2, "No face detected in second image"
+    face2 = faces2[0]  # Use the first detected face
+
+    # Extract features
+    feature1 = session.face_feature_extract(image1, face1)
+    feature2 = session.face_feature_extract(image2, face2)
+
+    # Calculate similarity score between the two faces
+    similarity = isf.feature_comparison(feature1, feature2)
+    
+    print(f"The cosine similarity score: {similarity:.4f}")
+    print(f"{'Same person' if similarity > isf.get_recommended_cosine_threshold() else 'Different person'}")
+
+    percentage = isf.cosine_similarity_convert_to_percentage(similarity)
+    print(f"The percentage similarity: {percentage:.4f}")
+
+
+if __name__ == '__main__':
+    case_face_comparison()
diff --git a/tools/transform_similarity_testing.py b/tools/transform_similarity_testing.py
new file mode 100644
index 00000000..a38162a0
--- /dev/null
+++ b/tools/transform_similarity_testing.py
@@ -0,0 +1,104 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+class SimilarityConverter:
+    def __init__(self, 
+                 threshold=0.48, 
+                 middle_score=0.6, 
+                 steepness=8.0, 
+                 output_range=(0.01, 0.99)):
+        self.threshold = threshold
+        self.middle_score = middle_score
+        self.steepness = steepness
+        self.output_min, self.output_max = output_range
+        self.output_scale = self.output_max - self.output_min
+        
+        self.bias = -np.log((self.output_max - self.middle_score)/(self.middle_score - self.output_min))
+        
+    def convert(self, cosine):
+        shifted_input = self.steepness * (cosine - self.threshold)
+        sigmoid = 1 / (1 + np.exp(-shifted_input - self.bias))
+        return sigmoid * self.output_scale + self.output_min
+    
+    def plot(self, test_points=None):
+        x = np.linspace(-1, 1, 200)
+        y = self.convert(x)
+        
+        plt.figure(figsize=(12, 6))
+        plt.plot(x, y, '-', label='Conversion Function', color='blue')
+        
+        if test_points is not None:
+            test_scores = self.convert(test_points)
+            plt.plot(test_points, test_scores, 'ro', label='Test Points')
+            
+            for point, score in zip(test_points, test_scores):
+                plt.annotate(f'({point:.2f}, {score:.3f})', 
+                            xy=(point, score), 
+                            xytext=(10, 10),
+                            textcoords='offset points')
+        
+        plt.axvline(x=self.threshold, color='gray', linestyle='--', alpha=0.5, 
+                   label=f'Threshold ({self.threshold:.2f})')
+        plt.axhline(y=self.middle_score, color='gray', linestyle='--', alpha=0.5)
+        
+        plt.plot(self.threshold, self.middle_score, 'r*', markersize=15, 
+                label='Passing Point', color='red', zorder=5)
+        
+        plt.annotate(f'Passing Point\n({self.threshold:.2f}, {self.middle_score:.2f})',
+                    xy=(self.threshold, self.middle_score),
+                    xytext=(30, 20),
+                    textcoords='offset points',
+                    bbox=dict(boxstyle='round,pad=0.5', fc='yellow', alpha=0.5),
+                    arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0', 
+                                  color='red', lw=2))
+        
+        
+        plt.fill_between(x, y, 0, 
+                        where=(x >= self.threshold),
+                        alpha=0.1, color='green',
+                        label='Passing Region')
+        
+        plt.grid(True, alpha=0.3)
+        plt.xlabel('Cosine Similarity')
+        plt.ylabel('Converted Score')
+        plt.title('Similarity Score Conversion')
+        plt.legend()
+        plt.xlim(-1.1, 1.1)
+        plt.ylim(-0.1, 1.1)
+        plt.tight_layout()
+        plt.show()
+
+if __name__ == "__main__":
+    # Set the threshold to 0.42
+    converter1 = SimilarityConverter(
+        threshold=0.42,
+        middle_score=0.6,
+        steepness=8.0,
+        output_range=(0.01, 1.0)
+    )
+    test_points1 = np.array([-0.8, -0.2, 0.02, 0.1, 0.25, 0.3, 0.48, 0.7, 0.8, 0.9, 1.0])
+    print("\nModel 1 (Threshold = 0.48):")
+    converter1.plot(test_points1)
+    
+    # Set the threshold to 0.32
+    converter2 = SimilarityConverter(
+        threshold=0.32,
+        middle_score=0.6,
+        steepness=10.0,
+        output_range=(0.02, 1.0)
+    )
+    test_points2 = np.array([-0.8, -0.2, 0.02, 0.1, 0.25,0.32, 0.5, 0.7, 0.8, 0.9, 1.0])
+    print("\nModel 2 (Threshold = 0.32):")
+    converter2.plot(test_points2)
+    
+    # Print the results
+    print("\nTest Results for Model 1 (threshold=0.48):")
+    for point in test_points1:
+        score = converter1.convert(point)
+        print(f"Cosine: {point:6.2f} -> Score: {score:.4f}")
+        
+    print("\nTest Results for Model 2 (threshold=0.32):")
+    for point in test_points2:
+        score = converter2.convert(point)
+        print(f"Cosine: {point:6.2f} -> Score: {score:.4f}")
\ No newline at end of file