~jinersong/ruleprocess.git

			@@ -237,7 +237,7 @@
			}
			}
			}
			// 作弊，直接让其比对全部底库
			// 为了测试作下弊，直接让其比对全部底库
			compareFlag = 1
			if compareFlag == 0 {
			logger.Info("没有配置对比底库参数")
			@@ -247,7 +247,7 @@
			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 {
			// 拿区域中每个人脸特征值去对比，填充其liker
			if groupRule.Rules[j].PolygonId == areaMap.areaId {
			@@ -259,8 +259,9 @@
			if err1 != nil {
			logger.Error("getBaseInfo解压错误", err1)
			}
			logger.Info("----------------------------------------map是", m)
			for key, val := range m {
			logger.Info("_______________________________________对比库的返回值",key,val)
			logger.Info("_______________________________________对比库的返回值", key, val)
			baseinfo, err1 := esutil.Dbpersoninfosbyid(key)
			if err1 != nil {
			logger.Error("查询底库人员信息出错", err1)
			@@ -288,8 +289,49 @@
			}
			}
			}
			logger.Info("-------------------成功给liker赋值：", arg.Liker)
			logger.Info("-------------------成功给liker赋值,长度为：", len(arg.Liker))
			}
			for _, arg := range areaMap.filterData {
			if compareFlag == 1 {
			bytes := bigCache.Getdbpersonmsg("", arg.Feature, true)
			var m map[string]float32
			err1 := json.Unmarshal(bytes, &m)
			if err1 != nil {
			logger.Error("getBaseInfo解压错误", err1)
			}
			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
			arg.Liker = append(arg.Liker, &baseinfo)
			}
			}
			if compareFlag == 2 {
			array := strings.Split(tableIds, ",")
			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)
			}
			}
			}
			logger.Info("-------------------成功给liker赋值,长度为：", len(arg.Liker))
			}
			logger.Info("----------------------第二次看args：",areaMap.filterData)
			}
			}
			}
			@@ -303,7 +345,7 @@
			logger.Error("比对规则有误", err.(string))
			}
			}()
			logger.Info("+++++++++++规则开始运行+++++++++++++++++当前规则--：", *groupRule)
			logger.Info("+++++++++++规则开始运行+++++++++++++++++当前大规则--：", *groupRule)
			Compare(args, groupRule)
			resultSplice := []*LittleRuleResult{}
			sdkNames := ""
			@@ -317,7 +359,7 @@
			}
			ipcId := sdk.IpcId
			sdkName := sdk.SdkName

			logger.Info("规则的ipcId与sdkData的IpcId:",ipcId,"===",sdkData.IpcId)
			if ipcId == sdkData.IpcId {
			logger.Info("当前走的规则的算法是--：", sdkName, "---")
			for _, areaMap := range sdkData.AreaMapList {
			@@ -392,7 +434,8 @@
			ipcId := sdk.IpcId
			if ipcId == sdkData.IpcId {
			for _, areaMap := range sdkData.AreaMapList {
			duration(groupRule.Rules[j], &areaMap, args)
			// 去开启一个定时器
			duration(groupRule.Rules[j], groupRule.GroupId, &areaMap, args)
			}
			}
			}
			@@ -428,43 +471,44 @@
			// 给这帧数据打上规则组标签
			//args.RuleResult = append(args.RuleResult, Result{TaskId: taskId, RuleGroupId: groupRule.GroupId})
			for k, timeEle := range TimeEleList {
			if strings.Contains(k, taskId) {
			if strings.Contains(k, groupRule.GroupId) {
			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 {
			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
			}
			// 去看池子里是否有与本帧数据有关的定时器，如果有，看此时是否走到0，没有此定时器或有定时器走到0的话返回成功报警
			// 判断持续时间条件，去看池子里是否有与本帧数据有关的定时器，如果有，看此时是否走到0，没有此定时器或有定时器走到0的话返回成功报警
			var flag bool = true
			for k, timeEle := range TimeEleList {
			if strings.Contains(k, taskId) {
			if timeEle.N != 0 { // 跟这个任务有关的定时器要全部等于0
			if strings.Contains(k, groupRule.GroupId) {
			if timeEle.N != 0 { // 这组规则的定时器要全部等于0
			logger.Info("———————————-------------不冤，你是被定时器打败的：")
			flag = false
			}
			}
			}
			if flag {
			// 最后成功报警才把符合条件的人脸数据塞进结果标签里
			// 配了人脸的算法才把人脸的数据甩出来打标签
			logger.Info("------------------------------最后一关")
			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{}
			@@ -490,6 +534,23 @@
			} else {
			return false
			}
			}
			func TimerAlarm(groupId string) (int){
			var flagTime int = 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
			}
			if timeEle.N == 0 && timeEle.AlarmFlag {
			logger.Info("-------------------------符合持续时间规则但并不是首次，不报警")
			flagTime = 2
			}
			}
			}
			return flagTime
			}

			func putFaceToResult(am *AreaMap) []Arg {
			@@ -662,7 +723,7 @@
			if rule.PolygonId == am.areaId { // 算法和区域都得对的上

			if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && rule.SdkArgAlias != "time_rule" {
			// 只需要过滤阈值，过滤完后数组长度大于0即为报警，但要考虑如何对每一张都报警呢
			// 只需要过滤阈值，过滤完后数组长度大于0即为报警
			argValue, err := strconv.ParseFloat(rule.SdkArgValue, 64)
			if err != nil {
			logger.Error("规则配置的阈值非法")
			@@ -794,14 +855,14 @@
			}
			}

			// 都过滤完条件之后看看是否要创建一个定时器元素创建定时器的条件：是否有靠右行，个体静止等自带定时器含义的算法以及是否有持续时间
			func duration(rule protomsg.Rule, am AreaMap, args *SdkDatas) {
			// 如果有持续时间条件维护开启一个定时器
			func duration(rule protomsg.Rule, groupId string, am AreaMap, args *SdkDatas) {
			if rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上配置的算法要对的上
			if rule.SdkArgAlias == "duration" { //
			// 先看看定时器元素队列中是否有这个摄像机这个区域的定时器,如果有就不能再次创建了
			var flag bool = true
			for k, _ := range TimeEleList {
			if k == am.taskId+" "+am.sdkId+" "+am.areaId {
			if k == groupId+" "+rule.Id {
			flag = false // 有就置为false
			logger.Info("有这个定时器，不再创建了：")
			}
			@@ -809,9 +870,9 @@

			if flag {
			timeLength, _ := strconv.Atoi(rule.SdkArgValue)
			timeEle := TimeElement{N: timeLength, InitN: timeLength, AlarmFlag: false, CacheSdkData: *args} // 扔进去一个定时器元素
			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为键
			TimeEleList[groupId+" "+rule.Id] = &timeEle // 定时器元素以摄像机id拼接区域id为键
			logger.Info("创建了计数器并且计数器集合为：", TimeEleList)
			}
			}