hzt_asc 1.0.0 → 1.0.1

package/CMakeLists.txt

@@ -28,6 +28,7 @@ target_link_libraries(${PROJECT_NAME} arcsoft_face)
 target_link_libraries(${PROJECT_NAME} arcsoft_face_engine)
 
 target_link_libraries(${PROJECT_NAME} ${CMAKE_JS_LIB})
+target_link_libraries(${PROJECT_NAME} curl)
 
 set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
 # Include Node-API wrappers

package/ask.cc

@@ -2,6 +2,8 @@
 #include <opencv2/opencv.hpp>
 #include <opencv2/highgui/highgui.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
+#include <curl/curl.h>
+
 #include <vector>
 #include <fstream>
 #include <iostream>
@@ -22,6 +24,10 @@ using namespace cv;
 #define SafeDelete(p) { if ((p)) delete (p); (p) = NULL; } 
 #define NSCALE 16 
 #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);
@@ -38,7 +44,11 @@ Napi::Object ASK::Init(Napi::Env env, Napi::Object exports) {
                    InstanceMethod("FaceFeatureInfo", &ASK::faceFeatureInfo),
                    //InstanceMethod("RegisterFaceFeature", &ASK::RegisterFaceFeature),
                    //InstanceMethod("SearchFaceFeature", &ASK::SearchFaceFeature),
-                   InstanceMethod("ImageFaceCompare", &ASK::ImageFaceCompare)});
+                   InstanceMethod("ImageFaceCompare", &ASK::ImageFaceCompare),
+                   InstanceMethod("FaceDetectUrl", &ASK::faceDetectUrl),
+                   InstanceMethod("FaceFeatureExtractUrl", &ASK::faceFeatureExtractUrl),
+                   InstanceMethod("ImageFaceCompareUrl", &ASK::ImageFaceCompareUrl)
+                   });
   exports.Set("ASK", func);
   return exports;
 }
@@ -68,7 +78,7 @@ ASK::ASK(const Napi::CallbackInfo& info) : Napi::ObjectWrap<ASK>(info) {
     }
     //初始化引擎
     MHandle handle = NULL;
-    MInt32 mask = ASF_FACE_DETECT | ASF_FACERECOGNITION | ASF_FACE3DANGLE  ; // ASF_AGE | ASF_GENDER | | ASF_LIVENESS
+    MInt32 mask = ASF_FACE_DETECT | ASF_FACERECOGNITION | ASF_FACE3DANGLE | ASF_AGE | ASF_GENDER | ASF_LIVENESS; // 
     res = ASFInitEngine(ASF_DETECT_MODE_IMAGE, ASF_OP_0_ONLY, NSCALE, FACENUM, mask, &handle);
     if (res != MOK) {
         printf("ASFInitEngine fail: %d\n", res);
@@ -130,6 +140,40 @@ Napi::Value ASK::faceDetect(const Napi::CallbackInfo& info) {
 }
 
 
+Napi::Value ASK::faceDetectUrl(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    int length = info.Length();
+    if (length != 1 || !info[0].IsString() ) {
+        Napi::TypeError::New(env, "input expected").ThrowAsJavaScriptException();
+        return errorData(env, "input expected"); //Napi::Number::New(info.Env(), -1);
+    }
+    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);
+    //cout << "faceNum:" << detectedFaces.faceNum << endl; 
+ 
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set(Napi::String::New(env, "faceNum"), detectedFaces.faceNum);
+    Napi::Array list = Napi::Array::New(env, detectedFaces.faceNum);
+    for(int i = 0; i < detectedFaces.faceNum; ++i) {
+        ASF_SingleFaceInfo sData;
+        getDetectFaceInfo(detectedFaces, sData, i);
+        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);
+        list[i] = data;
+    }
+    obj.Set(Napi::String::New(env, "faceRects"), list);
+    SafeArrayDelete(imageData);
+    return obj;
+}
+
+
 
 Napi::Value ASK::faceFeatureExtract(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -172,6 +216,46 @@ Napi::Value ASK::faceFeatureExtract(const Napi::CallbackInfo& info) {
     return obj;
 }
 
+Napi::Value ASK::faceFeatureExtractUrl(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    int length = info.Length();
+    if (length != 1 || !info[0].IsString() ) {
+        Napi::TypeError::New(env, "input expected").ThrowAsJavaScriptException();
+        return errorData(env, "input expected"); //Napi::Number::New(info.Env(), -1);
+    }
+    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) {
+        return obj;
+    }
+    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(this->handle, &offscreen, &sData, &feature);
+        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));
+        list[i] = data;
+        
+    }
+    obj.Set(Napi::String::New(env, "faceRects"), list);
+    SafeArrayDelete(imageData);
+    return obj;
+}
 
 
 Napi::Value ASK::faceFeatureInfo(const Napi::CallbackInfo& info) {
@@ -356,6 +440,90 @@ Napi::Value ASK::ImageFaceCompare(const Napi::CallbackInfo& info) {
     return obj;
 }
 
+Napi::Value ASK::ImageFaceCompareUrl(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    int length = info.Length();
+    if (length < 3) {
+        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) {
+        return obj;
+    }
+
+    //输入参数 
+    if (!info[1].IsArray()) {
+        Napi::TypeError::New(env, "array expected").ThrowAsJavaScriptException();
+        return errorData(env, "array expected"); 
+    }
+    Napi::Array arr = info[1].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();
+        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;
+    }
+
+    //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[len];
+        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;
+        }
+        sort(faceScores, faceScores + len, compareScore);
+        int ll = len > 5? 5 : len;
+        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);
+    delete []featureInfoList;
+    return obj;
+}
 
 
 ////获取激活信息（采集离线激活信息、激活文件信息、SDK版本信息）
@@ -445,6 +613,7 @@ void ASK::processFile(const char*  filePath, MUInt8* imageData, ASVLOFFSCREEN& o
     cv::Mat src = imread(filePath);
     int Width = src.cols;
 	int Height = src.rows;
+    cout << "Width:" << Width << ",Height:"<<Height<<endl;
     int wScore = Width % 4;
     int hScore = Height % 2;
     if (wScore != 0 || hScore != 0) {
@@ -465,6 +634,83 @@ void ASK::processFile(const char*  filePath, MUInt8* imageData, ASVLOFFSCREEN& o
     dest.release();
     ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, imageData, offscreen);
 }
+//curl writefunction to be passed as a parameter
+// we can't ever expect to get the whole image in one piece,
+// every router / hub is entitled to fragment it into parts
+// (like 1-8k at a time),
+// so insert the part at the end of our stream.
+size_t write_data(char *ptr, size_t size, size_t nmemb, void *userdata)
+{
+    vector<uchar> *stream = (vector<uchar>*)userdata;
+    //cout<<ptr<< size<<endl;
+    size_t count = size * nmemb;
+    stream->insert(stream->end(), ptr, ptr + count);
+    //cout<<count<<endl;
+    return count;
+}
+
+//function to retrieve the image as cv::Mat data type
+cv::Mat curlImg(const char *img_url, int timeout=100000)
+{
+    cout<<img_url<<endl;
+    vector<uchar> stream;
+    CURL *curl = curl_easy_init();
+    curl_easy_setopt(curl, CURLOPT_URL, img_url); //the img url
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data); // pass the writefunction
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &stream); // pass the stream ptr to the writefunction
+    curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout); // timeout if curl_easy hangs, 
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1); //重定向一次
+    CURLcode res = curl_easy_perform(curl); // start curl
+    curl_easy_cleanup(curl); // cleanup
+    cout<<res<<"xxxx" << stream.size() << " " << stream.max_size()<<endl;
+    return imdecode(stream, -1); // 'keep-as-is'
+}
+void ASK::processFileUrl(const char*  url, MUInt8* imageData, ASVLOFFSCREEN& offscreen) {
+    cv::Mat src = curlImg(url);
+    int Width = src.cols;
+	int Height = src.rows;
+    cout << "Width:" << Width << ",Height:"<<Height<<endl;
+    int wScore = Width % 4;
+    int hScore = Height % 2;
+    if (wScore != 0 || hScore != 0) {
+        Width -= wScore;
+        Height -= hScore;
+        cv::Mat dst;
+        cv::resize(src, dst, cv::Size(Width, Height));
+        src.release();
+        src = dst;
+    }
+    cv::Mat dest;
+    cvtColor(src, dest, COLOR_BGR2YUV_I420);
+    int len = Height*Width*3/2;
+    imageData = (MUInt8*)malloc(len);
+    memset(imageData, 0, len);    
+    memcpy(imageData, dest.data, len);
+    src.release();
+    dest.release();
+    ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, imageData, offscreen);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 // Napi::Value ASK::RegisterFaceFeature(const Napi::CallbackInfo& info) {

package/ask.h

@@ -25,11 +25,16 @@ class ASK : public Napi::ObjectWrap<ASK> {
 
   Napi::Value ImageFaceCompare(const Napi::CallbackInfo& info);
 
+  Napi::Value faceDetectUrl(const Napi::CallbackInfo& info);
+  Napi::Value faceFeatureExtractUrl(const Napi::CallbackInfo& info);
+  Napi::Value ImageFaceCompareUrl(const Napi::CallbackInfo& info);
+
  private:
   void getSdkRelatedInfo();
   void timestampToTime(char* timeStamp, char* dateTime, int dateTimeSize);
   int ColorSpaceConversion(MInt32 width, MInt32 height, MInt32 format, MUInt8* imgData, ASVLOFFSCREEN& offscreen);
   void processFile(const char* filePath,  MUInt8* imageData, ASVLOFFSCREEN& offscreen);
+  void processFileUrl(const char* filePath,  MUInt8* imageData, ASVLOFFSCREEN& offscreen);
 
   // void mFaceDetect(ASVLOFFSCREEN& offscree, ASF_MultiFaceInfo* detectedFaces);
   // void mFaceFeatureExtract(ASVLOFFSCREEN& offscree, ASF_MultiFaceInfo* detectedFaces);

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "hzt_asc",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "main": "index.js",
   "description": "hzt_asc_v3.",
   "author": {
-    "name": "wucpeng",
-    "email": "wuchangpeng@haizitong.com"
+    "name": "wuyunpeng",
+    "email": "wuyunpeng37@163.com"
   },
   "dependencies": {
     "bindings": "~1.2.1",

package/sample/demo.js

@@ -19,40 +19,45 @@ printMem()
 console.log("init end", Date.now() - start);
 
 for(let i = 0; i < 1; ++i) {
-    let num = ask.FaceDetect(path.join(__dirname, '../images/20200829105722.jpg'))
+    let num = ask.FaceDetect("/home/haizitong/workspace/hztFace/700dceca74304e11b6a48806df9085d2.png")
     console.log("FaceDetect", num)
     printMem()
+
+    let det = ask.FaceDetectUrl("http://min.haizitong.com/2/ali/i/700dceca74304e11b6a48806df9085d2");
+    console.log("det", det);
 }
 
 // console.log(num)
 console.log("detect end", Date.now() - start);
 let feature = null;
 for(let i = 0; i < 1; ++i) {
-    let num2 = ask.FaceFeatureExtract(path.join(__dirname, '../images/20200829105722.jpg'))
+    let num2 = ask.FaceFeatureExtract("/home/haizitong/workspace/hztFace/24aea309c9fa4d809b3b8f88782936a5.png")
     console.log("FaceFeatureExtract", num2);
     if (num2.faceNum && num2.faceRects.length) {
         feature = num2.faceRects[0].feature;
     }
+    let num22 = ask.FaceFeatureExtractUrl("http://min.haizitong.com/2/ali/i/24aea309c9fa4d809b3b8f88782936a5")
+    console.log("FaceFeatureExtract2", num22);
     printMem()
 }
-console.log("extract end", Date.now() - start);
+// 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);
+// //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);
     
-}
+// }
 
 
 // let num5 = ask.FaceFeatureInfo(path.join(__dirname, '../images/20200829105722.jpg'))