联动任务缓存数据(结构重整)

panlei

2019-07-31 b96e8aadb0f3c216031dc8f6f5f2dad0786b390a

联动任务缓存数据(结构重整)

 insertdata/insertDataToEs.go

@@ -312,111 +312,141 @@
// 往es中插入yolo数据
func InsertYolo(msg ruleserver.ResultMsg) {
    if msg.RuleResult["yolo"] != nil && len(msg.RuleResult["yolo"].([]ruleserver.Result)) > 0 {
        logger.Info("往ES插yolo数据")
        var sdkNames string = ""
        alarmRules := []AlarmRule{}
        for _, yoloResult := range msg.RuleResult["yolo"].([]ruleserver.Result) {
            sdkNames = sdkNames + yoloResult.SdkName
            alarm := ChangeToString(yoloResult.DefenceState, yoloResult.AlarmLevel)
            alarmRules = append(alarmRules, AlarmRule{yoloResult.RuleGroupId, alarm, yoloResult.RuleText,yoloResult.DefenceState})
        }
        isAlarm := 0
        resp := make(map[string]interface{})
        // 解压缩并上传图片
        bdata, err := util.UnCompress(msg.Data)
        if err != nil {
            panic("解压缩图片时出现错误")
        }
        i := protomsg.Image{}
        err = proto.Unmarshal(bdata, &i)
        if len(alarmRules) > 0 {
            isAlarm = 1
            //resp, err = util.PostFormBufferData(weedfsUrl, i, uuid.NewV4().String())
            resp, err = util.DrawPolygonOnImage(msg.Cid, i, msg.RuleResult["yolo"].([]ruleserver.Result), weedfsUrl)
            if err != nil {
                logger.Error("画框或上传图片服务器出错", err)
            } else {
                logger.Info("上传的图片信息：", resp)
        // 先判断一下数据带的规则标签是否有可以插入的
        flag := false
        for _,res := range msg.RuleResult["yolo"].([]ruleserver.Result) {
            if res.Others["timeLabel"].(string) == "01" || res.Others["timeLabel"].(string) == "10" {
                flag = true
            }
        } else {
            isAlarm = 0
            // 不是报警数据不存
            return
        }
        // logger.Println("图片上传返回值：", resp)
        // 查询本机信息
        localConfig, err := cache.GetServerInfo()
        if err != nil {
            logger.Error("查询本机信息失败！")
        }
        // 查询cameraName
        camera, err := cache.GetCameraById(msg.Cid)
        if err != nil {
            logger.Error("查询摄像机信息失败")
        }
        serverIp, err := GetLocalIP()
        url := []string{}
        if msg.RuleResult["cacheData"] != nil {
            //InsertYolo(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))
            // 把缓存的数据上传后得到地址存进去
        if flag {
            logger.Info("往ES插yolo数据")
            var sdkNames string = ""
            alarmRules := []AlarmRule{}
            url := []string{}
            for _, yoloResult := range msg.RuleResult["yolo"].([]ruleserver.Result) {
                if yoloResult.Others["timeLabel"].(string) == "01" || yoloResult.Others["timeLabel"].(string) == "10" {
                    // 拼出sdkname
                    sdkNames = sdkNames + yoloResult.SdkName
                    alarm := ChangeToString(yoloResult.DefenceState, yoloResult.AlarmLevel)
                    alarmRules = append(alarmRules, AlarmRule{yoloResult.RuleGroupId, alarm, yoloResult.RuleText,yoloResult.DefenceState})
                    // 上传缓存数据的图片拿到url
                    if yoloResult.Others["cacheData"] != nil {
                        //InsertYolo(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))
                        // 把缓存的数据上传后得到地址存进去
                        // 解压缩并上传图片
                        msgs :=yoloResult.Others["cacheData"].([]ruleserver.ResultMsg)
                        for _,msg1 := range msgs {
                            bdata, err := util.UnCompress(msg1.Data)
                            if err != nil {
                                panic("解压缩图片时出现错误")
                            }
                            i := protomsg.Image{}
                            err = proto.Unmarshal(bdata, &i)
                            resp1, err1 := util.DrawPolygonOnImage(msg1.Cid, i, msg1.RuleResult["yolo"].([]ruleserver.Result), weedfsUrl)
                            if err1 != nil {
                                logger.Error("缓存数据画框或上传图片服务器出错", err)
                            } else {
                                logger.Info("上传的图片信息：", resp1)
                            }
                            url = append(url, strings.Split(resp1["fileUrl"].(string), "/")[1])
                        }
                    }
                }
            }
            linkFlag := false
            for _, yoloResult := range msg.RuleResult["yolo"].([]ruleserver.Result) {
                if yoloResult.Others["timeLabel"].(string) == "01" || yoloResult.Others["timeLabel"].(string) == "10" && yoloResult.Others["linkCache"] != nil{
                    for _,msg2 := range yoloResult.Others["linkCache"].([]*ruleserver.ResultMsg) {
                        logger.Warn("插入联动数据")
                        InsertYolo(*msg2)
                        linkFlag = true
                    }
                }
            }
            if linkFlag {
                // 联动数据中包含本帧数据，插入联动数据后就不需要插入本帧数据了
                return
            }
            isAlarm := 0
            resp := make(map[string]interface{})
            // 解压缩并上传图片
            msgs := msg.RuleResult["cacheData"].([]ruleserver.ResultMsg)
            for _,msg1 := range msgs {
                bdata, err := util.UnCompress(msg1.Data)
                if err != nil {
                    panic("解压缩图片时出现错误")
                }
                i := protomsg.Image{}
                err = proto.Unmarshal(bdata, &i)
                resp1, err1 := util.DrawPolygonOnImage(msg1.Cid, i, msg1.RuleResult["yolo"].([]ruleserver.Result), weedfsUrl)
                if err1 != nil {
                    logger.Error("缓存数据画框或上传图片服务器出错", err)
                } else {
                    logger.Info("上传的图片信息：", resp1)
                }
                url = append(url, strings.Split(resp1["fileUrl"].(string), "/")[1])
            bdata, err := util.UnCompress(msg.Data)
            if err != nil {
                panic("解压缩图片时出现错误")
            }
        }
        url = append(url, strings.Split(resp["fileUrl"].(string), "/")[1])
        esDataId := uuid.NewV4().String()
        peraction := Personaction{
            esDataId,
            msg.Cid,
            camera.Name,
            camera.Addr,
            msg.Tasklab.Taskid,
            msg.Tasklab.Taskname,
            sdkNames,
            "",
            alarmRules,
            localConfig.ServerId,
            localConfig.ServerName,
            serverIp,
            "",
            url,
            i.Timestamp,
            "",
            isAlarm,
            0,
            0,
            0,
        }
        requstbody, err := json.Marshal(peraction)
            i := protomsg.Image{}
            err = proto.Unmarshal(bdata, &i)
            if len(alarmRules) > 0 {
                isAlarm = 1
                //resp, err = util.PostFormBufferData(weedfsUrl, i, uuid.NewV4().String())
                resp, err = util.DrawPolygonOnImage(msg.Cid, i, msg.RuleResult["yolo"].([]ruleserver.Result), weedfsUrl)
                if err != nil {
                    logger.Error("画框或上传图片服务器出错", err)
                } else {
                    logger.Info("上传的图片信息：", resp)
                }
            } else {
                isAlarm = 0
                // 不是报警数据不存
                return
            }
            // logger.Println("图片上传返回值：", resp)
            // 查询本机信息
            localConfig, err := cache.GetServerInfo()
            if err != nil {
                logger.Error("查询本机信息失败！")
            }
            // 查询cameraName
            camera, err := cache.GetCameraById(msg.Cid)
            if err != nil {
                logger.Error("查询摄像机信息失败")
            }
            serverIp, err := GetLocalIP()

        if err != nil {
            logger.Info("json parse error ", err)
            return
            url = append(url, strings.Split(resp["fileUrl"].(string), "/")[1])
            esDataId := uuid.NewV4().String()
            peraction := Personaction{
                esDataId,
                msg.Cid,
                camera.Name,
                camera.Addr,
                msg.Tasklab.Taskid,
                msg.Tasklab.Taskname,
                sdkNames,
                "",
                alarmRules,
                localConfig.ServerId,
                localConfig.ServerName,
                serverIp,
                "",
                url,
                i.Timestamp,
                "",
                isAlarm,
                0,
                0,
                0,
            }
            requstbody, err := json.Marshal(peraction)

        }
        resp1, err2 := EsReq("POST", personAction, requstbody)
        if err2 != nil {
            logger.Error("往ES插入数据失败", err)
            if err != nil {
                logger.Info("json parse error ", err)
                return

            }
            resp1, err2 := EsReq("POST", personAction, requstbody)
            if err2 != nil {
                logger.Error("往ES插入数据失败", err)
            } else {
                logger.Debug("插入es返回的数据信息是：", resp1)
                // 发出录像信号
                ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: esDataId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, ImgId: i.Id, SdkIds: []string{}, Type: 2})
                logger.Warn("__________________________________________往ES插入yolo数据成功")
                //os.Exit(1)
            }
        } else {
            logger.Debug("插入es返回的数据信息是：", resp1)
            // 发出录像信号
            ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: esDataId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, ImgId: i.Id, SdkIds: []string{}, Type: 2})
            logger.Warn("__________________________________________往ES插入yolo数据成功")
            //os.Exit(1)
            logger.Debug("timeLabel条件都不符合！" )
        }
    }
}

 ruleserver/ruleToformula.go

@@ -1,7 +1,6 @@
package ruleserver

import (
    "os"
    "ruleprocess/cache"
    "ruleprocess/logger"
    "sort"
@@ -71,12 +70,12 @@
    CameraId   string
    TaskId     string
    Sdkdata    []*SdkData
    RuleResult map[string]interface{} // 过完规则后打的标签 face: []FaceResult, yolo: []Result, cacheData: []ResultMsg, timeLabel: 0,1,2,3,4,5
    RuleResult map[string]interface{} // 过完规则后打的标签 face: []FaceResult, yolo: []Result
}

type ResultMsg struct {
    *protomsg.SdkMessage
    RuleResult map[string]interface{} // 过完规则后打的标签
    RuleResult map[string]interface{} // 过完规则后打的标签 face: []FaceResult, yolo: []Result
}

// 过规则库打上的标签
@@ -84,11 +83,12 @@
    TaskId       string // 任务id
    SdkName      string
    RuleGroupId  string // 规则组id
    DefenceState bool   //是否布防
    DefenceState bool   // 是否布防
    AlarmLevel   int32  // 报警等级
    RuleText     string // 文字版规则组
    Location     []Rect // 目标的坐标
    AlarmPolygon string // 触发的报警框
    Others         map[string]interface{} // cacheData: []ResultMsg,(本组规则中含有持续时间的规则开启的定时器缓存的数据帧)，linkCache: []ResultMsg ，timeLabel: 00,01,10,11,12
}

// 过规则库打上的标签
@@ -126,13 +126,14 @@
                taskId := taskGroup.TaskId
                //logger.Println("------------本组任务下的规则组的数量：",len(ruleList))
                temp := group.Rules // temp为一组完整规则 在此需要判断规则是否是联动规则
                label := make(map[string]interface{})
                if len(temp) > 0 {
                    if group.SetType == "linkTask" {
                        // groupId中含有link则为联动任务
                        LinkTask(args, group, taskId, message)
                        LinkTask(args, group, taskId, message,label)
                    } else {
                        // 独立任务的处理
                        RunRule(args, group, taskId, message)
                        RunRule(args, group, taskId, message,label)
                    }
                }
            }
@@ -140,7 +141,7 @@
    }
}

func RunRule(args *SdkDatas, groupRule *protomsg.GroupRule, taskId string, message *protomsg.SdkMessage) bool {
func RunRule(args *SdkDatas, groupRule *protomsg.GroupRule, taskId string, message *protomsg.SdkMessage,label map[string]interface{}) bool {
    defer func() {
        if err := recover(); err != nil {
            logger.Error("比对规则有误", err.(string))
@@ -211,7 +212,7 @@
            }
        }
    }
    // 这步过的是时间规则（时间段等）
    // 这步过的是时间段规则（时间段等）
    for j := 0; j < len(groupRule.Rules); j++ {
        for _, sdkData := range args.Sdkdata {
            sdk, err := cache.GetSdkById(groupRule.Rules[j].SdkId)
@@ -267,44 +268,6 @@
        result, _ := expression.Evaluate(nil) // 得到数学公式的结果

        if result.(bool) {
            // 最后成功报警才把符合条件的人脸数据塞进结果标签里
            // 配了人脸的算法才把人脸的数据甩出来打标签
            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,faces)...)
                    }
                }
            }
            //for _,face := range faces  {
            //    //logger.Debug("————————————————________________看看人脸的坐标:",face.Location)
            //}
            logger.Warn("___________________________________________________________________________终于走完万里长征")
            // 把他们的位置数据也传下去
            locations := []Rect{}
            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)...)
                    }
                }
            }
            //logger.Debug("------locations的内容：", locations)
            if sdkNames != "" {
                args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkNames, groupRule.GroupId,groupRule.DefenceState,groupRule.AlarmLevel, groupRule.GroupText, locations, polygonId})
                //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},faces})
                //logger.Info("-------------------face结果标签", len(args.RuleResult["face"].([]FaceResult)))
            }
            // 最后过持续时间等时间维度的条件   把时间规则位置调整到这个位置是为了缓存数据
            for j := 0; j < len(groupRule.Rules); j++ {
                for _, sdkData := range args.Sdkdata {
@@ -322,12 +285,52 @@
                }
            }
            // 进行定时器的处理和判断
            timeFlag := TimerAlarm(args, groupRule.GroupId, result.(bool))
            timeFlag := TimerAlarm(label, groupRule.GroupId, result.(bool))
            if timeFlag == "01" || timeFlag == "10" || timeFlag == "11" { // 满足定时器条件
                // 打人脸标签和yolo标签
                // 最后成功报警才把符合条件的人脸数据塞进结果标签里
                // 配了人脸的算法才把人脸的数据甩出来打标签
                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,faces)...)
                        }
                    }
                }
                //for _,face := range faces  {
                //    //logger.Debug("————————————————________________看看人脸的坐标:",face.Location)
                //}
                logger.Warn("___________________________________________________________________________终于走完万里长征")
                // 把他们的位置数据也传下去
                locations := []Rect{}
                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)...)
                        }
                    }
                }
                //logger.Debug("------locations的内容：", locations)
                if sdkNames != "" {
                    args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkNames, groupRule.GroupId,groupRule.DefenceState,groupRule.AlarmLevel, groupRule.GroupText, locations, polygonId,label})
                    //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,label},faces})
                    //logger.Info("-------------------face结果标签", len(args.RuleResult["face"].([]FaceResult)))
                }
                return true
            } else {
                return false
            }

        } else {
            // 结果为假时也要走，有时候为假的状态反转数据也需要记录下来
            //timeFlag := TimerAlarm(args, groupRule.GroupId, result.(bool))
@@ -371,7 +374,7 @@
}

// 联动任务的处理
func LinkTask(args *SdkDatas, groupRule *protomsg.GroupRule, taskId string, message *protomsg.SdkMessage) {
func LinkTask(args *SdkDatas, groupRule *protomsg.GroupRule, taskId string, message *protomsg.SdkMessage,label map[string]interface{}) {
    // new一个定时器，如果以此groupId为标志的定时器不存在的话
    logger.Info("------------------------------------------当前是联动任务，规则是：", groupRule.GroupText)
    var flag bool = true
@@ -401,7 +404,7 @@
        }
    }
    // 往数组里赋值
    isOk := RunRule(args, groupRule, taskId, message)
    isOk := RunRule(args, groupRule, taskId, message,label)
    if isOk {
        logger.Info("这帧图像在任务下的一整条规则下（联动任务下就是跟本摄像机像相关的小规则）的判断结果为true")
        // 根据cameraId去更新或者插入结果,然后判断是否数组是否可以得出报警的结论
@@ -436,12 +439,12 @@
                if result.(bool) {
                    logger.Info("___________________________________________________________________联动任务报警")
                    // 把数组里缓存的数据取出来一起报警
                    args.RuleResult["linkCache"] = []*ResultMsg{}
                    label["linkCache"] = []*ResultMsg{}
                    for _, ruleRes := range TimeEleList[groupRule.GroupId].RuleResults {
                        args.RuleResult["linkCache"] = append(args.RuleResult["linkCache"].([]*ResultMsg),ruleRes.CacheData)
                        label["linkCache"] = append(label["linkCache"].([]*ResultMsg),ruleRes.CacheData)
                    }
                    logger.Debug("联动任务缓存了几个数据",len(args.RuleResult["linkCache"].([]*ResultMsg)))
                    os.Exit(1)
                    logger.Debug("联动任务缓存了几个数据",len(label["linkCache"].([]*ResultMsg)))
                    //os.Exit(1)
                }
            }
        } else {

 ruleserver/timeTicker.go

@@ -69,7 +69,7 @@
}

// 判断是否符合定时器条件
func TimerAlarm(args *SdkDatas, groupId string, result bool) (string) {
func TimerAlarm(args map[string]interface{}, groupId string, result bool) (string) {
    var flagTime string //
    // 判断有无此规则组的定时器
    flag := false
@@ -82,19 +82,19 @@
    if flag { // 有定时器
        if result { // 结果为真
            for k, timeEle := range TimeEleList {
                if strings.Contains(k, groupId) {
                if strings.Contains(k, groupId) && k != groupId{
                    if timeEle.N == 0 && timeEle.AlarmFlag {
                        logger.Debug("-------------------------符合持续时间规则但并不是首次，不报警")
                        flagTime = "11"
                        args.RuleResult["timeLabel"] = flagTime
                        args["timeLabel"] = flagTime
                    }
                    if timeEle.N == 0 && !timeEle.AlarmFlag { // 这组规则的定时器要全部等于0   暂且认为一组规则只有一个定时器
                        logger.Debug("———————————-------------首次符合持续时间规则并报警")
                        flagTime = "10"
                        timeEle.AlarmFlag = true
                        args.RuleResult["cacheData"] = []ResultMsg{}
                        args.RuleResult["cacheData"] = append(args.RuleResult["cacheData"].([]ResultMsg),timeEle.CacheSdkData)
                        args.RuleResult["timeLabel"] = flagTime
                        args["cacheData"] = []ResultMsg{}
                        args["cacheData"] = append(args["cacheData"].([]ResultMsg),timeEle.CacheSdkData)
                        args["timeLabel"] = flagTime
                    }
                    if timeEle.N != 0 {
                        flagTime = "00"
@@ -111,7 +111,7 @@
                        if timeEle.BufferFlag == 0 {
                            logger.Debug("------------------------------杀死定时器，报警此帧状态改变的数据，此时的计数器的值为", timeEle.N)
                            flagTime = "12"
                            args.RuleResult["timeLabel"] = flagTime
                            args["timeLabel"] = flagTime
                            delete(TimeEleList, k)
                        } else {
                            if timeEle.BufferFlag > 0 {
@@ -127,7 +127,7 @@
    } else { // 无定时器
        if result {
            flagTime = "01"
            args.RuleResult["timeLabel"] = flagTime
            args["timeLabel"] = flagTime
        } else {
            flagTime = "00"
        }