upload img and getFea

liuxiaolong

2019-06-28 b4682ed34ef9e89649ded8723ffb4aaac63139e1

upload img and getFea

 config/dev.yaml

@@ -3,6 +3,7 @@
    jwtSecret: BASIC    
    jwtExpire: 24  
    url: http://127.0.0.1:8080
    imageUrl: http://192.168.1.182:6080
redis:
    host: 127.0.0.1
    port: 6379

 controllers/fileController.go

@@ -1,20 +1,22 @@
package controllers

import (
    "basic.com/pubsub/protomsg.git"
    "bytes"
    "encoding/base64"
    "fmt"
    "github.com/gin-gonic/gin"
    "webserver/extend/code"
    "webserver/extend/esutil"
    "webserver/extend/util"
    "webserver/models"
    "github.com/satori/go.uuid"
    "image"
    "image/jpeg"
    "log"
    "mime/multipart"
    "net/http"
    "webserver/extend/code"
    "webserver/extend/esutil"
    "webserver/extend/util"
    "webserver/models"
    "webserver/service"
)

type FileController struct {
@@ -100,6 +102,22 @@
        filename = uuid.NewV4().String()
    }

    //将上传的图片交人脸检测和人脸提取，获得特征
    var faceBase64=""
    faceExtArr, err := getFaceFeaFromSdk(file)
    if err ==nil && len(faceExtArr) >0 {
        for _,r := range faceExtArr {
            faceBase64 = base64.StdEncoding.EncodeToString(r.Feats)//获取提取到的第一张人脸特征
            break
        }
        fmt.Println("提取到的人脸特征为：",faceBase64)
        util.ResponseFormat(c,code.Success,faceBase64)
        return
    } else {
        util.ResponseFormat(c,code.ComError,"未提取到人脸")
    }


}

/*// 对上面的编码结果进行base64解码
@@ -124,6 +142,7 @@
    }
    if tableId != "" && field != "" {
        // 返回特征值  fileInfo["point"] = v.RcFace  fileInfo["feature"] = feat

        /*features := gorun.GetSimpleFaceDetect(picIp+field)  // 特征值     // linux
            if len(features) == 0 {                                               // linux
                return field,nil,errors.New("NotFeatureFindError")  // linux
@@ -134,14 +153,23 @@
        if len(feat) != 2560 {                                // linux
            return field,nil,errors.New("NotFeatureFindError")
        }    */                     // linux
        feat := []byte("hello world") // windows 测试放开

        //将上传的图片交人脸检测和人脸提取，获得特征
        var faceBase64=""
        faceExtArr, err := getFaceFeaFromSdk(file)
        if err ==nil && len(faceExtArr) >0 {
            for _,r := range faceExtArr {
                faceBase64 = base64.StdEncoding.EncodeToString(r.Feats)//获取提取到的第一张人脸特征
                break
            }
        }

        dbperson := new(models.Dbtablepersons)
        dbperson.FaceUrl = picIp+field       //  图片路经
        dbperson.TableId = tableId  //
        dbperson.PersonName = filename // 图片名
        // 演示base64编码
        encodeString := base64.StdEncoding.EncodeToString(feat)
        dbperson.Feature = encodeString // 特征值base64 码
        dbperson.Feature = faceBase64 // 特征值base64 码
        result := addDbPerson(dbperson)
        return field, result, nil
    } else {
@@ -149,6 +177,20 @@
    }
}

func getFaceFeaFromSdk(file multipart.File) ([]*protomsg.ResultFaceExtCom,error){
    s := service.NewFaceSdkService(file)
    i, err := s.ReadFromUploadImg()
    if err !=nil{
        return nil,err
    }
    bc, err := service.ImgCompress(i)
    if err !=nil {
        return nil,err
    }
    s.PushImgMsg(bc)
    return s.GetFaceFea()
}

/**上传方法**/



 extend/config/config.go

@@ -11,6 +11,7 @@
    JwtSecret string `mapstructure: "jwtSecret"`
    JwtExpire string `mapstructure: "jwtExpire"`
    Url       string `mapstructure: "url"`
    ImageUrl  string `mapstructure: "imageUrl"`
}

var Server = &server{}

 main.go

@@ -1,8 +1,10 @@
package main

import (
    "basic.com/dbapi.git"
    "flag"
    "github.com/golang/glog"
    "strconv"
    "webserver/extend/config"
    "webserver/models"
    "webserver/router"
@@ -11,9 +13,17 @@

func main() {

    service.TestPushImgMsg()
    service.InitService()

    envirment := flag.String("e", "dev", "")
    dbIp := flag.String("dbIp","192.168.1.11","default dbIp=192.168.1.11")
    dbPort := flag.String("dbPort","8001","default dbPort=8001")
    p, err := strconv.Atoi(*dbPort)
    if err !=nil {
        p = 8001
    }
    dbapi.Init(*dbIp,p)

    flag.Usage = func() {
        glog.Exit("flag parse usage !")
    }

 middlewares/auth/auth.go

@@ -4,8 +4,7 @@
    "github.com/gin-gonic/gin"
    "net/http"
    "strings"
    "webserver/extend/code"
    "webserver/extend/util"
    "webserver/extend/config"
)

const (
@@ -29,12 +28,17 @@
    return func(c *gin.Context) {
        urlPath := c.Request.URL.Path
        if strings.Contains(urlPath,"/data/api-v") && !strings.Contains(urlPath,"login"){
            jwtDriver :=NewJwtAuthDriver()
            if !jwtDriver.Check(c) {
                util.ResponseFormat(c,code.TokenNotFound,"尚未登录，请登录")
                c.Abort()
            }
            //jwtDriver :=NewJwtAuthDriver()
            //if !jwtDriver.Check(c) {
            //    util.ResponseFormat(c,code.TokenNotFound,"尚未登录，请登录")
            //    c.Abort()
            //}
            c.Next()
        } else if strings.HasPrefix(urlPath,"/httpImage") {
            imgUrl := config.Server.ImageUrl
            c.Header("Access-Control-Allow-Origin","*")
            c.Redirect(http.StatusMovedPermanently, imgUrl+urlPath[10:])
            return
        } else {
            c.Next()
        }

 router/router.go

@@ -7,6 +7,7 @@
    "github.com/szuecs/gin-glog"
    "time"
    "webserver/controllers"
    "webserver/middlewares/auth"

    _ "webserver/docs"
)
@@ -15,7 +16,7 @@
    r := gin.Default()
    r.Use(ginglog.Logger(3 * time.Second))

    //r.Use(auth.AuthHandler())//auth过滤器
    r.Use(auth.AuthHandler())//auth过滤器

    r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))


 service/FaceSdkService.go

@@ -7,10 +7,18 @@
    "fmt"
    "github.com/gogo/protobuf/proto"
    "github.com/pierrec/lz4"
    "github.com/pkg/errors"
    "github.com/satori/go.uuid"
    "gocv.io/x/gocv"
    "mime/multipart"
    "sync"
    "time"
)

type FaceSdkService struct {
    File multipart.File
    Id string
}

const (
    Ipc_Push_Ext = "_2.ipc"
@@ -21,6 +29,14 @@
    Url_Service_PUSH = Ipc_Url_Pre + Virtual_FaceSdkId + Ipc_Push_Ext
    Url_Service_PULL = Ipc_Url_Pre + Virtual_FaceSdkId + Ipc_Pull_Ext
)

func NewFaceSdkService(file multipart.File) FaceSdkService{
    return FaceSdkService{
        File:file,
        Id:uuid.NewV4().String(),
    }
}

var imgPushChan chan []byte
var client_push deliver.Deliver
var client_pull deliver.Deliver
@@ -28,33 +44,101 @@
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{

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

func (s *FaceSdkService) ReadFromUploadImg() (*protomsg.Image,error){
    defer s.File.Close()
    imgB := make([]byte,0)
    if _, err := s.File.Read(imgB);err !=nil{
        return nil,err
    }
    picMat, err := gocv.IMDecode(imgB, gocv.IMReadColor)
    if err !=nil {
        return nil,err
    }
    defer picMat.Close()
    if picMat.Empty() {
        fmt.Println("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{
        fmt.Println("protoImage marshal err")
        return
        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)
            return nil,err
        }
        if n >= len(b){
            fmt.Println("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() (feas []*protomsg.ResultFaceExtCom,err error){
    var wg sync.WaitGroup
    wg.Add(1)
    ch := make(chan []*protomsg.ResultFaceExtCom,0)
    go func() {
        for {
            select {
            case <-time.Tick(time.Second*10):
                ch <- nil
                wg.Done()
                return
            default:
                if feas,ok := resultMap[s.Id];ok {
                    fmt.Println("faceFea got!!!")
                    ch <- feas
                    return
                }
            }
        }
    }()
    wg.Wait()
    msg := <- ch
    if msg != nil {
        return msg,nil
    } else {
        return msg,errors.New("no fea")
    }
}

func readTestImgFile() protomsg.Image{
    var i protomsg.Image
    timeUnix := time.Now().Unix()
    formatTimeStr := time.Unix(timeUnix, 0).Format("2006-01-02 15:04:05")
@@ -87,17 +171,17 @@
    return i
}

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

var resultMap map[string]protomsg.SdkMessage
var resultMap map[string][]*protomsg.ResultFaceExtCom


func InitService(){
    fmt.Println("service init!")
    imgPushChan = make(chan []byte)
    resultMap = make(map[string]protomsg.SdkMessage,0)
    resultMap = make(map[string][]*protomsg.ResultFaceExtCom,0)
    client_push = deliver.NewClient(deliver.PushPull, Url_Service_PUSH)
    client_pull = deliver.NewClient(deliver.PushPull, Url_Service_PULL)
    defer func() {
@@ -138,40 +222,40 @@
            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)
                                }
                for _,swt :=range sdkInfos{
                    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))
                    }
                    if swt.Sdktype == "FaceExtract"{
                        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))
                            if len(pff.ExtComp) >0 {
                                resultMap[rMsg.Cid] = pff.ExtComp

                                for _,fea :=range pff.ExtComp{
                                    base64Fea := base64.StdEncoding.EncodeToString(fea.Feats)
                                    fmt.Println("perId:",perId)
                                    fmt.Println("faceFeature:",base64Fea)
                                }
                            }
                            break
                        }
                        break
                    }

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