merge V1.0

panlei

2019-11-07 0e441dc5137776776d367f4075f7a2f62ae03628

merge V1.0

 insertdata/EsClient.go

@@ -7,7 +7,7 @@
    "io"
    "io/ioutil"
    "net/http"
    "basic.com/valib/logger.git"
    "ruleprocess/logger"
    "strconv"
    "strings"
    "time"

 insertdata/insertDataToEs.go

@@ -1,7 +1,7 @@
package insertdata

import (
    "basic.com/valib/logger.git"
    "ruleprocess/logger"
    "encoding/base64"
    "encoding/json"
    "errors"
@@ -127,30 +127,6 @@
    rules []structure.Result
}

// 往ES插数据
//func InsertToEs(msg ruleserver.ResultMsg) {
//    var timeLabel string
//    // 直接从规则的标签数据里拿符合规则的人脸结果
//    if msg.RuleResult["timeLabel"] != nil {
//        timeLabel = msg.RuleResult["timeLabel"].(string)
//    }
//    logger.Debug("插入数据前看看报警标志位：", timeLabel)
//    if timeLabel == "01" { // 无定时器状态要插入的报警数据
//        InsertFace(msg)
//        flag := ruleserver.BodyIsSame(msg.SdkMessage)
//        if !flag {
//            InsertYolo(msg)
//        }
//    }
//    if timeLabel == "10" { // 定时器状态要插入的首帧报警数据。连带着定时器开启时的那帧
//        InsertFace(msg)
//        InsertYolo(msg)
//    }
//    //if timeLabel == "12" { // 并非报警数据，只是状态改变的数据
//    //    //ChangeStatusFace(msg)
//    //    ChangeStatusYolo(msg)
//    //}
//}
func InsertToEs(msg structure.ResultMsg) {
    defer func() {
        if err := recover(); err != nil {
@@ -186,7 +162,7 @@
                    panic("解压缩图片时出现错误")
                }
                alarmRules := []AlarmRule{}
                logger.Warn("人脸id为：", face.Id, "人脸的规则长度为：", len(face.rules))
                //logger.Warn("人脸id为：", face.Id, "人脸的规则长度为：", len(face.rules))
                //os.Exit(1)
                for _, faceResult := range face.rules {
                    alarm := ChangeToString(faceResult.DefenceState, faceResult.AlarmLevel)
@@ -228,7 +204,6 @@
                target.TargetScore = face.Score
                target.TargetLocation = Points{TopLeft:Point{face.Location.X,face.Location.Y},BottomRight:Point{face.Location.X+face.Location.Width,face.Location.Y+face.Location.Height}}
                //logger.Info("人脸的id:",strconv.FormatUint(face.Id, 10))
                logger.Info("%%%%%%%%%%%%%%%%%%%%%目标信息：",*target)
                pervideo := PerVideoPicture{
                    msg.Push.PushId,
                    msg.Cid,
@@ -296,12 +271,12 @@
func hebingFace(faces []*FaceAndRules, faceResult structure.FaceResult) []*FaceAndRules {
    for _, arg := range faceResult.Args {
        // 拿到每一张人脸
        logger.Info("归置人脸时相似者的数量：", len(arg.Liker))
        //logger.Info("归置人脸时相似者的数量：", len(arg.Liker))
        flag := false
        for _, face := range faces {
            for _, lik := range face.Liker {
                logger.Warn("--------合并人脸时相似者：", lik.PersonId, lik.TableName)
            }
            //for _, lik := range face.Liker {
            //    //logger.Warn("--------合并人脸时相似者：", lik.PersonId, lik.TableName)
            //}
            if arg.Id == face.Id {
                flag = true
                face.rules = append(face.rules, faceResult.Result)
@@ -382,7 +357,7 @@
                    // 装配目标信息数据
                    for _,target := range yoloResult.Location  {
                        // 去重添加
                        logger.Info("装配前的原始数据是：",target)
                        //logger.Info("装配前的原始数据是：",target)
                        var flag = true
                        for _,selectTarget := range targetInfos  {
                            if strconv.FormatUint(target.TargetId, 10) == selectTarget.TargetId {
@@ -442,7 +417,6 @@
                // 不是报警数据不存
                return
            }

            if resp["fileUrl"] != nil {
                url = append(url, resp["fileUrl"].(string))
                //esDataId := uuid.NewV4().String()

 labelFilter/readyDataForLabel.go

@@ -1,7 +1,7 @@
package labelFilter

import (
    "basic.com/valib/logger.git"
    "ruleprocess/logger"
    "ruleprocess/cache"
    "ruleprocess/structure"
    "time"

 labelFilter/ruleForLabel.go

@@ -21,7 +21,7 @@
    // 装配成自己可以识别的数据
    label := new(Label)
    label.DataFormatToLabel(msg)
    logger.Info("label的信息：", label.CameraName, label.DefenceLevel, label.Time)
    //logger.Info("label的信息：", label.CameraName, label.DefenceLevel, label.Time)
    if label.CameraName == "" {
        logger.Error("无效数据，直接返回")
        return
@@ -29,7 +29,7 @@
    //拿到所有规则组
    var api dbapi.EventPushApi
    b, allRules := api.FindAllDetails()
    logger.Info("查看所有规则组：", allRules)
    //logger.Info("查看所有规则组：", allRules)
    if !b {
        logger.Error("查询时间推送规则失败！")
    }
@@ -100,7 +100,7 @@
// 是否符合时间规则
func timeJudge(label *Label, groupRule protomsg.EventPush) bool {
    timeNow := time.Now().Format("2006-01-02 15:04:05")
    logger.Info("标签过滤器起始时间为：",groupRule.TimeStart,groupRule.TimeEnd)
    //logger.Info("标签过滤器起始时间为：",groupRule.TimeStart,groupRule.TimeEnd)
    flag1 := isBefore(groupRule.TimeStart, timeNow)
    flag2 := isBefore(timeNow, groupRule.TimeEnd)
    if flag1 && flag2 {
@@ -137,7 +137,7 @@
    if rule.TopicArg == "addr" {
        formula = "'" + label.CameraAddr + "'" + rule.Operator + "'" + rule.RuleValue + "'"
    }
    logger.Info("-------打印摄像机规则公式：",formula)
    //logger.Info("-------打印摄像机规则公式：",formula)
    expression, err := govaluate.NewEvaluableExpression(formula);
    if err != nil {
        logger.Error("表达式有误，请检查！", formula)
@@ -152,7 +152,7 @@
        logger.Info("符合摄像机规则!")
        return "true"
    }
    logger.Info("不符合摄像机规则!")
    //logger.Info("不符合摄像机规则!")
    return "false"
}

@@ -174,7 +174,7 @@
                for _, liker := range arg.Liker {
                    formula := "'" + liker.TableId + "'" + rule.Operator + "'" + rule.RuleValue + "'"
                    expression, err := govaluate.NewEvaluableExpression(formula);
                    logger.Info("-------打印底库规则公式：",formula)
                    //logger.Info("-------打印底库规则公式：",formula)
                    if err != nil {
                        logger.Error("表达式有误，请检查！", formula)
                        return "false"
@@ -214,7 +214,7 @@
                // 其他这个值先这么处理
                return "true"
            }
            logger.Info("-------打印人员规则公式：",formula)
            //logger.Info("-------打印人员规则公式：",formula)
            expression, err := govaluate.NewEvaluableExpression(formula);
            if err != nil {
                logger.Error("表达式有误，请检查！", formula)
@@ -238,7 +238,7 @@
                }
            } else {
                formula := strconv.Itoa(int(personGroup.AlarmLevel)) + rule.Operator + formate(rule.RuleValue)
                logger.Info("-------打印人员等级规则公式：",formula)
                //logger.Info("-------打印人员等级规则公式：",formula)
                expression, err := govaluate.NewEvaluableExpression(formula);
                if err != nil {
                    logger.Error("表达式有误，请检查！", formula)
@@ -275,7 +275,7 @@
    } else {
        for _, def := range label.DefenceLevel {
            formula := strconv.Itoa(int(def)) + rule.Operator + rule.RuleValue
            logger.Info("-------打印布防等级规则公式：",formula)
            //logger.Info("-------打印布防等级规则公式：",formula)
            expression, err := govaluate.NewEvaluableExpression(formula);
            if err != nil {
                logger.Error("表达式有误，请检查！", formula)
@@ -300,7 +300,7 @@
func taskJudge(label *Label, rule *protomsg.EventPushRule) string {
    formula := "'"+label.TaskId +"'"+ rule.Operator +"'"+ rule.RuleValue+"'"
    expression, err := govaluate.NewEvaluableExpression(formula);
    logger.Info("-------打印任务规则公式：",formula)
    //logger.Info("-------打印任务规则公式：",formula)
    if err != nil {
        logger.Error("表达式有误，请检查！", formula)
        return "false"

 logger/logger.go

New file
@@ -0,0 +1,225 @@
package logger

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

const (
    PanicLevel int = iota
    FatalLevel
    ErrorLevel
    WarnLevel
    InfoLevel
    DebugLevel
)
var loggerString string = ""
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 = 7        // 默认保存三天的
    logFile.level = DebugLevel
    //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...))
        //loggerString += fmt.Sprintln(args...)
    }
}

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

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

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

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

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

 main.go

@@ -87,7 +87,7 @@
            } else {
                //runtime.GOMAXPROCS(runtime.NumCPU())
                //logger.Debug("使用的cpu个数：",runtime.NumCPU())
                //go func(msg []byte) {
                go func(msg []byte) {
                    logger.Debug("当前时间戳：", time.Now().Unix())
                    arg := structure.SdkDatas{}
                    //paramFormat(msg, &arg)
@@ -106,7 +106,7 @@
                    logger.Debug("插入完Es所用时间：", esEnd)
                    //事件推送
                    labelFilter.PushSomthing(resultMsg)
                //}(msg)
                }(msg)
            }
        }
    }

 ruleserver/personTrack.go

@@ -2,12 +2,14 @@

import (
    "basic.com/pubsub/protomsg.git"
    "ruleprocess/logger"
    "github.com/golang/protobuf/proto"
    "basic.com/valib/logger.git"
    "ruleprocess/structure"
    "sync"
)

var TrackPond = make(map[string]*PersonTrack)
var lock = sync.RWMutex{}

type PersonTrack struct {
    Faces []*Face // 人脸的数组  改为数量
@@ -19,6 +21,7 @@
}

var num int = 25

// 检查是否前后两次的数据id是否完全相同（人脸）
func FaceIsSame(msg *protomsg.SdkMessage) {
    logger.Debug("+++++++++++++++++++++人脸追踪开始+++++++++++++++摄像机id为：", msg.Cid, "---缓存池为：", TrackPond)
@@ -30,14 +33,18 @@
                FaceIsInPond(msg.Cid, sdkinfo)
            } else {
                if num > 0 { // 连续num次没有数据才算是没有数据，不然只算作丢帧
                    logger.Info("我认为你只是丢帧了,此时的num值为：",num)
                    logger.Info("我认为你只是丢帧了,此时的num值为：", num)
                    num--
                } else {
                    if TrackPond[msg.Cid] != nil {
                        logger.Info("如果不为空：", TrackPond[msg.Cid])
                        lock.Lock()
                        TrackPond[msg.Cid].Faces = nil
                        lock.Unlock()
                    } else {
                        lock.Lock()
                        TrackPond[msg.Cid] = &PersonTrack{Faces: nil}
                        lock.Unlock()
                        logger.Info("如果为空：", TrackPond[msg.Cid])
                    }
                    logger.Info("摄像机:" + msg.Cid + "-没有人脸，被重置为空")
@@ -54,62 +61,62 @@
    logger.Debug("+++++++++++++++++++++人体追踪开始+++++++++++++++摄像机id为：", msg.Cid, "---缓存池为：", TrackPond)
    for _, sdkinfo := range msg.Tasklab.Sdkinfos { // 遍历各算法的sdkData
        if sdkinfo.Sdktype == "Yolo" {
                    if len(sdkinfo.Sdkdata) > 1 {
                        yoloParam := protomsg.ParamYoloObj{}
                        err := proto.Unmarshal(sdkinfo.Sdkdata, &yoloParam)
                        if err != nil {
                            logger.Info("解析yolo数据时出现错误", err)
                            continue
                        }
                        var yoloNum int = 0
                        for i := 0; i < len(yoloParam.Infos); i++ {
                            if yoloParam.Infos[i].Typ == 0 {
                                yoloNum++
                            }
                        }
                        if TrackPond[msg.Cid] != nil {
                            logger.Info("================追踪之前yolo的个数：", yoloNum, "现在缓存池中记录的个数：", TrackPond[msg.Cid].Yolo)
                        } else {
                            logger.Info("================追踪之前yolo的个数：", yoloNum, "还没有这个摄像机的缓存")
                        }
                        if yoloParam.Infos != nil && TrackPond[msg.Cid] != nil && yoloNum == TrackPond[msg.Cid].Yolo { // yolo的如果数量相同则视为不变、把yolo的sdkData清空
                            yoloParam.Infos = (yoloParam.Infos)[0:0]
                            sdkinfo.Sdkdata, err = proto.Marshal(&yoloParam)
                            if err != nil {
                                logger.Error("yolo序列化错误", err)
                            }
                            delete(args.RuleResult,"yolo")
                            logger.Info("清除yolo标签，",args.RuleResult["yolo"])
                            logger.Info("跟之前相同，清空yolo数据，人体追踪结束")
                            return true
                        } else {
                            if TrackPond[msg.Cid] != nil {
                                logger.Info("更新当前摄像机缓存池中的yolo个数：", yoloNum)
                                TrackPond[msg.Cid].Yolo = yoloNum
                            } else {
                                logger.Info("新建当前摄像机缓存池中的yolo个数：", yoloNum)
                                TrackPond[msg.Cid] = &PersonTrack{Yolo: yoloNum}
                            }
                            logger.Debug("---------------------------------人体追踪结束--------------------------------------")
                            return false
                        }
            if len(sdkinfo.Sdkdata) > 1 {
                yoloParam := protomsg.ParamYoloObj{}
                err := proto.Unmarshal(sdkinfo.Sdkdata, &yoloParam)
                if err != nil {
                    logger.Info("解析yolo数据时出现错误", err)
                    continue
                }
                var yoloNum int = 0
                for i := 0; i < len(yoloParam.Infos); i++ {
                    if yoloParam.Infos[i].Typ == 0 {
                        yoloNum++
                    }
                }
                if TrackPond[msg.Cid] != nil {
                    logger.Info("================追踪之前yolo的个数：", yoloNum, "现在缓存池中记录的个数：", TrackPond[msg.Cid].Yolo)
                } else {
                    logger.Info("================追踪之前yolo的个数：", yoloNum, "还没有这个摄像机的缓存")
                }
                if yoloParam.Infos != nil && TrackPond[msg.Cid] != nil && yoloNum == TrackPond[msg.Cid].Yolo { // yolo的如果数量相同则视为不变、把yolo的sdkData清空
                    yoloParam.Infos = (yoloParam.Infos)[0:0]
                    sdkinfo.Sdkdata, err = proto.Marshal(&yoloParam)
                    if err != nil {
                        logger.Error("yolo序列化错误", err)
                    }
                    delete(args.RuleResult,"yolo")
                    logger.Info("清除yolo标签，",args.RuleResult["yolo"])
                    logger.Info("跟之前相同，清空yolo数据，人体追踪结束")
                    return true
                } else {
                    if TrackPond[msg.Cid] != nil {
                        logger.Info("更新当前摄像机缓存池中的yolo个数：", yoloNum)
                        TrackPond[msg.Cid].Yolo = yoloNum
                    } else {
                        if TrackPond[msg.Cid] != nil {
                            TrackPond[msg.Cid].Yolo = 0
                        } else {
                            TrackPond[msg.Cid] = &PersonTrack{Yolo: 0}
                        }
                        logger.Info("摄像机:" + msg.Cid + "-没有yolo，被重置为0")
                        continue
                        logger.Info("新建当前摄像机缓存池中的yolo个数：", yoloNum)
                        TrackPond[msg.Cid] = &PersonTrack{Yolo: yoloNum}
                    }
                    logger.Debug("---------------------------------人体追踪结束--------------------------------------")
                    return false
                }
            } else {
                if TrackPond[msg.Cid] != nil {
                    TrackPond[msg.Cid].Yolo = 0
                } else {
                    TrackPond[msg.Cid] = &PersonTrack{Yolo: 0}
                }
                logger.Info("摄像机:" + msg.Cid + "-没有yolo，被重置为0")
                continue
            }
        }
    }
    logger.Debug("---------------------------------人体追踪结束--------------------------------------")
    return false
}
func TrackOrNot(label map[string]interface{}) bool{
func TrackOrNot(label map[string]interface{}) bool {
    if label["yolo"] != nil && len(label["yolo"].([]structure.Result)) > 0 {
        for _,res := range label["yolo"].([]structure.Result) {
        for _, res := range label["yolo"].([]structure.Result) {
            if res.TimeLabel == "10" {
                return true
            }
@@ -122,8 +129,8 @@
func FaceIsInPond(cameraId string, sdkinfor *protomsg.SdkmsgWithTask) {
    if TrackPond[cameraId] != nil {
        logger.Info("----马前炮：", TrackPond[cameraId], "=====", len(TrackPond[cameraId].Faces))
        for _,face := range TrackPond[cameraId].Faces  {
            logger.Info("缓存中存储的face数据：",face.Id,face.Score)
        for _, face := range TrackPond[cameraId].Faces {
            logger.Info("缓存中存储的face数据：", face.Id, face.Score)
        }
        faceParam := protomsg.ParamFacePos{}
        err := proto.Unmarshal(sdkinfor.Sdkdata, &faceParam)
@@ -131,12 +138,12 @@
            logger.Info("解析face sdk数据时出现错误", err)
        }
        logger.Info("================追踪之前人脸的个数：", len(faceParam.Faces))
        for _,face := range faceParam.Faces  {
            logger.Info("新来的的face数据：",face.Pos.FaceID,face.Pos.FAngle.Confidence)
        for _, face := range faceParam.Faces {
            logger.Info("新来的的face数据：", face.Pos.FaceID, face.Pos.FAngle.Confidence)
        }
        var facesTemp []protomsg.ResultFaceDetect
        for _,face := range faceParam.Faces {
            facesTemp = append(facesTemp,*face) // 先把数据转存一份，不然一会儿数据删减之后找不到原始数据，不能让缓存数据更新了
        for _, face := range faceParam.Faces {
            facesTemp = append(facesTemp, *face) // 先把数据转存一份，不然一会儿数据删减之后找不到原始数据，不能让缓存数据更新了
        }

        for i := 0; i < len(faceParam.Faces); {
@@ -145,14 +152,16 @@
                if faceParam.Faces[i].Pos.FaceID == val.Id && faceParam.Faces[i].Pos.FAngle.Confidence <= val.Score { // 在池子里并且分值更低，是要抛弃的数据
                    faceFlag = true
                    //return "true"
                    logger.Info("分值为：",faceParam.Faces[i].Pos.FAngle.Confidence,"--缓存的分值为：",val.Score,"此数据由于在池子中且分值更低，是要被抛弃的数据")
                    logger.Info("分值为：", faceParam.Faces[i].Pos.FAngle.Confidence, "--缓存的分值为：", val.Score, "此数据由于在池子中且分值更低，是要被抛弃的数据")
                    faceParam.Faces = append(faceParam.Faces[:i], faceParam.Faces[i+1:]...)
                    break
                }
                if faceParam.Faces[i].Pos.FaceID == val.Id && faceParam.Faces[i].Pos.FAngle.Confidence > val.Score { // 在池子里并且分值更高，更新缓存
                    faceFlag = true
                    logger.Info("分值由", val.Score, "更新为：", faceParam.Faces[i].Pos.FAngle.Confidence, "此数据由于在池子中且分值更高，是要被传递下去的数据")
                    lock.Lock()
                    val.Score = faceParam.Faces[i].Pos.FAngle.Confidence
                    lock.Unlock()
                }
            }
            if !faceFlag { // 此人脸不在池子中
@@ -161,10 +170,11 @@
                i++
            }
        }
        logger.Info("反序列化重新装配之前人脸的个数：",len(faceParam.Faces))
        logger.Info("反序列化重新装配之前人脸的个数：", len(faceParam.Faces))

        logger.Info("临时存储的新来数据：")
        for _, temp := range facesTemp {
            logger.Info("临时存储的新来的的face数据：",temp.Pos.FaceID,temp.Pos.FAngle.Confidence)
            logger.Info("临时存储的新来的的face数据：", temp.Pos.FaceID, temp.Pos.FAngle.Confidence)
        }
        sdkinfor.Sdkdata, err = proto.Marshal(&faceParam)
        if err != nil {
@@ -183,10 +193,14 @@
            } else {
                // 此数据在缓存中但不在来的数据帧中，删除此数据更新缓存
                logger.Info("删除池子中的数据更新缓存")
                lock.Lock()
                TrackPond[cameraId].Faces = append(TrackPond[cameraId].Faces[:i], TrackPond[cameraId].Faces[i+1:]...)
                lock.Unlock()
            }
        }
    } else {
        TrackPond[cameraId] = &PersonTrack{Faces: nil} 
        lock.Lock()
        TrackPond[cameraId] = &PersonTrack{Faces: nil}
        lock.Unlock()
    }
}

 ruleserver/readyDataForRule.go

@@ -13,7 +13,7 @@
    "nanomsg.org/go-mangos/transport/tcp"
    "net"
    "ruleprocess/cache"
    "basic.com/valib/logger.git"
    "ruleprocess/logger"
    "ruleprocess/structure"
    "strconv"
    "time"
@@ -63,7 +63,7 @@
            taskGroup = task
        }
    }
    logger.Debug("当前数据帧要匹配的规则组：-------------------------","摄像机id:",cameraId,"任务id",taskId)
    //logger.Debug("当前数据帧要匹配的规则组：-------------------------","摄像机id:",cameraId,"任务id",taskId)
    if taskGroup == nil  {
        return nil
    } else {
@@ -78,7 +78,7 @@
func GetPolygons(cameraId string) []protomsg.CameraPolygon {
    var cameraPolygons []protomsg.CameraPolygon
    cameraPolygons = cache.GetPolygonsByCameraId(cameraId)
    logger.Debug("------=======查看下全部区域：",cameraPolygons)
    //logger.Debug("------=======查看下全部区域：",cameraPolygons)
    return cameraPolygons
}

@@ -89,10 +89,10 @@
}
func Decimal(value float32) float64 {
    value1, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", float64(value)), 64)
    logger.Info("初步保留两位成str:",value1)
    //logger.Info("初步保留两位成str:",value1)
    n10 := math.Pow10(4)
    value2 := math.Trunc((value1+0.5/n10)*n10) / n10
    logger.Info("初步保留两位成str::::",value2)
    //logger.Info("初步保留两位成str::::",value2)
    return value2
}
// 取出某个时间规则的第几天的规则段集合
@@ -299,9 +299,9 @@
        }
    }
    logger.Info("区域是：",areaPoints,"区域内目标数量为：",a.TargetNum,"---",len(a.FilterData))
    for _,tar := range a.FilterData  {
        logger.Info("具体目标的坐标为",tar.Id,tar.Location)
    }
    //for _,tar := range a.FilterData  {
    //    logger.Info("具体目标的坐标为",tar.Id,tar.Location)
    //}
    a.Time = time.Unix(time.Now().Unix(), 0).String()[11:16]
    a.KeepRight = arg.KeepRight
    a.IsStatic = arg.IsStatic

 ruleserver/ruleToformula.go

@@ -3,7 +3,7 @@
import (
    "ruleprocess/cache"
    "ruleprocess/structure"
    "basic.com/valib/logger.git"
    "ruleprocess/logger"
    "sort"
    "strconv"
    "strings"
@@ -254,7 +254,7 @@
                        }
                    }
                }
                logger.Info("face标签的长度：",len(faces))
                //logger.Info("face标签的长度：",len(faces))
                //for _,face := range faces  {
                //    //logger.Debug("————————————————________________看看人脸的坐标:",face.Location)
                //}
@@ -373,20 +373,20 @@
            timeEle = *timeEle1
        }
    }
    for _,ruleRe := range timeEle.RuleResults {
        logger.Info("联动数组里的数据----",ruleRe.CameraId,ruleRe.Sort)
    }
    //for _,ruleRe := range timeEle.RuleResults {
    //    logger.Info("联动数组里的数据----",ruleRe.CameraId,ruleRe.Sort)
    //}
    if flag { // 如果还没有这个定时器元素就新增一个
        //timeEle := TimeElement{N: 2, InitN: 2, GroupId: groupRule.GroupId} // 扔进去一个定时器元素
        //TimeEleList = make(map[string]timeElement)
        TimeEleList[groupRule.GroupId] = &timeEle // 定时器元素以规则组id为键
        logger.Info("---------------------------------------------联动任务创建了计数器并且计数器集合为：", TimeEleList)
        //logger.Info("---------------------------------------------联动任务创建了计数器并且计数器集合为：", TimeEleList)
        // 得出这组完整规则里涉及到几个摄像机，决定着数组里有几个结构体,去重添加方式
        for j := 0; j < len(groupRule.Rules); j++ {
            var flag1 bool = true
            logger.Info("规则组信息：",groupRule.Rules[j].CameraId)
            //logger.Info("规则组信息：",groupRule.Rules[j].CameraId)
            for _, ruleRes := range TimeEleList[groupRule.GroupId].RuleResults {
                logger.Info("联动数组里的数据：",ruleRes.CameraId,ruleRes.Sort)
                //logger.Info("联动数组里的数据：",ruleRes.CameraId,ruleRes.Sort)
                if groupRule.Rules[j].CameraId == ruleRes.CameraId {
                    flag1 = false
                }
@@ -455,7 +455,7 @@
                        for _, ruleRes := range TimeEleList[groupRule.GroupId].RuleResults {
                            label.LinkCache = append(label.LinkCache, ruleRes.CacheData)
                        }
                        logger.Debug("联动任务缓存了几个数据", len(label.LinkCache))
                        //logger.Debug("联动任务缓存了几个数据", len(label.LinkCache))
                        for i := 0; i < len(args.RuleResult["yolo"].([]structure.Result)); i++ {
                            if args.RuleResult["yolo"].([]structure.Result)[i].RuleGroupId == groupRule.GroupId { // 把联动数据追加上
                                args.RuleResult["yolo"].([]structure.Result)[i].Others.LinkCache = label.LinkCache
@@ -526,7 +526,7 @@
                    // 把没有相似者的人脸从filterData中删除
                    for index := 0; index < len(am.FilterData); {
                        // 将达不到阈值的相似者从相似者数组中删除
                        logger.Info("看看相似者人数：",len(am.FilterData[index].Liker))
                        //logger.Info("看看相似者人数：",len(am.FilterData[index].Liker))
                        if len(am.FilterData[index].Liker) == 0 {
                            // Go 语言中切片删除元素的本质是：以被删除元素为分界点，将前后两个部分的内存重新连接起来。不用怀疑，数组删除元素就这么坑爹
                            am.FilterData = append(am.FilterData[:index], am.FilterData[index+1:]...)
@@ -537,7 +537,7 @@
                    if len(am.FilterData) > 0 {
                        flag = "true"
                    }
                    logger.Info("---------人脸比对符合条件的数量为：",len(am.FilterData))
                    //logger.Info("---------人脸比对符合条件的数量为：",len(am.FilterData))
                    return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort}
                }
            }
@@ -546,7 +546,7 @@
                if rule.Operator == "==" || rule.Operator == ">=" || rule.Operator == "<=" || rule.Operator == "<" || rule.Operator == ">" || rule.Operator == "!=" {
                    // 如果是不规矩的连接符统统返回false 规则也只能判断人脸的相似度，所以不存在别的连接符
                    if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
                        logger.Info("-----------------------过规则之前区域内的人脸数量为：",am.TargetNum)
                        //logger.Info("-----------------------过规则之前区域内的人脸数量为：",am.TargetNum)
                        var args []*structure.Arg
                        if rule.RuleWithPre == "&&" {
                            args = am.FilterData
@@ -578,7 +578,7 @@
                            }
                        }
                        am.TargetNum = len(am.FilterData) // 把符合条件的目标数量更新到targetNum字段
                        logger.Info("过完条件后的目标数量为：",am.TargetNum)
                        //logger.Info("过完条件后的目标数量为：",am.TargetNum)
                        if am.TargetNum > 0 {
                            logger.Info("！！！！！！！！！人脸检测成功")
                            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
@@ -654,14 +654,14 @@
    cacheId := ""
    if rule.PolygonId == am.AreaId { // 首先规则所对应的区域id要跟区域数据的id对的上  配置的算法要对的上
        if rule.SdkArgAlias == "duration" { //
            logger.Info("当前小规则是：---------", rule)
            //logger.Info("当前小规则是：---------", rule)
            // 先看看定时器元素队列中是否有这条规则的定时器,如果有就不能再次创建了
            rw.Lock()
            var flag bool = true
            for k, _ := range TimeEleList {
                if k == groupId+"+"+rule.Id {
                    flag = false // 有就置为false
                    logger.Info("有这个定时器，不再创建了：")
                    //logger.Info("有这个定时器，不再创建了：")
                }
            }


 ruleserver/server.go

@@ -4,7 +4,7 @@
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/gopherdiscovery.git"
    "github.com/gogo/protobuf/proto"
    "basic.com/valib/logger.git"
    "ruleprocess/logger"
    "time"
)


 ruleserver/timeTicker.go

@@ -2,7 +2,7 @@

import (
    "fmt"
    "basic.com/valib/logger.git"
    "ruleprocess/logger"
    "ruleprocess/structure"
    "strings"
    "time"