symbol.h

Go to the documentation of this file.

// Hang Zhou Xiao Kong Cheng Xiang Ke Ji You Xian Gong Si is pleased to support DFACE SDK LIBRARY.
//
//  Copyright © 2018, Hang Zhou Xiao Kong Cheng Xiang Ke Ji You Xian Gong Si Holding Limited//

#ifndef DFACE_SYMBOL_H
#define DFACE_SYMBOL_H

#include <stdio.h>
#include "dface_detect.h"
#include "dface_pose.h"
#include "dface_compare.h"
#include "dface_recognize.h"
#include "dface_nir_liveness.h"
#include "dface_rgb_liveness.h"
#include "dface_track.h"
#include "dface_assessment.h"
#include "dface_attribute.h"
#include "dface_accredit.h"


#ifdef _WIN32
#include <Windows.h>
#else
#include <dlfcn.h>
#endif

#ifdef _WIN32
//dynamic load library
static HMODULE handle = LoadLibraryEx(L"libdface.dll", NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
#else
//dynamic load library
static void *handle = dlopen("libdfacepro.so", RTLD_LAZY);
#endif


inline dface::DfaceDetect* load_dface_detect(const std::string &model_path, int precision){
#ifdef _WIN32
    if (handle == NULL)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateDetect* createDetect = (dface::CreateDetect*)GetProcAddress(handle, "create_detect");
#else
    if (!handle)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateDetect* createDetect = (dface::CreateDetect*)dlsym(handle, "create_detect");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return nullptr;
    }
#endif
    return createDetect(model_path, precision);
}

inline void destory_dface_detect(dface::DfaceDetect* p){
    if(p == nullptr){
        return;
    }
#ifdef _WIN32
    dface::DestroyDetect* destroyDetect = (dface::DestroyDetect*)GetProcAddress(handle, "destroy_detect");
#else
    dface::DestroyDetect* destroyDetect = (dface::DestroyDetect*)dlsym(handle, "destroy_detect");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return;
    }
#endif
    destroyDetect(p);
}


inline dface::DfaceAssessment* load_dface_assessment(const std::string &model_path){
#ifdef _WIN32
    if (handle == NULL)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateAssessment* createAssessment = (dface::CreateAssessment*)GetProcAddress(handle, "create_assessment");
#else
    if (!handle)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateAssessment* createAssessment = (dface::CreateAssessment*)dlsym(handle, "create_assessment");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return nullptr;
    }
#endif
    return createAssessment(model_path);
}

inline void destory_dface_assessment(dface::DfaceAssessment* p){
    if(p == nullptr){
        return;
    }
#ifdef _WIN32
    dface::DestroyAssessment* destroyAssessment = (dface::DestroyAssessment*)GetProcAddress(handle, "destroy_assessment");
#else
    dface::DestroyAssessment* destroyAssessment = (dface::DestroyAssessment*)dlsym(handle, "destroy_assessment");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return;
    }
#endif
    destroyAssessment(p);
}



inline dface::DfaceAttribute* load_dface_attribute(const std::string &model_path){
#ifdef _WIN32
    if (handle == NULL)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateAttribute* createAttribute = (dface::CreateAttribute*)GetProcAddress(handle, "create_attribute");
#else
    if (!handle)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateAttribute* createAttribute = (dface::CreateAttribute*)dlsym(handle, "create_attribute");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return nullptr;
    }
#endif
    return createAttribute(model_path);
}

inline void destory_dface_attribute(dface::DfaceAttribute* p){
    if(p == nullptr){
        return;
    }
#ifdef _WIN32
    dface::DestroyAttribute* destroyAttribute = (dface::DestroyAttribute*)GetProcAddress(handle, "destroy_attribute");
#else
    dface::DestroyAttribute* destroyAttribute = (dface::DestroyAttribute*)dlsym(handle, "destroy_attribute");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return;
    }
#endif
    destroyAttribute(p);
}



inline dface::DfaceRecognize* load_dface_recognize(const std::string &model_path, int precision) {
#ifdef _WIN32
    DWORD dwError = 0;
    if (handle == NULL)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateRecognize* createRecognize = (dface::CreateRecognize*)GetProcAddress(handle, "create_recognize");
#else
    if (!handle)
    {
        printf("library failed to load.\n");
        return nullptr;
    }

    dface::CreateRecognize* createRecognize = (dface::CreateRecognize*)dlsym(handle, "create_recognize");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return nullptr;
    }
#endif
    return createRecognize(model_path, precision);
}


inline void destory_dface_recognize(dface::DfaceRecognize* p){
    if(p == nullptr){
        return;
    }
#ifdef _WIN32
    dface::DestroyRecognize* destroyRecognize = (dface::DestroyRecognize*)GetProcAddress(handle, "destroy_recognize");
#else
    dface::DestroyRecognize* destroyRecognize = (dface::DestroyRecognize*)dlsym(handle, "destroy_recognize");
    char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return;
    }
#endif
    destroyRecognize(p);
}


inline dface::DfaceCompare* load_dface_compare(const std::string &model_path, int feature_precision)
{
#ifdef _WIN32
    DWORD dwError = 0;
    if (handle == NULL)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateCompare* createCompare = (dface::CreateCompare*)GetProcAddress(handle, "create_compare");
#else
    if (!handle)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateCompare* createCompare = (dface::CreateCompare *)dlsym(handle, "create_compare");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return nullptr;
    }
#endif
    return createCompare(model_path, feature_precision);
}


inline void destory_dface_compare(dface::DfaceCompare* p){
    if(p == nullptr){
        return;
    }
#ifdef _WIN32
    dface::DestroyCompare  *destroyCompare = (dface::DestroyCompare *)GetProcAddress(handle, "destroy_compare");
#else
    dface::DestroyCompare  *destroyCompare = (dface::DestroyCompare*)dlsym(handle, "destroy_compare");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return;
    }
#endif
    destroyCompare(p);
}


inline dface::DfacePose* load_dface_pose(const std::string &model_path)
{
#ifdef _WIN32
    DWORD dwError = 0;
    if (handle == NULL)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreatePose* createPose = (dface::CreatePose*)GetProcAddress(handle, "create_pose");
#else
    if (!handle)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreatePose * createPose = (dface::CreatePose*)dlsym(handle, "create_pose");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return nullptr;
    }
#endif
    return createPose(model_path);
}


inline void destory_dface_pose(dface::DfacePose* p){
    if(p == nullptr){
        return;
    }
#ifdef _WIN32
    dface::DestroyPose  *destroyPose = (dface::DestroyPose*)GetProcAddress(handle, "destroy_pose");
#else
    dface::DestroyPose  *destroyPose = (dface::DestroyPose*)dlsym(handle, "destroy_pose");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return;
    }
#endif
    destroyPose(p);
}


inline dface::DfaceNIRLiveness* load_dface_nir_liveness(const std::string &model_path)
{
#ifdef _WIN32
    DWORD dwError = 0;
    if (handle == NULL)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateNIRLiveness* createNirLiveness = (dface::CreateNIRLiveness*)GetProcAddress(handle, "create_nir_liveness");
#else
    if (!handle)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateNIRLiveness * createNirLiveness = (dface::CreateNIRLiveness*)dlsym(handle, "create_nir_liveness");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return nullptr;
    }
#endif
    return createNirLiveness(model_path);
}


inline void destory_dface_nir_liveness(dface::DfaceNIRLiveness* p){
    if(p == nullptr){
        return;
    }
#ifdef _WIN32
    dface::DestroyNIRLiveness  *destoryNirLiveness = (dface::DestroyNIRLiveness*)GetProcAddress(handle, "destroy_nir_liveness");
#else
    dface::DestroyNIRLiveness  *destoryNirLiveness = (dface::DestroyNIRLiveness*)dlsym(handle, "destroy_nir_liveness");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return;
    }
#endif
    destoryNirLiveness(p);
}



inline dface::DfaceRGBLiveness* load_dface_rgb_liveness(const std::string &model_path, int level)
{
#ifdef _WIN32
    DWORD dwError = 0;
    if (handle == NULL)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateRGBLiveness* createRgbLiveness = (dface::CreateRGBLiveness*)GetProcAddress(handle, "create_rgb_liveness");
#else
    if (!handle)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateRGBLiveness * createRgbLiveness = (dface::CreateRGBLiveness*)dlsym(handle, "create_rgb_liveness");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return nullptr;
    }
#endif
    return createRgbLiveness(model_path, level);
}


inline void destory_dface_rgb_liveness(dface::DfaceRGBLiveness* p){
    if(p == nullptr){
        return;
    }
#ifdef _WIN32
    dface::DestroyRGBLiveness  *destroyRgbLiveness = (dface::DestroyRGBLiveness*)GetProcAddress(handle, "destroy_rgb_liveness");
#else
    dface::DestroyRGBLiveness  *destroyRgbLiveness = (dface::DestroyRGBLiveness *)dlsym(handle, "destroy_rgb_liveness");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return;
    }
#endif
    destroyRgbLiveness(p);
}



inline dface::DfaceTrack* load_dface_track(const std::string &model_path, int frame_width, int frame_height, int max_age = 200, int min_hit = 3)
{
#ifdef _WIN32
    DWORD dwError = 0;
    if (handle == NULL)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateTrack* createTrack = (dface::CreateTrack*)GetProcAddress(handle, "create_track");
#else
    if (!handle)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    dface::CreateTrack * createTrack = (dface::CreateTrack *)dlsym(handle, "create_track");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return nullptr;
    }
#endif
    return createTrack(model_path, frame_width, frame_height, max_age, min_hit);
}


inline void destory_dface_track(dface::DfaceTrack* p){
    if(p == nullptr){
        return;
    }
#ifdef _WIN32
    dface::DestroyTrack  *destroyTrack = (dface::DestroyTrack*)GetProcAddress(handle, "destroy_track");
#else
    dface::DestroyTrack  *destroyTrack = (dface::DestroyTrack *)dlsym(handle, "destroy_track");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return;
    }
#endif
    destroyTrack(p);
}


inline DfaceAccredit* load_dface_accredit()
{
#ifdef _WIN32
    DWORD dwError = 0;
    if (handle == NULL)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    CreateAccredit* createAccredit = (CreateAccredit*)GetProcAddress(handle, "create_accredit");
#else
    if (!handle)
    {
        printf("library failed to load.\n");
        return nullptr;
    }
    CreateAccredit * createAccredit = (CreateAccredit *)dlsym(handle, "create_accredit");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return nullptr;
    }
#endif
    return createAccredit();
}


inline void destory_dface_accredit(DfaceAccredit* p){
    if(p == nullptr){
        return;
    }
#ifdef _WIN32
    DestroyAccredit  *destroyAccredit = (DestroyAccredit*)GetProcAddress(handle, "destroy_accredit");
#else
    DestroyAccredit  *destroyAccredit = (DestroyAccredit *)dlsym(handle, "destroy_accredit");
    const char* dlsym_error = dlerror();
    if (dlsym_error) {
        printf("%s", dlsym_error);
        return;
    }
#endif
    destroyAccredit(p);
}


inline void free_dface(){
#ifdef _WIN32
    if(handle != NULL){
        FreeLibrary(handle);
    }
#else
    if(handle){
        dlclose(handle);
    }
#endif
}

#endif //DFACE_SYMBOL_H