package sdk
|
|
import (
|
"analysis/logo"
|
"analysis/work"
|
"context"
|
"plugin"
|
"time"
|
|
"github.com/gogo/protobuf/proto"
|
|
"basic.com/libgowrapper/sdkstruct.git"
|
"basic.com/pubsub/protomsg.git"
|
"basic.com/valib/gogpu.git"
|
)
|
|
// HumanTracker track
|
type HumanTracker struct {
|
gpu int
|
batchSize int
|
flag int
|
|
handle interface{}
|
fnInit func(int, int, int) interface{}
|
fnFree func(interface{})
|
fnRun func(interface{}, []byte, int, int, int) []sdkstruct.FgResult
|
fnProcess func(interface{}, []sdkstruct.SDKImage) ([]sdkstruct.FgResult, error)
|
fnVer func(interface{}) string
|
fnSimilarity func([]float32, []float32) (float64, error)
|
}
|
|
// NewHumanTracker new
|
func NewHumanTracker(gpu, batchSize, flag int) *HumanTracker {
|
soFile := "libhumantrack.so"
|
|
plug, err := plugin.Open(soFile)
|
if err != nil {
|
logo.Errorln("Open: ", soFile, " error: ", err)
|
return nil
|
}
|
|
fnInit, _ := LoadFunc(plug, soFile, "NewSDK")
|
fnFree, _ := LoadFunc(plug, soFile, "Free")
|
fnRun, _ := LoadFunc(plug, soFile, "Run")
|
fnProc, _ := LoadFunc(plug, soFile, "Process")
|
fnVer, _ := LoadFunc(plug, soFile, "GetVersion")
|
fnSim, _ := LoadFunc(plug, soFile, "CFFSimilarity")
|
|
return &HumanTracker{
|
gpu: gpu,
|
batchSize: batchSize,
|
flag: flag,
|
|
handle: nil,
|
fnInit: fnInit.(func(int, int, int) interface{}),
|
fnFree: fnFree.(func(interface{})),
|
fnRun: fnRun.(func(interface{}, []byte, int, int, int) []sdkstruct.FgResult),
|
fnProcess: fnProc.(func(interface{}, []sdkstruct.SDKImage) ([]sdkstruct.FgResult, error)),
|
fnVer: fnVer.(func(interface{}) string),
|
fnSimilarity: fnSim.(func([]float32, []float32) (float64, error)),
|
}
|
}
|
|
// Init impl
|
func (t *HumanTracker) Init() bool {
|
if t.batchSize != 1 {
|
logo.Errorln("ONLY SUPPORT BATCH SIZE = 1")
|
return false
|
}
|
gpu := t.gpu
|
if gpu == -1 {
|
gpu = gogpu.ValidGPU(2048)
|
}
|
h := t.fnInit(gpu, t.batchSize, t.flag)
|
logo.Infoln("HumanTrack USE GPU: ", gpu)
|
|
if h == nil {
|
logo.Errorln("CREATE HumanTrack DETECTOR ERROR")
|
return false
|
}
|
|
t.handle = h
|
return true
|
}
|
|
// Run impl
|
func (t *HumanTracker) Run(ctx context.Context, in <-chan work.MsgRS, out chan<- work.MsgRS, typ string) {
|
tm := time.Now()
|
sc := 0
|
|
for {
|
select {
|
case <-ctx.Done():
|
return
|
default:
|
rMsg := <-in
|
if !validRemoteMessage(rMsg, typ) {
|
ejectResult(nil, rMsg, out)
|
continue
|
}
|
|
i := unpackImage(rMsg, typ)
|
if i == nil || i.Data == nil || i.Width <= 0 || i.Height <= 0 {
|
ejectResult(nil, rMsg, out)
|
continue
|
}
|
|
imgW, imgH := int(i.Width), int(i.Height)
|
|
// var images []sdkstruct.SDKImage
|
// img := sdkstruct.SDKImage{
|
// Data: i.Data,
|
// Width: imgW,
|
// Height: imgH,
|
// Channel: 3,
|
// }
|
// images = append(images, img)
|
res := t.fnRun(t.handle, i.Data, imgW, imgH, 3)
|
if res != nil {
|
ejectResult(nil, rMsg, out)
|
continue
|
}
|
|
hr := convert2ProtoHumanTrackResult(res)
|
result := protomsg.HumanTrackResult{Result: hr[0]}
|
data, err := proto.Marshal(&result)
|
if err != nil {
|
logo.Errorln("HUMAN TRACKER MARSHAL PROTO PLATE IDS ERROR", err)
|
data = nil
|
}
|
ejectResult(data, rMsg, out)
|
|
/////////////////////////////////////
|
sc++
|
if sc == 25 {
|
logo.Infoln("HUMAN TRACKER RUN 25 FRAME USE TIME: ", time.Since(tm))
|
sc = 0
|
tm = time.Now()
|
}
|
|
if time.Since(tm) > time.Second {
|
logo.Infof("HUMAN TRACKER RUN %d FRAME USE TIME: %v", sc, time.Since(tm))
|
sc = 0
|
tm = time.Now()
|
}
|
|
}
|
}
|
}
|
|
// message HumanTrack {
|
// Rect rcHuman = 1;
|
// float confidence = 2;
|
// int32 x = 3;
|
// int32 y = 4;
|
// int32 id = 5;
|
// repeated float feature = 6;
|
// }
|
|
// message HumanTrackResult {
|
// repeated HumanTrack result = 1;
|
// }
|
|
func convert2ProtoHumanTrackResult(obj []sdkstruct.FgResult) [][]*protomsg.HumanTrack {
|
ret := [][]*protomsg.HumanTrack{}
|
for _, v := range obj {
|
res := []*protomsg.HumanTrack{}
|
for i := 0; i < int(v.FgNum); i++ {
|
r := v.Fginfo[i]
|
|
rect := protomsg.Rect{
|
Left: r.Left,
|
Right: r.Right,
|
Top: r.Top,
|
Bottom: r.Bottom,
|
}
|
pr := &protomsg.HumanTrack{
|
RcHuman: &rect,
|
Confidence: r.Confidence,
|
X: r.X,
|
Y: r.Y,
|
Id: r.ID,
|
Feature: r.Feature[:],
|
}
|
res = append(res, pr)
|
}
|
ret = append(ret, res)
|
}
|
return ret
|
}
|
