削减日志

panlei

2019-11-30 54c923158d991c0db54307cef60a96ed0b7ac410

削减日志

 algorithm/car/plate.go

@@ -49,34 +49,34 @@
            switch rule.SdkArgAlias {
            case "fVDConf":
                formula = strconv.FormatFloat(arg.Score, 'f', -1, 32) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("车辆置信度小公式：", formula)
                //logger.Info("车辆置信度小公式：", formula)
            case "nVehicleColor1":
                formula = strconv.Itoa(int(arg.Car.NVehicleColor1)) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("车身主颜色小公式：", formula)
                //logger.Info("车身主颜色小公式：", formula)
            case "nVehicleColor2":
                formula = strconv.Itoa(int(arg.Car.NVehicleColor2)) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("车身辅颜色小公式：", formula)
                //logger.Info("车身辅颜色小公式：", formula)
            case "fConfidence":
                formula = arg.Car.VehicleType1 + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("车辆类型小公式：", formula)
                //logger.Info("车辆类型小公式：", formula)
            case "nVehicleBright":
                formula = strconv.Itoa(int(arg.Car.NVehicleBright)) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("车辆亮度小公式：", formula)
                //logger.Info("车辆亮度小公式：", formula)
            case "nPlateFlag":
                formula = strconv.Itoa(int(arg.Car.NPlateFlag)) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("识别到车牌小公式：", formula)
                //logger.Info("识别到车牌小公式：", formula)
            case "license":
                formula = arg.Car.License + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("车牌号码小公式：", formula)
                //logger.Info("车牌号码小公式：", formula)
            case "nConfidence":
                formula = strconv.Itoa(int(arg.Car.NConfidence)) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("车牌可信度小公式：", formula)
                //logger.Info("车牌可信度小公式：", formula)
            case "nColor":
                formula = strconv.Itoa(int(arg.Car.NColor)) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("车牌颜色小公式：", formula)
                //logger.Info("车牌颜色小公式：", formula)
            case "nType":
                formula = strconv.Itoa(int(arg.Car.NType)) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("车牌类型小公式：", formula)
                //logger.Info("车牌类型小公式：", formula)
            }
            expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
            result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
@@ -112,7 +112,7 @@
    //args := am.targetNum     targetNum 已成所有目标的总数量，这里只算yolo的
    var num int = len(am.FilterData)
    formula := strconv.Itoa(num) + " " + rule.Operator + " " + rule.SdkArgValue
    logger.Info("车辆数量公式",formula)
    //logger.Info("车辆数量公式",formula)
    expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
    result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
    return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + " " + strconv.FormatBool(result.(bool)), rule.Sort}

 algorithm/face/face.go

@@ -29,7 +29,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:]...)
@@ -40,7 +40,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}
                }
            }
@@ -49,7 +49,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
@@ -67,13 +67,13 @@
                            switch rule.SdkArgAlias {
                            case "score":
                                formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                                logger.Info("相似度小公式：", formula)
                                //logger.Info("相似度小公式：", formula)
                            case "proportion":
                                formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                                logger.Info("占比公式：", formula)
                                //logger.Info("占比公式：", formula)
                            case "size":
                                formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                                logger.Info("尺寸小公式：", formula)
                                //logger.Info("尺寸小公式：", formula)
                            }
                            expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
                            result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
@@ -82,9 +82,9 @@
                            }
                        }
                        am.TargetNum = len(am.FilterData) // 把符合条件的目标数量更新到targetNum字段
                        logger.Info("过完条件后的目标数量为：",am.TargetNum)
                        //logger.Info("过完条件后的目标数量为：",am.TargetNum)
                        if am.TargetNum > 0 {
                            logger.Info("！！！！！！！！！人脸检测成功")
                            //logger.Info("！！！！！！！！！人脸检测成功")
                            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
                        } else {
                            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}

 algorithm/faceCompare/faceCompare.go

@@ -30,7 +30,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:]...)
@@ -41,7 +41,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}
                }
            }
@@ -50,7 +50,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
@@ -68,13 +68,13 @@
                            switch rule.SdkArgAlias {
                            case "score":
                                formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                                logger.Info("相似度小公式：", formula)
                                //logger.Info("相似度小公式：", formula)
                            case "proportion":
                                formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                                logger.Info("占比公式：", formula)
                                //logger.Info("占比公式：", formula)
                            case "size":
                                formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                                logger.Info("尺寸小公式：", formula)
                                //logger.Info("尺寸小公式：", formula)
                            }
                            expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
                            result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
@@ -83,9 +83,9 @@
                            }
                        }
                        am.TargetNum = len(am.FilterData) // 把符合条件的目标数量更新到targetNum字段
                        logger.Info("过完条件后的目标数量为：",am.TargetNum)
                        //logger.Info("过完条件后的目标数量为：",am.TargetNum)
                        if am.TargetNum > 0 {
                            logger.Info("！！！！！！！！！人脸检测成功")
                            //logger.Info("！！！！！！！！！人脸检测成功")
                            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
                        } else {
                            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}

 algorithm/intrusion/intrusion.go

@@ -21,7 +21,7 @@
func filterRule(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
    // 处理的都是yolo数据
    if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
        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
@@ -36,13 +36,13 @@
            switch rule.SdkArgAlias {
                case "score":
                    formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                    logger.Info("相似度小公式：", formula)
                    //logger.Info("相似度小公式：", formula)
                case "proportion":
                    formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                    logger.Info("占比公式：", formula)
                    //logger.Info("占比公式：", formula)
                case "size":
                    formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                    logger.Info("尺寸小公式：", formula)
                    //logger.Info("尺寸小公式：", formula)
            }
            expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
            result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果

 algorithm/middleware/middleware.go

@@ -37,11 +37,11 @@
                sdkName := sdk.SdkName
                //logger.Info("规则的ipcId与sdkData的IpcId:", ipcId, "===", sdkData.IpcId)
                if ipcId == sdkData.IpcId {
                    logger.Info("当前走的规则是--：", groupRule.Rules[j],sdkName,groupRule.Rules[j].SdkArgAlias, "---","")
                    //logger.Info("当前走的规则是--：", groupRule.Rules[j],sdkName,groupRule.Rules[j].SdkArgAlias, "---","")
                    for _, areaMap := range sdkData.AreaMapList {
                        ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap,lable,args,message)
                        if ruleResult.Result != "" {
                            logger.Info("条件规则结果：", ruleResult.Result)
                            //logger.Info("条件规则结果：", ruleResult.Result)
                            // 如果结果为真，把这条规则中的区域置为有效
                            if strings.Contains(ruleResult.Result, "true") {
                                areaMap.IsEffective = true
@@ -77,7 +77,7 @@
                    for _, areaMap := range sdkData.AreaMapList {
                        ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap,lable,args,message)
                        if ruleResult.Result != "" {
                            logger.Info("人脸比对规则结果：", ruleResult.Result)
                            //logger.Info("人脸比对规则结果：", ruleResult.Result)
                            // 如果结果为真，把这条规则中的区域置为有效
                            if strings.Contains(ruleResult.Result, "true") {
                                areaMap.IsEffective = true
@@ -109,11 +109,11 @@
                sdkName := sdk.SdkName
                //logger.Info("规则的ipcId与sdkData的IpcId:", ipcId, "===", sdkData.IpcId)
                if ipcId == sdkData.IpcId {
                    logger.Info("当前走的规则是--：", groupRule.Rules[j],sdkName,groupRule.Rules[j].SdkArgAlias, "---","")
                    //logger.Info("当前走的规则是--：", groupRule.Rules[j],sdkName,groupRule.Rules[j].SdkArgAlias, "---","")
                    for _, areaMap := range sdkData.AreaMapList {
                        ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap,lable,args,message)
                        if ruleResult.Result != "" {
                            logger.Info("个体静止结果：", ruleResult.Result)
                            //logger.Info("个体静止结果：", ruleResult.Result)
                            // 如果结果为真，把这条规则中的区域置为有效
                            if strings.Contains(ruleResult.Result, "true") {
                                areaMap.IsEffective = true
@@ -145,11 +145,11 @@
                sdkName := sdk.SdkName
                //logger.Info("规则的ipcId与sdkData的IpcId:", ipcId, "===", sdkData.IpcId)
                if ipcId == sdkData.IpcId {
                    logger.Info("当前走的规则是--：", groupRule.Rules[j],sdkName,groupRule.Rules[j].SdkArgAlias, "---","")
                    //logger.Info("当前走的规则是--：", groupRule.Rules[j],sdkName,groupRule.Rules[j].SdkArgAlias, "---","")
                    for _, areaMap := range sdkData.AreaMapList {
                        ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap,lable,args,message)
                        if ruleResult.Result != "" {
                            logger.Info("车牌结果：", ruleResult.Result)
                            //logger.Info("车牌结果：", ruleResult.Result)
                            // 如果结果为真，把这条规则中的区域置为有效
                            if strings.Contains(ruleResult.Result, "true") {
                                areaMap.IsEffective = true
@@ -186,7 +186,7 @@
                            if strings.Contains(ruleResult.Result, "true") {
                                areaMap.IsEffective = true
                            }
                            logger.Info("数量规则结果：", ruleResult.Result)
                            //logger.Info("数量规则结果：", ruleResult.Result)
                            if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                                sdkNames = sdkName + " "
                            }
@@ -216,7 +216,7 @@
                        if strings.Contains(ruleResult.Result, "true") {
                            areaMap.IsEffective = true
                        }
                        logger.Info("时间规则结果：", ruleResult.Result)
                        //logger.Info("时间规则结果：", ruleResult.Result)
                        if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                            sdkNames = sdkName + " "
                        }
@@ -348,7 +348,7 @@
    if err1 != nil {
        panic("没有找到入口函数")
    }
    logger.Info("发给so的数据：",sdkId,rule.SdkArgValue,rule.Operator,rule.SdkArgAlias)
    //logger.Info("发给so的数据：",sdkId,rule.SdkArgValue,rule.Operator,rule.SdkArgAlias)
    ruleResult := f.(func(rule *protomsg.Rule, am *structure.AreaMap,lable *structure.Others, args *structure.SdkDatas,message *protomsg.SdkMessage)structure.LittleRuleResult)(rule,am,lable,args,message)
    return ruleResult
}

 algorithm/personUnsual/personUnsual.go

@@ -42,13 +42,13 @@
            switch rule.SdkArgAlias {
            case "score":
                formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("相似度小公式：", formula)
                //logger.Info("相似度小公式：", formula)
            case "proportion":
                formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("占比公式：", formula)
                //logger.Info("占比公式：", formula)
            case "size":
                formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue
                logger.Info("尺寸小公式：", formula)
                //logger.Info("尺寸小公式：", formula)
            }
            expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
            result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果

 algorithm/static/static.go

@@ -45,13 +45,13 @@
            var formula string
            if rule.SdkArgAlias == "score" {
                formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                logger.Info("当前相似度小公式：", formula)
                //logger.Info("当前相似度小公式：", formula)
            } else if rule.SdkArgAlias == "proportion" {
                formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                logger.Info("当前占比小公式：", formula)
                //logger.Info("当前占比小公式：", formula)
            } else {
                formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                logger.Info("当前尺寸小公式：", formula)
                //logger.Info("当前尺寸小公式：", formula)
            }
            expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
            result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
@@ -103,7 +103,7 @@
            logger.Error("个体静止规则有误", err)
        }
    }()
    logger.Info("走了个体静止核心算法")
    //logger.Info("走了个体静止核心算法")
    initN := 5
    if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a977" && rule.SdkArgAlias == "duration" {
        if init,err := strconv.Atoi(rule.SdkArgValue); err != nil {
@@ -123,7 +123,7 @@
    m["target"] = append(m["target"].([]structure.Result), structure.Result{args.TaskId, "", "", true, 0, "", am.FilterData, am.AreaJson, false,*lable})

    if structure.StaticMap[am.AreaId] == nil || len(structure.StaticMap[am.AreaId].Targets) == 0 {
        logger.Info("之前无缓存并且此次区域内有人")
        //logger.Info("之前无缓存并且此次区域内有人")

        objs := []*structure.Obj{}
        for _, tar := range am.FilterData {
@@ -133,7 +133,7 @@
        structure.StaticMap[am.AreaId] = &structure.CameraArea{objs}
        return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
    } else {
        logger.Info("之前有缓存")
        //logger.Info("之前有缓存")
        flag := "false"
        // 以之前静止的对象为主判断是否静止
        tars := []*structure.Arg{}
@@ -146,7 +146,7 @@
            if singleResult {
                flag = "true"
                tars = append(tars,arg)
                logger.Info("静止的目标：",arg.Id,arg.Location,arg.Score)
                //logger.Info("静止的目标：",arg.Id,arg.Location,arg.Score)
            }
        }

@@ -185,7 +185,7 @@

// 判断一个目标是否静止了指定时间
func SingleStatic(person *structure.Obj, am *structure.AreaMap,lable *structure.Others, argValue float64) (bool,*structure.Arg){
    logger.Info("单个目标的判断：")
    //logger.Info("单个目标的判断：")
    flag := false
    var o *structure.Arg = nil
    for _, obj := range am.FilterData {

 insertdata/insertDataToEs.go

@@ -165,7 +165,7 @@
                            panic("解压缩图片时出现错误")
                        }
                        alarmRules := []AlarmRule{}
                        logger.Info("循环每一个目标")
                        //logger.Info("循环每一个目标")
                        for _, faceResult := range face.rules {
                            alarm := ChangeToString(faceResult.DefenceState, faceResult.AlarmLevel)
                            alarmRules = append(alarmRules, AlarmRule{faceResult.RuleGroupId, alarm, faceResult.RuleText, faceResult.DefenceState, ""})
@@ -204,7 +204,7 @@
                        case "plate":
                            sdkname = "车牌识别"
                        }
                        logger.Info("人脸目标target:",targetInfos)
                        //logger.Info("人脸目标target:",targetInfos)
                        pervideo := PerVideoPicture{
                            face.Uuid,
                            msg.Cid,
@@ -324,7 +324,7 @@
                        linkInfo = "联动任务"
                    }
                    alarmRules = append(alarmRules, AlarmRule{yoloResult.RuleGroupId, alarm, yoloResult.RuleText, yoloResult.DefenceState, linkInfo})
                    logger.Info("打印任务名称：", )
                    //logger.Info("打印任务名称：", )
                    // 上传缓存数据的图片拿到url
                    if yoloResult.Others.CacheData != nil {
                        //InsertYolo(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))

 labelFilter/readyDataForLabel.go

@@ -29,7 +29,7 @@
        }
    }
    if flag1{ // 有可推送的数据
        logger.Info("---------------标签过滤器赋值")
        //logger.Info("---------------标签过滤器赋值")
        label.CameraId = result.Cid
        camera, err := cache.GetCameraById(result.Cid)
        if err != nil {
@@ -52,6 +52,6 @@
                }
            }
        }
        logger.Info("------------标签过滤器赋值完毕")
        //logger.Info("------------标签过滤器赋值完毕")
    }
}

 labelFilter/req.go

@@ -62,7 +62,7 @@

    var api dbapi.EventPushApi
    b, allRules := api.FindAllDetails()
    logger.Info("初始化事件推送，查看所有规则组：", allRules)
    //logger.Info("初始化事件推送，查看所有规则组：", allRules)
    if !b {
        logger.Error("查询时间推送规则失败！")
    }
@@ -72,7 +72,7 @@
                // 为每个url建立一个chan
                if urlPool[url.Url] == nil {
                    urlPool[url.Url] = make(chan []byte,100)
                    logger.Info("初始化信息：",urlPool)
                    //logger.Info("初始化信息：",urlPool)
                    go GoPush(url.Url)
                }
            }
@@ -128,7 +128,7 @@
    //        ch = v.ch
    //    }
    //}
    logger.Info("chan信息：",urlPool[url])
    //logger.Info("chan信息：",urlPool[url])
    for {
        select {
        // case <-ctx.Done():
@@ -137,12 +137,12 @@
            //logger.Info("接收到数据",data.Cid)
            //bytes,err1 := proto.Marshal(data)
            go func(data []byte) {
                logger.Info("数据长度为：",len(data))
                //logger.Info("数据长度为：",len(data))
                //if err1 != nil {
                //    logger.Info("序列化失败：",err1)
                //}
                start := time.Now()
                logger.Debug("groutine"+url+"推送数据")
                //logger.Debug("groutine"+url+"推送数据")
                //bytes := []byte("ndfasojdfaidsos")
                if err = sock.Send(data); err != nil {
                    Die("groutine"+url+"推送socket发送数据失败: ", err.Error())
@@ -152,7 +152,7 @@
                if err != nil {
                    Die("groutine"+url+"接收响应失败: ", err.Error(),pushTime,time.Since(start))
                } else {
                    logger.Debug("事件推送成功！groutine"+url+"收到响应",string(msg),pushTime,time.Since(start))
                    //logger.Debug("事件推送成功！groutine"+url+"收到响应",string(msg),pushTime,time.Since(start))
                }
            }(data)
        default:

 labelFilter/ruleForLabel.go

@@ -266,10 +266,10 @@
func defenceJudge(label *Label, rule *protomsg.EventPushRule) string {
    if rule.RuleValue == "all" { // 布防等级为全部时只有有布防等级即为通过
        if len(label.DefenceLevel) > 0 {
            logger.Info("符合布防等级规则，布防等级为全部")
            //logger.Info("符合布防等级规则，布防等级为全部")
            return "true"
        } else {
            logger.Info("不符合布防等级规则")
            //logger.Info("不符合布防等级规则")
            return "false"
        }
    } else {
@@ -287,11 +287,11 @@
                //return "false"
            }
            if result.(bool) {
                logger.Info("符合布防等级规则!")
                //logger.Info("符合布防等级规则!")
                return "true"
            }
        }
        logger.Info("不符合布防等级规则")
        //logger.Info("不符合布防等级规则")
        return "false"
    }
}
@@ -311,17 +311,17 @@
        return "false"
    }
    if result.(bool) {
        logger.Info("符合任务规则!")
        //logger.Info("符合任务规则!")
        return "true"
    }
    logger.Info("不符合任务规则")
    //logger.Info("不符合任务规则")
    return "false"
}

// 调用目标服务器的插入接口
func pushData(urls []*protomsg.PushUrl, data structure.ResultMsg) {
    for _, url := range urls {
        logger.Debug("推送地址：",url.Url)
        //logger.Debug("推送地址：",url.Url)
        bytes,err1 := proto.Marshal(data)
        if err1 != nil {
            logger.Info("序列化失败：",err1)

 ruleserver/attachInfo.go

@@ -13,7 +13,7 @@
    if err != nil {
        logger.Error("查询本机信息失败！")
    }
    logger.Info("localConfig信息：",localConfig)
    //logger.Info("localConfig信息：",localConfig)
    push.ServerId = localConfig.ServerId
    push.ServerName = localConfig.ServerName
    serverIp, err := GetLocalIP()

 ruleserver/personTrack.go

@@ -38,11 +38,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].Faces = nil
                        lock.Unlock()
@@ -50,7 +50,7 @@
                        lock.Lock()
                        TrackPond[msg.Cid] = &PersonTrack{Faces: nil}
                        lock.Unlock()
                        logger.Info("如果为空：", TrackPond[msg.Cid])
                        //logger.Info("如果为空：", TrackPond[msg.Cid])
                    }
                    logger.Info("摄像机:" + msg.Cid + "-没有人脸，被重置为空")
                    continue
@@ -91,15 +91,15 @@
                        logger.Error("yolo序列化错误", err)
                    }
                    delete(args.RuleResult,"yolo")
                    logger.Info("清除yolo标签，",args.RuleResult["yolo"])
                    logger.Info("跟之前相同，清空yolo数据，人体追踪结束")
                    //logger.Info("清除yolo标签，",args.RuleResult["yolo"])
                    //logger.Info("跟之前相同，清空yolo数据，人体追踪结束")
                    return true
                } else {
                    if TrackPond[msg.Cid] != nil {
                        logger.Info("更新当前摄像机缓存池中的yolo个数：", yoloNum)
                        //logger.Info("更新当前摄像机缓存池中的yolo个数：", yoloNum)
                        TrackPond[msg.Cid].Yolo = yoloNum
                    } else {
                        logger.Info("新建当前摄像机缓存池中的yolo个数：", yoloNum)
                        //logger.Info("新建当前摄像机缓存池中的yolo个数：", yoloNum)
                        TrackPond[msg.Cid] = &PersonTrack{Yolo: yoloNum}
                    }
                    return false
@@ -133,19 +133,19 @@
// 过滤掉那些已在缓存中且分值更低的人脸，更新缓存（没有的加上，分值更新为更高的，多的删除）
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)
        }
        //logger.Info("----马前炮：", TrackPond[cameraId], "=====", len(TrackPond[cameraId].Faces))
        //for _, face := range TrackPond[cameraId].Faces {
        //    logger.Info("缓存中存储的face数据：", face.Id, face.Score)
        //}
        faceParam := protomsg.ParamFacePos{}
        err := proto.Unmarshal(sdkinfor.Sdkdata, &faceParam)
        if err != nil {
            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)
        }
        //logger.Info("================追踪之前人脸的个数：", len(faceParam.Faces))
        //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) // 先把数据转存一份，不然一会儿数据删减之后找不到原始数据，不能让缓存数据更新了
@@ -156,13 +156,13 @@
                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, "此数据由于在池子中且分值更高，是要被传递下去的数据")
                    //logger.Info("分值由", val.Score, "更新为：", faceParam.Faces[i].Pos.FAngle.Confidence, "此数据由于在池子中且分值更高，是要被传递下去的数据")
                    lock.Lock()
                    val.Score = faceParam.Faces[i].Pos.FAngle.Confidence
                    lock.Unlock()
@@ -174,11 +174,11 @@
                i++
            }
        }
        logger.Info("反序列化重新装配之前人脸的个数：", len(faceParam.Faces))
        logger.Info("临时存储的新来数据：")
        for _, temp := range facesTemp {
            logger.Info("临时存储的新来的的face数据：", temp.Pos.FaceID, temp.Pos.FAngle.Confidence)
        }
        //logger.Info("反序列化重新装配之前人脸的个数：", len(faceParam.Faces))
        //logger.Info("临时存储的新来数据：")
        //for _, temp := range facesTemp {
        //    logger.Info("临时存储的新来的的face数据：", temp.Pos.FaceID, temp.Pos.FAngle.Confidence)
        //}
        sdkinfor.Sdkdata, err = proto.Marshal(&faceParam)
        if err != nil {
            logger.Error("人脸序列化错误", err)
@@ -195,7 +195,7 @@
                i++
            } else {
                // 此数据在缓存中但不在来的数据帧中，删除此数据更新缓存
                logger.Info("删除池子中的数据更新缓存")
                //logger.Info("删除池子中的数据更新缓存")
                lock.Lock()
                TrackPond[cameraId].Faces = append(TrackPond[cameraId].Faces[:i], TrackPond[cameraId].Faces[i+1:]...)
                lock.Unlock()

 ruleserver/readyDataForRule.go

@@ -157,7 +157,7 @@
            if err != nil || len(table) == 0 {
                logger.Error("根据id查询底库信息出错！", err, "--返回值长度为：", len(table))
            }
            logger.Debug("看看这个base的对比值是多少：", Decimal(m[baseinfo.Id].CompareScore))
            //logger.Debug("看看这个base的对比值是多少：", Decimal(m[baseinfo.Id].CompareScore))
            base := structure.BaseInfo{TableId: baseinfo.TableId, TableName: table[0].TableName, BwType: table[0].BwType, CompareScore: Decimal(m[baseinfo.Id].CompareScore), TargetId: baseinfo.Id, TargetName: baseinfo.PersonName, TargetPicUrl: baseinfo.PersonPicUrl, MonitorLevel: baseinfo.MonitorLevel, Content: baseinfo.Reserved,DbLabel: baseinfo.PhoneNum+"/"+baseinfo.Sex+"/"+baseinfo.IdCard,}
            //os.Exit(1)
            arg.Liker = append(arg.Liker, &base)
@@ -196,12 +196,12 @@
        logger.Info("没有配置对比底库参数")
        return
    }
    logger.Debug("=====配置的阈值为：", threshold)
    //logger.Debug("=====配置的阈值为：", threshold)
    for j := 0; j < len(groupRule.Rules); j++ {
        if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
            for _, sdkData := range args.Sdkdata {
                if sdkData.IpcId == "A8B73405-373D-4F23-CED2-A617EBD7EC55" { // 搜索到人脸检测的sdkdata 现在关于人脸的只有他一个sdk，全找他
                    logger.Info("============================================进行人脸对比")
                    //logger.Info("============================================进行人脸对比")
                    for _, areaMap := range sdkData.AreaMapList {
                        // 拿区域中每个人脸特征值去对比，填充其liker
                        if groupRule.Rules[j].PolygonId == areaMap.AreaId {

 ruleserver/ruleToformula.go

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