compare 改为isHave

panlei

2019-12-17 f8aa9316d6bf32392883081c3d08196f6ca344c9

 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)                      // 得到数学公式的结果
@@ -61,16 +61,16 @@
      }
      am.TargetNum = len(am.FilterData) // 把符合条件的目标数量更新到targetNum字段
      if am.TargetNum > 0 {
         return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
         return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort,am.FilterData}
      } else {
         return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
         return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort,am.FilterData}
      }

   } else if rule.SdkArgAlias == "" {
      if am.TargetNum > 0 {
         return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
         return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort,am.FilterData}
      } else {
         return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
         return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort,am.FilterData}
      }
   }
   return structure.LittleRuleResult{}
@@ -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 {
@@ -112,37 +112,47 @@
         initN = init
      }
   }
   if structure.StaticMap[am.AreaId] == nil || len(structure.StaticMap[am.AreaId].Targets) == 0 { // 即第一帧数据(也不一定)，还没有缓存
      logger.Info("之前无缓存")
   if len(am.FilterData) < 0 {
      logger.Info("本帧区域内无数据，返回")
      // 清空缓存的目标

      return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort,am.FilterData}
   }
   m := make(map[string]interface{})
   m["target"] = []structure.Result{}
   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("之前无缓存并且此次区域内有人")

      objs := []*structure.Obj{}
      for _, tar := range am.FilterData {
         obj := &structure.Obj{Id: tar.Id, Location: tar.Location, N: initN,InitN:initN}
         obj := &structure.Obj{Id: tar.Id, Location: tar.Location, N: initN, InitN:initN, AlarmFlag: false, BufferFlag: 10, CacheSdkData:structure.ResultMsg{message, m}}
         objs = append(objs, obj)
      }
      structure.StaticMap[am.AreaId] = &structure.CameraArea{objs}
      return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
      return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort,am.FilterData}
   } else {
      logger.Info("之前有缓存")
      //logger.Info("之前有缓存")
      flag := "false"
      // 以之前静止的对象为主判断是否静止
      tars := []*structure.Arg{}
      logger.Info("看一下静止区域内的目标：",am.AreaId)
      //logger.Info("看一下静止区域内的目标：",am.AreaId)
      //for _, tar := range structure.StaticMap[am.AreaId].Targets {
      //   logger.Info("具体目标：",tar.Location)
      //}
      for _, tar := range structure.StaticMap[am.AreaId].Targets {
         logger.Info("具体目标：",tar.Location)
      }
      for _, tar := range structure.StaticMap[am.AreaId].Targets {
         singleResult,arg := SingleStatic(tar,am,lable,90)
         singleResult,arg := SingleStatic(tar,am,lable,95)
         if singleResult {
            flag = "true"
            tars = append(tars,arg)
            logger.Info("静止的目标：",arg.Id,arg.Location,arg.Score)
            //logger.Info("静止的目标：",arg.Id,arg.Location,arg.Score)
         }
      }

      // 把满足条件的目标放进areaMap中
      am.AlarmObj = tars
      // 更新数据,把新来的数据写入缓存
      objs := []*structure.Obj{}
      for _, tar := range am.FilterData {
         flag1 := false
         for _, OBJ := range structure.StaticMap[am.AreaId].Targets {
@@ -151,12 +161,11 @@
            }
         }
         if !flag1 { // 集合中没有的才插入
            obj := &structure.Obj{Id: tar.Id, Location: tar.Location, N: initN,InitN:initN,AlarmFlag: false, BufferFlag: 10, CacheSdkData: structure.ResultMsg{message, nil}}
            objs = append(objs, obj)
            obj := &structure.Obj{Id: tar.Id, Location: tar.Location, N: initN, InitN:initN,AlarmFlag: false, BufferFlag: 10, CacheSdkData: structure.ResultMsg{message, m}}
            structure.StaticMap[am.AreaId].Targets = append(structure.StaticMap[am.AreaId].Targets, obj)
         }
      }
      structure.StaticMap[am.AreaId] = &structure.CameraArea{objs}
      return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort}
      return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort,am.FilterData}
   }
}

@@ -176,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 {
@@ -190,45 +199,45 @@
      }
   }
   if flag { // 当前检测对象保持静止（id相等并且重合度高于阈值）
      flagTime := TimerAlarm(lable,person,flag,am.AreaId)
      flagTime := TimerAlarm(o,person,flag,am.AreaId)
      if flagTime == "10" || flagTime == "11" {
         return flag,o
      } else {
         return false,o
      }
   } else {
      TimerAlarm(lable,person,flag,am.AreaId)
      TimerAlarm(o,person,flag,am.AreaId)
      return flag,o
   }
}
var rw sync.RWMutex
// 判断是否符合定时器条件
func TimerAlarm(oth *structure.Others,person *structure.Obj, result bool,areaId string) (string) {
func TimerAlarm(o *structure.Arg,person *structure.Obj, result bool,areaId string) (string) {
   var flagTime string //
   logger.Info("目标的定时器：")
   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"
                  oth.TimeLabel = flagTime
                  o.TimeLable = flagTime
                  o.CacheData = tar.CacheSdkData
               }
               if tar.N == 0 && !tar.AlarmFlag { // 这组规则的定时器要全部等于0   暂且认为一组规则只有一个定时器
                  logger.Debug("———————————-------------首次符合持续时间规则并报警")
                  flagTime = "10"
                  tar.AlarmFlag = true
                  oth.CacheData = []structure.ResultMsg{}
                  oth.CacheData = append(oth.CacheData,tar.CacheSdkData)
                  oth.TimeLabel = flagTime
                  o.TimeLable = flagTime
                  o.CacheData = tar.CacheSdkData
               }
               if tar.N != 0 {
                  flagTime = "00"
                  // 有定时器但不为0把已打的标签删除
                  // args.RuleResult = nil
                  logger.Debug("------------------------结果为真但计数器不到0，不报警,此时的计数器", k, "的值为：", tar.N)
                  //logger.Debug("------------------------结果为真但计数器不到0，不报警,此时的计数器", k, "的值为：", tar.N)
               }
            }
         }
@@ -237,9 +246,8 @@
            if tar.Id == person.Id {
               if tar.AlarmFlag {
                  if tar.BufferFlag == 0 {
                     logger.Debug("------------------------------杀死计数器，报警此帧状态改变的数据，此时的计数器的值为", tar.N)
                     //logger.Debug("------------------------------杀死计数器，报警此帧状态改变的数据，此时的计数器的值为", tar.N)
                     flagTime = "12"
                     oth.TimeLabel = flagTime
                     structure.StaticMap[areaId].Targets = append(structure.StaticMap[areaId].Targets[:index],structure.StaticMap[areaId].Targets[index+1:]...)
                  } else {
                     if tar.BufferFlag > 0 {
@@ -248,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:]...)
               }
            }