再削减日志

panlei

2019-11-30 371eec6fc2618458e037affaf646ff83e6887e63

再削减日志

 algorithm/car/plate.go

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

import (
"basic.com/pubsub/protomsg.git"
logger "github.com/alecthomas/log4go"
"github.com/knetic/govaluate"
"ruleprocess/structure"
"strconv"
    "basic.com/pubsub/protomsg.git"
    "github.com/knetic/govaluate"
    "ruleprocess/structure"
    "strconv"
)

// 车牌算法
@@ -13,10 +12,10 @@
func Entrance(rule *protomsg.Rule, am *structure.AreaMap,lable *structure.Others,args *structure.SdkDatas,message *protomsg.SdkMessage) structure.LittleRuleResult {
    if rule.PolygonId == am.AreaId { // 首先这条规则得是这个算法的规则，其次规则所对应的区域id要跟区域数据的id对的上
        if rule.SdkArgAlias != "nCarCount" {
            logger.Info("过滤车牌信息")
            //logger.Info("过滤车牌信息")
            return filterRule(rule, am)
        } else {
            logger.Info("计算车牌车辆数量") // 目前只能检测出车牌数量
            //logger.Info("计算车牌车辆数量") // 目前只能检测出车牌数量
            return transferParameters(rule, am)
        }
    } else {
@@ -34,7 +33,7 @@
        rule.SdkArgAlias == "fVDConf" || rule.SdkArgAlias == "nVehicleColor2" ||  rule.SdkArgAlias == "nColor" || rule.SdkArgAlias == "nPlateFlag"

    if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" || carFlag{ // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
        logger.Debug("---------走了车牌识别过滤算法",rule.Id,rule.SdkArgAlias,rule.Operator,rule.SdkArgValue,am.AreaId)
        //logger.Debug("---------走了车牌识别过滤算法",rule.Id,rule.SdkArgAlias,rule.Operator,rule.SdkArgValue,am.AreaId)
        var args []*structure.Arg
        if rule.RuleWithPre == "&&" {
            args = am.FilterData

 algorithm/face/face.go

@@ -2,14 +2,13 @@

import (
    "basic.com/pubsub/protomsg.git"
    logger "github.com/alecthomas/log4go"
    "github.com/knetic/govaluate"
    "ruleprocess/structure"
    "strconv"
)
// 人脸算法
func Entrance(rule *protomsg.Rule, am *structure.AreaMap,lable *structure.Others,args *structure.SdkDatas,message *protomsg.SdkMessage) structure.LittleRuleResult {
    logger.Debug("---------走了人脸检测算法",rule.Id,rule.SdkArgAlias,rule.Operator,rule.SdkArgValue,am.AreaId)
    //logger.Debug("---------走了人脸检测算法",rule.Id,rule.SdkArgAlias,rule.Operator,rule.SdkArgValue,am.AreaId)
    return filterRule(rule,am)
}


 algorithm/faceCompare/faceCompare.go

@@ -2,14 +2,13 @@

import (
    "basic.com/pubsub/protomsg.git"
    logger "github.com/alecthomas/log4go"
    "github.com/knetic/govaluate"
    "ruleprocess/structure"
    "strconv"
)
// 人脸算法
func Entrance(rule *protomsg.Rule, am *structure.AreaMap,lable *structure.Others,args *structure.SdkDatas,message *protomsg.SdkMessage) structure.LittleRuleResult {
    logger.Debug("---------走了人脸比对算法",rule.Id,rule.SdkArgAlias,rule.Operator,rule.SdkArgValue,am.AreaId)
    //logger.Debug("---------走了人脸比对算法",rule.Id,rule.SdkArgAlias,rule.Operator,rule.SdkArgValue,am.AreaId)
    return filterRule1(rule,am)
}


 algorithm/personUnsual/personUnsual.go

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

import (
    "basic.com/pubsub/protomsg.git"
    logger "github.com/alecthomas/log4go"
    "github.com/knetic/govaluate"
    "ruleprocess/structure"
    "strconv"
@@ -11,7 +10,7 @@
// 人员异常算法
func Entrance(rule *protomsg.Rule, am *structure.AreaMap, lable *structure.Others, args *structure.SdkDatas, message *protomsg.SdkMessage) structure.LittleRuleResult {
    if rule.PolygonId == am.AreaId { // 首先这条规则得是这个算法的规则，其次规则所对应的区域id要跟区域数据的id对的上
        logger.Debug("---------走了人员异常算法", rule.Id, rule.SdkArgAlias, rule.Operator, rule.SdkArgValue, am.AreaId)
        //logger.Debug("---------走了人员异常算法", rule.Id, rule.SdkArgAlias, rule.Operator, rule.SdkArgValue, am.AreaId)
        if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" || rule.SdkArgAlias == "" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
            return filterRule(rule, am)
        } else if rule.SdkArgAlias == "objCount" {

 algorithm/static/static.go

@@ -218,10 +218,10 @@
    rw.Lock()

        if result { // 结果为真
            for k, tar := range structure.StaticMap[areaId].Targets {
            for _, tar := range structure.StaticMap[areaId].Targets {
                if tar.Id == person.Id {
                    if tar.N == 0 && tar.AlarmFlag {
                        logger.Debug("-------------------------符合持续时间规则但并不是首次，不报警")
                        //logger.Debug("-------------------------符合持续时间规则但并不是首次，不报警")
                        flagTime = "11"
                        o.TimeLable = flagTime
                        o.CacheData = tar.CacheSdkData
@@ -237,7 +237,7 @@
                        flagTime = "00"
                        // 有定时器但不为0把已打的标签删除
                        // args.RuleResult = nil
                        logger.Debug("------------------------结果为真但计数器不到0，不报警,此时的计数器", k, "的值为：", tar.N)
                        //logger.Debug("------------------------结果为真但计数器不到0，不报警,此时的计数器", k, "的值为：", tar.N)
                    }
                }
            }
@@ -246,7 +246,7 @@
                if tar.Id == person.Id {
                    if tar.AlarmFlag {
                        if tar.BufferFlag == 0 {
                            logger.Debug("------------------------------杀死计数器，报警此帧状态改变的数据，此时的计数器的值为", tar.N)
                            //logger.Debug("------------------------------杀死计数器，报警此帧状态改变的数据，此时的计数器的值为", tar.N)
                            flagTime = "12"
                            structure.StaticMap[areaId].Targets = append(structure.StaticMap[areaId].Targets[:index],structure.StaticMap[areaId].Targets[index+1:]...)
                        } else {
@@ -256,7 +256,7 @@
                            }
                        }
                    } else {
                        logger.Debug("-----------结果为假且不到0，杀死定时器")
                        //logger.Debug("-----------结果为假且不到0，杀死定时器")
                        structure.StaticMap[areaId].Targets = append(structure.StaticMap[areaId].Targets[:index],structure.StaticMap[areaId].Targets[index+1:]...)
                    }
                }

 main.go

@@ -10,8 +10,6 @@
    "ruleprocess/insertdata"
    "ruleprocess/labelFilter"
    "ruleprocess/structure"
    "time"

    //"basic.com/valib/logger.git"
    "flag"
    "fmt"
@@ -86,29 +84,29 @@
            msg, err = c.Recv()
            //msgChan <- msg
            if err != nil {
                logger.Info("recv error : ", err)
                //logger.Info("recv error : ", err)
                fmt.Println("recv error : ", err)
                continue
            } else {

                //go func(msg []byte) {
                    logger.Debug("当前时间戳：", time.Now().Unix())
                    //logger.Debug("当前时间戳：", time.Now().Unix())
                    //logger.Warn(time.Now().Format("2006-01-02 15:04:05"))
                    arg := structure.SdkDatas{}
                    //paramFormat(msg, &arg)
                    start := time.Now()
                    //start := time.Now()
                    m := CallParamFormat(msg, &arg)
                    // 进行规则处理判断(打上规则的标签)
                    ruleserver.Judge(&arg, &m) // 把sdkMessage传进去，方便缓存数据时拼出一个resultMag
                    // 把arg里的打的标签拿出来给m再封装一层
                    resultMsg := structure.ResultMsg{SdkMessage: &m, RuleResult: arg.RuleResult}
                    ruleserver.GetAttachInfo(resultMsg.SdkMessage)
                    ruleEnd := time.Since(start)
                    logger.Debug("规则判断完所用时间：", ruleEnd)
                    //ruleEnd := time.Since(start)
                    //logger.Debug("规则判断完所用时间：", ruleEnd)
                    // 将打完标签的数据插入到ES
                    insertdata.InsertToEs(resultMsg)
                    esEnd := time.Since(start)
                    logger.Debug("插入完Es所用时间：", esEnd)
                    //esEnd := time.Since(start)
                    //logger.Debug("插入完Es所用时间：", esEnd)
                    //事件推送
                    labelFilter.PushSomthing(resultMsg)
                //}(msg)
@@ -118,7 +116,7 @@
}

func CallParamFormat(msg []byte, args *structure.SdkDatas) protomsg.SdkMessage{
    logger.Info("呼叫中间件格式化数据")
    //logger.Info("呼叫中间件格式化数据")
    p,err :=  plugin.Open("./algorithm/middleware.so")
    if err != nil {
        panic(err)

 ruleserver/personTrack.go

@@ -30,7 +30,7 @@

// 检查是否前后两次的数据id是否完全相同（人脸）
func FaceIsSame(msg *protomsg.SdkMessage) {
    logger.Debug("+++++++++++++++++++++人脸追踪开始+++++++++++++++摄像机id为：", msg.Cid, "---缓存池为：", TrackPond)
    //logger.Debug("+++++++++++++++++++++人脸追踪开始+++++++++++++++摄像机id为：", msg.Cid, "---缓存池为：", TrackPond)
    for _, sdkinfo := range msg.Tasklab.Sdkinfos { // 遍历各算法的sdkData
        if sdkinfo.Sdktype == "FaceDetect" { // 人脸检测
            if len(sdkinfo.Sdkdata) > 1 {
@@ -58,12 +58,12 @@
            }
        }
    }
    logger.Debug("--------------------------------人脸追踪结束--------------------------------------")
    //logger.Debug("--------------------------------人脸追踪结束--------------------------------------")
}

//  追踪人体，检查数量是否一致
func BodyIsSame(args *structure.SdkDatas,msg *protomsg.SdkMessage) bool{
    logger.Debug("+++++++++++++++++++++人体追踪开始+++++++++++++++摄像机id为：", msg.Cid, "---缓存池为：", TrackPond)
    //logger.Debug("+++++++++++++++++++++人体追踪开始+++++++++++++++摄像机id为：", msg.Cid, "---缓存池为：", TrackPond)
    for _, sdkinfo := range msg.Tasklab.Sdkinfos { // 遍历各算法的sdkData
        if sdkinfo.Sdktype == "Yolo" {
            if len(sdkinfo.Sdkdata) > 1 {
@@ -79,11 +79,11 @@
                        yoloNum++
                    }
                }
                if TrackPond[msg.Cid] != nil {
                    logger.Info("================追踪之前yolo的个数：", yoloNum, "现在缓存池中记录的个数：", TrackPond[msg.Cid].Yolo)
                } else {
                    logger.Info("================追踪之前yolo的个数：", 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)
@@ -115,7 +115,7 @@
            }
        }
    }
    logger.Debug("---------------------------------人体追踪结束--------------------------------------")
    //logger.Debug("---------------------------------人体追踪结束--------------------------------------")
    return false
}

@@ -210,7 +210,7 @@

// 检查是否前后两次的数据id是否完全相同（人脸）
func CarIsSame(msg *protomsg.SdkMessage) {
    logger.Debug("+++++++++++++++++++++车辆追踪开始+++++++++++++++摄像机id为：", msg.Cid, "---缓存池为：", TrackPond)
    //logger.Debug("+++++++++++++++++++++车辆追踪开始+++++++++++++++摄像机id为：", msg.Cid, "---缓存池为：", TrackPond)
    for _, sdkinfo := range msg.Tasklab.Sdkinfos { // 遍历各算法的sdkData
        if sdkinfo.Sdktype == "Plate" { // 人脸检测
            if len(sdkinfo.Sdkdata) > 1 {
@@ -218,11 +218,11 @@
                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])
                        //logger.Info("如果不为空：", TrackPond[msg.Cid])
                        lock.Lock()
                        TrackPond[msg.Cid].Cars = nil
                        lock.Unlock()
@@ -230,15 +230,15 @@
                        lock.Lock()
                        TrackPond[msg.Cid] = &PersonTrack{Cars: nil}
                        lock.Unlock()
                        logger.Info("如果为空：", TrackPond[msg.Cid])
                        //logger.Info("如果为空：", TrackPond[msg.Cid])
                    }
                    logger.Info("摄像机:" + msg.Cid + "-没有车辆，被重置为空")
                    //logger.Info("摄像机:" + msg.Cid + "-没有车辆，被重置为空")
                    continue
                }
            }
        }
    }
    logger.Debug("--------------------------------车辆追踪结束--------------------------------------")
    //logger.Debug("--------------------------------车辆追踪结束--------------------------------------")
}



 ruleserver/readyDataForRule.go

@@ -184,7 +184,7 @@
            if groupRule.Rules[j].SdkArgAlias == "cmpThreshold" {
                v2, err := strconv.ParseFloat(groupRule.Rules[j].SdkArgValue, 32)
                if err != nil {
                    logger.Error("string转float32失败！")
                    //logger.Error("string转float32失败！")
                }
                threshold = float32(v2)
            }
@@ -193,7 +193,7 @@
    // 为了测试作下弊，直接让其比对全部底库
    //compareFlag = 1
    if compareFlag == 0 {
        logger.Info("没有配置对比底库参数")
        //logger.Info("没有配置对比底库参数")
        return
    }
    //logger.Debug("=====配置的阈值为：", threshold)
@@ -252,7 +252,7 @@
            a.FilterData = append(a.FilterData, &arg1)
        }
    }
    logger.Info("区域是：",areaPoints,"区域内目标数量为：",a.TargetNum,"---",len(a.FilterData))
    //logger.Info("区域是：",areaPoints,"区域内目标数量为：",a.TargetNum,"---",len(a.FilterData))
    a.Time = time.Unix(time.Now().Unix(), 0).String()[11:16]
    //logger.Println("--------------------看看区域数据：",*a)
}

 ruleserver/ruleToformula.go

@@ -160,7 +160,7 @@
            //for _,face := range faces  {
            //    //logger.Debug("————————————————________________看看人脸的坐标:",face.Location)
            //}
            logger.Warn("___________________________________________________________________________终于走完万里长征")
            //logger.Warn("___________________________________________________________________________终于走完万里长征")
            // 把他们的位置数据也传下去
            yolos := []*structure.Arg{}
            for _, sdkData := range args.Sdkdata {
@@ -172,7 +172,7 @@
                    }
                }
            }
            logger.Debug("------locations的内容：", yolos)
            //logger.Debug("------locations的内容：", yolos)
            // 处理目标定时数据
            targets := []*structure.Arg{}
            for _, sdkData := range args.Sdkdata {
@@ -187,7 +187,7 @@
            // 车辆目标统计
            cars := []*structure.Arg{}
            for _, sdkData := range args.Sdkdata {
                logger.Info("看看sdkNames",sdkNames)
                //logger.Info("看看sdkNames",sdkNames)
                if sdkData.IpcId == "91d923ef-6200-4549-ab1b-8e773e85d729" { // 把车牌数据的各个目标的坐标输出方便后面画框
                    for _, areaMap := range sdkData.AreaMapList {
                        if areaMap.IsEffective {
@@ -202,7 +202,7 @@
            } else {
                islink = false
            }
            logger.Info("触发的区域id：",polygonId)
            //logger.Info("触发的区域id：",polygonId)
            var labelTypes []int // 0为yolo标签，1为face标签 2为两者标签
            if sdkNames != "" && len(targets) == 0 {
                args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]structure.Result), structure.Result{taskId, sdkNames, groupRule.GroupId, groupRule.DefenceState, groupRule.AlarmLevel, groupRule.GroupText, yolos, polygonId, islink,label})
@@ -211,17 +211,17 @@
            }
            if faceFlag {
                args.RuleResult["face"] = append(args.RuleResult["face"].([]structure.Result), structure.Result{taskId, sdkNames, groupRule.GroupId, groupRule.DefenceState, groupRule.AlarmLevel, groupRule.GroupText, faces, polygonId, islink,label})
                logger.Info("-------------------face结果标签", len(args.RuleResult["face"].([]structure.Result)))
                //logger.Info("-------------------face结果标签", len(args.RuleResult["face"].([]structure.Result)))
                labelTypes = append(labelTypes,1)
            }
            if len(targets) > 0 {
                args.RuleResult["target"] = append(args.RuleResult["target"].([]structure.Result), structure.Result{taskId, sdkNames, groupRule.GroupId, groupRule.DefenceState, groupRule.AlarmLevel, groupRule.GroupText, targets, polygonId, islink,label})
                logger.Info("-------------------目标持续结果标签", len(args.RuleResult["target"].([]structure.Result)))
                //logger.Info("-------------------目标持续结果标签", len(args.RuleResult["target"].([]structure.Result)))
                //labelTypes = append(labelTypes,2)
            }
            if len(cars) > 0 {
                args.RuleResult["plate"] = append(args.RuleResult["plate"].([]structure.Result), structure.Result{taskId, sdkNames, groupRule.GroupId, groupRule.DefenceState, groupRule.AlarmLevel, groupRule.GroupText, cars, polygonId, islink,label})
                logger.Info("-------------------车牌结果标签", len(args.RuleResult["plate"].([]structure.Result)))
                //logger.Info("-------------------车牌结果标签", len(args.RuleResult["plate"].([]structure.Result)))
                //labelTypes = append(labelTypes,2)
            }
            // 给持续时间的第一张赋予缓存数据（遍历复制）
@@ -255,7 +255,7 @@
        // 结果为假时也要走，有杀死定时器的操作
        TimerAlarm(&label, groupRule.GroupId, result)
        //fmt.Println(timeFlag)
        logger.Info("不符合规则")
        //logger.Info("不符合规则")
        return false,[]int{}
    }
}
@@ -354,7 +354,7 @@
                    }
                }
                va.CacheData = structure.ResultMsg{message, tempMap}
                logger.Info("这个摄像机--", args.CameraId, "--被赋予了result", va.Result)
                //logger.Info("这个摄像机--", args.CameraId, "--被赋予了result", va.Result)
            }
        }
        // 判断结果数组是否完满(即被赋值完毕)可得出报警结果
@@ -374,12 +374,12 @@
            for _, va := range timeEle.RuleResults {
                completeFormula = completeFormula + va.RuleWithPre + "" + va.Result
            }
            logger.Info("---------------------------联动任务的公式", completeFormula)
            //logger.Info("---------------------------联动任务的公式", completeFormula)
            if completeFormula != "" {
                expression, _ := govaluate.NewEvaluableExpression(completeFormula)
                result, _ := expression.Evaluate(nil) // 得到数学公式的结果
                if result.(bool) {
                    logger.Info("___________________________________________________________________联动任务报警")
                    //logger.Info("___________________________________________________________________联动任务报警")
                    rw.RLock()
                    if TimeEleList[groupRule.GroupId] != nil {  // 极偶尔有情况会等于nil，不知道为啥，做个判断以防宕机
                        // 把数组里缓存的数据取出来一起报警
@@ -403,7 +403,7 @@
                }
            }
        } else {
            logger.Warn("数组不圆满不打标签")
            //logger.Warn("数组不圆满不打标签")
            // 倒是把打的组规则标签给去掉了啊
            for _,val := range labelTypes {
                if val == 0 {
@@ -432,7 +432,7 @@
        for k, _ := range TimeEleList {
            if k == groupRule.GroupId {
                delete(TimeEleList, k)
                logger.Debug("因为定时器的一帧数据结果为false，干掉定时器")
                //logger.Debug("因为定时器的一帧数据结果为false，干掉定时器")
            }
        }
        rw.Unlock()

 ruleserver/timeTicker.go

@@ -1,7 +1,6 @@
package ruleserver

import (
    "fmt"
    logger "github.com/alecthomas/log4go"
    "ruleprocess/structure"
    "strings"
@@ -39,15 +38,15 @@
    for {
        select {
        case <-ticker.C:
            logger.Info("定时器执行单元", time.Now().Unix())
            fmt.Println("定时器执行单元", time.Now().Unix())
            //logger.Info("定时器执行单元", time.Now().Unix())
            //fmt.Println("定时器执行单元", time.Now().Unix())
            // 每秒钟计数器池子里所有的计数器元素都减一，减到0的是该报警的
            // 图片定时器系列
            rw.Lock()
            for k, timeEle := range TimeEleList {
                if timeEle.N > 0 {
                    timeEle.N = timeEle.N - 1
                    logger.Debug("-------------------------------------打印定时器计数元素当前值-----------------------------------------：", timeEle.N)
                    //logger.Debug("-------------------------------------打印定时器计数元素当前值-----------------------------------------：", timeEle.N)
                }
                if timeEle.GroupId != "" && timeEle.N == 0 {
                    // 说明是联动任务的时间窗口 到点儿了该销毁了,再来了再创建