人脸多区域坐标去重

panlei

2019-07-29 ee960033e881a16f0243a349036b7fdac8975228

 ruleserver/ruleToformula.go

@@ -22,7 +22,7 @@
   Location   Rect    // 记下每个目标的位置参数，最后给结果装配人脸数据的时候用的到
   Feature    []byte
   ThftRes    protomsg.ThftResult
   Liker      []*protomsg.Baseinfo
   Liker      []*BaseInfo
}

// 每个区域内的图片数据集合
@@ -69,6 +69,7 @@
// 从算法模块儿拿来的对一帧图像各个算法提取的数据集合
type SdkDatas struct {
   CameraId   string
   TaskId     string
   Sdkdata    []*SdkData
   RuleResult map[string]interface{} // 过完规则后打的标签 face: []Arg, yolo: []Result, cacheData: SdkDatas, timeLabel: 0,1,2,3,4,5
}
@@ -83,10 +84,17 @@
   TaskId       string // 任务id
   SdkName      string
   RuleGroupId  string // 规则组id
   DefenceState bool   //是否布防
   AlarmLevel   int32  // 报警等级
   RuleText     string // 文字版规则组
   Location     []Rect // 目标的坐标
   AlarmPolygon string // 触发的报警框
}

// 过规则库打上的标签
type FaceResult struct {
   Result
   Args         []Arg
}
type LittleRuleResult struct {
   SdkName string // 记录下此结果是哪个sdk的结果
@@ -95,37 +103,35 @@
}

// 对单帧图像的判断 thisSdkDatas  当前传入的这帧数据，cacheSdkData 定时器里缓存的一帧数据 没有就返回nil  (thisSdkDatas SdkDatas, cacheSdkDatas SdkDatas)
func Judge(args *SdkDatas,message *protomsg.SdkMessage) {
func Judge(args *SdkDatas, message *protomsg.SdkMessage) {
   if len(args.Sdkdata) > 0 {
      // 拿到本摄像机的区域
      cameraPolygons := GetPolygons(args.CameraId)
      // 把所有的sdk提取的数据都按所属摄像机的区域归置
      logger.Debug("当前摄像机id为：",message.Cid,"当前摄像机执行的任务是：",message.Tasklab.Taskname)
      for _, arg := range args.Sdkdata {
         SdkDataFormat(args.CameraId, arg, cameraPolygons)
      }
      // 跑本摄像机的所有规则组 一组一组跑
      taskRuleList := GetRuleGroup(args.CameraId) // 本摄像机下所有任务组
      taskGroup := GetRuleGroup(args.CameraId, args.TaskId) // 本摄像机下所有任务组
      //logger.Println("看下摄像机下的任务组：",taskRuleList)
      // 得到属于该摄像机的若干组任务的完整规则（跟每一条完整规则比较之后得出本张图像对于某个规则是否报警的结果。放进map，比如本帧图像的id，所碰撞成功的规则id）
      args.RuleResult = make(map[string]interface{})
      args.RuleResult["yolo"] = []Result{}
      args.RuleResult["face"] = []Arg{}
      if len(taskRuleList) > 0 {
         for _, taskRule := range taskRuleList {
      args.RuleResult["face"] = []FaceResult{}
      if taskGroup != nil && len(taskGroup.GroupRules) > 0 {
         for _, group := range taskGroup.GroupRules {
            //logger.Println("------------------------------任务规则：",taskRule)
            ruleList := taskRule.GroupRules // 获取的是task下面的任务组
            taskId := taskRule.TaskId
            taskId := taskGroup.TaskId
            //logger.Println("------------本组任务下的规则组的数量：",len(ruleList))
            for i := 0; i < len(ruleList); i++ {
               temp := ruleList[i].Rules // temp为一组完整规则 在此需要判断规则是否是联动规则
               if len(temp) > 0 {
                  if ruleList[i].SetType == "linkTask" {
                     // groupId中含有link则为联动任务
                     LinkTask(args, ruleList[i], taskId,message)
                  } else {
                     // 独立任务的处理
                     RunRule(args, ruleList[i], taskId,message)
                  }
            temp := group.Rules // temp为一组完整规则 在此需要判断规则是否是联动规则
            if len(temp) > 0 {
               if group.SetType == "linkTask" {
                  // groupId中含有link则为联动任务
                  LinkTask(args, group, taskId, message)
               } else {
                  // 独立任务的处理
                  RunRule(args, group, taskId, message)
               }
            }
         }
@@ -133,7 +139,7 @@
   }
}

func RunRule(args *SdkDatas, groupRule *protomsg.GroupRule, taskId string,message *protomsg.SdkMessage) bool {
func RunRule(args *SdkDatas, groupRule *protomsg.GroupRule, taskId string, message *protomsg.SdkMessage) bool {
   defer func() {
      if err := recover(); err != nil {
         logger.Error("比对规则有误", err.(string))
@@ -156,11 +162,7 @@
         sdkName := sdk.SdkName
         logger.Info("规则的ipcId与sdkData的IpcId:", ipcId, "===", sdkData.IpcId)
         if ipcId == sdkData.IpcId {
            logger.Info("当前走的规则的算法是--：", sdkName, "---")
            logger.Info("========================有几个区域：",len(sdkData.AreaMapList))
            for _,areaMap := range sdkData.AreaMapList{
               logger.Info("检查一下区域的具体数据：",areaMap.areaJson)
            }
            logger.Info("当前走的规则是--：", sdkName, "---","")
            for _, areaMap := range sdkData.AreaMapList {
               ruleResult := filterRule(groupRule.Rules[j], areaMap)
               if ruleResult.Result != "" {
@@ -256,8 +258,8 @@
   }
   if completeFormula != "" {
      logger.Info("结果公式-----------：", completeFormula)
      expression, _ := govaluate.NewEvaluableExpression(completeFormula)
      if strings.HasPrefix(completeFormula, "&&") || strings.HasPrefix(completeFormula, "||") {
      expression, err := govaluate.NewEvaluableExpression(completeFormula)
      if strings.HasPrefix(completeFormula, "&&") || strings.HasPrefix(completeFormula, "||") || err != nil{
         panic("规则有误，得到的数学公式不可解析")
      }
      result, _ := expression.Evaluate(nil) // 得到数学公式的结果
@@ -275,12 +277,12 @@
         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)...)
                  faces = append(faces, putFaceToResult(areaMap,faces)...)
               }
            }
         }
         if faceFlag {
            args.RuleResult["face"] = faces
         for _,face := range faces  {
            logger.Debug("————————————————________________看看人脸的坐标:",face.Location)
         }
         logger.Warn("___________________________________________________________________________终于走完万里长征")
         // 把他们的位置数据也传下去
@@ -292,13 +294,14 @@
               }
            }
         }
         logger.Debug("------locations的内容：",locations)
         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})
            args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkNames, groupRule.GroupId,groupRule.DefenceState,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)))
         if faceFlag {
            args.RuleResult["face"] = append(args.RuleResult["face"].([]FaceResult), FaceResult{Result{taskId, sdkNames, groupRule.GroupId,groupRule.DefenceState,groupRule.AlarmLevel, groupRule.GroupText, []Rect{}, polygonId},faces})
            logger.Info("-------------------face结果标签", len(args.RuleResult["face"].([]FaceResult)))
         }
         // 最后过持续时间等时间维度的条件   把时间规则位置调整到这个位置是为了缓存数据
         for j := 0; j < len(groupRule.Rules); j++ {
@@ -311,13 +314,13 @@
               if ipcId == sdkData.IpcId {
                  for _, areaMap := range sdkData.AreaMapList {
                     // 去开启一个定时器
                     duration(groupRule.Rules[j], groupRule.GroupId, areaMap, args,message)
                     duration(groupRule.Rules[j], groupRule.GroupId, areaMap, args, message)
                  }
               }
            }
         }
         // 进行定时器的处理和判断
         timeFlag := TimerAlarm(args,groupRule.GroupId,result.(bool))
         timeFlag := TimerAlarm(args, groupRule.GroupId, result.(bool))
         if timeFlag == "01" || timeFlag == "10" || timeFlag == "11" { // 满足定时器条件
            return true
         } else {
@@ -325,7 +328,7 @@
         }
      } else {
         // 结果为假时也要走，有时候为假的状态反转数据也需要记录下来
         timeFlag := TimerAlarm(args,groupRule.GroupId,result.(bool))
         timeFlag := TimerAlarm(args, groupRule.GroupId, result.(bool))
         fmt.Println(timeFlag)
         return false
      }
@@ -334,12 +337,19 @@
   }
}


func putFaceToResult(am *AreaMap) []Arg {
func putFaceToResult(am *AreaMap,faceList []*Arg) []Arg {
   faces := []Arg{}
   if len(am.filterData) > 0 {
      for _, data := range am.filterData {
         faces = append(faces, *data)
         flag := true 
         for _,face := range faceList  {
            if data.Location.X == face.Location.X && data.Location.Y == face.Location.Y && data.Location.Width == face.Location.Width && data.Location.Height == face.Location.Height {
               flag = false
            }
         }
         if flag {
            faces = append(faces, *data)
         }
      }
   }

@@ -359,7 +369,7 @@
}

// 联动任务的处理
func LinkTask(args *SdkDatas, groupRule *protomsg.GroupRule, taskId string,message *protomsg.SdkMessage) {
func LinkTask(args *SdkDatas, groupRule *protomsg.GroupRule, taskId string, message *protomsg.SdkMessage) {
   // new一个定时器，如果以此groupId为标志的定时器不存在的话
   logger.Info("------------------------------------------当前是联动任务，规则是：", groupRule.GroupText)
   var flag bool = true
@@ -389,7 +399,7 @@
      }
   }
   // 往数组里赋值
   isOk := RunRule(args, groupRule, taskId,message)
   isOk := RunRule(args, groupRule, taskId, message)
   if isOk {
      logger.Info("这帧图像在任务下的一整条规则下（联动任务下就是跟本摄像机像相关的小规则）的判断结果为true")
      // 根据cameraId去更新或者插入结果,然后判断是否数组是否可以得出报警的结论
@@ -422,7 +432,7 @@
            result, _ := expression.Evaluate(nil) // 得到数学公式的结果
            if result.(bool) {
               logger.Info("___________________________________________________________________联动任务报警")
               args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, "", groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, []Rect{},""})
               args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, "", groupRule.GroupId, groupRule.DefenceState,groupRule.AlarmLevel, groupRule.GroupText, []Rect{}, ""})
               logger.Info("-------------------yolo结果标签有几个", len(args.RuleResult["yolo"].([]Result)))
               if args.RuleResult["face"] != nil {
                  logger.Info("-------------------face结果标签有几个", len(args.RuleResult["face"].([]Arg)))
@@ -452,25 +462,9 @@
      //logger.Info("规则的算法id和区域的算法id：", rule.SdkId, "===", am.sdkId)
      if rule.PolygonId == am.areaId { // 算法和区域都得对的上

         if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && rule.SdkArgAlias != "time_rule" && rule.SdkArgAlias != "compareBase"{
            argValue, err := strconv.ParseFloat(rule.SdkArgValue, 64)
            if err != nil {
               logger.Error("规则配置的阈值非法")
               return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + "false", rule.Sort}
            }
         if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && rule.SdkArgAlias != "time_rule" && rule.SdkArgAlias != "compareBase" {
            logger.Debug("当前小规则是：",rule)
            flag := "false"
            for _, obj := range am.filterData {
               for index := 0; index < len(obj.Liker); {
                  // 将达不到阈值的相似者从相似者数组中删除
                  logger.Debug("=======================相似值：", float64(obj.Liker[index].CompareScore*100))
                  if float64(obj.Liker[index].CompareScore*100) < argValue {
                     // Go 语言中切片删除元素的本质是：以被删除元素为分界点，将前后两个部分的内存重新连接起来。不用怀疑，数组删除元素就这么坑爹
                     obj.Liker = append(obj.Liker[:index], obj.Liker[index+1:]...)
                  } else {
                     index++
                  }
               }
            }
            // 把没有相似者的人脸从filterData中删除
            for index := 0; index < len(am.filterData); {
               // 将达不到阈值的相似者从相似者数组中删除
@@ -487,6 +481,7 @@
            return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + flag, rule.Sort}
         }
         if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" { // 人脸检测
            logger.Debug("当前小规则是：",rule)
            if rule.Operator == "==" || rule.Operator == ">=" || rule.Operator == "<=" || rule.Operator == "<" || rule.Operator == ">" || rule.Operator == "!=" {
               // 如果是不规矩的连接符统统返回false 规则也只能判断人脸的相似度，所以不存在别的连接符
               if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
@@ -494,8 +489,10 @@
                  var args []*Arg
                  if rule.RuleWithPre == "&&" {
                     args = am.filterData
                     logger.Info("过滤后的args的长度为：",len(args))
                  } else {
                     args = am.args
                     logger.Info("没过滤的args的长度为：",len(args))
                  }
                  // 先清空过滤后的数据，再往里塞本次过滤后的数据
                  am.filterData = am.filterData[0:0]
@@ -539,7 +536,6 @@
      // 处理的都是yolo数据
      if rule.PolygonId == am.areaId { // 首先这条规则得是这个算法的规则，其次规则所对应的区域id要跟区域数据的id对的上
         if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
            logger.Info("----------当前条件规则：---------", rule)
            var args []*Arg
            if rule.RuleWithPre == "&&" {
               args = am.filterData
@@ -548,7 +544,7 @@
            }
            // 先清空过滤后的数据，再往里塞本次过滤后的数据
            am.filterData = am.filterData[0:0]
            logger.Debug("看看args：：：：：",args)
            logger.Debug("看看args：：：：：", args)
            for _, arg := range args {
               var formula string
               if rule.SdkArgAlias == "score" {
@@ -585,9 +581,10 @@
}

// 如果有持续时间条件维护开启一个定时器
func duration(rule *protomsg.Rule, groupId string, am *AreaMap, args *SdkDatas,message *protomsg.SdkMessage) {
func duration(rule *protomsg.Rule, groupId string, am *AreaMap, args *SdkDatas, message *protomsg.SdkMessage) {
   if rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上  配置的算法要对的上
      if rule.SdkArgAlias == "duration" { //
         logger.Info("当前小规则是：---------", rule)
         // 先看看定时器元素队列中是否有这个摄像机这个区域的定时器,如果有就不能再次创建了
         var flag bool = true
         for k, _ := range TimeEleList {
@@ -599,9 +596,9 @@

         if flag {
            timeLength, _ := strconv.Atoi(rule.SdkArgValue)
            timeEle := TimeElement{N: timeLength, InitN: timeLength, AlarmFlag: false,BufferFlag:10, CacheSdkData: ResultMsg{message,args.RuleResult}} // 扔进去一个定时器元素（并缓存当前画面帧数据）
            timeEle := TimeElement{N: timeLength, InitN: timeLength, AlarmFlag: false, BufferFlag: 10, CacheSdkData: ResultMsg{message, args.RuleResult}} // 扔进去一个定时器元素（并缓存当前画面帧数据）
            //TimeEleList = make(map[string]timeElement)
            TimeEleList[groupId+" "+rule.Id] = &timeEle // 定时器元素以摄像机id拼接区域id为键
            TimeEleList[groupId+" "+rule.Id] = &timeEle // 定时器元素以组规则id和当前持续时间小规则id为键
            logger.Info("创建了计数器并且计数器集合为：", TimeEleList)
         }
      }
@@ -611,7 +608,8 @@
// 给数据库的规则表达式代参 args: 一条子规则，区域数据
func transferParameters(rule *protomsg.Rule, am *AreaMap) LittleRuleResult {
   if rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上
      if rule.SdkArgAlias == "targetNum" { // 如果参数是要区域内目标数量 即yolo 人脸不会有数量
      if rule.SdkArgAlias == "objCount" { // 如果参数是要区域内目标数量 即yolo 人脸不会有数量
         logger.Info("当前小规则是：---------", rule)
         //logger.Info("得出结果阶段", "比较的规则是：", rule)
         if rule.Operator == "" {
            return LittleRuleResult{am.sdkName, strconv.Itoa(am.targetNum) + "" + rule.RuleWithPre, rule.Sort} // 如果后面不跟操作符就直接返回数量  比如要跟下一个区域比较数量的就直接返回本区域的数量
@@ -626,7 +624,7 @@
         formula := strconv.Itoa(num) + " " + rule.Operator + " " + rule.SdkArgValue
         expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
         result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
         return LittleRuleResult{am.sdkName, strconv.FormatBool(result.(bool)) + "" + rule.RuleWithPre, rule.Sort}
         return LittleRuleResult{am.sdkName, rule.RuleWithPre + " " + strconv.FormatBool(result.(bool)), rule.Sort}
         // 加上关于算法的判断条件，不能只有关于规则的，有的算法本身就是一个规则，如个体静止，靠右行,所以，拿到当前子规则的sdkid来判断是否是那些特殊的规则
      } else if rule.SdkId == "IsStatic" { // 静止算法
         if am.isStatic {
@@ -646,7 +644,7 @@
}
func timeRuleResult(rule *protomsg.Rule, am *AreaMap) LittleRuleResult {
   if rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上
      if rule.SdkArgAlias == "time_rule" { // 判断是否符合时间规则
      if rule.SdkArgAlias == "time_rule" { // 判断是否符合时间规
         logger.Info("----------当前时间规则：---------", rule)
         // 根据放值字段里存的时间规则的id去另一个表里查需要比对的时间段（比如当前时间是周三，应根据区域id查出其周三的几个布防时间段，数组）
         //logger.Info("时间规则的测试")
@@ -700,5 +698,3 @@
   }
   return LittleRuleResult{}
}