package main
|
|
import (
|
"context"
|
"unsafe"
|
|
"basic.com/libgowrapper/sdkhelper.git"
|
"basic.com/valib/gogpu.git"
|
|
"basic.com/pubsub/protomsg.git"
|
|
"basic.com/valib/deliver.git"
|
"github.com/gogo/protobuf/proto"
|
)
|
|
type reid struct {
|
handle *ReID
|
fnLogger func(...interface{})
|
|
ipc string
|
}
|
|
// Create Reid
|
func Create(config string, typ, id string, gpu int, shm bool, ipc2Rule string, ruleMaxSize int, fn func(...interface{}), reserved map[string]interface{}) interface{} {
|
|
cfg, err := sdkhelper.ReadConfig(config)
|
if err != nil {
|
fn("Reid SDK Create Error When Read Config: ", err)
|
return nil
|
}
|
|
sModel, sGPU, sIPC :=
|
"reid-model",
|
"gpu-memory",
|
"ipc-url"
|
|
params := []string{sModel, sGPU, sIPC}
|
|
for _, v := range params {
|
if _, ok := cfg.Param[v]; !ok {
|
fn("Reid SDK Create Error Because of Param Not Found: ", v)
|
return nil
|
}
|
}
|
|
gpuM := sdkhelper.Atoi(cfg.Param[sGPU])
|
|
rGPU := gpu
|
|
if rGPU == -1 {
|
rGPU = gogpu.ValidGPU(gpuM + 512)
|
}
|
if rGPU == -1 {
|
fn("Reid SDK Create Error When Find GPU")
|
return nil
|
}
|
|
handle := NewSDK(rGPU, cfg.Param[sModel])
|
if handle == nil {
|
fn("Reid SDK Create Error When New SDK")
|
return nil
|
}
|
|
return &reid{
|
handle: handle,
|
fnLogger: fn,
|
|
ipc: cfg.Param[sIPC],
|
}
|
}
|
|
// Run run
|
func Run(ctx context.Context, i interface{}) {
|
s := i.(*reid)
|
|
c := deliver.NewClient(deliver.ReqRep, s.ipc)
|
|
var msg []byte
|
var err error
|
|
for {
|
select {
|
case <-ctx.Done():
|
return
|
default:
|
|
msg, err = c.Recv()
|
if err != nil {
|
continue
|
}
|
|
i := &protomsg.Image{}
|
err := proto.Unmarshal(msg, i)
|
if err != nil {
|
s.fnLogger("REID~~~~~~protobuf decode CameraImage error: ", err)
|
continue
|
}
|
if i.Data == nil {
|
s.fnLogger("REID~~~~~~protomsg.Image data null")
|
continue
|
}
|
s.fnLogger("REID~~~~~~Recv Image:", len(i.Data))
|
|
feat := s.handle.Extract2(unsafe.Pointer(&i.Data[0]), int(i.Width), int(i.Height), 3)
|
if feat == nil {
|
feat = make([]float32, 1)
|
} else {
|
for k := 0; k < 3; k++ {
|
s.fnLogger("REID~~~~~~extractor---human_feats------%f", feat[k+2000])
|
}
|
}
|
buf := float32SliceAsByteSlice(feat)
|
c.Send(buf)
|
}
|
|
}
|
}
|
|
func float32SliceAsByteSlice(src []float32) []byte {
|
if len(src) == 0 {
|
return nil
|
}
|
|
l := len(src) * 4
|
ptr := unsafe.Pointer(&src[0])
|
// It is important to keep in mind that the Go garbage collector
|
// will not interact with this data, and that if src if freed,
|
// the behavior of any Go code using the slice is nondeterministic.
|
// Reference: https://github.com/golang/go/wiki/cgo#turning-c-arrays-into-go-slices
|
return (*[1 << 26]byte)((*[1 << 26]byte)(ptr))[:l:l]
|
}
|
