get faceFea from FaceDetect sdk

liuxiaolong

2019-07-08 76ee1245a5be00553a4971035c04fc057177be97

get faceFea from FaceDetect sdk

 controllers/fileController.go

@@ -103,13 +103,13 @@

    //将上传的图片交人脸检测和人脸提取，获得特征
    fileBytes, _ := ioutil.ReadAll(file)
    faceExtArr, err, pI := getFaceFeaFromSdk(fileBytes)
    if err ==nil && len(faceExtArr) >0 {
    faceArr, err, pI := service.GetFaceFeaFromSdk(fileBytes)
    if err ==nil && len(faceArr) >0 {
        var faceBase64= ""
        var field = ""
        var rcFace *protomsg.Rect
        for _,r := range faceExtArr {
            rcFace = r.Pos.Pos.RcFace
        for _,r := range faceArr {
            rcFace = r.Pos.RcFace
            faceBase64 = base64.StdEncoding.EncodeToString(r.Feats)//获取提取到的第一张人脸特征
            break
        }
@@ -150,15 +150,15 @@

    //将上传的图片交人脸检测和人脸提取，获得特征
    var faceBase64=""
    faceExtArr, err,pI := getFaceFeaFromSdk(fileBytes)
    if faceExtArr ==nil {
    faceArr, err,pI := service.GetFaceFeaFromSdk(fileBytes)
    if faceArr ==nil {
        return "",nil,errors.New("NotFeatureFindError")
    }
    var rcFace *protomsg.Rect
    if err ==nil && len(faceExtArr) >0 {
        for _,r := range faceExtArr {
    if err ==nil && len(faceArr) >0 {
        for _,r := range faceArr {
            //拿到人脸的坐标
            rcFace = r.Pos.Pos.RcFace
            rcFace = r.Pos.RcFace

            faceBase64 = base64.StdEncoding.EncodeToString(r.Feats)//获取提取到的第一张人脸特征
            break
@@ -192,26 +192,26 @@

}

func getFaceFeaFromSdk(fileBytes []byte) ([]*protomsg.ResultFaceExtCom,error,*protomsg.Image){
    s := service.NewFaceSdkService(fileBytes)
    i, err := s.ReadFromUploadImg()
    if err !=nil{
        fmt.Println("readFromUploadImg err:",err)
        return nil,err,i
    }
    bc, err := service.ImgCompress(i)
    if err !=nil {
        fmt.Println("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 getFaceFeaFromSdk(fileBytes []byte) ([]*protomsg.ResultFaceExtCom,error,*protomsg.Image){
//    s := service.NewFaceSdkService(fileBytes)
//    i, err := s.ReadFromUploadImg()
//    if err !=nil{
//        fmt.Println("readFromUploadImg err:",err)
//        return nil,err,i
//    }
//    bc, err := service.ImgCompress(i)
//    if err !=nil {
//        fmt.Println("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
//    }
//}

/**上传方法**/


 extend/logger/logger.go

@@ -1 +1,217 @@
package logger

import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "strings"
    "time"
)

const (
    PanicLevel int = iota
    FatalLevel
    ErrorLevel
    WarnLevel
    InfoLevel
    DebugLevel
)

const (
    color_red = uint8(iota + 91)
    color_green        //    绿
    color_yellow        //    黄
    color_blue            //     蓝
    color_magenta         //    洋红
)

const (
    fatalPrefix        =    "[FATAL] "
    errorPrefix        =    "[ERROR] "
    warnPrefix        =    "[WARN] "
    infoPrefix        =    "[INFO] "
    debugPrefix        =    "[DEBUG] "
)

const (
    ByDay    int = iota
    ByWeek
    ByMonth
    BySize
)

type LogFile struct {
    level    int        // 日志等级
    saveMode int        // 保存模式
    saveDays int        // 日志保存天数
    logTime  int64        //
    fileName string        // 日志文件名
    filesize int64        // 文件大小, 需要设置 saveMode 为 BySize 生效
    fileFd   *os.File
}

var logFile LogFile

func init()  {
    logFile.saveMode = ByDay    // 默认按天保存
    logFile.saveDays = 15        // 默认保存三天的
    logFile.level = ErrorLevel
    logFile.filesize = 1024 * 1024 * 10    // 默认10M， 需要设置 saveMode 为 BySize
}

func Config(logFolder string, level int) {
    logFile.fileName = logFolder
    logFile.level = level

    log.SetOutput(logFile)
    //log.SetFlags(log.Lmicroseconds | log.Lshortfile)
    log.SetFlags(log.Ldate | log.Ltime)
}
func GetLogFile() (*LogFile) {
    return &logFile
}

func SetLevel(level int) {
    logFile.level = level
}

func SetSaveMode(saveMode int)  {
    logFile.saveMode = saveMode
}

func SetSaveDays(saveDays int)  {
    logFile.saveDays = saveDays
}

func SetSaveSize(saveSize int64)  {
    logFile.filesize = saveSize
}

func Debug(args ...interface{}) {
    if logFile.level >= DebugLevel {
        log.SetPrefix(blue(debugPrefix))
        _ = log.Output(2, fmt.Sprintln(args...))
    }
}

func Info(args ...interface{}) {
    if logFile.level >= InfoLevel {
        log.SetPrefix(green(infoPrefix))
        _ = log.Output(2, fmt.Sprintln(args...))
    }
}

func Warn(args ...interface{}) {
    if logFile.level >= WarnLevel {
        log.SetPrefix(magenta(warnPrefix))
        _ = log.Output(2, fmt.Sprintln(args...))
    }
}

func Error(args ...interface{}) {
    if logFile.level >= ErrorLevel {
        log.SetPrefix(red(errorPrefix))
        _ = log.Output(2, fmt.Sprintln(args...))
    }
}

func Fatal(args ...interface{}) {
    if logFile.level >= FatalLevel {
        log.SetPrefix(red(fatalPrefix))
        _ = log.Output(2, fmt.Sprintln(args...))
    }
}

func GetRedPrefix(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_red, s)
}

func red(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_red, s)
}

func green(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_green, s)
}

func yellow(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_yellow, s)
}

func blue(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_blue, s)
}

func magenta(s string) string {
    return fmt.Sprintf("\x1b[%dm%s\x1b[0m", color_magenta, s)
}

func (me LogFile) Write(buf []byte) (n int, err error) {
    if me.fileName == "" {
        fmt.Printf("consol: %s", buf)
        return len(buf), nil
    }

    switch logFile.saveMode {
    case BySize:
        fileInfo, err := os.Stat(logFile.fileName)
        if  err != nil {
            logFile.createLogFile()
            logFile.logTime = time.Now().Unix()
        }else {
            filesize:= fileInfo.Size();
            if logFile.fileFd == nil ||
                filesize > logFile.filesize {
                logFile.createLogFile()
                logFile.logTime = time.Now().Unix()
            }
        }
    default:    // 默认按天  ByDay
        if logFile.logTime+3600 < time.Now().Unix() {
            logFile.createLogFile()
            logFile.logTime = time.Now().Unix()
        }
    }

    if logFile.fileFd == nil {
        fmt.Printf("log fileFd is nil !\n")
        return len(buf), nil
    }

    return logFile.fileFd.Write(buf)
}

func (me *LogFile) createLogFile() {
    logdir := "./"
    if index := strings.LastIndex(me.fileName, "/"); index != -1 {
        logdir = me.fileName[0:index] + "/"
        os.MkdirAll(me.fileName[0:index], os.ModePerm)
    }

    now := time.Now()
    filename := fmt.Sprintf("%s_%04d%02d%02d",
        me.fileName, now.Year(), now.Month(), now.Day())
    if err := os.Rename(me.fileName, filename); err == nil {
        go func() {
            tarCmd := exec.Command("tar", "-zcf", filename+".tar.gz", filename, "--remove-files")
            tarCmd.Run()

            rmCmd := exec.Command("/bin/sh", "-c",
                "find "+logdir+` -type f -mtime +` +string(logFile.saveDays)+ ` -exec rm {} \;`)
            rmCmd.Run()
        }()
    }

    for index := 0; index < 10; index++ {
        if fd, err := os.OpenFile(me.fileName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, os.ModeExclusive); nil == err {
            me.fileFd.Sync()
            me.fileFd.Close()
            me.fileFd = fd
            break
        }else {
            fmt.Println("Open logfile error! err: ", err.Error())
        }
        me.fileFd = nil
    }
}

 service/FaceSdkService.go

@@ -3,7 +3,6 @@
import (
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/deliver.git"
    "fmt"
    "github.com/gogo/protobuf/proto"
    "github.com/pierrec/lz4"
    "github.com/pkg/errors"
@@ -11,12 +10,13 @@
    "gocv.io/x/gocv"
    "sync"
    "time"
    "webserver/extend/logger"
)

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

const (
@@ -28,6 +28,27 @@
    Url_Service_PUSH   = Ipc_Url_Pre + Virtual_FaceSdkId + Ipc_Push_Ext
    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{
@@ -45,11 +66,11 @@

    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)
    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 {
        fmt.Println("image is not compressible")
        logger.Debug("image is not compressible")
    } else {
        var s FaceSdkService
        s.PushImgMsg(bc)
@@ -60,18 +81,18 @@
    //defer (*(s.File)).Close()
    //imgB, err := ioutil.ReadAll(*(s.File))
    //if err !=nil{
    //    fmt.Println("File.Read err:",err)
    //    logger.Debug("File.Read err:",err)
    //    return nil,err
    //}

    picMat, err := gocv.IMDecode(s.File, gocv.IMReadColor)
    if err !=nil {
        fmt.Println("gocv.IMDecode err:",err)
        logger.Debug("gocv.IMDecode err:",err)
        return nil,err
    }
    defer picMat.Close()
    if picMat.Empty() {
        fmt.Println("file not exist")
        logger.Debug("file not exist")
        return nil,errors.New("picMat is empty")
    }
    height := int32(picMat.Rows())
@@ -92,18 +113,18 @@

func ImgCompress(i *protomsg.Image) ([]byte,error){
    if b, err := proto.Marshal(i); err != nil {
        fmt.Println("protoImage marshal err")
        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]
@@ -124,8 +145,8 @@
            case <-ticker.C:
                return
            default:
                if feas,ok := resultMap.Get(s.Id);ok {
                    s.Result = feas
                if faces,ok := resultMap.Get(s.Id);ok {
                    s.Result = faces
                    return
                }
            }
@@ -145,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())
@@ -163,7 +184,7 @@
        Id:        timeUnix,
    }
    i.Cid = uuid.NewV4().String() //数据唯一id
    fmt.Println("gocv read img completed")
    logger.Debug("gocv read img completed")
    return i
}

@@ -172,35 +193,35 @@
}

type FeaResult struct {
    FeaM map[string][]*protomsg.ResultFaceExtCom
    FaceM map[string][]*protomsg.ResultFaceDetect
    Lock sync.Mutex
}

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

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

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

var resultMap =  FeaResult{}

func InitService() {
    fmt.Println("service init!")
    logger.Debug("service init!")
    imgPushChan = make(chan []byte)
    resultMap.FeaM = make(map[string][]*protomsg.ResultFaceExtCom,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() {
@@ -216,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")
        }
    }
}
@@ -231,60 +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))
                logger.Debug("Len(sdkInfos)=",len(sdkInfos))
                for _,swt :=range sdkInfos{
                    //人脸检测的结果
                    //if swt.Sdktype =="FaceDetect"{
                    //    fmt.Println("人脸检测结果长度：",len(swt.Sdkdata))
                    //    if len(swt.Sdkdata)>1{
                    //        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("人脸提取结果长度:",len(swt.Sdkdata))
                        if len(swt.Sdkdata) > 1{
                            var pff protomsg.ParamFaceFeature
                            if err := proto.Unmarshal(swt.Sdkdata, &pff);err !=nil{
                                //fmt.Println("ParamFaceFeature unmarshal err:",err)
                    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 {
                                fmt.Println("目标数：",len(pff.ExtComp))
                                if len(pff.ExtComp) >0 {
                                    resultMap.Write(perId,pff.ExtComp)

                                    //for _,fea :=range pff.ExtComp{
                                    //    base64Fea := base64.StdEncoding.EncodeToString(fea.Feats)
                                    //    fmt.Println("perId:",perId)
                                    //    fmt.Println("faceFeature:",base64Fea)
                                    //}
                                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
                        }
                        break
                    }
                }
            }
        } else {
            fmt.Println("recv msg Err:", err)
            logger.Debug("recv msg Err:", err)
        }

    }