hzt_asc 1.0.1 → 1.0.5

package/CMakeLists.txt

@@ -8,11 +8,14 @@ find_package( OpenCV REQUIRED )
 include_directories( ${OpenCV_INCLUDE_DIRS} )
 include_directories(${CMAKE_JS_INC})
 
+#find_library(SERIALDEVICE_LIB arcsoft_face)
+
 #指定头文件目录
 include_directories(./)	
 include_directories(./inc)
 #指定静态和动态文件目录
-link_directories(./so)
+link_directories(linux_so)
+link_directories(lib)
 aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} SRC)
 
 add_library(${PROJECT_NAME} SHARED ${SRC} ${CMAKE_JS_SRC})
@@ -20,15 +23,16 @@ add_library(${PROJECT_NAME} SHARED ${SRC} ${CMAKE_JS_SRC})
 
 
 
-
 #链接库文件
-target_link_libraries(${PROJECT_NAME} ${OpenCV_LIBS} )
+target_link_libraries(${PROJECT_NAME} ${CMAKE_JS_LIB})
 
 target_link_libraries(${PROJECT_NAME} arcsoft_face)
+#link_directories(./so)
 target_link_libraries(${PROJECT_NAME} arcsoft_face_engine)
 
-target_link_libraries(${PROJECT_NAME} ${CMAKE_JS_LIB})
+
 target_link_libraries(${PROJECT_NAME} curl)
+target_link_libraries(${PROJECT_NAME} ${OpenCV_LIBS} )
 
 set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
 # Include Node-API wrappers

package/ask.cc

@@ -17,6 +17,8 @@
 #include <string.h>
 #include <time.h>
 #include <algorithm>
+
+#include "base64.h"
 using namespace std;
 using namespace cv;
 #define SafeFree(p) { if ((p)) free(p); (p) = NULL; }
@@ -26,8 +28,6 @@ using namespace cv;
 #define FACENUM	5
 
 
-
-
 Napi::Value errorData(Napi::Env env, string msg) {
     Napi::Object obj = Napi::Object::New(env);
     obj.Set(Napi::String::New(env, "errorMsg"), msg);
@@ -45,9 +45,11 @@ Napi::Object ASK::Init(Napi::Env env, Napi::Object exports) {
                    //InstanceMethod("RegisterFaceFeature", &ASK::RegisterFaceFeature),
                    //InstanceMethod("SearchFaceFeature", &ASK::SearchFaceFeature),
                    InstanceMethod("ImageFaceCompare", &ASK::ImageFaceCompare),
+                   InstanceMethod("RegisterFaces", &ASK::RegisterFaces),
                    InstanceMethod("FaceDetectUrl", &ASK::faceDetectUrl),
                    InstanceMethod("FaceFeatureExtractUrl", &ASK::faceFeatureExtractUrl),
-                   InstanceMethod("ImageFaceCompareUrl", &ASK::ImageFaceCompareUrl)
+                   InstanceMethod("ImageFaceCompareUrl", &ASK::ImageFaceCompareUrl),
+                   InstanceMethod("ImageFaceCompareUrl2", &ASK::ImageFaceCompareUrl2)
                    });
   exports.Set("ASK", func);
   return exports;
@@ -90,6 +92,7 @@ ASK::ASK(const Napi::CallbackInfo& info) : Napi::ObjectWrap<ASK>(info) {
 
 ASK::~ASK()
 {
+    delete []mFeatureInfoList;
     ASFUninitEngine(this->handle);
     printf("ASK end\n");
 }
@@ -197,17 +200,32 @@ Napi::Value ASK::faceFeatureExtract(const Napi::CallbackInfo& info) {
     }
     Napi::Array list = Napi::Array::New(env, detectedFaces.faceNum);
     for(int i = 0; i < detectedFaces.faceNum; ++i) {
-        ASF_SingleFaceInfo sData;
+        ASF_SingleFaceInfo sData = {0};
         getDetectFaceInfo(detectedFaces, sData, i);
         ASF_FaceFeature feature = { 0 };
         res = ASFFaceFeatureExtractEx(this->handle, &offscreen, &sData, &feature);
+        //cout<<&(feature.feature)<endl;
         Napi::Object data = Napi::Object::New(env);
         data.Set(Napi::String::New(env, "left"), sData.faceRect.left);
         data.Set(Napi::String::New(env, "top"), sData.faceRect.top);
         data.Set(Napi::String::New(env, "right"), sData.faceRect.right);
         data.Set(Napi::String::New(env, "bottom"), sData.faceRect.bottom);
-        data.Set(Napi::String::New(env, "featureSize"), feature.featureSize);
-        data.Set(Napi::String::New(env, "feature"), Napi::ArrayBuffer::New(env, feature.feature, feature.featureSize));
+        // reinterpret_cast<MByte*>(buf2.Data());
+        // char* ff = encode(reinterpret_cast<const char*>(feature.feature));
+        // cout << ff << endl;
+
+        uint8* cc = base64_encode(reinterpret_cast<const uint8*>(feature.feature), feature.featureSize);
+        //cout <<  "c++base64: "  << cc << endl;
+
+        data.Set(Napi::String::New(env, "feature64"), Napi::String::New(env, reinterpret_cast<const char*>(cc), feature.featureSize/3*4));
+
+        // Base64Encoder encoder;
+        // const string &encodedText = encoder.encode(reinterpret_cast<const char*>(feature.feature));
+        // cout << encodedText << endl;
+
+        // data.Set(Napi::String::New(env, "featureSize"), feature.featureSize);
+        // data.Set(Napi::String::New(env, "feature"), Napi::ArrayBuffer::New(env, feature.feature, feature.featureSize));
+        // cout << "addr: "<< &(feature.feature) << endl;
         list[i] = data;
         
     }
@@ -247,8 +265,12 @@ Napi::Value ASK::faceFeatureExtractUrl(const Napi::CallbackInfo& info) {
         data.Set(Napi::String::New(env, "top"), sData.faceRect.top);
         data.Set(Napi::String::New(env, "right"), sData.faceRect.right);
         data.Set(Napi::String::New(env, "bottom"), sData.faceRect.bottom);
-        data.Set(Napi::String::New(env, "featureSize"), feature.featureSize);
-        data.Set(Napi::String::New(env, "feature"), Napi::ArrayBuffer::New(env, feature.feature, feature.featureSize));
+        uint8* cc = base64_encode(reinterpret_cast<const uint8*>(feature.feature), feature.featureSize);
+        //cout <<  "c++base64: "  << cc << endl;
+        data.Set(Napi::String::New(env, "feature64"), Napi::String::New(env, reinterpret_cast<const char*>(cc), feature.featureSize/3*4));
+        // data.Set(Napi::String::New(env, "featureSize"), feature.featureSize);
+        // data.Set(Napi::String::New(env, "feature"), Napi::ArrayBuffer::New(env, feature.feature, feature.featureSize));
+        // cout << "addr: "<< &(feature.feature) << endl;
         list[i] = data;
         
     }
@@ -300,6 +322,12 @@ Napi::Value ASK::faceFeatureInfo(const Napi::CallbackInfo& info) {
     return obj;
 }
 
+void strToFeatureInfo(string& feature, ASF_FaceFeature& featureInfo) {
+    uint8* feature11 =  base64_decode(reinterpret_cast<const uint8 *>(feature.c_str()), feature.size());
+    featureInfo.featureSize = feature.size() / 4 * 3;
+    featureInfo.feature = reinterpret_cast<MByte*>(feature11);
+}
+
 
 Napi::Value ASK::faceFeatureCompare(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -308,47 +336,31 @@ Napi::Value ASK::faceFeatureCompare(const Napi::CallbackInfo& info) {
         Napi::Error::New(info.Env(), "Expected exactly one argument").ThrowAsJavaScriptException();
         return errorData(env, "input expected"); //info.Env().Undefined();
     }
-    if (!info[0].IsArrayBuffer()) {
-        Napi::Error::New(info.Env(), "Expected an ArrayBuffer").ThrowAsJavaScriptException();
+    if (!info[0].IsString()) {
+        Napi::Error::New(info.Env(), "Expected an String").ThrowAsJavaScriptException();
         return errorData(env, "input expected"); //info.Env().Undefined();
     }
 
-    if (!info[1].IsArrayBuffer()) {
-        Napi::Error::New(info.Env(), "Expected an ArrayBuffer").ThrowAsJavaScriptException();
+    if (!info[1].IsString()) {
+        Napi::Error::New(info.Env(), "Expected an String").ThrowAsJavaScriptException();
         return errorData(env, "input expected"); //info.Env().Undefined();
     }
 
-    Napi::ArrayBuffer buf = info[0].As<Napi::ArrayBuffer>();
-    //printf("buf byte size %d \n", buf.ByteLength());
-
+    string feature1 = info[0].As<Napi::String>().ToString();
+    string feature2 = info[1].As<Napi::String>().ToString();
     ASF_FaceFeature featureInfo1 = {};
-    featureInfo1.featureSize = buf.ByteLength();
-    featureInfo1.feature = reinterpret_cast<MByte*>(buf.Data());
-
-    Napi::ArrayBuffer buf2 = info[1].As<Napi::ArrayBuffer>();
-    //printf("buf2 byte size %d \n", buf2.ByteLength());
     ASF_FaceFeature featureInfo2 = {};
-    featureInfo2.featureSize = buf2.ByteLength();
-    featureInfo2.feature = reinterpret_cast<MByte*>(buf2.Data());
+
+    strToFeatureInfo(feature1, featureInfo1);
+    strToFeatureInfo(feature2, featureInfo2);
+
     MFloat confidenceLevel;			
     MRESULT res = ASFFaceFeatureCompare(this->handle, &featureInfo1, &featureInfo2, &confidenceLevel);
     //cout << "result: " << res << ", score: " << confidenceLevel << endl;
     return Napi::Number::New(env, confidenceLevel);
-}
 
+}
 
-typedef struct __face_score
-{
-	MInt32 searchId;
-	MFloat score;
-	string name;
-} MFaceSore, *PMFaceSore;
-
-typedef struct{
-        MInt32      searchId;       // 唯一标识符
-        LPASF_FaceFeature feature;  // 人脸特征值
-        MPCChar     tag;            // 备注
-}ASF_FaceFeatureInfo, *LPASF_FaceFeatureInfo;
 
 bool compareScore(MFaceSore& a, MFaceSore& b){
     if (b.score > a.score) return false;
@@ -387,10 +399,17 @@ Napi::Value ASK::ImageFaceCompare(const Napi::CallbackInfo& info) {
         MInt32 searchId = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"searchId"))).As<Napi::Number>().Uint32Value();
         std::string* tag = new std::string();  
         *tag = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"tag"))).As<Napi::String>().ToString();
-        Napi::ArrayBuffer buf = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::ArrayBuffer>();
+        
         ASF_FaceFeature* featureInfo = new ASF_FaceFeature();
-        featureInfo->featureSize = buf.ByteLength();
-        featureInfo->feature = reinterpret_cast<MByte*>(buf.Data());;
+
+        std::string* feature = new std::string();
+        *feature = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::String>().ToString();
+        strToFeatureInfo(*feature, *featureInfo);
+
+        // Napi::ArrayBuffer buf = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::ArrayBuffer>();
+        // featureInfo->featureSize = buf.ByteLength();
+        // featureInfo->feature = reinterpret_cast<MByte*>(buf.Data());
+        
         ASF_FaceFeatureInfo* info = new ASF_FaceFeatureInfo();
         info->searchId = searchId;
         info->tag = (*tag).c_str();
@@ -409,6 +428,7 @@ Napi::Value ASK::ImageFaceCompare(const Napi::CallbackInfo& info) {
         for(int j = 0; j < len; ++j) {
             MFloat confidenceLevel;	
             MRESULT res1 = ASFFaceFeatureCompare(this->handle, &feature, featureInfoList[j].feature, &confidenceLevel);
+            cout << confidenceLevel <<endl;
             MFaceSore* pFace = new MFaceSore();
             pFace->searchId = featureInfoList[j].searchId;
             pFace->score = confidenceLevel;
@@ -440,6 +460,103 @@ Napi::Value ASK::ImageFaceCompare(const Napi::CallbackInfo& info) {
     return obj;
 }
 
+Napi::Value ASK::RegisterFaces(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    int length = info.Length();
+    if (length < 1) {
+        Napi::TypeError::New(env, "input expected").ThrowAsJavaScriptException();
+        return errorData(env, "input expected"); 
+    }
+    //输入参数 
+    if (!info[0].IsArray()) {
+        Napi::TypeError::New(env, "array expected").ThrowAsJavaScriptException();
+        return errorData(env, "array expected"); 
+    }
+    Napi::Array arr = info[0].As<Napi::Array>();
+    MUInt32 len = arr.Length();
+    ASF_FaceFeatureInfo* featureInfoList = new ASF_FaceFeatureInfo[len];
+    for(int i = 0; i < len; ++i) {
+        Napi::Object obj = static_cast<Napi::Value>(arr[i]).As<Napi::Object>().ToObject();
+        MInt32 searchId = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"searchId"))).As<Napi::Number>().Uint32Value();
+        std::string* tag = new std::string();  
+        *tag = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"tag"))).As<Napi::String>().ToString();
+        //Napi::ArrayBuffer buf = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::ArrayBuffer>();
+        ASF_FaceFeature* featureInfo = new ASF_FaceFeature();
+        std::string* feature = new std::string();
+        *feature = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::String>().ToString();
+        strToFeatureInfo(*feature, *featureInfo);
+        featureInfoList[i].searchId = searchId;
+        featureInfoList[i].tag = (*tag).c_str();
+        featureInfoList[i].feature = featureInfo;
+    }
+    mFeatureInfoList = featureInfoList;
+    mFeatureLen = len;
+    return Napi::Number::New(env, 1);
+}
+
+Napi::Value ASK::ImageFaceCompareUrl2(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    int length = info.Length();
+    if (length < 1) {
+        Napi::TypeError::New(env, "input expected").ThrowAsJavaScriptException();
+        return errorData(env, "input expected"); 
+    }
+    string filePath = info[0].As<Napi::String>().ToString();
+    ASVLOFFSCREEN offscreen = { 0 };
+    MUInt8* imageData;
+    processFileUrl(filePath.c_str(), imageData, offscreen);
+    ASF_MultiFaceInfo detectedFaces = { 0 };
+    MRESULT res = ASFDetectFacesEx(this->handle, &offscreen, &detectedFaces);
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set(Napi::String::New(env, "faceNum"), detectedFaces.faceNum);
+    if (0 == detectedFaces.faceNum) {
+        SafeArrayDelete(imageData);
+        return obj;
+    }
+    //compare
+    Napi::Array list = Napi::Array::New(env, detectedFaces.faceNum);
+    for(int i = 0; i < detectedFaces.faceNum; ++i) {
+        ASF_SingleFaceInfo sData;
+        getDetectFaceInfo(detectedFaces, sData, i);
+        ASF_FaceFeature feature = { 0 };
+        res = ASFFaceFeatureExtractEx(handle, &offscreen, &sData, &feature);
+        MFaceSore* faceScores = new MFaceSore[mFeatureLen];
+        for(int j = 0; j < mFeatureLen; ++j) {
+            MFloat confidenceLevel;	
+            MRESULT res1 = ASFFaceFeatureCompare(this->handle, &feature, mFeatureInfoList[j].feature, &confidenceLevel);
+            faceScores[j].searchId = mFeatureInfoList[j].searchId;
+            faceScores[j].score = confidenceLevel;
+            faceScores[j].name = mFeatureInfoList[j].tag;
+        }
+        sort(faceScores, faceScores + mFeatureLen, compareScore);
+        int ll = mFeatureLen > 5? 5 : mFeatureLen;
+        Napi::Array mFaceScores = Napi::Array::New(env, ll);
+        for(int n = 0; n < ll; ++n) {
+            Napi::Object faceScore = Napi::Object::New(env);
+            faceScore.Set(Napi::String::New(env, "searchId"), faceScores[n].searchId);
+            faceScore.Set(Napi::String::New(env, "score"), faceScores[n].score);
+            faceScore.Set(Napi::String::New(env, "name"), faceScores[n].name);
+            mFaceScores[n] = faceScore;
+        }
+        Napi::Object data = Napi::Object::New(env);
+        data.Set(Napi::String::New(env, "left"), sData.faceRect.left);
+        data.Set(Napi::String::New(env, "top"), sData.faceRect.top);
+        data.Set(Napi::String::New(env, "right"), sData.faceRect.right);
+        data.Set(Napi::String::New(env, "bottom"), sData.faceRect.bottom);
+        data.Set(Napi::String::New(env, "faceScores"), mFaceScores);
+        list[i] = data;
+        delete []faceScores;
+    }
+    obj.Set(Napi::String::New(env, "faceRects"), list);
+    SafeArrayDelete(imageData);
+    // for(int i = 0; i < len; ++i) {
+    //     delete featureInfoList[i].feature;
+    // }
+    //delete []featureInfoList;
+    return obj;
+}
+
+
 Napi::Value ASK::ImageFaceCompareUrl(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     int length = info.Length();
@@ -456,6 +573,7 @@ Napi::Value ASK::ImageFaceCompareUrl(const Napi::CallbackInfo& info) {
     Napi::Object obj = Napi::Object::New(env);
     obj.Set(Napi::String::New(env, "faceNum"), detectedFaces.faceNum);
     if (0 == detectedFaces.faceNum) {
+        SafeArrayDelete(imageData);
         return obj;
     }
 
@@ -472,15 +590,18 @@ Napi::Value ASK::ImageFaceCompareUrl(const Napi::CallbackInfo& info) {
         MInt32 searchId = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"searchId"))).As<Napi::Number>().Uint32Value();
         std::string* tag = new std::string();  
         *tag = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"tag"))).As<Napi::String>().ToString();
-        Napi::ArrayBuffer buf = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::ArrayBuffer>();
+        //Napi::ArrayBuffer buf = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::ArrayBuffer>();
         ASF_FaceFeature* featureInfo = new ASF_FaceFeature();
-        featureInfo->featureSize = buf.ByteLength();
-        featureInfo->feature = reinterpret_cast<MByte*>(buf.Data());;
-        ASF_FaceFeatureInfo* info = new ASF_FaceFeatureInfo();
-        info->searchId = searchId;
-        info->tag = (*tag).c_str();
-        info->feature = featureInfo;
-        featureInfoList[i] = *info;
+        std::string* feature = new std::string();
+        *feature = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::String>().ToString();
+        strToFeatureInfo(*feature, *featureInfo);
+        // featureInfo->featureSize = buf.ByteLength();
+        // featureInfo->feature = reinterpret_cast<MByte*>(buf.Data());;
+        //ASF_FaceFeatureInfo* info = new ASF_FaceFeatureInfo();
+        featureInfoList[i].searchId = searchId;
+        featureInfoList[i].tag = (*tag).c_str();
+        featureInfoList[i].feature = featureInfo;
+        //featureInfoList[i] = *info;
     }
 
     //compare
@@ -494,11 +615,12 @@ Napi::Value ASK::ImageFaceCompareUrl(const Napi::CallbackInfo& info) {
         for(int j = 0; j < len; ++j) {
             MFloat confidenceLevel;	
             MRESULT res1 = ASFFaceFeatureCompare(this->handle, &feature, featureInfoList[j].feature, &confidenceLevel);
-            MFaceSore* pFace = new MFaceSore();
-            pFace->searchId = featureInfoList[j].searchId;
-            pFace->score = confidenceLevel;
-            pFace->name = featureInfoList[j].tag;
-            faceScores[j] = *pFace;
+            //cout << confidenceLevel <<endl;
+            //MFaceSore* pFace = new MFaceSore();
+            faceScores[j].searchId = featureInfoList[j].searchId;
+            faceScores[j].score = confidenceLevel;
+            faceScores[j].name = featureInfoList[j].tag;
+            // faceScores[j] = *pFace;
         }
         sort(faceScores, faceScores + len, compareScore);
         int ll = len > 5? 5 : len;
@@ -521,6 +643,9 @@ Napi::Value ASK::ImageFaceCompareUrl(const Napi::CallbackInfo& info) {
     }
     obj.Set(Napi::String::New(env, "faceRects"), list);
     SafeArrayDelete(imageData);
+    for(int i = 0; i < len; ++i) {
+        delete featureInfoList[i].feature;
+    }
     delete []featureInfoList;
     return obj;
 }
@@ -611,6 +736,7 @@ int ASK::ColorSpaceConversion(MInt32 width, MInt32 height, MInt32 format, MUInt8
 //读取文件 图片修正 并颜色通道转换
 void ASK::processFile(const char*  filePath, MUInt8* imageData, ASVLOFFSCREEN& offscreen) {
     cv::Mat src = imread(filePath);
+    cout<<filePath<<endl;
     int Width = src.cols;
 	int Height = src.rows;
     cout << "Width:" << Width << ",Height:"<<Height<<endl;
@@ -787,3 +913,74 @@ void ASK::processFileUrl(const char*  url, MUInt8* imageData, ASVLOFFSCREEN& off
 //     SafeArrayDelete(imageData);
 //     return obj;
 // }
+
+
+
+
+// #include <b64/cencode.h>
+// #include <b64/cdecode.h>
+
+// #include <stdio.h>
+// #include <stdlib.h>
+// #include <string.h>
+
+// #include <assert.h>
+
+// /* arbitrary buffer size */
+// #define SIZE 100
+
+// char* encode(const char* input)
+// {
+// 	/* set up a destination buffer large enough to hold the encoded data */
+// 	char* output = (char*)malloc(1376);
+// 	/* keep track of our encoded position */
+// 	char* c = output;
+// 	/* store the number of bytes encoded by a single call */
+// 	int cnt = 0;
+// 	/* we need an encoder state */
+// 	base64_encodestate s;
+	
+// 	/*---------- START ENCODING ----------*/
+// 	/* initialise the encoder state */
+// 	base64_init_encodestate(&s);
+// 	/* gather data from the input and send it to the output */
+// 	cnt = base64_encode_block(input, strlen(input), c, &s);
+// 	c += cnt;
+// 	/* since we have encoded the entire input string, we know that 
+// 	   there is no more input data; finalise the encoding */
+// 	cnt = base64_encode_blockend(c, &s);
+// 	c += cnt;
+// 	/*---------- STOP ENCODING  ----------*/
+	
+// 	/* we want to print the encoded data, so null-terminate it: */
+// 	*c = 0;
+	
+// 	return output;
+// }
+
+// char* decode(const char* input)
+// {
+// 	/* set up a destination buffer large enough to hold the encoded data */
+// 	char* output = (char*)malloc(1032);
+// 	/* keep track of our decoded position */
+// 	char* c = output;
+// 	/* store the number of bytes decoded by a single call */
+// 	int cnt = 0;
+// 	/* we need a decoder state */
+// 	base64_decodestate s;
+	
+// 	/*---------- START DECODING ----------*/
+// 	/* initialise the decoder state */
+// 	base64_init_decodestate(&s);
+// 	/* decode the input data */
+// 	cnt = base64_decode_block(input, strlen(input), c, &s);
+// 	c += cnt;
+// 	/* note: there is no base64_decode_blockend! */
+// 	/*---------- STOP DECODING  ----------*/
+	
+// 	/* we want to print the decoded data, so null-terminate it: */
+// 	*c = 0;
+	
+// 	return output;
+// }
+

package/ask.h

@@ -6,6 +6,19 @@
 #include "amcomdef.h"
 #include "asvloffscreen.h"
 #include "merror.h"
+#include <string>
+typedef struct __face_score
+{
+	MInt32 searchId;
+	MFloat score;
+	std::string name;
+} MFaceSore, *PMFaceSore;
+
+typedef struct{
+        MInt32      searchId;       // 唯一标识符
+        LPASF_FaceFeature feature;  // 人脸特征值
+        MPCChar     tag;            // 备注
+}ASF_FaceFeatureInfo, *LPASF_FaceFeatureInfo;
 
 class ASK : public Napi::ObjectWrap<ASK> {
  public:
@@ -28,6 +41,8 @@ class ASK : public Napi::ObjectWrap<ASK> {
   Napi::Value faceDetectUrl(const Napi::CallbackInfo& info);
   Napi::Value faceFeatureExtractUrl(const Napi::CallbackInfo& info);
   Napi::Value ImageFaceCompareUrl(const Napi::CallbackInfo& info);
+  Napi::Value ImageFaceCompareUrl2(const Napi::CallbackInfo& info);
+  Napi::Value RegisterFaces(const Napi::CallbackInfo& info);
 
  private:
   void getSdkRelatedInfo();
@@ -40,6 +55,8 @@ class ASK : public Napi::ObjectWrap<ASK> {
   // void mFaceFeatureExtract(ASVLOFFSCREEN& offscree, ASF_MultiFaceInfo* detectedFaces);
 
   MHandle handle;
+  ASF_FaceFeatureInfo* mFeatureInfoList;
+  MUInt32 mFeatureLen;
 };
 
 #endif

package/base64.cc

@@ -0,0 +1,118 @@
+#include "base64.h"
+#include <vector>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <algorithm>
+#include <assert.h>
+using namespace std;
+
+//定义编码字典
+static uint8 alphabet_map[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+//定义解码字典
+static uint8 reverse_map[] =
+        {
+                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
+                52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 255, 255, 255,
+                255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+                15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255,
+                255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+                41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 255, 255, 255, 255, 255
+        };
+
+/*
+*  编码
+*     传入需要编码的数据地址和数据长度
+*  返回:解码后的数据
+*/
+uint8* base64_encode(const uint8 *text, uint32 text_len)
+{
+    //计算解码后的数据长度
+    //由以上可知  Base64就是将3个字节的数据(24位)，拆成4个6位的数据，然后前两位补零
+    //将其转化为0-63的数据  然后根据编码字典进行编码
+    int encode_length = text_len/3*4;
+    if(text_len%3>0)
+    {
+        encode_length += 4;
+    }
+
+    //为编码后数据存放地址申请内存
+    uint8 *encode = (uint8*)malloc(encode_length);
+
+    //编码
+    uint32 i, j;
+    for (i = 0, j = 0; i+3 <= text_len; i+=3)
+    {
+        encode[j++] = alphabet_map[text[i]>>2];                             //取出第一个字符的前6位并找出对应的结果字符
+        encode[j++] = alphabet_map[((text[i]<<4)&0x30)|(text[i+1]>>4)];     //将第一个字符的后2位与第二个字符的前4位进行组合并找到对应的结果字符
+        encode[j++] = alphabet_map[((text[i+1]<<2)&0x3c)|(text[i+2]>>6)];   //将第二个字符的后4位与第三个字符的前2位组合并找出对应的结果字符
+        encode[j++] = alphabet_map[text[i+2]&0x3f];                         //取出第三个字符的后6位并找出结果字符
+    }
+
+    //对于最后不够3个字节的  进行填充
+    if (i < text_len)
+    {
+        uint32 tail = text_len - i;
+        if (tail == 1)
+        {
+            encode[j++] = alphabet_map[text[i]>>2];
+            encode[j++] = alphabet_map[(text[i]<<4)&0x30];
+            encode[j++] = '=';
+            encode[j++] = '=';
+        }
+        else //tail==2
+        {
+            encode[j++] = alphabet_map[text[i]>>2];
+            encode[j++] = alphabet_map[((text[i]<<4)&0x30)|(text[i+1]>>4)];
+            encode[j++] = alphabet_map[(text[i+1]<<2)&0x3c];
+            encode[j++] = '=';
+        }
+    }
+    return encode;
+}
+
+
+
+uint8* base64_decode(const uint8 *code, uint32 code_len)
+{
+    //由编码处可知，编码后的base64数据一定是4的倍数个字节
+    assert((code_len&0x03) == 0);  //如果它的条件返回错误，则终止程序执行。4的倍数。
+
+    //为解码后的数据地址申请内存
+    uint8 *plain = (uint8*)malloc(code_len/4*3);
+
+    //开始解码
+    uint32 i, j = 0;
+    uint8 quad[4];
+    for (i = 0; i < code_len; i+=4)
+    {
+        for (uint32 k = 0; k < 4; k++)
+        {
+            quad[k] = reverse_map[code[i+k]];//分组，每组四个分别依次转换为base64表内的十进制数
+        }
+
+        assert(quad[0]<64 && quad[1]<64);
+
+        plain[j++] = (quad[0]<<2)|(quad[1]>>4); //取出第一个字符对应base64表的十进制数的前6位与第二个字符对应base64表的十进制数的前2位进行组合
+
+        if (quad[2] >= 64)
+            break;
+        else if (quad[3] >= 64)
+        {
+            plain[j++] = (quad[1]<<4)|(quad[2]>>2); //取出第二个字符对应base64表的十进制数的后4位与第三个字符对应base64表的十进制数的前4位进行组合
+            break;
+        }
+        else
+        {
+            plain[j++] = (quad[1]<<4)|(quad[2]>>2);
+            plain[j++] = (quad[2]<<6)|quad[3];//取出第三个字符对应base64表的十进制数的后2位与第4个字符进行组合
+        }
+    }
+    return plain;
+}

package/base64.h

@@ -0,0 +1,9 @@
+#ifndef BASE64_H
+#define BASE64_H
+//类型宏定义
+typedef unsigned char     uint8;
+typedef unsigned long    uint32;
+uint8* base64_encode(const uint8 *text, uint32 text_len);
+uint8* base64_decode(const uint8 *code, uint32 code_len);
+
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hzt_asc",
-  "version": "1.0.1",
+  "version": "1.0.5",
   "main": "index.js",
   "description": "hzt_asc_v3.",
   "author": {

package/sample/demo.js

@@ -15,49 +15,93 @@ const ACTIVEKEY = "82K1-118E-813R-CJQ3";
 
 let start = Date.now();
 let ask = new addon.ASK(APPID, SDKKEY, ACTIVEKEY);
+let ask2 = new addon.ASK(APPID, SDKKEY, ACTIVEKEY);
 printMem()
 console.log("init end", Date.now() - start);
 
-for(let i = 0; i < 1; ++i) {
-    let num = ask.FaceDetect("/home/haizitong/workspace/hztFace/700dceca74304e11b6a48806df9085d2.png")
-    console.log("FaceDetect", num)
-    printMem()
+ for(let i = 0; i < 1; ++i) {
+     let num = ask.FaceDetect("/home/haizitong/workspace/hztFace/72b57b47372c490a88663c334e530530.png")
+     console.log("FaceDetect", num)
+     printMem()
 
-    let det = ask.FaceDetectUrl("http://min.haizitong.com/2/ali/i/700dceca74304e11b6a48806df9085d2");
-    console.log("det", det);
-}
+     let det = ask.FaceDetectUrl("http://min.haizitong.com/2/ali/i/a5f91d52783d49989777e8b82b545e2c");
+     console.log("det", det);
+ }
+
+let urls = [ 
+    "http://min.haizitong.com/2/ali/i/ba676af499174fbab46525605974ca79", 
+        "http://min.haizitong.com/2/ali/i/4449177b33604d45ad96497c95a00284", 
+        "http://min.haizitong.com/2/ali/i/a6daaf38d3924b64a26ba603ab155744", 
+        "http://min.haizitong.com/2/ali/i/e537426869fd4809a9e8e8dd481b1432"
+];
 
 // console.log(num)
 console.log("detect end", Date.now() - start);
 let feature = null;
+let feature2 = null;
+let s1, s2;
 for(let i = 0; i < 1; ++i) {
-    let num2 = ask.FaceFeatureExtract("/home/haizitong/workspace/hztFace/24aea309c9fa4d809b3b8f88782936a5.png")
+    let num2 = ask.FaceFeatureExtractUrl("http://min.haizitong.com/2/ali/i/90780254ca34403cbb542951431e59dc");
     console.log("FaceFeatureExtract", num2);
     if (num2.faceNum && num2.faceRects.length) {
-        feature = num2.faceRects[0].feature;
+        feature = num2.faceRects[0].feature64;
+    //     let str = Buffer.from(feature).toString('base64');
+    //    //console.log("str", str, str.length);
+    //    s1 = str;
     }
-    let num22 = ask.FaceFeatureExtractUrl("http://min.haizitong.com/2/ali/i/24aea309c9fa4d809b3b8f88782936a5")
-    console.log("FaceFeatureExtract2", num22);
+    let num22 = ask.FaceFeatureExtract(path.join(__dirname, '../images/20200829105722.jpg'));
+    console.log("FaceFeatureExtract", num22);
+    if (num22.faceNum && num22.faceRects.length) {
+        feature2 = num22.faceRects[0].feature64;
+    //     let str = Buffer.from(feature2).toString('base64');
+    //    console.log("str", str, str.length);
+    //    s2 = str;
+    }
+    //console.log("FaceFeatureExtract2", num22);
     printMem()
+    console.log("xx", s1 == s2, feature == feature2)
 }
 // console.log("extract end", Date.now() - start);
 
-// //FaceFeatureCompare
-// if (feature) {
-//     let compareResult = ask.FaceFeatureCompare(feature, feature);
-//     console.log("FaceFeatureCompare", compareResult);
-//     console.log("FaceFeatureCompare end", Date.now() - start);
-//     let list = [
-//         {searchId: 1, tag: "wo", feature},
-//         {searchId: 2, tag: "wo2", feature},
-//     ];
-//     let imageResult = ask.ImageFaceCompare(path.join(__dirname, '../images/20200829105722.jpg'), list, 1);
-//     console.log("imageResult", JSON.stringify(imageResult, null, 4));
-//     console.log("ImageFaceCompare end", Date.now() - start);
-//     let str = Buffer.from(feature).toString('base64');
-//     console.log("str", str, str.length);
+
+function toArrayBuffer(buf) {
+    var ab = new ArrayBuffer(buf.length);
+    var view = new Uint8Array(ab);
+    for (var i = 0; i < buf.length; ++i) {
+        view[i] = buf[i];
+    }
+    return ab;
+}
+
+//FaceFeatureCompare
+if (feature) {
+    // let str = Buffer.from(feature).toString('base64');
+    // console.log("str", feature, str, str.length);
+
+    // let str2 = Buffer.from(feature2).toString('base64');
+    // console.log("str2", feature2, str2, str2.length, str2 == str);
+    
+    
+    //console.log("xxx", s1, s2);
+
+    // let ss1 = Buffer.from(s1, 'base64');
+    // let ss2 = Buffer.from(s2, 'base64');
+    // console.log("xx", s1 == s2, feature == feature2)
+
+    //let compareResult = ask.FaceFeatureCompare(toArrayBuffer(ss1), toArrayBuffer(ss2));
+    let compareResult = ask.FaceFeatureCompare(feature, feature2);
+    console.log("FaceFeatureCompare", compareResult);
+    //console.log("FaceFeatureCompare end", Date.now() - start);
+    let list = [
+        {searchId: 1, tag: "wo", feature: feature2},
+        {searchId: 2, tag: "wo2", feature},
+    ];
+    let imageResult = ask.ImageFaceCompare(path.join(__dirname, '../images/20200829105722.jpg'), list, 1);
+    console.log("imageResult", JSON.stringify(imageResult, null, 4));
+    console.log("ImageFaceCompare end", Date.now() - start);
     
-// }
+    
+}
 
 
 // let num5 = ask.FaceFeatureInfo(path.join(__dirname, '../images/20200829105722.jpg'))