panlei
2019-07-10 a49dcd9e6d0cca3cecaa520c06295666de9b9630
ruleserver/ruleToformula.go
@@ -2,7 +2,6 @@
import (
   "encoding/json"
   "fmt"
   "ruleprocess/cache"
   "ruleprocess/logger"
   "sort"
@@ -11,6 +10,7 @@
   "time"
   bigCache "basic.com/pubsub/cache.git"
   "basic.com/pubsub/cache.git/esutil"
   "basic.com/pubsub/protomsg.git"
   "github.com/knetic/govaluate"
)
@@ -163,28 +163,18 @@
// 根据摄像机id拿到摄像机所有区域
func GetPolygons(cameraId string) []protomsg.CameraPolygon {
   //var api dbapi.CameraApi
   //data := api.FindAllPolygons()
   ////logger.Info("查到的所有区域:", data)
   //// 根据id从map中拿到区域
   var cameraPolygons []protomsg.CameraPolygon
   //for _, item := range data {
   //   if item.CameraId == cameraId && item.Type != "line" {
   //      // 需要根据比例把前台画的区域的坐标转化为相应摄像机拍摄的图像的大小   x坐标分别*image.width/页面区域宽  y坐标分别*image.height/页面区域高
   //      // 前台宽高固定
   //      //logger.Println("------------符合条件的区域:",item)
   //      cameraPolygons = append(cameraPolygons, item)
   //   }
   //}
   cameraPolygons = cache.GetPolygonsByCameraId(cameraId)
   //logger.Println("根据摄像机id查到的区域", cameraPolygons, "--区域数量为:", len(cameraPolygons))
   return cameraPolygons
}
// 把sdk从数据帧上提取的按照区域分类归置
func SdkDataFormat(cameraId string, arg *SdkData, cameraPolygons []protomsg.CameraPolygon) {
   logger.Info("--------看看解析出来的数据---", *arg)
   logger.Info("==================================本sdkData中解出来的目标数据=======================================")
   for _, photo := range arg.Photo {
      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}
@@ -194,7 +184,7 @@
   }
}
// 对单帧图像的判断 是舍弃(或者说对于某些需求可以放ES数据库一份)还是返回
// 对单帧图像的判断 thisSdkDatas  当前传入的这帧数据,cacheSdkData 定时器里缓存的一帧数据 没有就返回nil  (thisSdkDatas SdkDatas, cacheSdkDatas SdkDatas)
func Judge(args *SdkDatas) {
   if len(args.Sdkdata) > 0 {
      // 拿到本摄像机的区域
@@ -247,15 +237,17 @@
         }
      }
   }
   // 作弊,直接让其比对全部底库
   compareFlag = 1
   if compareFlag == 0 {
      logger.Info("没有配置对比底库参数")
      return
   }
   for j := 0; j < len(groupRule.Rules); j++ {
      // 只有是人脸对比并且配置的参数是对比底库才走(若配的对比阈值则不走)
      if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && groupRule.Rules[j].SdkArgAlias == "compareBase" {
      if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
         for _, sdkData := range args.Sdkdata {
            if sdkData.IpcId == "812b674b-2375-4589-919a-5c1c3278a97e" { // 搜索到人脸检测的sdkdata 现在关于人脸的只有他一个sdk,全找他
            if sdkData.IpcId == "A8B73405-373D-4F23-CED2-A617EBD7EC55" { // 搜索到人脸检测的sdkdata 现在关于人脸的只有他一个sdk,全找他
            logger.Info("============================================第一关")
               for _, areaMap := range sdkData.AreaMapList {
                  // 拿区域中每个人脸特征值去对比,填充其liker
                  if groupRule.Rules[j].PolygonId == areaMap.areaId {
@@ -268,8 +260,11 @@
                              logger.Error("getBaseInfo解压错误", err1)
                           }
                           for key, val := range m {
                              fmt.Println(key)
                              baseinfo := protomsg.Baseinfo{}
                              logger.Info("_______________________________________对比库的返回值",key,val)
                              baseinfo, err1 := esutil.Dbpersoninfosbyid(key)
                              if err1 != nil {
                                 logger.Error("查询底库人员信息出错", err1)
                              }
                              baseinfo.CompareScore = val
                              arg.Liker = append(arg.Liker, &baseinfo)
                           }
@@ -284,8 +279,10 @@
                                 logger.Error("getBaseInfo解压错误", err1)
                              }
                              for key, val := range m {
                                 fmt.Println(key)
                                 baseinfo := protomsg.Baseinfo{}
                                 baseinfo, err1 := esutil.Dbpersoninfosbyid(key)
                                 if err1 != nil {
                                    logger.Error("查询底库人员信息出错", err1)
                                 }
                                 baseinfo.CompareScore = val
                                 arg.Liker = append(arg.Liker, &baseinfo)
                              }
@@ -393,9 +390,17 @@
            logger.Error("没查到sdk的信息---", err)
         }
         ipcId := sdk.IpcId
         sdkName := sdk.SdkName
         if ipcId == sdkData.IpcId {
            for _, areaMap := range sdkData.AreaMapList {
               duration(groupRule.Rules[j], &areaMap)
               ruleResult := duration(groupRule.Rules[j], &areaMap, args)
               if ruleResult.Result != "" {
                  logger.Info("时间规则结果:", ruleResult.Result)
                  if ruleResult.Result == "true" && !strings.Contains(sdkNames, sdkName) {
                     sdkNames = sdkName + ","
                  }
                  resultSplice = append(resultSplice, &ruleResult)
               }
            }
         }
      }
@@ -435,26 +440,26 @@
               timeEle.N = timeEle.InitN // 重置定时器
            }
         }
         logger.Info("-------------------重置定时器并返回false---------------")
         logger.Info("-------------------重置可能存在的定时器并返回false---------------")
         return false
      } else {
         // 最后成功报警才把符合条件的人脸数据塞进结果标签里
         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 {
            for _, areaMap := range sdkData.AreaMapList {
               for j := 0; j < len(groupRule.Rules); j++ {
                  faces = append(faces, putFaceToResult(groupRule.Rules[j], &areaMap)...)
            if sdkData.IpcId == "A8B73405-373D-4F23-CED2-A617EBD7EC55" && faceFlag { // sdkData里有人脸数据且配置了算法才把符合条件的数据塞进标签里去
               for _, areaMap := range sdkData.AreaMapList {
                  faces = append(faces, putFaceToResult(&areaMap)...)
               }
            }
         }
         // 配了人脸的算法才把人脸的数据甩出来打标签
         flag11 := 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" {
               flag11 = true
            }
         }
         if flag11 {
         if faceFlag {
            args.RuleResult["face"] = faces
         }
         // 去看池子里是否有与本帧数据有关的定时器,如果有,看此时是否走到0,没有此定时器或有定时器走到0的话返回成功报警
@@ -472,22 +477,12 @@
            // 把他们的位置数据也传下去
            locations := []Rect{}
            for _, sdkData := range args.Sdkdata {
               for _, areaMap := range sdkData.AreaMapList {
                  for j := 0; j < len(groupRule.Rules); j++ {
                     locations = append(locations, putYolosToResult(groupRule.Rules[j], &areaMap)...)
               if sdkData.IpcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && sdkNames != "" { // 把yolo数据的各个目标的坐标输出方便后面画框
                  for _, areaMap := range sdkData.AreaMapList {
                     locations = append(locations, putYolosToResult(&areaMap)...)
                  }
               }
            }
            //// 配了人脸的算法才把人脸的数据甩出来打标签
            //flag11 := 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-5c1c3278a971" {
            //      flag11 = true
            //   }
            //}
            //if flag11 {
            //   args.RuleResult["face"] = faces
            //}
            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))
@@ -505,26 +500,23 @@
   }
}
func putFaceToResult(rule *protomsg.Rule, am *AreaMap) []Arg {
func putFaceToResult(am *AreaMap) []Arg {
   faces := []Arg{}
   if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" || rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
      if len(am.filterData) > 0 {
         for _, data := range am.filterData {
            faces = append(faces, data)
         }
   if len(am.filterData) > 0 {
      for _, data := range am.filterData {
         faces = append(faces, data)
      }
   }
   //logger.Println("-----------------------------------------------听说你是空的?",faces)
   return faces
}
func putYolosToResult(rule *protomsg.Rule, am *AreaMap) []Rect {
func putYolosToResult(am *AreaMap) []Rect {
   locations := []Rect{}
   if rule.SdkId != "812b674b-2375-4589-919a-5c1c3278a97e" && rule.SdkId != "812b674b-2375-4589-919a-5c1c3278a972" {
      if len(am.filterData) > 0 {
         for _, data := range am.filterData {
            locations = append(locations, data.Location)
         }
   if len(am.filterData) > 0 {
      for _, data := range am.filterData {
         locations = append(locations, data.Location)
      }
   }
   //logger.Println("-----------------------------------------------听说你是空的?",faces)
@@ -542,12 +534,6 @@
   areaPoints := Json2points(a.areaJson)
   widthScale := float64(arg.ImageWidth / 960)
   heigthScale := float64(arg.ImageHeight / 540)
   // for _, sdkInfo := range arg.SdkMessage.Tasklab.Sdkinfos {
   //    if sdkInfo.Sdktype == "yolo" {
   //       //sdkInfo.Sdkdata.
   //    }
   // }
   for _, obj := range arg.Photo {
      //logger.Info("------------------看看sdkData:", arg.SdkName, "的Photo数据----------------", obj, "----顺便看看占比-----:", PgsInterPercent(areaPoints, obj.Rects, widthScale, heigthScale))
      if threshold <= obj.Score && size <= float64(obj.Rects.Width*obj.Rects.Height) && intersectionper <= PgsInterPercent(areaPoints, obj.Rects, widthScale, heigthScale) {
@@ -585,17 +571,6 @@
// 以摄像机id查出跟其相关的所有任务下的所有规则组
func GetRuleGroup(cameraId string) []*protomsg.TaskGroupArgs {
   // 查询数据库
   // 第一步查出跟这个摄像机相关的group_id(大规则)
   //var api dbapi.CameraTaskArgsApi
   //
   ////logger.Info("所有规则:", all)
   //var taskArgs []*protomsg.TaskGroupArgs
   //for _, camArg := range all {
   //   if camArg.CameraId == cameraId {
   //      taskArgs = camArg.TaskArgs
   //   }
   //}
   all := cache.GetCameraTaskRulesByCameraId(cameraId)
   return all
}
@@ -665,9 +640,9 @@
            if result.(bool) {
               logger.Info("___________________________________________________________________联动任务报警")
               args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, "", groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, []Rect{}})
               logger.Info("-------------------yolo结果标签", args.RuleResult["yolo"].([]Result))
               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)))
               }
               //os.Exit(0)
            }
@@ -679,7 +654,7 @@
      logger.Info("这帧图像在任务下的一整条规则下(联动任务下就是跟本摄像机像相关的小规则)的判断结果为false")
      // 所以也要去结果数组里放值或更新
      for _, va := range timeEle.RuleResults {
         if args.CameraId != "" && va.CameraId == args.CameraId { // arg.CameraId 随便找一个数据
         if args.CameraId != "" && va.CameraId == args.CameraId {
            va.Result = strconv.FormatBool(isOk)
         }
      }
@@ -734,6 +709,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("--------------------终于等到你的下文")
                  var args []Arg
                  if rule.RuleWithPre == "&&" {
                     args = am.filterData
@@ -742,6 +718,7 @@
                  }
                  // 先清空过滤后的数据,再往里塞本次过滤后的数据
                  am.filterData = am.filterData[0:0]
                  //logger.Info("-----------------------人脸过滤的args:", args)
                  for _, arg := range args {
                     var formula string
                     if rule.SdkArgAlias == "score" {
@@ -826,43 +803,37 @@
}
// 都过滤完条件之后看看是否要创建一个定时器元素 创建定时器的条件:是否有靠右行,个体静止等自带定时器含义的算法以及是否有持续时间
func duration(rule *protomsg.Rule, am *AreaMap) {
func duration(rule *protomsg.Rule, am *AreaMap, args *SdkDatas) LittleRuleResult{
   if rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上  配置的算法要对的上
      if rule.SdkArgAlias == "duration" { //
         // 先看看定时器元素队列中是否有这个摄像机这个区域的定时器,如果有就不能再次创建了
         var flag bool = true
         for k, _ := range TimeEleList {
         for k,value := range TimeEleList {
            if k == am.taskId+" "+am.sdkId+" "+am.areaId {
               flag = false // 有就置为false
               logger.Info("有这个定时器,不再创建了:")
               // 看看定时器中的值是否为0 如果为0应该报警,如果不为0返回false,未达到持续时间的要求
               if value.N == 0 {
                  return LittleRuleResult{am.sdkName, "true" + "" + rule.RuleWithPre, rule.Sort}
               }else {
                  logger.Info("------------------------------持续时间条件不满足")
                  return LittleRuleResult{am.sdkName, "false" + "" + rule.RuleWithPre, rule.Sort}
               }
            }
         }
         if flag {
            timeLength, _ := strconv.Atoi(rule.SdkArgValue)
            timeEle := TimeElement{N: timeLength, InitN: timeLength} // 扔进去一个定时器元素
            timeEle := TimeElement{N: timeLength, InitN: timeLength, AlarmFlag: false, CacheSdkData: *args} // 扔进去一个定时器元素
            //TimeEleList = make(map[string]timeElement)
            TimeEleList[am.taskId+" "+am.sdkId+" "+am.areaId] = &timeEle // 定时器元素以摄像机id拼接区域id为键
            logger.Info("创建了计数器并且计数器集合为:", TimeEleList)
            return LittleRuleResult{am.sdkName, "false" + "" + rule.RuleWithPre, rule.Sort}
         }
      }
   }
   return LittleRuleResult{}
}
//// 冗余拼接一个目标数量大于0
//func splice1(am *AreaMap) string {
//   var num int = 0
//   for _, data := range am.filterData {
//      if data.isYolo {
//         num++
//      }
//   }
//   logger.Println("看看区域内符合条件的目标数量:----------", num)
//   formula := strconv.Itoa(num) + " " + ">" + "0"
//   expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
//   result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
//   return strconv.FormatBool(result.(bool))
//}
// 给数据库的规则表达式代参 args: 一条子规则,区域数据
func transferParameters(rule *protomsg.Rule, am *AreaMap) LittleRuleResult {
@@ -979,14 +950,6 @@
// 取出某个时间规则的第几天的规则段集合
func GetTimeById(id string, index int) []TimeRange {
   //var cameraTimeRule protomsg.CameraTimerule
   //var api dbapi.CameraApi
   //_, rules := api.FindAllTimeRules()
   //for _, rule := range rules {
   //   if rule.Id == id {
   //      cameraTimeRule = rule
   //   }
   //}
   _, cameraTimeRule := cache.GetTimeRuleById(id)
   var timeRangeList []day
   err := json.Unmarshal([]byte(cameraTimeRule.TimeRule), &timeRangeList)