~jinersong/ruleprocess.git

			@@ -2,10 +2,11 @@

			import (
			"ruleprocess/cache"
			"ruleprocess/logger"
			"basic.com/valib/logger.git"
			"sort"
			"strconv"
			"strings"
			"sync"
			"time"

			"basic.com/pubsub/protomsg.git"
			@@ -81,6 +82,11 @@
			RuleResult map[string]interface{} // 过完规则后打的标签 face: []FaceResult, yolo: []Result
			}

			type TargetInfo struct {
			Rect
			TargetId uint64
			TargetScore float64
			}
			// 过规则库打上的标签
			type Result struct {
			TaskId string // 任务id
			@@ -89,7 +95,7 @@
			DefenceState bool // 是否布防
			AlarmLevel int32 // 报警等级
			RuleText string // 文字版规则组
			Location []Rect // 目标的坐标
			Location []TargetInfo // 目标的坐标
			AlarmPolygon string // 触发的报警框
			IsLink bool // 是否是联动任务
			Others
			@@ -111,13 +117,20 @@
			Sort int32
			}

			var rw sync.RWMutex // 读写锁

			// 对单帧图像的判断 thisSdkDatas 当前传入的这帧数据，cacheSdkData 定时器里缓存的一帧数据没有就返回nil (thisSdkDatas SdkDatas, cacheSdkDatas SdkDatas)
			func Judge(args SdkDatas, message protomsg.SdkMessage) {
			defer func() {
			if err := recover(); err != nil {
			logger.Error("规则模块儿的异常捕获：",err)
			}
			}()
			if len(args.Sdkdata) > 0 {
			// 拿到本摄像机的区域
			cameraPolygons := GetPolygons(args.CameraId)
			// 把所有的sdk提取的数据都按所属摄像机的区域归置
			//logger.Debug("当前摄像机id为：",message.Cid,"当前摄像机执行的任务是：",message.Tasklab.Taskname)
			logger.Debug("当前摄像机id为：",message.Cid,"当前摄像机执行的任务是：",message.Tasklab.Taskname,"--任务id为：",message.Tasklab.Taskid)
			for _, arg := range args.Sdkdata {
			SdkDataFormat(args.CameraId, arg, cameraPolygons)
			}
			@@ -161,7 +174,7 @@
			}
			}

			func RunRule(args SdkDatas, groupRule protomsg.GroupRule, taskId string, message *protomsg.SdkMessage, label Others) bool {
			func RunRule(args SdkDatas, groupRule protomsg.GroupRule, taskId string, message *protomsg.SdkMessage, label Others) (bool,[]int) {
			defer func() {
			if err := recover(); err != nil {
			logger.Error("比对规则有误", err.(string))
			@@ -197,9 +210,8 @@
			// 如果此结果为真且当前过的是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) {
			if strings.Contains(ruleResult.Result, "true") && !strings.Contains(polygonId, groupRule.Rules[j].PolygonId) {
			polygonId = groupRule.Rules[j].PolygonId + ","
			}
			resultSplice = append(resultSplice, &ruleResult)
			@@ -208,7 +220,6 @@
			}
			}
			}

			// 再过其他数据这步直接得到结果（真或假）过目标数量
			for j := 0; j < len(groupRule.Rules); j++ {
			for _, sdkData := range args.Sdkdata {
			@@ -336,12 +347,13 @@
			}
			}
			}
			logger.Info("face标签的长度：",len(faces))
			//for _,face := range faces {
			// //logger.Debug("————————————————________________看看人脸的坐标:",face.Location)
			//}
			logger.Warn("___________________________________________________________________________终于走完万里长征")
			// 把他们的位置数据也传下去
			locations := []Rect{}
			locations := []TargetInfo{}
			for _, sdkData := range args.Sdkdata {
			if sdkData.IpcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && sdkNames != "" { // 把yolo数据的各个目标的坐标输出方便后面画框
			for _, areaMap := range sdkData.AreaMapList {
			@@ -356,27 +368,30 @@
			} else {
			islink = false
			}
			var labelTypes []int // 0为yolo标签，1为face标签 2为两者标签
			if sdkNames != "" {
			args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkNames, groupRule.GroupId, groupRule.DefenceState, groupRule.AlarmLevel, groupRule.GroupText, locations, polygonId, islink,label,})
			labelTypes = append(labelTypes,0)
			//logger.Info("-------------------yolo结果标签长度", len(args.RuleResult["yolo"].([]Result)))
			}
			if faceFlag {
			args.RuleResult["face"] = append(args.RuleResult["face"].([]FaceResult), FaceResult{Result{taskId, sdkNames, groupRule.GroupId, groupRule.DefenceState, groupRule.AlarmLevel, groupRule.GroupText, []Rect{}, polygonId, islink,label,}, faces})
			args.RuleResult["face"] = append(args.RuleResult["face"].([]FaceResult), FaceResult{Result{taskId, sdkNames, groupRule.GroupId, groupRule.DefenceState, groupRule.AlarmLevel, groupRule.GroupText, []TargetInfo{}, polygonId, islink,label,}, faces})
			//logger.Info("-------------------face结果标签", len(args.RuleResult["face"].([]FaceResult)))
			labelTypes = append(labelTypes,1)
			}
			return true
			return true,labelTypes
			} else {
			return false
			return false,[]int{}
			}

			} else {
			// 结果为假时也要走，有时候为假的状态反转数据也需要记录下来
			//timeFlag := TimerAlarm(args, groupRule.GroupId, result.(bool))
			// 结果为假时也要走，有杀死定时器的操作
			TimerAlarm(&label, groupRule.GroupId, result.(bool))
			//fmt.Println(timeFlag)
			return false
			return false,[]int{}
			}
			} else {
			return false
			return false,[]int{}
			}
			}

			@@ -399,11 +414,15 @@
			return faces
			}

			func putYolosToResult(am *AreaMap) []Rect {
			locations := []Rect{}
			func putYolosToResult(am *AreaMap) []TargetInfo {
			locations := []TargetInfo{}
			if len(am.filterData) > 0 {
			for _, data := range am.filterData {
			locations = append(locations, data.Location)
			location := TargetInfo{}
			location.Rect = data.Location
			location.TargetId = data.Id
			location.TargetScore = data.Score
			locations = append(locations, location)
			}
			}
			//logger.Println("-----------------------------------------------听说你是空的？",faces)
			@@ -416,11 +435,15 @@
			logger.Info("------------------------------------------当前是联动任务，规则是：", groupRule.GroupText)
			var flag bool = true
			var timeEle = TimeElement{N: 2, InitN: 2, GroupId: groupRule.GroupId}
			rw.Lock()
			for k, timeEle1 := range TimeEleList {
			if k == groupRule.GroupId {
			flag = false // 已经有了这个定时器就置为false 不再新增
			timeEle = *timeEle1
			}
			}
			for _,ruleRe := range timeEle.RuleResults {
			logger.Info("联动数组里的数据----",ruleRe.CameraId,ruleRe.Sort)
			}
			if flag { // 如果还没有这个定时器元素就新增一个
			//timeEle := TimeElement{N: 2, InitN: 2, GroupId: groupRule.GroupId} // 扔进去一个定时器元素
			@@ -430,7 +453,9 @@
			// 得出这组完整规则里涉及到几个摄像机，决定着数组里有几个结构体,去重添加方式
			for j := 0; j < len(groupRule.Rules); j++ {
			var flag1 bool = true
			logger.Info("规则组信息：",groupRule.Rules[j].CameraId)
			for _, ruleRes := range TimeEleList[groupRule.GroupId].RuleResults {
			logger.Info("联动数组里的数据：",ruleRes.CameraId,ruleRes.Sort)
			if groupRule.Rules[j].CameraId == ruleRes.CameraId {
			flag1 = false
			}
			@@ -440,8 +465,9 @@
			}
			}
			}
			rw.Unlock()
			// 往数组里赋值
			isOk := RunRule(args, groupRule, taskId, message, label)
			isOk,labelTypes := RunRule(args, groupRule, taskId, message, label)
			if isOk {
			logger.Info("这帧图像在任务下的一整条规则下（联动任务下就是跟本摄像机像相关的小规则）的判断结果为true")
			// 根据cameraId去更新或者插入结果,然后判断是否数组是否可以得出报警的结论
			@@ -491,6 +517,7 @@
			result, _ := expression.Evaluate(nil) // 得到数学公式的结果
			if result.(bool) {
			logger.Info("___________________________________________________________________联动任务报警")
			rw.RLock()
			if TimeEleList[groupRule.GroupId] != nil { // 极偶尔有情况会等于nil，不知道为啥，做个判断以防宕机
			// 把数组里缓存的数据取出来一起报警
			label.LinkCache = []ResultMsg{}
			@@ -509,13 +536,28 @@
			}
			}
			}
			rw.RUnlock()
			}
			}
			} else {
			logger.Warn("数组不圆满不打标签")
			// 倒是把打的组规则标签给去掉了啊
			lens := len(args.RuleResult["yolo"].([]Result))-1
			args.RuleResult["yolo"] = args.RuleResult["yolo"].([]Result)[0:lens]
			for _,val := range labelTypes {
			if val == 0 {
			if len(args.RuleResult["yolo"].([]Result)) >= 1 {
			lens := len(args.RuleResult["yolo"].([]Result))-1
			args.RuleResult["yolo"] = args.RuleResult["yolo"].([]Result)[0:lens]
			}
			}
			if val == 1 {
			if len(args.RuleResult["face"].([]FaceResult)) >= 1 {
			lens := len(args.RuleResult["face"].([]FaceResult))-1
			args.RuleResult["face"] = args.RuleResult["face"].([]FaceResult)[0:lens]
			}
			}
			}


			}
			} else { // 没有报警，
			//logger.Info("这帧图像在任务下的一整条规则下（联动任务下就是跟本摄像机像相关的小规则）的判断结果为false")
			@@ -525,12 +567,14 @@
			// va.Result = strconv.FormatBool(isOk)
			// }
			//}
			rw.Lock()
			for k, _ := range TimeEleList {
			if k == groupRule.GroupId {
			delete(TimeEleList, k)
			logger.Debug("因为定时器的一帧数据结果为false，干掉定时器")
			}
			}
			rw.Unlock()
			// 因为本帧数据不符合规则，所以也不用统计结果数组里的东西

			}
			@@ -543,25 +587,29 @@
			//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"{
			//logger.Debug("当前小规则是：",rule)
			flag := "false"
			// 把没有相似者的人脸从filterData中删除
			for index := 0; index < len(am.filterData); {
			// 将达不到阈值的相似者从相似者数组中删除
			logger.Info("看看相似者人数：",len(am.filterData[index].Liker))
			if len(am.filterData[index].Liker) == 0 {
			// Go 语言中切片删除元素的本质是：以被删除元素为分界点，将前后两个部分的内存重新连接起来。不用怀疑，数组删除元素就这么坑爹
			am.filterData = append(am.filterData[:index], am.filterData[index+1:]...)
			} else {
			index++
			if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && rule.SdkArgAlias != "time_rule" {
			if rule.RuleWithPre == "\|\|" {
			return LittleRuleResult{}
			} else {
			//logger.Debug("当前小规则是：",rule)
			flag := "false"
			// 把没有相似者的人脸从filterData中删除
			for index := 0; index < len(am.filterData); {
			// 将达不到阈值的相似者从相似者数组中删除
			logger.Info("看看相似者人数：",len(am.filterData[index].Liker))
			if len(am.filterData[index].Liker) == 0 {
			// Go 语言中切片删除元素的本质是：以被删除元素为分界点，将前后两个部分的内存重新连接起来。不用怀疑，数组删除元素就这么坑爹
			am.filterData = append(am.filterData[:index], am.filterData[index+1:]...)
			} else {
			index++
			}
			}
			if len(am.filterData) > 0 {
			flag = "true"
			}
			logger.Info("---------人脸比对符合条件的数量为：",len(am.filterData))
			return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + flag, rule.Sort}
			}
			if len(am.filterData) > 0 {
			flag = "true"
			}
			logger.Info("---------人脸比对符合条件的数量为：",len(am.filterData))
			return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + flag, rule.Sort}
			}
			if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" { // 人脸检测
			//logger.Debug("当前小规则是：",rule)
			@@ -575,6 +623,7 @@
			//logger.Info("过滤后的args的长度为：",len(args))
			} else {
			args = am.args
			//不清空之前的过滤数据，继续塞
			//logger.Info("没过滤的args的长度为：",len(args))
			}
			// 先清空过滤后的数据，再往里塞本次过滤后的数据
			@@ -606,17 +655,15 @@
			} else {
			return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + "false", rule.Sort}
			}
			} else {
			return LittleRuleResult{}
			}
			} else {
			return LittleRuleResult{}
			} else if rule.SdkArgAlias == "" { // 什么参数都不配的情况
			if am.targetNum > 0 {
			return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + "true", rule.Sort}
			} else {
			return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + "false", rule.Sort}
			}
			}
			} else {
			return LittleRuleResult{}
			}
			} else {
			return LittleRuleResult{}
			}
			} else {
			// 处理的都是yolo数据
			@@ -656,14 +703,16 @@
			return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + "false", rule.Sort}
			}

			} else {
			return LittleRuleResult{}
			} else if rule.SdkArgAlias == "" {
			if am.targetNum > 0 {
			return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + "true", rule.Sort}
			} else {
			return LittleRuleResult{am.sdkName, rule.RuleWithPre + "" + "false", rule.Sort}
			}
			}

			} else {
			return LittleRuleResult{}
			}
			}
			return LittleRuleResult{}
			}

			// 如果有持续时间条件维护开启一个定时器
			@@ -672,6 +721,7 @@
			if rule.SdkArgAlias == "duration" { //
			logger.Info("当前小规则是：---------", rule)
			// 先看看定时器元素队列中是否有这条规则的定时器,如果有就不能再次创建了
			rw.Lock()
			var flag bool = true
			for k, _ := range TimeEleList {
			if k == groupId+"+"+rule.Id {
			@@ -687,6 +737,7 @@
			TimeEleList[groupId+"+"+rule.Id] = &timeEle // 定时器元素以当前持续时间小规则id为键
			logger.Info("创建了计数器")
			}
			rw.Unlock()
			}
			}
			}
			@@ -712,18 +763,6 @@
			result, _ := expression.Evaluate(nil) // 得到数学公式的结果
			return LittleRuleResult{am.sdkName, rule.RuleWithPre + " " + strconv.FormatBool(result.(bool)), rule.Sort}
			// 加上关于算法的判断条件，不能只有关于规则的，有的算法本身就是一个规则，如个体静止，靠右行,所以，拿到当前子规则的sdkid来判断是否是那些特殊的规则
			} else if rule.SdkId == "IsStatic" { // 静止算法
			if am.isStatic {
			return LittleRuleResult{}
			} else {
			return LittleRuleResult{}
			}
			} else if rule.SdkId == "KeepRight" { // 靠右行算法
			if am.keepRight {
			return LittleRuleResult{}
			} else {
			return LittleRuleResult{}
			}
			}
			}
			return LittleRuleResult{}