派生自 development/c++

pansen
2019-03-05 ed223aee5fe5f3b222488549597976f34c679c3d
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
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
//
// Created by pans on 4/27/18.
//
#include <iostream>
#include <string>
#include <basic/util/app/AppPreference.hpp>
#include <atomic>
 
#include "CasiaFaceWrapperN.h"
 
using namespace std;
 
std::atomic_int CasiaFaceWrapperN::instanceCount(0);
 
CasiaFaceWrapperN::CasiaFaceWrapperN() {
    threadMax = appPref.getLongData("thread.max");
//    long gpuIndex = appPref.getLongData("gpu.index");
//    for(int i = 0;i<threadMax;i++){
//        resourcesManager.pushResource(i);
//    }
//    if(gpuIndex < 0){
//        THFI_Param* param = new THFI_Param[threadMax];
////        THFI_Create(threadMax, param);
//        CHKERR(THFI_Create(threadMax, param), threadMax, "THFI_Create return");//old version ,default GPU device ID is 0
//        CHKERR(EF_Init(threadMax), threadMax, "EF_Create return");//old version ,default GPU device ID is 0
//        delete[] param;
//    }else{
//        THFI_Param_Ex* param = new THFI_Param_Ex[threadMax];
//        THFI_Param detParam;
//        EF_Param pParam[threadMax];
//        detParam.nMinFaceSize = 20;
//        detParam.nRollAngle = 60;
//        for(int i = 0;i<threadMax;i++){
//            param[i].tp = detParam;
//            param[i].nDeviceID = gpuIndex;
//            pParam[i].nDeviceID = gpuIndex;//GPU device ID,eg:0,1,2....
//        }
//        THFI_Create_Ex(threadMax, param);
//        CHKERR(EF_Init_Ex(threadMax,pParam), threadMax, "EF_Create return");//old version ,default GPU device ID is 0
////        EF_Init_Ex(gpuIndexs.size(),pParam);
//        delete[] param;
//    }
//    THFP_Create(threadMax);
 
    channel = instanceCount;
    THFI_Param detParam;
    detParam.nMinFaceSize = 50;
    detParam.nRollAngle = 60;
    if(instanceCount++ == 0){
//        if(gpuIndexs.empty()){
            CHKERR(THFI_Create(threadMax, &detParam), threadMax, "THFI_Create return");//old version ,default GPU device ID is 0
            CHKERR(EF_Init(threadMax), threadMax, "EF_Create return");//old version ,default GPU device ID is 0
//        }
//        else{
//            THFI_Param_Ex pParamx[gpuIndexs.size()];
//            EF_Param pParam[gpuIndexs.size()];
//            for(int i = 0; i<gpuIndexs.size(); i++){
//                pParamx[i].tp=detParam;
//                pParamx[i].nDeviceID=gpuIndexs[i];//GPU device ID,eg:0,1,2....
//                pParam[i].nDeviceID=gpuIndexs[i];//GPU device ID,eg:0,1,2....
//            }
//            int ret=THFI_Create_Ex(gpuIndexs.size(), pParamx);
//            if(ret !=gpuIndexs.size()){
//                printf("THFI_Create failed!(ret=%d)\n",ret);
//            }
//            ret=EF_Init_Ex(gpuIndexs.size(),pParam);
//            if(ret !=gpuIndexs.size()){
//                printf("EF_Init_Ex failed!(ret=%d)\n",ret);
//            }
//        }
    }else if(instanceCount> threadMax){
        channel = -1;
        ERR("too many channels instanced, channel "<<channel<<" instance faild.");
    }
 
}
 
CasiaFaceWrapperN::~CasiaFaceWrapperN() {
    //#todo
    THFI_Release();
    THFP_Release();
}
 
float CasiaFaceWrapperN::compareFeature(std::vector<unsigned char> &feature1, std::vector<unsigned char> &feature2) {
    if(feature1.size()!= EF_Size()){
        ERR("feature1 size is not incorrect");
        return 0;
    }else if(feature2.size()!= EF_Size()){
        ERR("feature2 size is not incorrect");
        return 0;
    }
    return EF_Compare(feature1.data(), feature2.data());
}
#define COPY(NAME) memcpy(&face.NAME, &pos.NAME, sizeof (pos.NAME));s
Features CasiaFaceWrapperN::extractFace(FaceImageN img) {
    Features results;
    if(channel ==-1){
        ERR("invalid face channel, face detect faild");
        return results;
    }
    vector<unsigned char> feature;
    THFI_FacePos facesPos[30];
//    int channel;
//    for(int loop = 0;loop < threadMax;loop++){
//        channel = resourcesManager.getAvilableChannel(to_string(loop));
//        if(channel > 0){
//            cout << channel << endl;
//            break;
//        }
//    }
    int faceNum = THFI_DetectFace(channel, img.data,24, img.width, img.height, facesPos ,30);
    if(faceNum>0){
        if(feature.size()!= EF_Size()*faceNum){
            feature.resize(EF_Size()*faceNum);
        }
        CHKERR(EF_Extract_M(channel, img.data, img.width, img.height, 3, facesPos, feature.data(), faceNum), 1, " return");
        for(int i = 0; i< faceNum; i++){
            FaceFeaWithScore result;
            THFI_FacePos& face = facesPos[i];
            result.left = face.rcFace.left;
            result.top = face.rcFace.top;
            result.width = face.rcFace.right - face.rcFace.left;
            result.height = face.rcFace.bottom - face.rcFace.top;
            result.score = face.fAngle.confidence;
//            if(face.fAngle.confidence >= 0.6){
                if((face.fAngle.pitch >-30 || face.fAngle.pitch <30 ) &&
                   (face.fAngle.roll >-30 || face.fAngle.roll <30 ) &&
                   (face.fAngle.yaw >-30 || face.fAngle.yaw <30 )){
                    result.feature.resize(EF_Size());
                    memcpy(result.feature.data(),feature.data()+i*EF_Size(),EF_Size());
                    results.push_back(result);
                }
//            }
        }
    } else{
        DBG("faceNum is < 0");
    }
    return results;
}
 
 
//#todo
//Features CasiaFaceWrapperN::extractFace(FaceImageN &img, THFI_FacePos& facePos,int faceNum) {
//    return Features();
//}