---

panlei

2019-07-12 7f27fef93bd62eb1367a43430fee594cf33eb54e

 ruleserver/ruleToformula.go

@@ -89,8 +89,8 @@
   triggerLine   string
   directionLine string
   targetNum     int    // 区域内目标数量
   args          []Arg  // 区域内目标集合
   filterData    []Arg  // 过滤后区域内目标集合
   args          []*Arg // 区域内目标集合
   filterData    []*Arg // 过滤后区域内目标集合
   time          string // 当前时间（用以匹配时间规则）
   keepRight     bool   // 是否靠右行
   isStatic      bool   // 是否静止
@@ -115,14 +115,14 @@
   IsStatic    bool       // 是否静止
   ImageWidth  int        // 摄像机拍摄的图像宽 像素
   ImageHeight int        // 摄像机拍摄的图像高 像素
   AreaMapList []AreaMap  // 本sdk提取的数据按照区域划分后的数据集合
   AreaMapList []*AreaMap // 本sdk提取的数据按照区域划分后的数据集合
}

// 从算法模块儿拿来的对一帧图像各个算法提取的数据集合
type SdkDatas struct {
   CameraId   string
   Sdkdata    []*SdkData
   RuleResult map[string]interface{} // 过完规则后打的标签 face: []Arg  yolo: []Result
   RuleResult map[string]interface{} // 过完规则后打的标签 face: []Arg  yolo: []Result cacheData: SdkDatas
}

// 将传递过来的参数转化为
@@ -135,12 +135,13 @@

// 过规则库打上的标签
type Result struct {
   TaskId      string // 任务id
   SdkName     string
   RuleGroupId string // 规则组id
   AlarmLevel  int32  // 报警等级
   RuleText    string // 文字版规则组
   Location    []Rect
   TaskId       string // 任务id
   SdkName      string
   RuleGroupId  string // 规则组id
   AlarmLevel   int32  // 报警等级
   RuleText     string // 文字版规则组
   Location     []Rect // 目标的坐标
   AlarmPolygon string // 触发的报警框
}
type LittleRuleResult struct {
   SdkName string // 记录下此结果是哪个sdk的结果
@@ -165,7 +166,7 @@
func GetPolygons(cameraId string) []protomsg.CameraPolygon {
   var cameraPolygons []protomsg.CameraPolygon
   cameraPolygons = cache.GetPolygonsByCameraId(cameraId)

   logger.Debug("------=======查看下全部区域：",cameraPolygons)
   return cameraPolygons
}

@@ -173,14 +174,14 @@
func SdkDataFormat(cameraId string, arg *SdkData, cameraPolygons []protomsg.CameraPolygon) {
   logger.Info("==================================本sdkData中解出来的目标数据=======================================")
   for _, photo := range arg.Photo {
      logger.Info("--------看看解析出来的数据---", cameraId, arg.IpcId, photo.Rects, photo.Score)
      logger.Info("--------解析出来的数据---", cameraId, arg.IpcId, photo.Rects, photo.Score)
   }
   for _, polygon := range cameraPolygons {
      //logger.Println("++++++在这儿看一下区域啊:", polygon.Polygon)
      areaMap := AreaMap{cameraId: cameraId, areaId: polygon.Id, areaJson: polygon.Polygon, triggerLine: polygon.TriggerLine, directionLine: polygon.DirectionLine}
      // 为每个摄像机区域填充数据
      areaMap.CountAreaObjs(arg)
      arg.AreaMapList = append(arg.AreaMapList, areaMap)
      arg.AreaMapList = append(arg.AreaMapList, &areaMap)
   }
}

@@ -222,7 +223,9 @@
      }
   }
}
func (arg *Arg) fillLiker(){

// 给目标填充liker
func (arg *Arg) fillLiker() {
   bytes := bigCache.Getdbpersonmsg("", arg.Feature, true)
   var m map[string]float32
   err1 := json.Unmarshal(bytes, &m)
@@ -231,14 +234,23 @@
   }
   logger.Info("----------------------------------------map是", m)
   for key, val := range m {
      logger.Info("_______________________________________对比库的返回值", key, val)
      baseinfo, err1 := esutil.Dbpersoninfosbyid(key)
      if err1 != nil {
         logger.Error("查询底库人员信息出错", err1)
      }
      baseinfo.CompareScore = val
      baseinfo.CompareScore = Retain(val)
      arg.Liker = append(arg.Liker, &baseinfo)
   }
   //logger.Info("------------------第一次看args:",*arg)
}
// 保留四位小数
func Retain(f float32)(float32) {
   s:= strconv.FormatFloat(float64(f), 'f', 4, 64)
   v, err := strconv.ParseFloat(s, 32)
   if err != nil {
      logger.Error("保留四位小数转换错误")
   }
   return float32(v)
}
func Compare(args *SdkDatas, groupRule *protomsg.GroupRule) {
   compareFlag := 0
@@ -256,7 +268,7 @@
      }
   }
   // 为了测试作下弊，直接让其比对全部底库
   compareFlag = 1
   //compareFlag = 1
   if compareFlag == 0 {
      logger.Info("没有配置对比底库参数")
      return
@@ -265,37 +277,29 @@
      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 {
                  logger.Info("-------------人脸比对之前目标数量",len(areaMap.args))
                  // 拿区域中每个人脸特征值去对比，填充其liker
                  if groupRule.Rules[j].PolygonId == areaMap.areaId {
                     logger.Info("--------------看看compareFlag的值：",compareFlag)
                     for _, arg := range areaMap.args {
                        if compareFlag == 1 {
                           arg.fillLiker()
                        }
                        if compareFlag == 2 {
                           array := strings.Split(tableIds, ",")
                           logger.Info("--------------------------看看对比底库的值;",array)
                           for i := 0; i < len(array)-1; i++ {
                              bytes := bigCache.Getdbpersonmsg(array[i], arg.Feature, true)
                              var m map[string]float32
                              err1 := json.Unmarshal(bytes, &m)
                              if err1 != nil {
                                 logger.Error("getBaseInfo解压错误", err1)
                              }
                              for key, val := range m {
                                 baseinfo, err1 := esutil.Dbpersoninfosbyid(key)
                                 if err1 != nil {
                                    logger.Error("查询底库人员信息出错", err1)
                                 }
                                 baseinfo.CompareScore = val
                                 arg.Liker = append(arg.Liker, &baseinfo)
                              }
                              arg.fillLiker()
                           }
                        }
                        logger.Info("-------------------成功给liker赋值,长度为：", len(arg.Liker))
                     }
                     logger.Info("=======第一次看args：",areaMap.args)
                     areaMap.filterData = areaMap.args
                     //logger.Info("=======第一次看args：",(areaMap.filterData))
                  }
                  logger.Info("-------------------------------人脸对比之后的目标数量",len(areaMap.args))
               }
            }
         }
@@ -312,6 +316,7 @@
   Compare(args, groupRule)
   resultSplice := []*LittleRuleResult{}
   sdkNames := ""
   polygonId := ""
   // 先过完条件规则
   for j := 0; j < len(groupRule.Rules); j++ {
      for _, sdkData := range args.Sdkdata {
@@ -322,16 +327,24 @@
         }
         ipcId := sdk.IpcId
         sdkName := sdk.SdkName
         logger.Info("规则的ipcId与sdkData的IpcId:",ipcId,"===",sdkData.IpcId)
         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)
            }
            for _, areaMap := range sdkData.AreaMapList {
               ruleResult := filterRule(groupRule.Rules[j], &areaMap)
               ruleResult := filterRule(groupRule.Rules[j], areaMap)
               if ruleResult.Result != "" {
                  logger.Info("条件规则结果：", ruleResult.Result)
                  // 如果此结果为真且当前过的是yolo算法，应记下此规则所对应的sdkName,另外，还要去重
                  if ruleResult.Result == "true" && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                  // 如果此结果为真且当前过的是yolo算法，应记下此规则所对应的sdkName,另外，还要去重 (后加：把此条触碰的区域id也记录下来)
                  if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                     sdkNames = sdkName + ","
                     polygonId = groupRule.Rules[j].PolygonId + ","
                  }
                  if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(polygonId, groupRule.Rules[j].PolygonId) {
                     polygonId = groupRule.Rules[j].PolygonId + ","
                  }
                  resultSplice = append(resultSplice, &ruleResult)
               }
@@ -352,11 +365,14 @@
         sdkName := sdk.SdkName
         if ipcId == sdkData.IpcId {
            for _, areaMap := range sdkData.AreaMapList {
               ruleResult := transferParameters(groupRule.Rules[j], &areaMap)
               ruleResult := transferParameters(groupRule.Rules[j], areaMap)
               if ruleResult.Result != "" {
                  logger.Info("数量规则结果：", ruleResult.Result)
                  if ruleResult.Result == "true" && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                  if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                     sdkNames = sdkName + ","
                  }
                  if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(polygonId, groupRule.Rules[j].PolygonId) {
                     polygonId = groupRule.Rules[j].PolygonId + ","
                  }
                  resultSplice = append(resultSplice, &ruleResult)
               }
@@ -375,11 +391,14 @@
         sdkName := sdk.SdkName
         if ipcId == sdkData.IpcId {
            for _, areaMap := range sdkData.AreaMapList {
               ruleResult := timeRuleResult(groupRule.Rules[j], &areaMap)
               ruleResult := timeRuleResult(groupRule.Rules[j], areaMap)
               if ruleResult.Result != "" {
                  logger.Info("时间规则结果：", ruleResult.Result)
                  if ruleResult.Result == "true" && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                  if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                     sdkNames = sdkName + ","
                  }
                  if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(polygonId, groupRule.Rules[j].PolygonId) {
                     polygonId = groupRule.Rules[j].PolygonId + ","
                  }
                  resultSplice = append(resultSplice, &ruleResult)
               }
@@ -398,7 +417,7 @@
         if ipcId == sdkData.IpcId {
            for _, areaMap := range sdkData.AreaMapList {
               // 去开启一个定时器
               duration(groupRule.Rules[j], groupRule.GroupId, &areaMap, args)
               duration(groupRule.Rules[j], groupRule.GroupId, areaMap, args)
            }
         }
      }
@@ -451,10 +470,10 @@
               }
            }
         }
         //TimerAlarm(args,groupRule.GroupId)
         if flag {
            // 最后成功报警才把符合条件的人脸数据塞进结果标签里
            // 配了人脸的算法才把人脸的数据甩出来打标签
            logger.Info("------------------------------最后一关")
            faces := []Arg{}
            faceFlag := false
            for j := 0; j < len(groupRule.Rules); j++ {
@@ -465,7 +484,7 @@
            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)...)
                  }
               }
            }
@@ -478,16 +497,17 @@
            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)...)
                     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})
               logger.Info("-------------------yolo结果标签", args.RuleResult["yolo"].([]Result))
               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结果标签", args.RuleResult["face"].([]Arg))
               logger.Info("-------------------face结果标签", len(args.RuleResult["face"].([]Arg)))
            }
            return true
         } else {
@@ -498,14 +518,15 @@
      return false
   }
}
func TimerAlarm(groupId string) (int){
   var flagTime int = 0
func TimerAlarm(args SdkDatas,groupId string) (int) {
   var flagTime int = 0  // 为0的意思是
   for k, timeEle := range TimeEleList {
      if strings.Contains(k, groupId) {
         if timeEle.N == 0 && !timeEle.AlarmFlag { // 这组规则的定时器要全部等于0   暂且认为一组规则只有一个定时器
            logger.Info("———————————-------------首次符合持续时间规则并报警")
            flagTime = 1
            timeEle.AlarmFlag = true
            args.RuleResult["cacheData"] = timeEle.CacheSdkData
         }
         if timeEle.N == 0 && timeEle.AlarmFlag {
            logger.Info("-------------------------符合持续时间规则但并不是首次，不报警")
@@ -520,7 +541,7 @@
   faces := []Arg{}
   if len(am.filterData) > 0 {
      for _, data := range am.filterData {
         faces = append(faces, data)
         faces = append(faces, *data)
      }
   }

@@ -557,8 +578,8 @@
         a.targetNum++
         arg1 := Arg{obj.Score, PgsInterPercent(areaPoints, obj.Rects, widthScale, heigthScale), float64(obj.Rects.Width * obj.Rects.Height), obj.IsYolo, obj.Rects, obj.Feature, obj.ThftRes, []*protomsg.Baseinfo{}}
         //logger.Println("放进去的arg：-------", arg1)
         a.args = append(a.args, arg1)
         a.filterData = append(a.filterData, arg1)
         a.args = append(a.args, &arg1)
         a.filterData = append(a.filterData, &arg1)
      }
   }
   a.time = time.Unix(time.Now().Unix(), 0).String()[11:16]
@@ -570,7 +591,8 @@
// 将字符串格式的坐标序列化为Point格式
func Json2points(areaPoints string) []Point {
   var pts []Point
   if areaPoints == "" {
   if areaPoints == "[]" {
      logger.Error("=====================此区域为全部区域")
      pts = append(pts, Point{0, 0})
      pts = append(pts, Point{0, 540})
      pts = append(pts, Point{960, 540})
@@ -655,7 +677,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.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)))
@@ -685,8 +707,7 @@
      //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" {
            // 只需要过滤阈值，过滤完后数组长度大于0即为报警
         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("规则配置的阈值非法")
@@ -696,7 +717,7 @@
            for _, obj := range am.filterData {
               for index := 0; index < len(obj.Liker); {
                  // 将达不到阈值的相似者从相似者数组中删除
                  logger.Warn("=======================相似值：", float64(obj.Liker[index].CompareScore*100))
                  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:]...)
@@ -721,12 +742,11 @@
            return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + flag, rule.Sort}
         }
         if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" { // 人脸检测
            logger.Info("------------------------------------------------------------------------------------------------------------------------------------终于等到你")
            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("--------------------终于等到你的下文")
                  var args []Arg
                  //logger.Info("---------------------------终于等到你")
                  var args []*Arg
                  if rule.RuleWithPre == "&&" {
                     args = am.filterData
                  } else {
@@ -734,7 +754,7 @@
                  }
                  // 先清空过滤后的数据，再往里塞本次过滤后的数据
                  am.filterData = am.filterData[0:0]
                  //logger.Info("-----------------------人脸过滤的args：", args)
                  //logger.Info("-----------------------人脸过滤的args里的数量：", len(args))
                  for _, arg := range args {
                     var formula string
                     if rule.SdkArgAlias == "score" {
@@ -775,7 +795,7 @@
      if rule.PolygonId == am.areaId { // 首先这条规则得是这个算法的规则，其次规则所对应的区域id要跟区域数据的id对的上
         if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
            logger.Info("----------当前条件规则：---------", rule)
            var args []Arg
            var args []*Arg
            if rule.RuleWithPre == "&&" {
               args = am.filterData
            } else {