lable？label？

panlei

2019-07-13 1b10c0c996b4b338da2ca175fa48725f7df9c545

 ruleserver/ruleToformula.go

@@ -122,7 +122,7 @@
type SdkDatas struct {
   CameraId   string
   Sdkdata    []*SdkData
   RuleResult map[string]interface{} // 过完规则后打的标签 face: []Arg  yolo: []Result cacheData: SdkDatas
   RuleResult map[string]interface{} // 过完规则后打的标签 face: []Arg, yolo: []Result, cacheData: SdkDatas, timeLabel: 0,1,2,3,4,5
}

// 将传递过来的参数转化为
@@ -449,89 +449,103 @@
         panic("规则有误，得到的数学公式不可解析")
      }
      result, _ := expression.Evaluate(nil) // 得到数学公式的结果
      if !result.(bool) {
         // 给这帧数据打上规则组标签
         //args.RuleResult = append(args.RuleResult, Result{TaskId: taskId, RuleGroupId: groupRule.GroupId})
         for k, timeEle := range TimeEleList {
            if strings.Contains(k, groupRule.GroupId) {
               timeEle.N = timeEle.InitN // 重置定时器
      // 进行定时器的处理和判断
      timeFlag := TimerAlarm(args,groupRule.GroupId,result.(bool))
      if timeFlag == "01" || timeFlag == "10" || timeFlag == "11" {
         // 最后成功报警才把符合条件的人脸数据塞进结果标签里
         // 配了人脸的算法才把人脸的数据甩出来打标签
         faces := []Arg{}
         faceFlag := false
         for j := 0; j < len(groupRule.Rules); j++ {
            if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" || groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
               faceFlag = true
            }
         }
         logger.Info("-------------------重置相关的定时器并返回false---------------")
         return false
         for _, sdkData := range args.Sdkdata {
            if sdkData.IpcId == "A8B73405-373D-4F23-CED2-A617EBD7EC55" && faceFlag { // sdkData里有人脸数据且配置了算法才把符合条件的数据塞进标签里去
               for _, areaMap := range sdkData.AreaMapList {
                  faces = append(faces, putFaceToResult(areaMap)...)
               }
            }
         }
         if faceFlag {
            args.RuleResult["face"] = faces
         }
         logger.Warn("___________________________________________________________________________终于走完万里长征")
         // 把他们的位置数据也传下去
         locations := []Rect{}
         for _, sdkData := range args.Sdkdata {
            if sdkData.IpcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && sdkNames != "" { // 把yolo数据的各个目标的坐标输出方便后面画框
               for _, areaMap := range sdkData.AreaMapList {
                  locations = append(locations, putYolosToResult(areaMap)...)
               }
            }
         }
         logger.Debug("------locations的内容：",locations)
         if sdkNames != "" {
            args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkNames, groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, locations,polygonId})
            logger.Info("-------------------yolo结果标签长度", len(args.RuleResult["yolo"].([]Result)))
         }
         if args.RuleResult["face"] != nil {
            logger.Info("-------------------face结果标签", len(args.RuleResult["face"].([]Arg)))
         }
         return true
      } else {
         // 判断持续时间条件，去看池子里是否有与本帧数据有关的定时器，如果有，看此时是否走到0，没有此定时器或有定时器走到0的话返回成功报警
         var flag bool = true
         for k, timeEle := range TimeEleList {
            if strings.Contains(k, groupRule.GroupId) {
               if timeEle.N != 0 { // 这组规则的定时器要全部等于0
                  logger.Info("———————————-------------不冤，你是被定时器打败的：")
                  flag = false
               }
            }
         }
         //TimerAlarm(args,groupRule.GroupId)
         if flag {
            // 最后成功报警才把符合条件的人脸数据塞进结果标签里
            // 配了人脸的算法才把人脸的数据甩出来打标签
            faces := []Arg{}
            faceFlag := false
            for j := 0; j < len(groupRule.Rules); j++ {
               if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" || groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
                  faceFlag = true
               }
            }
            for _, sdkData := range args.Sdkdata {
               if sdkData.IpcId == "A8B73405-373D-4F23-CED2-A617EBD7EC55" && faceFlag { // sdkData里有人脸数据且配置了算法才把符合条件的数据塞进标签里去
                  for _, areaMap := range sdkData.AreaMapList {
                     faces = append(faces, putFaceToResult(areaMap)...)
                  }
               }
            }
            if faceFlag {
               args.RuleResult["face"] = faces
            }
            logger.Warn("___________________________________________________________________________终于走完万里长征")
            // 把他们的位置数据也传下去
            locations := []Rect{}
            for _, sdkData := range args.Sdkdata {
               if sdkData.IpcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && sdkNames != "" { // 把yolo数据的各个目标的坐标输出方便后面画框
                  for _, areaMap := range sdkData.AreaMapList {
                     locations = append(locations, putYolosToResult(areaMap)...)
                  }
               }
            }
            logger.Debug("------locations的内容：",locations)
            if sdkNames != "" {
               args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkNames, groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, locations,polygonId})
               logger.Info("-------------------yolo结果标签长度", len(args.RuleResult["yolo"].([]Result)))
            }
            if args.RuleResult["face"] != nil {
               logger.Info("-------------------face结果标签", len(args.RuleResult["face"].([]Arg)))
            }
            return true
         } else {
            return false
         }
         return false
      }
   } else {
      return false
   }
}
func TimerAlarm(args SdkDatas,groupId string) (int) {
   var flagTime int = 0  // 为0的意思是
   for k, timeEle := range TimeEleList {
// 判断是否符合定时器条件
func TimerAlarm(args *SdkDatas,groupId string,result bool) (string) {
   var flagTime string  //
   // 判断有无此规则组的定时器
   flag := false
   for k,_ := range TimeEleList {
      logger.Debug("-----------------看看这个key和groupId",k,groupId)
      if strings.Contains(k, groupId) {
         if timeEle.N == 0 && !timeEle.AlarmFlag { // 这组规则的定时器要全部等于0   暂且认为一组规则只有一个定时器
            logger.Info("———————————-------------首次符合持续时间规则并报警")
            flagTime = 1
            timeEle.AlarmFlag = true
            args.RuleResult["cacheData"] = timeEle.CacheSdkData
         flag = true
      }
   }
   if flag {     // 有定时器
      if result { // 结果为真
         for k, timeEle := range TimeEleList {
            if strings.Contains(k, groupId) {
               if timeEle.N == 0 && timeEle.AlarmFlag {
                  logger.Debug("-------------------------符合持续时间规则但并不是首次，不报警")
                  flagTime = "11"
                  args.RuleResult["timeLabel"] = flagTime
               }
               if timeEle.N == 0 && !timeEle.AlarmFlag { // 这组规则的定时器要全部等于0   暂且认为一组规则只有一个定时器
                  logger.Debug("———————————-------------首次符合持续时间规则并报警")
                  flagTime = "10"
                  timeEle.AlarmFlag = true
                  args.RuleResult["cacheData"] = timeEle.CacheSdkData
                  args.RuleResult["timeLabel"] = flagTime
               }
               if timeEle.N != 0 {
                  flagTime = "00"
                  logger.Debug("------------------------结果为真但计数器不到0，不报警,此时的计数器的值为：",timeEle.N)
               }
            }
         }
         if timeEle.N == 0 && timeEle.AlarmFlag {
            logger.Info("-------------------------符合持续时间规则但并不是首次，不报警")
            flagTime = 2
      } else { // 结果为假
         for k, timeEle := range TimeEleList {
            if strings.Contains(k, groupId) {
               logger.Debug("------------------------------重置定时器，此时的计数器的值为",timeEle.N)
               timeEle.N = timeEle.InitN // 重置定时器
               timeEle.CacheSdkData = SdkDatas{} // 把缓存数据扔了
               flagTime = "12"
            }
         }

      }
   } else { // 无定时器
      if result {
         flagTime = "01"
      } else {
         flagTime = "00"
      }
   }
   return flagTime
@@ -803,6 +817,7 @@
            }
            // 先清空过滤后的数据，再往里塞本次过滤后的数据
            am.filterData = am.filterData[0:0]
            logger.Debug("看看args：：：：：",args)
            for _, arg := range args {
               var formula string
               if rule.SdkArgAlias == "score" {