hzt_asc 1.0.4 → 1.0.8

package/ask.cc

@@ -92,7 +92,7 @@ ASK::ASK(const Napi::CallbackInfo& info) : Napi::ObjectWrap<ASK>(info) {
 
 ASK::~ASK()
 {
-    delete []mFeatureInfoList;
+    // delete []mFeatureInfoList;
     ASFUninitEngine(this->handle);
     printf("ASK end\n");
 }
@@ -117,13 +117,13 @@ Napi::Value ASK::faceDetect(const Napi::CallbackInfo& info) {
         return errorData(env, "input expected"); //Napi::Number::New(info.Env(), -1);
     }
     string filePath = info[0].As<Napi::String>().ToString();
+    int Width, Height;
+    MUInt8* imageData = processFile(filePath.c_str(), Width, Height);
     ASVLOFFSCREEN offscreen = { 0 };
-    MUInt8* imageData;
-    processFile(filePath.c_str(), imageData, offscreen);
+    ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, 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);
@@ -138,11 +138,10 @@ Napi::Value ASK::faceDetect(const Napi::CallbackInfo& info) {
         list[i] = data;
     }
     obj.Set(Napi::String::New(env, "faceRects"), list);
-    SafeArrayDelete(imageData);
+    SafeFree(imageData);
     return obj;
 }
 
-
 Napi::Value ASK::faceDetectUrl(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     int length = info.Length();
@@ -151,13 +150,13 @@ Napi::Value ASK::faceDetectUrl(const Napi::CallbackInfo& info) {
         return errorData(env, "input expected"); //Napi::Number::New(info.Env(), -1);
     }
     string filePath = info[0].As<Napi::String>().ToString();
+    int Width, Height;
+    MUInt8* imageData = processFileUrl(filePath.c_str(), Width, Height);
     ASVLOFFSCREEN offscreen = { 0 };
-    MUInt8* imageData;
-    processFileUrl(filePath.c_str(), imageData, offscreen);
+    ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, 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);
@@ -172,12 +171,10 @@ Napi::Value ASK::faceDetectUrl(const Napi::CallbackInfo& info) {
         list[i] = data;
     }
     obj.Set(Napi::String::New(env, "faceRects"), list);
-    SafeArrayDelete(imageData);
+    SafeFree(imageData);
     return obj;
 }
 
-
-
 Napi::Value ASK::faceFeatureExtract(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     int length = info.Length();
@@ -187,15 +184,17 @@ Napi::Value ASK::faceFeatureExtract(const Napi::CallbackInfo& info) {
     }
     string filePath = info[0].As<Napi::String>().ToString();
    
+    int Width, Height;
+    MUInt8* imageData = processFile(filePath.c_str(), Width, Height);
     ASVLOFFSCREEN offscreen = { 0 };
-    MUInt8* imageData;
-    processFile(filePath.c_str(), imageData, offscreen);
+    ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, 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) {
+        SafeFree(imageData);
         return obj;
     }
     Napi::Array list = Napi::Array::New(env, detectedFaces.faceNum);
@@ -230,7 +229,7 @@ Napi::Value ASK::faceFeatureExtract(const Napi::CallbackInfo& info) {
         
     }
     obj.Set(Napi::String::New(env, "faceRects"), list);
-    SafeArrayDelete(imageData);
+    SafeFree(imageData);
     return obj;
 }
 
@@ -243,15 +242,18 @@ Napi::Value ASK::faceFeatureExtractUrl(const Napi::CallbackInfo& info) {
     }
     string filePath = info[0].As<Napi::String>().ToString();
    
+    int Width, Height;
+    MUInt8* imageData = processFileUrl(filePath.c_str(), Width, Height);
     ASVLOFFSCREEN offscreen = { 0 };
-    MUInt8* imageData;
-    processFileUrl(filePath.c_str(), imageData, offscreen);
+    ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, 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) {
+        SafeFree(imageData);
         return obj;
     }
     Napi::Array list = Napi::Array::New(env, detectedFaces.faceNum);
@@ -275,11 +277,10 @@ Napi::Value ASK::faceFeatureExtractUrl(const Napi::CallbackInfo& info) {
         
     }
     obj.Set(Napi::String::New(env, "faceRects"), list);
-    SafeArrayDelete(imageData);
+    SafeFree(imageData);
     return obj;
 }
 
-
 Napi::Value ASK::faceFeatureInfo(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     int length = info.Length();
@@ -288,9 +289,10 @@ Napi::Value ASK::faceFeatureInfo(const Napi::CallbackInfo& info) {
         return errorData(env, "input expected"); //Napi::Number::New(info.Env(), -1);
     }
     string filePath = info[0].As<Napi::String>().ToString();
+    int Width, Height;
+    MUInt8* imageData = processFile(filePath.c_str(), Width, Height);
     ASVLOFFSCREEN offscreen = { 0 };
-    MUInt8* imageData;
-    processFile(filePath.c_str(), imageData, offscreen);
+    ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, imageData, offscreen);
     ASF_MultiFaceInfo detectedFaces = { 0 };
     MRESULT res = ASFDetectFacesEx(this->handle, &offscreen, &detectedFaces);
 
@@ -300,6 +302,7 @@ Napi::Value ASK::faceFeatureInfo(const Napi::CallbackInfo& info) {
     Napi::Object obj = Napi::Object::New(env);
     obj.Set(Napi::String::New(env, "faceNum"), detectedFaces.faceNum);
     if (0 == detectedFaces.faceNum) {
+        SafeFree(imageData);
         return obj;
     }
     //计算年龄
@@ -318,7 +321,7 @@ Napi::Value ASK::faceFeatureInfo(const Napi::CallbackInfo& info) {
         genderList[i] = *(gender.genderArray + i);
     }
     obj.Set(Napi::String::New(env, "genders"), genderList);
-    SafeArrayDelete(imageData);
+    SafeFree(imageData);
     return obj;
 }
 
@@ -328,7 +331,6 @@ void strToFeatureInfo(string& feature, ASF_FaceFeature& featureInfo) {
     featureInfo.feature = reinterpret_cast<MByte*>(feature11);
 }
 
-
 Napi::Value ASK::faceFeatureCompare(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     //printf("AcceptArrayBuffer from js %d \n", info.Length());
@@ -361,10 +363,10 @@ Napi::Value ASK::faceFeatureCompare(const Napi::CallbackInfo& info) {
 
 }
 
-
-bool compareScore(MFaceSore& a, MFaceSore& b){
-    if (b.score > a.score) return false;
-    return true;
+bool compareScore(const MFaceSore& a, const MFaceSore& b){
+    // if (b.score > a.score) return false;
+    // return true;
+    return a.score > b.score;//
 }
 
 Napi::Value ASK::ImageFaceCompare(const Napi::CallbackInfo& info) {
@@ -375,14 +377,17 @@ Napi::Value ASK::ImageFaceCompare(const Napi::CallbackInfo& info) {
         return errorData(env, "input expected"); 
     }
     string filePath = info[0].As<Napi::String>().ToString();
+    int Width, Height;
+    MUInt8* imageData = processFile(filePath.c_str(), Width, Height);
     ASVLOFFSCREEN offscreen = { 0 };
-    MUInt8* imageData;
-    processFile(filePath.c_str(), imageData, offscreen);
+    ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, 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) {
+        SafeFree(imageData);
         return obj;
     }
 
@@ -412,7 +417,7 @@ Napi::Value ASK::ImageFaceCompare(const Napi::CallbackInfo& info) {
         
         ASF_FaceFeatureInfo* info = new ASF_FaceFeatureInfo();
         info->searchId = searchId;
-        info->tag = (*tag).c_str();
+        info->tag = *tag; //(*tag).c_str();
         info->feature = featureInfo;
         featureInfoList[i] = *info;
     }
@@ -455,7 +460,7 @@ Napi::Value ASK::ImageFaceCompare(const Napi::CallbackInfo& info) {
         delete []faceScores;
     }
     obj.Set(Napi::String::New(env, "faceRects"), list);
-    SafeArrayDelete(imageData);
+    SafeFree(imageData);
     delete []featureInfoList;
     return obj;
 }
@@ -472,69 +477,66 @@ Napi::Value ASK::RegisterFaces(const Napi::CallbackInfo& info) {
         Napi::TypeError::New(env, "array expected").ThrowAsJavaScriptException();
         return errorData(env, "array expected"); 
     }
-    Napi::Array arr = info[1].As<Napi::Array>();
+    Napi::Array arr = info[0].As<Napi::Array>();
+    m_vecFeatureInfoList.clear();
+
     MUInt32 len = arr.Length();
-    ASF_FaceFeatureInfo* featureInfoList = new ASF_FaceFeatureInfo[len];
+    //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>();
+        // 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;
+        // std::string* feature = new std::string();
+        // *feature = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::String>().ToString();
+        std::string strFeature = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::String>().ToString();
+        strToFeatureInfo(strFeature, *featureInfo);
+        // featureInfoList[i].searchId = searchId;
+        // featureInfoList[i].tag = *tag; //(*tag).c_str();
+        // featureInfoList[i].feature = featureInfo;
+        ASF_FaceFeatureInfo fInfo = {0};
+        fInfo.searchId = searchId;
+        fInfo.tag = obj.Get(static_cast<napi_value>(Napi::String::New(env,"tag"))).As<Napi::String>().ToString();
+        fInfo.feature = featureInfo;
+        m_vecFeatureInfoList.push_back(fInfo);
+    }
+    // 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 ASK::faceReg(std::vector<ASF_FaceFeatureInfo>& vecFeatureInfoList, ASF_MultiFaceInfo& detectedFaces, Napi::Env& env, ASVLOFFSCREEN& offscreen) {
     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) {
+        MRESULT res = ASFFaceFeatureExtractEx(handle, &offscreen, &sData, &feature);
+        vector<MFaceSore> vecfaceScores;
+        for(int j = 0; j < vecFeatureInfoList.size(); ++j) {
+            ASF_FaceFeatureInfo& fInfo = vecFeatureInfoList[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;
+            MRESULT res1 = ASFFaceFeatureCompare(this->handle, &feature, fInfo.feature, &confidenceLevel);
+            //cout << " confidenceLevel: " << confidenceLevel;
+            MFaceSore sInfo;
+            sInfo.searchId = fInfo.searchId;
+            sInfo.score = confidenceLevel;
+            sInfo.name = fInfo.tag;
+		    vecfaceScores.push_back(sInfo);
         }
-        sort(faceScores, faceScores + mFeatureLen, compareScore);
-        int ll = mFeatureLen > 5? 5 : mFeatureLen;
+        sort(vecfaceScores.begin(), vecfaceScores.end(), compareScore);
+        int ll = vecfaceScores.size() > 3? 3 : vecfaceScores.size();
         Napi::Array mFaceScores = Napi::Array::New(env, ll);
+        //cout << " i=" << i << ", len=" << ll << ",mFeatureLen=" << vecFeatureInfoList.size() << endl;
         for(int n = 0; n < ll; ++n) {
+            MFaceSore& sInfo = vecfaceScores[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);
+            faceScore.Set(Napi::String::New(env, "searchId"), sInfo.searchId);
+            faceScore.Set(Napi::String::New(env, "score"), sInfo.score);
+            faceScore.Set(Napi::String::New(env, "name"), sInfo.name);
+            //cout << "name:" << sInfo.name << ",searchId:" << sInfo.searchId << ",score=" << sInfo.score << endl;
             mFaceScores[n] = faceScore;
         }
         Napi::Object data = Napi::Object::New(env);
@@ -544,18 +546,41 @@ Napi::Value ASK::ImageFaceCompareUrl2(const Napi::CallbackInfo& info) {
         data.Set(Napi::String::New(env, "bottom"), sData.faceRect.bottom);
         data.Set(Napi::String::New(env, "faceScores"), mFaceScores);
         list[i] = data;
-        delete []faceScores;
+        vecfaceScores.clear();
+    }
+    //obj.Set(Napi::String::New(env, "faceRects"), list);
+    return list;
+}
+
+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();
+    int Width, Height;
+    MUInt8* imageData = processFileUrl(filePath.c_str(), Width, Height);
+    ASVLOFFSCREEN offscreen = { 0 };
+    ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, 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) {
+        SafeFree(imageData);
+        return obj;
+    }
+    Napi::Array list = faceReg(this->m_vecFeatureInfoList, detectedFaces, env, offscreen);
     obj.Set(Napi::String::New(env, "faceRects"), list);
-    SafeArrayDelete(imageData);
-    // for(int i = 0; i < len; ++i) {
-    //     delete featureInfoList[i].feature;
-    // }
-    //delete []featureInfoList;
+    SafeFree(imageData);
     return obj;
 }
 
 
+
 Napi::Value ASK::ImageFaceCompareUrl(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     int length = info.Length();
@@ -564,15 +589,17 @@ Napi::Value ASK::ImageFaceCompareUrl(const Napi::CallbackInfo& info) {
         return errorData(env, "input expected"); 
     }
     string filePath = info[0].As<Napi::String>().ToString();
+    int Width, Height;
+    MUInt8* imageData = processFileUrl(filePath.c_str(), Width, Height);
     ASVLOFFSCREEN offscreen = { 0 };
-    MUInt8* imageData;
-    processFileUrl(filePath.c_str(), imageData, offscreen);
+    ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, 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);
+        SafeFree(imageData);
         return obj;
     }
 
@@ -583,69 +610,26 @@ Napi::Value ASK::ImageFaceCompareUrl(const Napi::CallbackInfo& info) {
     }
     Napi::Array arr = info[1].As<Napi::Array>();
     MUInt32 len = arr.Length();
-    ASF_FaceFeatureInfo* featureInfoList = new ASF_FaceFeatureInfo[len];
+
+    std::vector<ASF_FaceFeatureInfo> vecFeatureInfoList;
     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>();
+        std::string strFeature = obj.Get(static_cast<napi_value>(Napi::String::New(info.Env(),"feature"))).As<Napi::String>().ToString();
         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);
-        // 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
-    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);
-            //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;
-        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;
-    }
+        strToFeatureInfo(strFeature, *featureInfo);
+        ASF_FaceFeatureInfo fInfo = {0};
+        fInfo.searchId = searchId;
+        fInfo.tag = obj.Get(static_cast<napi_value>(Napi::String::New(env,"tag"))).As<Napi::String>().ToString();
+        fInfo.feature = featureInfo;
+        vecFeatureInfoList.push_back(fInfo);
+    }
+    Napi::Array list = faceReg(vecFeatureInfoList, detectedFaces, env, offscreen);
     obj.Set(Napi::String::New(env, "faceRects"), list);
-    SafeArrayDelete(imageData);
+    SafeFree(imageData);
     for(int i = 0; i < len; ++i) {
-        delete featureInfoList[i].feature;
+        delete vecFeatureInfoList[i].feature;
     }
-    delete []featureInfoList;
     return obj;
 }
 
@@ -732,8 +716,9 @@ int ASK::ColorSpaceConversion(MInt32 width, MInt32 height, MInt32 format, MUInt8
 	return 1;
 }
 
-//读取文件 图片修正 并颜色通道转换
-void ASK::processFile(const char*  filePath, MUInt8* imageData, ASVLOFFSCREEN& offscreen) {
+
+
+MUInt8* ASK::processFile(const char*  filePath, int& picWidth, int& picHeight) {
     cv::Mat src = imread(filePath);
     cout<<filePath<<endl;
     int Width = src.cols;
@@ -741,24 +726,29 @@ void ASK::processFile(const char*  filePath, MUInt8* imageData, ASVLOFFSCREEN& o
     cout << "Width:" << Width << ",Height:"<<Height<<endl;
     int wScore = Width % 4;
     int hScore = Height % 2;
+    cv::Mat dest;
     if (wScore != 0 || hScore != 0) {
         Width -= wScore;
         Height -= hScore;
         cv::Mat dst;
         cv::resize(src, dst, cv::Size(Width, Height));
-        src.release();
-        src = dst;
+        src.release();  
+        cvtColor(dst, dest, COLOR_BGR2YUV_I420);
+        dst.release();
+    } else {
+        cvtColor(src, dest, COLOR_BGR2YUV_I420);
     }
-    cv::Mat dest;
-    cvtColor(src, dest, COLOR_BGR2YUV_I420);
     int len = Height*Width*3/2;
-    imageData = (MUInt8*)malloc(len);
+    MUInt8* 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);
+    picHeight = Height;
+    picWidth = Width;
+    return imageData;
 }
+
 //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
@@ -790,30 +780,35 @@ cv::Mat curlImg(const char *img_url, int timeout=100000)
     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) {
+
+MUInt8* ASK::processFileUrl(const char*  url, int& picWidth, int& picHeight) {
     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;
+    cv::Mat dest;
     if (wScore != 0 || hScore != 0) {
         Width -= wScore;
         Height -= hScore;
         cv::Mat dst;
         cv::resize(src, dst, cv::Size(Width, Height));
         src.release();
-        src = dst;
+        cvtColor(dst, dest, COLOR_BGR2YUV_I420);
+        dst.release();
+    } else {
+        cvtColor(src, dest, COLOR_BGR2YUV_I420);
     }
-    cv::Mat dest;
-    cvtColor(src, dest, COLOR_BGR2YUV_I420);
     int len = Height*Width*3/2;
-    imageData = (MUInt8*)malloc(len);
+    MUInt8* 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);
+    picHeight = Height;
+    picWidth = Width;
+    return imageData;
 }
 
 
@@ -826,8 +821,65 @@ void ASK::processFileUrl(const char*  url, MUInt8* imageData, ASVLOFFSCREEN& off
 
 
 
+// //读取文件 图片修正 并颜色通道转换
+// 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;
+//     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);
+//     //imageData = new MUInt8[len];
+//     memset(imageData, 0, len);    
+//     memcpy(imageData, dest.data, len);
+//     //free(imageData);
+//     src.release();
+//     dest.release();
+//     ColorSpaceConversion(Width, Height, ASVL_PAF_NV21, imageData, offscreen);
+// }
 
-
+// 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;
+//     cv::Mat dest;
+//     if (wScore != 0 || hScore != 0) {
+//         Width -= wScore;
+//         Height -= hScore;
+//         cv::Mat dst;
+//         cv::resize(src, dst, cv::Size(Width, Height));
+//         src.release();
+//         //src = dst;
+//         cvtColor(dst, dest, COLOR_BGR2YUV_I420);
+//         dst.release();
+//     } else {
+//         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);
+// }
 
 
 
@@ -915,71 +967,3 @@ void ASK::processFileUrl(const char*  url, MUInt8* imageData, ASVLOFFSCREEN& off
 
 
 
-
-// #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;
-// }
-