package main
|
|
/*
|
#cgo CFLAGS: -I${SRCDIR}/sdk/include -w -g
|
#cgo CXXFLAGS: -I${SRCDIR}/sdk/include -w -g -std=c++11
|
#cgo LDFLAGS: -L/usr/local/cuda-8.0/lib64 -L${SRCDIR}/sdk/lib
|
#cgo LDFLAGS: -Wl,-rpath,${SRCDIR}/sdk/lib
|
#cgo LDFLAGS: -lTHFaceImage -lTHFeature -lTHFaceProperty -lTHFaceTracking
|
#cgo LDFLAGS: -lcudart -lcublas -lcurand -lrt -ldl -lpthread
|
#include <stdlib.h>
|
#include "cface.h"
|
*/
|
import "C"
|
import (
|
"unsafe"
|
|
"basic.com/libgowrapper/sdkstruct.git"
|
)
|
|
// SDKFace sdk
|
type SDKFace struct {
|
handle unsafe.Pointer
|
detector bool
|
extractor bool
|
propertizer bool
|
tracker bool
|
fnLogger func(...interface{})
|
}
|
|
// NewSDK sdk
|
func NewSDK(fn func(...interface{})) interface{} {
|
h := C.create_sdkface()
|
if h == nil {
|
return nil
|
}
|
|
return &SDKFace{
|
handle: h,
|
detector: false,
|
extractor: false,
|
propertizer: false,
|
tracker: false,
|
fnLogger: fn,
|
}
|
}
|
|
// Free free
|
func Free(i interface{}) {
|
s := i.(*SDKFace)
|
if s != nil && s.handle != nil {
|
C.release(s.handle)
|
}
|
}
|
|
func (s *SDKFace) printLog(l ...interface{}) {
|
if s.fnLogger != nil {
|
s.fnLogger(l)
|
}
|
}
|
|
// Detector detector
|
func Detector(i interface{}, minFaces, rollAngles, threadMax, gpu int) bool {
|
s := i.(*SDKFace)
|
if s.detector {
|
return true
|
}
|
ret := C.init_detector(s.handle, C.int(minFaces), C.int(rollAngles), C.int(threadMax), C.int(gpu))
|
if ret <= 0 {
|
s.printLog("->face--> CREATE Detector ERROR")
|
return false
|
}
|
s.detector = true
|
return true
|
}
|
|
// Extractor ext
|
func Extractor(i interface{}, threadMax, gpu int) bool {
|
s := i.(*SDKFace)
|
if s.extractor {
|
return true
|
}
|
ret := C.init_extractor(s.handle, C.int(threadMax), C.int(gpu))
|
if ret <= 0 {
|
s.printLog("->face--> CREATE Extractor ERROR")
|
return false
|
}
|
s.extractor = true
|
return true
|
}
|
|
// Propertizer prop
|
func Propertizer(i interface{}, threadMax int) bool {
|
s := i.(*SDKFace)
|
if s.propertizer {
|
return true
|
}
|
ret := C.init_propertizer(s.handle, C.int(threadMax))
|
if ret <= 0 {
|
s.printLog("->face--> CREATE Propertizer ERROR")
|
return false
|
}
|
s.propertizer = true
|
return true
|
}
|
|
// Tracker track
|
func Tracker(i interface{}, w, h, maxFaces, interval, sampleSize, threadMax, gpu int) bool {
|
s := i.(*SDKFace)
|
if s.tracker {
|
return s.tracker
|
}
|
ret := C.init_tracker(s.handle, C.int(w), C.int(h), C.int(maxFaces), C.int(interval), C.int(sampleSize), C.int(threadMax), C.int(gpu))
|
|
if ret <= 0 {
|
s.printLog("->face--> CREATE Tracker ERROR")
|
return false
|
}
|
s.tracker = true
|
return true
|
}
|
|
// CFacePosArrayToGoArray convert cFacePos array to go
|
func CFacePosArrayToGoArray(cArray unsafe.Pointer, count int) (goArray []sdkstruct.CFacePos) {
|
p := uintptr(cArray)
|
|
for i := 0; i < count; i++ {
|
j := *(*sdkstruct.CFacePos)(unsafe.Pointer(p))
|
|
goArray = append(goArray, j)
|
|
p += unsafe.Sizeof(j)
|
}
|
return
|
}
|
|
// Detect det
|
func Detect(s *SDKFace, data []byte, w, h, c int, ch int) []sdkstruct.CFacePos {
|
if !s.detector {
|
return nil
|
}
|
|
var cfpos unsafe.Pointer
|
var count C.int
|
ret := C.detect(s.handle, unsafe.Pointer(&data[0]), C.int(w), C.int(h), C.int(c), C.int(ch), &cfpos, &count)
|
if ret > 0 {
|
return CFacePosArrayToGoArray(cfpos, int(count))
|
}
|
s.printLog("->face--> Detect No One, Ret: ", ret)
|
return nil
|
}
|
|
// Extract extract
|
func Extract(s *SDKFace, fpos sdkstruct.CFacePos, data []byte, w, h, c int, ch int) []byte {
|
|
pos := (*C.cFacePos)(unsafe.Pointer(&fpos))
|
|
//(void *handle, const cFacePos *pos, const void*data, const int w, const int h, const int c, const int chan, void **feat, int *featLen);
|
var feat unsafe.Pointer
|
var featLen C.int
|
ret := C.extract(s.handle, pos, unsafe.Pointer(&data[0]), C.int(w), C.int(h), C.int(c), C.int(ch), &feat, &featLen)
|
if ret > 0 {
|
return C.GoBytes(feat, featLen)
|
}
|
s.printLog("->face--> Extract Nothing, Ret: ", ret)
|
return nil
|
}
|
|
// Compare face compare
|
func Compare(i interface{}, feat1 []byte, feat2 []byte) float32 {
|
s := i.(*SDKFace)
|
if s.extractor {
|
return 0
|
}
|
|
res := C.compare(s.handle, (*C.uchar)(unsafe.Pointer(&feat1[0])), (*C.uchar)(unsafe.Pointer(&feat2[0])))
|
return float32(res)
|
}
|
|
// Propertize prop
|
func Propertize(s *SDKFace, fpos sdkstruct.CFacePos, data []byte, w, h, c int, ch int) *sdkstruct.CThftResult {
|
if !s.propertizer {
|
return nil
|
}
|
|
pos := (*C.cFacePos)(unsafe.Pointer(&fpos))
|
|
var thft unsafe.Pointer
|
ret := C.propertize(s.handle, pos, unsafe.Pointer(&data[0]), C.int(w), C.int(h), C.int(c), C.int(ch), &thft)
|
if ret == 0 {
|
gothft := *(*sdkstruct.CThftResult)(thft)
|
C.free(thft)
|
return &gothft
|
}
|
s.printLog("->face--> Propertize Nothing, Ret: ", ret)
|
return nil
|
}
|
|
// CFaceInfoArrayToGoArray convert cFaceInfo array to go
|
func CFaceInfoArrayToGoArray(cArray unsafe.Pointer, count int) (goArray []sdkstruct.CFaceInfo) {
|
p := uintptr(cArray)
|
|
for i := 0; i < count; i++ {
|
j := *(*sdkstruct.CFaceInfo)(unsafe.Pointer(p))
|
goArray = append(goArray, j)
|
p += unsafe.Sizeof(j)
|
}
|
return
|
}
|
|
// Track track
|
func Track(s *SDKFace, data []byte, w, h, c int, ch int) []sdkstruct.CFaceInfo {
|
if !s.tracker {
|
return nil
|
}
|
|
//img, const int chan, void **fInfo, int *fcnt);
|
|
var fCount C.int
|
var finfos unsafe.Pointer
|
ret := C.track(s.handle, unsafe.Pointer(&data[0]), C.int(w), C.int(h), C.int(c), C.int(ch), &finfos, &fCount)
|
|
if ret > 0 {
|
faces := CFaceInfoArrayToGoArray(finfos, int(fCount))
|
//if len(faces) > 0{
|
// fmt.Println("faces detected:", len(faces))
|
//}
|
return faces
|
}
|
return nil
|
}
|
|
// FaceInfo2FacePos info -> pos
|
func FaceInfo2FacePos(face sdkstruct.CFaceInfo) (fPos sdkstruct.CFacePos) {
|
fPos.RcFace = face.RcFace
|
fPos.PtLeftEye = face.PtLeftEye
|
fPos.PtRightEye = face.PtRightEye
|
fPos.PtNose = face.PtNose
|
fPos.PtMouth = face.PtMouth
|
fPos.FAngle.Yaw = face.FAngle.Yaw
|
fPos.FAngle.Pitch = face.FAngle.Pitch
|
fPos.FAngle.Roll = face.FAngle.Roll
|
fPos.FAngle.Confidence = face.FAngle.Confidence
|
|
copy(fPos.PFacialData[:], face.PFacialData[:512])
|
|
return fPos
|
}
|
|
// TrackerResize init face tracker
|
func TrackerResize(i interface{}, w, h, ch int) bool {
|
s := i.(*SDKFace)
|
|
if !s.tracker {
|
s.printLog("->face--> TrackerResize Failed, No Tracker Init")
|
return false
|
}
|
ret := C.resize(s.handle, C.int(w), C.int(h), C.int(ch))
|
if ret == 1 {
|
return true
|
}
|
s.printLog("->face--> TrackerResize Failed, Ret: ", ret, " SDK Channel: ", ch, " Size: ", w, "x", h)
|
return false
|
}
|
|
// Run run
|
func Run(i interface{}, data []byte, w, h, c, dchan int) []sdkstruct.CFaceResult {
|
if data == nil || w <= 0 || h <= 0 {
|
return nil
|
}
|
|
s := i.(*SDKFace)
|
|
if !s.tracker || !s.extractor || !s.propertizer {
|
return nil
|
}
|
|
channel := c
|
if channel == 0 {
|
channel = 3
|
}
|
|
// if !TrackerResize(i, w, h, dchan) {
|
// return nil
|
// }
|
|
var fInfo []sdkstruct.CFaceInfo
|
|
fInfo = Track(s, data, w, h, c, dchan)
|
|
var faces []sdkstruct.CFaceResult
|
//将sdk返回值转换成protomsg类型
|
for _, d := range fInfo {
|
|
//运行sd
|
dec := FaceInfo2FacePos(d)
|
prop := Propertize(s, dec, data, w, h, c, dchan)
|
feat := Extract(s, dec, data, w, h, c, dchan)
|
|
result := sdkstruct.CFaceResult{
|
Info: d,
|
Prop: *prop,
|
Feat: feat,
|
}
|
faces = append(faces, result)
|
|
}
|
|
return faces
|
}
|
