~suntianyu/webserver.git

			@@ -3,14 +3,21 @@
			import (
			"basic.com/pubsub/protomsg.git"
			"basic.com/valib/deliver.git"
			"encoding/base64"
			"fmt"
			"github.com/gogo/protobuf/proto"
			"github.com/pierrec/lz4"
			"github.com/pkg/errors"
			"github.com/satori/go.uuid"
			"gocv.io/x/gocv"
			"sync"
			"time"
			"webserver/extend/logger"
			)

			type FaceSdkService struct {
			File []byte
			Id string
			Result []*protomsg.ResultFaceDetect
			}

			const (
			Ipc_Push_Ext = "_2.ipc"
			@@ -22,6 +29,34 @@
			Url_Service_PULL = Ipc_Url_Pre + Virtual_FaceSdkId + Ipc_Pull_Ext
			)

			func GetFaceFeaFromSdk(fileBytes []byte) ([]protomsg.ResultFaceDetect,error,protomsg.Image){
			s := NewFaceSdkService(fileBytes)
			i, err := s.ReadFromUploadImg()
			if err !=nil{
			logger.Debug("readFromUploadImg err:",err)
			return nil,err,i
			}
			bc, err := ImgCompress(i)
			if err !=nil {
			logger.Debug("ImgCompress err:",err)
			return nil,err,i
			}
			s.PushImgMsg(bc)
			s.GetFaceFea()
			if s.Result == nil{
			return nil,errors.New("no fea"),i
			} else {
			return s.Result,nil,i
			}
			}

			func NewFaceSdkService(fileBytes []byte) FaceSdkService{
			return FaceSdkService{
			File:fileBytes,
			Id:uuid.NewV4().String(),
			}
			}

			var imgPushChan chan []byte
			var client_push deliver.Deliver
			var client_pull deliver.Deliver
			@@ -29,33 +64,98 @@
			func TestPushImgMsg() {
			InitService()

			i := readImgFile()
			i := readTestImgFile()

			fmt.Printf("width:%d,height:%d,data.length:%d,timestamp:%s,id:%d\n", i.Width, i.Height, len(i.Data), i.Timestamp, i.Id)
			if b, err := proto.Marshal(&i); err != nil {
			fmt.Println("protoImage marshal err")
			return
			logger.Debug("width:%d,height:%d,data.length:%d,timestamp:%s,id:%d\n",i.Width,i.Height,len(i.Data),i.Timestamp,i.Id)

			bc, err := ImgCompress(&i)
			if err !=nil {
			logger.Debug("image is not compressible")
			} else {
			var s FaceSdkService
			s.PushImgMsg(bc)
			}
			}

			func (s FaceSdkService) ReadFromUploadImg() (protomsg.Image,error){
			//defer (*(s.File)).Close()
			//imgB, err := ioutil.ReadAll(*(s.File))
			//if err !=nil{
			// logger.Debug("File.Read err:",err)
			// return nil,err
			//}

			picMat, err := gocv.IMDecode(s.File, gocv.IMReadColor)
			if err !=nil {
			logger.Debug("gocv.IMDecode err:",err)
			return nil,err
			}
			defer picMat.Close()
			if picMat.Empty() {
			logger.Debug("file not exist")
			return nil,errors.New("picMat is empty")
			}
			height := int32(picMat.Rows())
			width := int32(picMat.Cols())
			data := picMat.ToBytes()
			timeUnix := time.Now().Unix()
			formatTimeStr := time.Unix(timeUnix, 0).Format("2006-01-02 15:04:05")

			return &protomsg.Image{
			Width: width,
			Height: height,
			Timestamp: formatTimeStr,
			Data: data,
			Id: timeUnix,
			Cid:s.Id,
			},nil
			}

			func ImgCompress(i *protomsg.Image) ([]byte,error){
			if b, err := proto.Marshal(i); err != nil {
			logger.Debug("protoImage marshal err")
			return nil,err
			} else {
			bc := make([]byte, len(b))
			ht := make([]int, 64<<10)
			n, err := lz4.CompressBlock(b, bc, ht)
			if err != nil {
			fmt.Println(err)
			logger.Debug(err)
			return nil,err
			}
			if n >= len(b) {
			fmt.Println("image is not compressible")
			logger.Debug("image is not compressible")
			return nil,errors.New("compressed len is 0")
			}
			bc = bc[:n]
			for {
			PushImgMsg(bc)
			fmt.Println("pushed img")
			time.Sleep(5 * time.Second)
			}

			return bc,nil
			}
			}

			func readImgFile() protomsg.Image {
			func (s *FaceSdkService) GetFaceFea(){
			var wg sync.WaitGroup
			wg.Add(1)
			ticker := time.NewTicker(time.Second * 3)
			go func(ticker time.Ticker, s FaceSdkService) {
			defer ticker.Stop()
			defer wg.Done()

			for {
			select {
			case <-ticker.C:
			return
			default:
			if faces,ok := resultMap.Get(s.Id);ok {
			s.Result = faces
			return
			}
			}
			}
			}(ticker, s)
			wg.Wait()
			}

			func readTestImgFile() protomsg.Image{
			var i protomsg.Image
			timeUnix := time.Now().Unix()
			formatTimeStr := time.Unix(timeUnix, 0).Format("2006-01-02 15:04:05")
			@@ -66,7 +166,7 @@
			defer picMat.Close()

			if picMat.Empty() {
			fmt.Println("file not exist")
			logger.Debug("file not exist")
			return i
			}
			height := int32(picMat.Rows())
			@@ -84,20 +184,44 @@
			Id: timeUnix,
			}
			i.Cid = uuid.NewV4().String() //数据唯一id
			fmt.Println("gocv read img completed")
			logger.Debug("gocv read img completed")
			return i
			}

			func PushImgMsg(is []byte) {
			func (s *FaceSdkService) PushImgMsg(is []byte){
			imgPushChan <- is
			}

			var resultMap map[string]protomsg.SdkMessage
			type FeaResult struct {
			FaceM map[string][]*protomsg.ResultFaceDetect
			Lock sync.Mutex
			}

			func (f FeaResult) Write(id string,faceDetectResult []protomsg.ResultFaceDetect){
			f.Lock.Lock()
			defer f.Lock.Unlock()
			f.FaceM[id] = faceDetectResult
			}

			func (f FeaResult) Get(id string) ([]protomsg.ResultFaceDetect,bool){
			f.Lock.Lock()
			defer f.Lock.Unlock()
			coms,ok := f.FaceM[id]
			return coms,ok
			}

			func (f *FeaResult) Delete(id string){
			f.Lock.Lock()
			defer f.Lock.Unlock()
			delete(f.FaceM,id)
			}

			var resultMap = FeaResult{}

			func InitService() {
			fmt.Println("service init!")
			logger.Debug("service init!")
			imgPushChan = make(chan []byte)
			resultMap = make(map[string]protomsg.SdkMessage, 0)
			resultMap.FaceM = make(map[string][]*protomsg.ResultFaceDetect,0)
			client_push = deliver.NewClient(deliver.PushPull, Url_Service_PUSH)
			client_pull = deliver.NewClient(deliver.PushPull, Url_Service_PULL)
			defer func() {
			@@ -113,13 +237,13 @@
			for {
			select {
			case d := <-imgPushChan:
			fmt.Println("imgPushChan in")
			logger.Debug("imgPushChan in")
			err := client_push.Send(d)
			if err != nil {
			fmt.Println("img Send err:", err)
			logger.Debug("img Send err:", err)
			}
			default:
			//fmt.Println("no img in")
			//logger.Debug("no img in")
			}
			}
			}
			@@ -128,52 +252,46 @@
			for {
			resultBytes, err := client_pull.Recv()
			if err != nil {
			fmt.Println("pull err:", err)
			//logger.Debug("pull err:", err)
			continue
			}
			rMsg := protomsg.SdkMessage{}
			if err := proto.Unmarshal(resultBytes, &rMsg); err == nil {
			fmt.Println("received MSG:", rMsg.Cid)
			logger.Debug("received MSG:", rMsg.Cid)
			perId := rMsg.Cid //数据id
			if rMsg.Tasklab != nil && rMsg.Tasklab.Taskid == Virtual_FaceTaskId {
			sdkInfos := rMsg.Tasklab.Sdkinfos
			fmt.Println("Len(sdkInfos)=", len(sdkInfos))
			for _, swt := range sdkInfos {
			fmt.Println("sdkName:", swt.SdkName)
			if swt.Sdktype == "FaceDetect" {
			fmt.Println("人脸检测结果")
			var pfp protomsg.ParamFacePos
			err := proto.Unmarshal(swt.Sdkdata, &pfp)
			if err != nil {
			fmt.Println("faceDetect result unmarshal err:", err)
			} else {
			for _, face := range pfp.Faces {
			fmt.Println("FacePos:", face.Pos)
			fmt.Println("ThftResult:", face.Result)
			}
			}
			}
			if swt.Sdktype == "FaceExtract" {
			fmt.Println("sdkData.len:", len(swt.Sdkdata))
			var pff protomsg.ParamFaceFeature
			if err := proto.Unmarshal(swt.Sdkdata, &pff); err != nil {
			//fmt.Println("ParamFaceFeature unmarshal err:",err)
			} else {
			fmt.Println("目标数：", len(pff.ExtComp))
			for _, fea := range pff.ExtComp {
			base64Fea := base64.StdEncoding.EncodeToString(fea.Feats)
			fmt.Println("perId:", perId)
			fmt.Println("faceFeature:", base64Fea)

			logger.Debug("Len(sdkInfos)=",len(sdkInfos))
			for _,swt :=range sdkInfos{
			//人脸检测的结果
			if swt.Sdktype =="FaceDetect"{
			logger.Debug("人脸检测结果长度：",len(swt.Sdkdata))
			if len(swt.Sdkdata)>1{
			var pfp protomsg.ParamFacePos
			err := proto.Unmarshal(swt.Sdkdata, &pfp)
			if err !=nil {
			logger.Debug("faceDetect result unmarshal err:",err)
			} else {
			logger.Debug("检测人脸数:",len(pfp.Faces))
			if len(pfp.Faces)>0{
			resultMap.Write(perId,pfp.Faces)
			}
			//for _,face :=range pfp.Faces{
			//logger.Debug("FacePos:",face.Pos)
			//logger.Debug("ThftResult:",face.Result)
			// base64Fea := base64.StdEncoding.EncodeToString(face.Feats)
			// logger.Debug("perId:",perId)
			// logger.Debug("faceFeature:",base64Fea)
			//}
			}
			}
			break
			}
			}

			}
			//resultMap[rMsg.Cid] = rMsg
			} else {
			fmt.Println("recv msg Err:", err)
			logger.Debug("recv msg Err:", err)
			}

			}