compareResult sort

liuxiaolong

2019-07-27 59e648d84df45c97c4591dd8c651fca0f20f86c1

compareResult sort

 controllers/dbtablesCon.go

@@ -38,6 +38,9 @@
    } else if isSync == "2" {
        analyServerFilterStr = "{\"term\":{\"analyServerId\":\"" + sysconf.ServerId + "\"}}" // 本地库
    }
    if analyServerFilterStr !="" {
        analyServerFilterStr = ","+ analyServerFilterStr
    }
    params := "{\"query\":{\"bool\":{\"must\":[" +
        "{\"term\":{\"isDelete\":\"0\"}}" + analyServerFilterStr + "]}}," +
        "\"from\":0,\"size\":1000,\"sort\":{\"id\":{\"order\":\"asc\"}}}"

 controllers/fileController.go

@@ -2,16 +2,13 @@

import (
    "basic.com/dbapi.git"
    "basic.com/pubsub/protomsg.git"
    "basic.com/fileServer/WeedFSClient.git"
    "basic.com/valib/deliver.git"
    "basic.com/pubsub/protomsg.git"
    "bytes"
    "encoding/base64"
    "encoding/json"
    "errors"
    "fmt"
    "github.com/gin-gonic/gin"
    "github.com/gogo/protobuf/proto"
    "github.com/satori/go.uuid"
    "image"
    "image/jpeg"
@@ -30,7 +27,6 @@
    "webserver/extend/util"
    "webserver/models"
    "webserver/service"
    esApi "basic.com/pubsub/esutil.git"
)

type FileController struct {
@@ -151,39 +147,6 @@
    }
}

type CompareResult struct {
    Id string `json:"id"`
    CompareScore float32 `json:"compareScore"`
    CameraId string `json:"cameraId"`
    CameraAddr string `json:"cameraAddr"`
    PicDate string `json:"picDate"`
    Content string `json:"content"`
    IsAlarm int `json:"isAlarm"`
    PicMaxUrl string `json:"picMaxUrl"`
    PicSmUrl string `json:"picSmUrl"`
    Sex string `json:"sex"`
    AgeDescription string `json:"ageDescription"`
    Race string `json:"race"`
    TaskId string `json:"taskId"`
    TaskName string `json:"taskName"`
    BaseInfo []DbPersonVo `json:"baseInfo"`
    VideoUrl string `json:"videoUrl"`
}
type DbPersonVo struct {
    BwType string `json:"bwType"`
    CompareScore float32 `json:"compareScore"`
    IdCard string `json:"idCard"`
    MonitorLevel string `json:"monitorLevel"`
    PersonId string `json:"personId"`
    PersonName string `json:"personName"`
    PersonPicUrl string `json:"personPicUrl"`
    PhoneNum string `json:"phoneNum"`
    Sex string `json:"sex"`
    TableId string `json:"tableId"`
    TableName string `json:"tableName"`
}

var captureTable = "capturetable" // 抓拍库
// @Summary 以图搜图
// @Description  以图搜图
// @Accept json
@@ -222,7 +185,7 @@
            for idx,tableId :=range searchBody.DataBases {
                if tableId == "esData" {
                    searchBody.DataBases = append(searchBody.DataBases[:idx], searchBody.DataBases[idx+1:]...)
                    searchBody.DataBases = append(searchBody.DataBases,captureTable)
                    searchBody.DataBases = append(searchBody.DataBases,service.CaptureTable)
                    break
                }
            }
@@ -240,128 +203,21 @@

        logger.Debug("arg.TableIds:", arg.TableIds, ",alarmLevel:",arg.AlarmLevel,",treeNodes:",arg.TreeNodes,",searchTime:",arg.SearchTime,
            ",inputValue:",arg.InputValue,",tasks:",arg.Tasks,",compThreshold:",arg.CompareThreshold)
        b, err := proto.Marshal(&arg)
        if err !=nil{
            util.ResponseFormat(c, code.ComError, "请求marshal失败")
            return
        compareService := service.NewFaceCompareService(arg)
        compareOnce := compareService.Compare()
        logger.Debug("compareResult:",*compareOnce)
        dataList := compareOnce.CompareData
        service.SortByScore(dataList)
        totalList := len(dataList)
        m := make(map[string]interface{},3)
        m["compareNum"] = compareOnce.CompareNum
        m["total"] = totalList
        if totalList <= searchBody.Size {
            m["totalList"] = dataList
        } else {
            m["totalList"] = dataList[0:searchBody.Size]
        }
        compServerList := config.CompServerInfo.Url
        logger.Debug("compServerList:", compServerList)
        resultList :=make([]CompareResult,0)
        for _,str :=range compServerList{
            reqUrl := "tcp://"+str
            reqClient := deliver.NewClient(deliver.ReqRep, reqUrl)
            err = reqClient.Send(b)
            if err !=nil{
                logger.Debug("reqClient.Send err:",err)
                continue
            }
            resultB, err := reqClient.Recv()
            if err !=nil{
                logger.Debug("reqClient.Recv err:",err)
                continue
            }
            rList :=make([]protomsg.Esinfo,0)
            err = json.Unmarshal(resultB, &rList)
            if err !=nil{
                logger.Debug("recv result Unmarshal err:", err)
                continue
            }
            logger.Debug("rList:", rList)

            dbPersonM := make(map[string]*protomsg.Esinfo,0)
            captureM := make(map[string]*protomsg.Esinfo,0)
            personIds :=make([]string,0)
            captureIds := make([]string,0)
            for _,v :=range rList{
                if v.Tableid == captureTable {
                    captureM[v.Id] = &v
                    captureIds = append(captureIds,v.Id)
                } else {
                    dbPersonM[v.Id] = &v
                    personIds = append(personIds,v.Id)
                }
            }
            logger.Debug("personIds:", personIds)
            logger.Debug("captureIds:",captureIds)
            esServerIp := config.EsInfo.Masterip
            esServerPort := config.EsInfo.Httpport
            index := config.EsInfo.EsIndex.Dbtablepersons.IndexName
            var dbpersons []protomsg.Dbperson
            if len(personIds) >0 {
                dbpersons, _ = esApi.Dbpersoninfosbyid(personIds, index, esServerIp, esServerPort)
            }

            logger.Debug("dbpersons:", dbpersons)
            if dbpersons !=nil {
                for _,p :=range dbpersons {
                    var dbP = DbPersonVo {
                        PersonId: p.Id,
                        IdCard: p.IdCard,
                        CompareScore: util.ParseScore(dbPersonM[p.Id].CompareScore),
                        MonitorLevel: p.MonitorLevel,
                        PersonName: p.PersonName,
                        PersonPicUrl: p.PersonPicUrl,
                        PhoneNum: p.PhoneNum,
                        Sex: p.Sex,
                        TableId: p.TableId,
                    }
                    dbTableInfos, _ := esApi.Dbtablefosbyid([]string{p.TableId}, config.EsInfo.EsIndex.DbTables.IndexName, esServerIp, esServerPort)
                    if dbTableInfos !=nil{
                        dbP.BwType = dbTableInfos[0].BwType
                        dbP.TableName = dbTableInfos[0].TableName
                    }
                    var cr = CompareResult{
                        BaseInfo:[]DbPersonVo{ dbP },
                    }
                    resultList = append(resultList,cr)
                }
            }
            var capturePersons []protomsg.Videopersons
            if len(captureIds) >0 {
                logger.Debug("capturePersons:", capturePersons)
                videopersons, _ := esApi.Videopersonsinfosbyid(captureIds, config.EsInfo.EsIndex.VideoPersons.IndexName, config.EsInfo.Masterip, config.EsInfo.Httpport)
                logger.Debug("videoPersons.len:",len(videopersons))
                for _,vp :=range videopersons {
                    isAlarmInt, _ := strconv.Atoi(vp.IsAlarm)
                    var bi []DbPersonVo
                    for _,p :=range vp.BaseInfo {
                        bi = append(bi, DbPersonVo{
                            PersonId: p.PersonId,
                            IdCard: p.IdCard,
                            CompareScore: util.ParseScore(p.CompareScore),
                            MonitorLevel: p.MonitorLevel,
                            PersonName: p.PersonName,
                            PersonPicUrl: p.PersonPicUrl,
                            PhoneNum: p.PhoneNum,
                            Sex: p.Sex,
                            TableId: p.TableId,
                        })
                    }
                    vpE := CompareResult{
                        Id: vp.Id,
                        CompareScore: util.ParseScore(captureM[vp.Id].CompareScore),
                        CameraId: vp.CameraId,
                        CameraAddr: vp.CameraAddr,
                        PicDate: vp.PicDate,
                        PicMaxUrl: vp.PicMaxUrl,
                        PicSmUrl: vp.PicSmUrl,
                        IsAlarm: isAlarmInt,
                        Sex: vp.Sex,
                        AgeDescription: vp.AgeDescription,
                        Race: vp.Race,
                        TaskName: vp.TaskName,
                        TaskId: vp.TaskId,
                        VideoUrl: vp.VideoUrl,
                        BaseInfo: bi,
                    }
                    resultList = append(resultList,vpE)
                }
            }

            logger.Debug("resultList:",resultList)
        }
        util.ResponseFormat(c,code.Success,resultList)
        util.ResponseFormat(c,code.Success,m)
    }
}


 service/FaceCompareService.go

New file
@@ -0,0 +1,244 @@
package service

import (
    esApi "basic.com/pubsub/esutil.git"
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/deliver.git"
    "encoding/json"
    "github.com/gogo/protobuf/proto"
    "github.com/satori/go.uuid"
    "sort"
    "strconv"
    "sync"
    "webserver/extend/config"
    "webserver/extend/logger"
    "webserver/extend/util"
)

type FaceCompareService struct {
    CompareNum string
    CompareArgs protomsg.CompareArgs
}

func NewFaceCompareService(args protomsg.CompareArgs) *FaceCompareService {
    return &FaceCompareService{
        CompareNum: uuid.NewV4().String(),
        CompareArgs:args,
    }
}

type CompareOnce struct {
    CompareNum string `json:"compareOnce"`
    CompareData []CompareResult `json:"compareData"`
}

type CompareResultWrapper struct {
    CompareData []CompareResult
    By func(p,q *CompareResult) bool
}

func (crw CompareResultWrapper) Len()int {
    return len(crw.CompareData)
}
func (crw CompareResultWrapper) Swap(i,j int) {
    crw.CompareData[i],crw.CompareData[j] = crw.CompareData[j],crw.CompareData[i]
}
func (crw CompareResultWrapper) Less(i,j int) bool{
    return crw.By(&crw.CompareData[i],&crw.CompareData[j])
}

func SortByScore(list []CompareResult) {
    sort.Sort(CompareResultWrapper{list, func(p, q *CompareResult) bool {
        return q.CompareScore < p.CompareScore //递减排序
    }})
}

var compResultHisM = make(map[string]*CompareOnce,0)
var lock sync.Mutex

func SetCompResultByNum(co *CompareOnce) {
    lock.Lock()
    defer lock.Unlock()
    compResultHisM[co.CompareNum] = co
}

func GetCompResultByNum(num string) *CompareOnce {
    lock.Lock()
    defer lock.Unlock()
    if co,ok := compResultHisM[num];ok {
        return co
    } else {
        return nil
    }
}

var CaptureTable = "capturetable" // 抓拍库

type CompareResult struct {
    Id string `json:"id"`
    CompareScore float32 `json:"compareScore"`
    CameraId string `json:"cameraId"`
    CameraAddr string `json:"cameraAddr"`
    PicDate string `json:"picDate"`
    Content string `json:"content"`
    IsAlarm int `json:"isAlarm"`
    PicMaxUrl string `json:"picMaxUrl"`
    PicSmUrl string `json:"picSmUrl"`
    Sex string `json:"sex"`
    AgeDescription string `json:"ageDescription"`
    Race string `json:"race"`
    TaskId string `json:"taskId"`
    TaskName string `json:"taskName"`
    BaseInfo []DbPersonVo `json:"baseInfo"`
    VideoUrl string `json:"videoUrl"`
}
type DbPersonVo struct {
    BwType string `json:"bwType"`
    CompareScore float32 `json:"compareScore"`
    IdCard string `json:"idCard"`
    MonitorLevel string `json:"monitorLevel"`
    PersonId string `json:"personId"`
    PersonName string `json:"personName"`
    PersonPicUrl string `json:"personPicUrl"`
    PhoneNum string `json:"phoneNum"`
    Sex string `json:"sex"`
    TableId string `json:"tableId"`
    TableName string `json:"tableName"`
}

func (sv *FaceCompareService) Compare() *CompareOnce{
    b, err := proto.Marshal(&sv.CompareArgs)
    compServerList := config.CompServerInfo.Url
    logger.Debug("compServerList:", compServerList)
    //1.向各个compare进程发起请求拿到比对结果
    resultList :=make([]CompareResult,0)
    for _,str :=range compServerList{
        reqUrl := "tcp://"+str
        reqClient := deliver.NewClient(deliver.ReqRep, reqUrl)
        err = reqClient.Send(b)
        if err !=nil{
            logger.Debug("reqClient.Send err:",err)
            continue
        }
        resultB, err := reqClient.Recv()
        if err !=nil{
            logger.Debug("reqClient.Recv err:",err)
            continue
        }
        rList :=make([]protomsg.Esinfo,0)
        err = json.Unmarshal(resultB, &rList)
        if err !=nil{
            logger.Debug("recv result Unmarshal err:", err)
            continue
        }
        logger.Debug("len(rList):", len(rList))
        if len(rList) >0 {
            resultList = append(resultList, FillDataToCompareResult(&rList)...)
        }
    }

    //2.缓存比对结果
    co := &CompareOnce{
        CompareNum: sv.CompareNum,
        CompareData: resultList,
    }
    SetCompResultByNum(co)

    return co
}

//填充向前端返回的数据
func FillDataToCompareResult(rList *[]protomsg.Esinfo) []CompareResult {
    resultList :=make([]CompareResult,0)

    dbPersonM := make(map[string]*protomsg.Esinfo,0)
    captureM := make(map[string]*protomsg.Esinfo,0)
    personIds :=make([]string,0)
    captureIds := make([]string,0)
    for _,v :=range *rList{
        if v.Tableid == CaptureTable {
            captureM[v.Id] = &v
            captureIds = append(captureIds,v.Id)
        } else {
            dbPersonM[v.Id] = &v
            personIds = append(personIds,v.Id)
        }
    }
    logger.Debug("personIds:", personIds)
    logger.Debug("captureIds:",captureIds)
    esServerIp := config.EsInfo.Masterip
    esServerPort := config.EsInfo.Httpport
    index := config.EsInfo.EsIndex.Dbtablepersons.IndexName
    var dbpersons []protomsg.Dbperson
    if len(personIds) >0 {
        dbpersons, _ = esApi.Dbpersoninfosbyid(personIds, index, esServerIp, esServerPort)
    }

    logger.Debug("dbpersons:", dbpersons)
    if dbpersons !=nil {
        for _,p :=range dbpersons {
            var dbP = DbPersonVo {
                PersonId: p.Id,
                IdCard: p.IdCard,
                CompareScore: util.ParseScore(dbPersonM[p.Id].CompareScore),
                MonitorLevel: p.MonitorLevel,
                PersonName: p.PersonName,
                PersonPicUrl: p.PersonPicUrl,
                PhoneNum: p.PhoneNum,
                Sex: p.Sex,
                TableId: p.TableId,
            }
            dbTableInfos, _ := esApi.Dbtablefosbyid([]string{p.TableId}, config.EsInfo.EsIndex.DbTables.IndexName, esServerIp, esServerPort)
            if dbTableInfos !=nil{
                dbP.BwType = dbTableInfos[0].BwType
                dbP.TableName = dbTableInfos[0].TableName
            }
            var cr = CompareResult{
                BaseInfo:[]DbPersonVo{ dbP },
            }
            resultList = append(resultList,cr)
        }
    }
    var capturePersons []protomsg.Videopersons
    if len(captureIds) >0 {
        logger.Debug("capturePersons:", capturePersons)
        videopersons, _ := esApi.Videopersonsinfosbyid(captureIds, config.EsInfo.EsIndex.VideoPersons.IndexName, config.EsInfo.Masterip, config.EsInfo.Httpport)
        logger.Debug("videoPersons.len:",len(videopersons))
        for _,vp :=range videopersons {
            isAlarmInt, _ := strconv.Atoi(vp.IsAlarm)
            var bi []DbPersonVo
            for _,p :=range vp.BaseInfo {
                bi = append(bi, DbPersonVo{
                    PersonId: p.PersonId,
                    IdCard: p.IdCard,
                    CompareScore: util.ParseScore(p.CompareScore),
                    MonitorLevel: p.MonitorLevel,
                    PersonName: p.PersonName,
                    PersonPicUrl: p.PersonPicUrl,
                    PhoneNum: p.PhoneNum,
                    Sex: p.Sex,
                    TableId: p.TableId,
                })
            }
            vpE := CompareResult{
                Id: vp.Id,
                CompareScore: util.ParseScore(captureM[vp.Id].CompareScore),
                CameraId: vp.CameraId,
                CameraAddr: vp.CameraAddr,
                PicDate: vp.PicDate,
                PicMaxUrl: vp.PicMaxUrl,
                PicSmUrl: vp.PicSmUrl,
                IsAlarm: isAlarmInt,
                Sex: vp.Sex,
                AgeDescription: vp.AgeDescription,
                Race: vp.Race,
                TaskName: vp.TaskName,
                TaskId: vp.TaskId,
                VideoUrl: vp.VideoUrl,
                BaseInfo: bi,
            }
            resultList = append(resultList,vpE)
        }
    }
    return  resultList
}