减少日志量外加放开标签过滤器

panlei

2019-10-24 c165dbb634d3c8f3446d499c25894e8d61945c2d

减少日志量外加放开标签过滤器

 insertdata/insertDataToEs.go

@@ -199,7 +199,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)
@@ -318,11 +318,11 @@
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)
                //logger.Warn("--------合并人脸时相似者：", lik.PersonId, lik.TableName)
            }
            if arg.Id == face.Id {
                flag = true
@@ -404,7 +404,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 {

 labelFilter/readyDataForLabel.go

@@ -18,10 +18,10 @@
}
// 把数据装配到label
func (label *Label)DataFormatToLabel(result structure.ResultMsg) {
    logger.Debug("face结果：",result.RuleResult["face"] != nil && len(result.RuleResult["face"].([]structure.FaceResult)) > 0)
    logger.Debug("yolo结果：",result.RuleResult["yolo"] != nil && len(result.RuleResult["yolo"].([]structure.Result)) > 0)
    //logger.Debug("face结果：",result.RuleResult["face"] != nil && len(result.RuleResult["face"].([]structure.FaceResult)) > 0)
    //logger.Debug("yolo结果：",result.RuleResult["yolo"] != nil && len(result.RuleResult["yolo"].([]structure.Result)) > 0)
    if (result.RuleResult["face"] != nil && len(result.RuleResult["face"].([]structure.FaceResult)) > 0) || (result.RuleResult["yolo"] != nil && len(result.RuleResult["yolo"].([]structure.Result)) > 0) {
        logger.Info("---------------标签过滤器赋值")
        //logger.Info("---------------标签过滤器赋值")
        label.CameraId = result.Cid
        camera, err := cache.GetCameraById(result.Cid)
        if err != nil {
@@ -42,7 +42,7 @@
                label.DefenceLevel = append(label.DefenceLevel,yoloGroup.AlarmLevel)
            }
        }
        logger.Info("------------标签过滤器赋值完毕")
        //logger.Info("------------标签过滤器赋值完毕")
    }
}


 labelFilter/ruleForLabel.go

@@ -14,7 +14,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
@@ -22,7 +22,7 @@
    //拿到所有规则组
    var api dbapi.EventPushApi
    b, allRules := api.FindAllDetails()
    logger.Info("查看所有规则组：", allRules)
    //logger.Info("查看所有规则组：", allRules)
    if !b {
        logger.Error("查询时间推送规则失败！")
    }
@@ -92,7 +92,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 {
@@ -129,7 +129,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)
@@ -144,7 +144,7 @@
        logger.Info("符合摄像机规则!")
        return "true"
    }
    logger.Info("不符合摄像机规则!")
    //logger.Info("不符合摄像机规则!")
    return "false"
}

@@ -166,7 +166,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"
@@ -206,7 +206,7 @@
                // 其他这个值先这么处理
                return "true"
            }
            logger.Info("-------打印人员规则公式：",formula)
            //logger.Info("-------打印人员规则公式：",formula)
            expression, err := govaluate.NewEvaluableExpression(formula);
            if err != nil {
                logger.Error("表达式有误，请检查！", formula)
@@ -230,7 +230,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)
@@ -267,7 +267,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)
@@ -292,7 +292,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

@@ -91,8 +91,8 @@
func Debug(args ...interface{}) {
    if logFile.level >= DebugLevel {
        log.SetPrefix(blue(debugPrefix))
        //_ = log.Output(2, fmt.Sprintln(args...))
        loggerString += fmt.Sprintln(args...)
        _ = log.Output(2, fmt.Sprintln(args...))
        //loggerString += fmt.Sprintln(args...)
    }
}

@@ -107,24 +107,24 @@
func Warn(args ...interface{}) {
    if logFile.level >= WarnLevel {
        log.SetPrefix(magenta(warnPrefix))
        //_ = log.Output(2, fmt.Sprintln(args...))
        loggerString += fmt.Sprintln(args...)
        _ = 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...)
        _ = 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...)
        _ = log.Output(2, fmt.Sprintln(args...))
        //loggerString += fmt.Sprintln(args...)
    }
}
func OutPutByPanlei() {

 main.go

@@ -7,6 +7,7 @@
    "net/http"
    _ "net/http/pprof"
    "ruleprocess/insertdata"
    "ruleprocess/labelFilter"
    "ruleprocess/logger"
    "ruleprocess/structure"
    "ruleprocess/util"
@@ -17,6 +18,7 @@
    "flag"
    "fmt"
    "github.com/golang/protobuf/proto"
    "github.com/spf13/viper"
    //"gocv.io/x/gocv"
    //"image"
    //"image/color"
@@ -24,7 +26,6 @@
    "ruleprocess/cache"
    "ruleprocess/ruleserver"
    "sync"
    "github.com/spf13/viper"
)

var dbIp = flag.String("dbIp", "127.0.0.1", "dbserver ip")
@@ -91,7 +92,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,9 +107,9 @@
                    insertdata.InsertToEs(resultMsg)
                    logger.Debug("插入完Es所用时间：", time.Since(start))
                    //事件推送
                    //go labelFilter.Judge(resultMsg)
                    logger.OutPutByPanlei()
                //}(msg)
                    go labelFilter.Judge(resultMsg)
                    //logger.OutPutByPanlei()
                }(msg)
            }
        }
    }

 ruleserver/readyDataForRule.go

@@ -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
}
// 取出某个时间规则的第几天的规则段集合

 ruleserver/ruleToformula.go

@@ -244,7 +244,7 @@
                        }
                    }
                }
                logger.Info("face标签的长度：",len(faces))
                //logger.Info("face标签的长度：",len(faces))
                //for _,face := range faces  {
                //    //logger.Debug("————————————————________________看看人脸的坐标:",face.Location)
                //}
@@ -339,20 +339,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
                }
@@ -421,7 +421,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
@@ -492,7 +492,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:]...)
@@ -503,7 +503,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}
                }
            }
@@ -512,7 +512,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
@@ -544,7 +544,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}
@@ -615,14 +615,14 @@
func duration(rule *protomsg.Rule, groupId string, am *structure.AreaMap, args *structure.SdkDatas, message *protomsg.SdkMessage) {
    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("有这个定时器，不再创建了：")
                }
            }

@@ -631,7 +631,7 @@
                timeEle := TimeElement{N: timeLength, InitN: timeLength, AlarmFlag: false, BufferFlag: 10, CacheSdkData: structure.ResultMsg{message, args.RuleResult}} // 扔进去一个定时器元素（并缓存当前画面帧数据）
                //TimeEleList = make(map[string]timeElement)
                TimeEleList[groupId+"+"+rule.Id] = &timeEle // 定时器元素以当前持续时间小规则id为键
                logger.Info("创建了计数器")
                //logger.Info("创建了计数器")
            }
            rw.Unlock()
        }