pans
2017-01-10 21d2e4cd4e3ec5ec6f7f32ed5426b069a303adfb
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
#include "faceAPI.h"
 
faceDB *fdb;
faceAPI::faceAPI()
{
    //创建静态人脸识别句柄,同时创建状态标量
    cv_result_t cv_result = 0;
 
    //faceDB* f_db = faceDB.GetInstance();
    fdb=new faceDB();
}
 
faceAPI::~faceAPI()
{
 
}
 
//@brief 搜索功能
//@param 图片
//@return 人脸id
int faceAPI::do_reasch(cv::Mat image)
{
    if (!image.data) {
        fprintf(stderr, "fail to read img\n");
        return -1;
    } else
        fprintf(stderr, "read img\n");
    p_f = fdb->extract_feature(image);
    fprintf(stderr, "fdb->extract_feature(image)\n");
    if (!p_f) {
        fprintf(stderr, "p_f is null\n");
        return -2;
    }
    return p_img_search(p_f);
}
 
//@brief 搜索功能
//@param 字符串格式的特征值
//@return 人脸id
int faceAPI::do_reasch(char* s_feature)
{
    get_feature(s_feature,p_f);
    return p_img_search(p_f);
}
 
//@brief 注册功能
//@param 图片
//@return 人脸id
int faceAPI::do_register(cv::Mat image)
{
    p_f = fdb->extract_feature(image);
    int indx = fdb->db_add(p_f);
    if(fdb->db_save())
        return indx;
    return -2;
}
 
//@brief 在数据库中搜索人脸id
//@param 特征值
//@return 人脸id
int faceAPI::p_img_search(cv_feature_t *p_feature)
{
    std::cout<<"p img search"<<std::endl;
 
    return fdb->search_db(p_feature);
}
 
//@brief 特征值转换为字符串
//@param 特征值
//@param 字符串格式的特征值
//@return 状态量
int faceAPI::get_char(cv_feature_t *p_feature,char* feature_str)
{
 
    return cv_verify_serialize_feature(p_feature,feature_str);
}
 
//@brief 字符串转换为特征值
//@param 字符串格式的特征值
//@param 特征值
//@return 状态量
int faceAPI::get_feature(char *feature_str,cv_feature_t *p_feature)
{
 
    p_feature = cv_verify_deserialize_feature(feature_str);
    if(p_feature != NULL) {
        return 0;
    } else
        return -1;
}
 
//faceDB实现部分
#include <iostream>
 
//"./out1.db"
char *db_path = "out.db";
 
faceDB::faceDB()
{
    // 创建人脸数据库句柄
    cv_verify_create_db(&handle_db);
    fprintf(stderr, "create cv_verify_create_db\n");
    cv_verify_create_handle(&handle_verify, "../models/verify.model");
    fprintf(stderr, "create cv_verify_create_handle\n");
    cv_face_create_detector(&handle_detect, NULL, CV_DETECT_ENABLE_ALIGN_21);
    fprintf(stderr, "create cv_face_create_detector\n");
    db_load();
    fprintf(stderr, "db load\n");
}
 
faceDB::~faceDB() {}
 
/*
faceDB* faceDB::GetInstance(){
    if (db == NULL)
    {
        db = new faceDB();
    }
 
    return db;
}*/
 
//@brief 数据库添加数据
//@param 特征值
//@return 人脸id
int faceDB::db_add(cv_feature_t* p_feature)
{
    int idx;
    cv_result_t cv_result = cv_verify_add_face(handle_db, p_feature, &idx);
    if (cv_result != CV_OK) {
        fprintf(stderr, "cv_verify_add_face failed, error code %d\n", cv_result);
    }
    cv_verify_release_feature(p_feature);
    return idx;
}
 
 
//@brief 保存数据库
//@return 状态量
bool faceDB::db_save()
{
    cv_result = cv_verify_save_db(handle_db, db_path);
    if (cv_result != CV_OK) {
        fprintf(stderr, "cv_verify_save_db failed, error code %d\n", cv_result);
        return false;
    } else {
        fprintf(stderr, "save done!\n");
    }
 
    return true;
}
 
//@brief 加载数据库
//@return 状态量
bool faceDB::db_load()
{
    if (handle_db != NULL) {
        fprintf(stderr, "handle_db is not null!%s\n",db_path);
    } else {
        fprintf(stderr, "handle_db is null!%s\n",db_path);
    }
    cv_result = cv_verify_load_db(handle_db, db_path);
    if (cv_result != CV_OK) {
        fprintf(stderr, "cv_verify_load_db failed, error code %d\n", cv_result);
        return false;
    } else {
        fprintf(stderr, "load done!\n");
    }
 
    return true;
}
 
//@brief 搜索数据库
//@param 人脸特征值
//@return 人脸id
int faceDB::search_db(cv_feature_t *p_feature)
{
    int indx=-1;
    //查询前10条
    int top_k = 3;
    int *top_idxs = new int[top_k];
    float *top_scores = new float[top_k];
    unsigned int result_length = 0;
    cv_result = cv_verify_search_face(handle_verify, handle_db,
                                      p_feature, top_k,
                                      top_idxs, top_scores, &result_length);
 
 
    if (cv_result == CV_OK) {
        //输出检查结果
        for (unsigned int t = 0; t < result_length; t++) {
            // const cv_feature_t item = result[t].item;
            fprintf(stderr, "%d\t", top_idxs[t]);
            fprintf(stderr, "%0.2f\n", top_scores[t]);
        }
    } else {
        fprintf(stderr, "cv_verify_search_face failed, error code %d\n", cv_result);
    }
    std::cout<<"this is hits"<<std::endl;
    if (top_scores[0] != 0) {
        indx=top_idxs[0];
        std::cout<<"indx="<<indx<<std::endl;
    }
    if (top_idxs) {
        delete[]top_idxs;
    }
    if (top_scores) {
        delete[]top_scores;
    }
    cv_verify_release_feature(p_feature);
    std::cout<<"return indx"<<std::endl;
    return indx;
}
 
//@brief 提取特征值
//@param 图片
//@return 特征值
cv_feature_t* faceDB::extract_feature(cv::Mat image_color)
{
    if (handle_verify != NULL) {
        fprintf(stderr, "fdb.handle_verify is not null!\n");
    } else {
        fprintf(stderr, "fdb.handle_verify is null!\n");
    }
 
    cv_feature_t *p_feature = NULL;
    cv_face_t *p_face = NULL;
    int face_count = 0;
    cv_result_t st_result = CV_OK;
    st_result = cv_face_detect(handle_detect, image_color.data, CV_PIX_FMT_BGR888,
                               image_color.cols, image_color.rows, image_color.step,
                               CV_FACE_UP, &p_face, &face_count);
    if (face_count >= 1) {
        st_result = cv_verify_get_feature(handle_verify,
                                          (unsigned char *)image_color.data, CV_PIX_FMT_BGR888,
                                          image_color.cols, image_color.rows, image_color.step,
                                          p_face, &p_feature, NULL);
        if (st_result != CV_OK) {
            fprintf(stderr, "cv_verify_get_feature failed, error code %d\n", st_result);
        }
    } else {
        fprintf(stderr, "can't find face in ");
    }
    // release the memory of face
    cv_face_release_detector_result(p_face, face_count);
    return p_feature;
}