Merge branch 'master' of ssh://192.168.5.5:29418/valib/gosdk

chenshijun

2019-10-22 1b388e4b0207003630c326ba1e71af8c8746070f

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
#include "tracker.h"
 
#include <stdio.h>
#include "THFaceTracking_i.h"
 
namespace csdk_wrap{
    static THFT_Param param;
    int init_face_tracker(const int tm, const int gi,const int w, const int h,
                    const int maxFaces, const int detinterval,  const int sampleSize,
                              VecFunc &vec){
        param.nDeviceID = gi;
        param.nImageWidth = w;
        param.nImageHeight = h;
        param.nMaxFaceNum = maxFaces;
        param.nSampleSize = sampleSize > 0 ? sampleSize : w/2;
        param.nDetectionIntervalFrame = detinterval;
printf("threads %d gi: %d size: %dx%d maxface: %d, sample: %d, interval: %d\n",
            tm, gi, w, h, maxFaces, sampleSize, detinterval);
        auto nNum = THFT_Create(tm, &param);
        if(nNum != tm){
            printf("create face detector failed!\n");
        }else{
            vec.emplace_back([]{THFT_Release();});
        }
        return nNum;
    }
 
    cRECT* face_track_only(int *faceCount, const cIMAGE *img, const int chan){
 
        *faceCount = 0;
 
        cRECT *pFaces = (cRECT*)malloc(param.nMaxFaceNum * sizeof(cRECT));
        auto nNum = THFT_FaceOnly(chan, img->data, img->width, img->height, (tagRECT*)pFaces, param.nMaxFaceNum, param.nSampleSize);
        if (nNum > 0)
        {
            *faceCount = nNum;
        }else{
            free(pFaces);
            pFaces = NULL;
        }
        return pFaces;
    }
 
    cFaceInfo* face_track_detect(int *faceCount, const cIMAGE *img, const int chan){
        *faceCount = 0;
 
        cFaceInfo* pFaceInfos = (cFaceInfo*)malloc(param.nMaxFaceNum * sizeof(cFaceInfo));
        auto nNum = THFT_FaceDetect(chan, img->data, img->width, img->height, (THFT_FaceInfo*)pFaceInfos, param.nMaxFaceNum, param.nSampleSize);
        if (nNum > 0){
            *faceCount = nNum;
        }else{
            free(pFaceInfos);
            pFaceInfos = NULL;
        }
        return pFaceInfos;
    }
 
    cFaceInfo* face_track(int *faceCount, const cIMAGE *img, const int chan){
        *faceCount = 0;
 
        cFaceInfo* pFaceInfos = (cFaceInfo*)malloc(param.nMaxFaceNum * sizeof(cFaceInfo));
        auto nNum = THFT_FaceTracking(chan, img->data, (THFT_FaceInfo*)pFaceInfos);
        if (nNum > 0){
            *faceCount = nNum;
        }else{
            free(pFaceInfos);
            pFaceInfos = NULL;
        }
        return pFaceInfos;
    }
 
    //THFACETRACKING_API int    THFT_Reset(short nChannelID, THFT_Param* pParam);
    int sdkface::face_track_resize(const int chan, const int w, const int h){
        THFT_Param tmpParam;
        tmpParam.nDeviceID = param.nDeviceID;
        tmpParam.nImageWidth = w;
        tmpParam.nImageHeight = h;
        tmpParam.nMaxFaceNum = param.nMaxFaceNum;
        tmpParam.nSampleSize = param.nSampleSize;
        tmpParam.nDetectionIntervalFrame = param.nDetectionIntervalFrame;
 
        printf("chan %d size: %dx%d", chan, w, h);
 
        auto flag = THFT_Reset(chan, &tmpParam);
 
        return flag;
    }
 
}