update

zhangmeng

2020-01-14 1e0d1e8caa7790c036b36a7ca62261f3625bb09c

 run.go

@@ -1,16 +1,27 @@
package main

import (
   "bufio"
   "context"
   "fmt"
   "io/ioutil"
   "os"
   "strings"
   "time"
   "unsafe"

   "basic.com/libgowrapper/sdkhelper.git"
   "basic.com/valib/gogpu.git"

   "basic.com/pubsub/protomsg.git"
   "basic.com/valib/godraw.git"

   "basic.com/valib/deliver.git"
   "github.com/gogo/protobuf/proto"

   "nanomsg.org/go-mangos"
   "nanomsg.org/go-mangos/protocol/rep"
   "nanomsg.org/go-mangos/transport/ipc"
   "nanomsg.org/go-mangos/transport/tcp"
)

type reid struct {
@@ -71,19 +82,47 @@
func Run(ctx context.Context, i interface{}) {
   s := i.(*reid)

   c := deliver.NewClient(deliver.ReqRep, s.ipc)

   var msg []byte
   var sock mangos.Socket
   var err error
   var msg []byte

   for {
      if sock, err = rep.NewSocket(); err != nil {
         s.fnLogger("can't get new rep socket: ", err)
         time.Sleep(5 * time.Millisecond)
      } else {
         break
      }
   }

   sock.AddTransport(ipc.NewTransport())
   sock.AddTransport(tcp.NewTransport())

   for {
      if err = sock.Listen(s.ipc); err != nil {
         suf := "ipc://"
         p := strings.Index(s.ipc, suf)
         if p >= 0 {
            file := s.ipc[p+len(string(suf)):]
            os.Remove(file)
                s.fnLogger("remove:", file)
         }
         s.fnLogger("can't listen on rep socket: ", err)
         time.Sleep(5 * time.Millisecond)
      } else {
         break
      }
   }

   for {
      select {
      case <-ctx.Done():
         sock.Close()
         return
      default:

         msg, err = c.Recv()
         if err != nil {
         if msg, err = sock.Recv(); err != nil {
            s.fnLogger("REID~~~~~~Recv From HumanTrack error: ", err)
            continue
         }

@@ -99,6 +138,11 @@
         }
         s.fnLogger("REID~~~~~~Recv Image:", len(i.Data))

         /////////////////////////////////
         if jpg, err := godraw.ToJpeg(i.Data, int(i.Width), int(i.Height), nil); err == nil {
            ioutil.WriteFile("./pic.jpg", jpg, 0644)
         }
         /////////////////////////////////
         feat := s.handle.Extract2(unsafe.Pointer(&i.Data[0]), int(i.Width), int(i.Height), 3)
         if feat == nil {
            // feat = make([]float32, 1)
@@ -107,9 +151,28 @@
               s.fnLogger("REID~~~~~~extractor---human_feats------%f", feat[k+2000])
            }
            s.fnLogger("REID~~~~~~Run Reid Use GPU: ", s.gpu)

            /////////////////////////////////
            if f, err := os.Create("./reid-feat.txt"); err == nil {
               defer f.Close()

               w := bufio.NewWriter(f)
               for k, v := range feat {
                  lineStr := fmt.Sprintf("%d->%f", k, v)
                  fmt.Fprintln(w, lineStr)
               }
               w.Flush()
            }
            /////////////////////////////////

         }
         buf := float32SliceAsByteSlice(feat)
         c.Send(buf)
         ioutil.WriteFile("./reid-feat-byte.txt", buf, 0644)

         if err = sock.Send(buf); err != nil {
            s.fnLogger("REID~~~~~~Send HumanTrack error: ", err)
         }

      }

   }
@@ -122,9 +185,5 @@

   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]
}