一帧数据只做一个任务

panlei

2019-07-15 964418cf0fb7b143d16529d879968d7c8381f6f2

一帧数据只做一个任务

 main.go

@@ -106,6 +106,7 @@
        panic("解析msg时出现错误")
    }
    args.CameraId = m.Cid
    args.TaskId = m.Tasklab.Taskid
    // 把图片的二进制解压缩进行画框在压缩回去
    bdata, err := util.UnCompress(m.Data)
    if err != nil {

 ruleserver/readyDataForRule.go

@@ -31,9 +31,15 @@
    Content string `json:"content"`
}
// 以摄像机id查出跟其相关的所有任务下的所有规则组
func GetRuleGroup(cameraId string) []*protomsg.TaskGroupArgs {
func GetRuleGroup(cameraId string,taskId string) *protomsg.TaskGroupArgs {
    all := cache.GetCameraTaskRulesByCameraId(cameraId)
    return all
    var taskGroup  *protomsg.TaskGroupArgs
    for _,task := range all  {
        if task.TaskId == taskId {
            taskGroup = task
        }
    }
    return taskGroup
}
// 根据摄像机id拿到摄像机所有区域
func GetPolygons(cameraId string) []protomsg.CameraPolygon {
@@ -112,7 +118,7 @@

// 给目标填充liker
func (arg *Arg) fillLiker() {
    bytes := sdkcompare.GetComparePersonBaseInfo(nil, arg.Feature, 70)
    bytes := sdkcompare.GetComparePersonBaseInfo(nil, arg.Feature, 40)
    var m map[string]float32
    err1 := json.Unmarshal(bytes, &m)
    if err1 != nil {

 ruleserver/ruleToformula.go

@@ -69,6 +69,7 @@
// 从算法模块儿拿来的对一帧图像各个算法提取的数据集合
type SdkDatas struct {
    CameraId   string
    TaskId     string
    Sdkdata    []*SdkData
    RuleResult map[string]interface{} // 过完规则后打的标签 face: []Arg, yolo: []Result, cacheData: SdkDatas, timeLabel: 0,1,2,3,4,5
}
@@ -95,7 +96,7 @@
}

// 对单帧图像的判断 thisSdkDatas  当前传入的这帧数据，cacheSdkData 定时器里缓存的一帧数据 没有就返回nil  (thisSdkDatas SdkDatas, cacheSdkDatas SdkDatas)
func Judge(args *SdkDatas,message *protomsg.SdkMessage) {
func Judge(args *SdkDatas, message *protomsg.SdkMessage) {
    if len(args.Sdkdata) > 0 {
        // 拿到本摄像机的区域
        cameraPolygons := GetPolygons(args.CameraId)
@@ -104,36 +105,31 @@
            SdkDataFormat(args.CameraId, arg, cameraPolygons)
        }
        // 跑本摄像机的所有规则组 一组一组跑
        taskRuleList := GetRuleGroup(args.CameraId) // 本摄像机下所有任务组
        taskGroup := GetRuleGroup(args.CameraId, args.TaskId) // 本摄像机下所有任务组
        //logger.Println("看下摄像机下的任务组：",taskRuleList)
        // 得到属于该摄像机的若干组任务的完整规则（跟每一条完整规则比较之后得出本张图像对于某个规则是否报警的结果。放进map，比如本帧图像的id，所碰撞成功的规则id）
        args.RuleResult = make(map[string]interface{})
        args.RuleResult["yolo"] = []Result{}
        args.RuleResult["face"] = []Arg{}
        if len(taskRuleList) > 0 {
            for _, taskRule := range taskRuleList {
                //logger.Println("------------------------------任务规则：",taskRule)
                ruleList := taskRule.GroupRules // 获取的是task下面的任务组
                taskId := taskRule.TaskId
                //logger.Println("------------本组任务下的规则组的数量：",len(ruleList))
                for i := 0; i < len(ruleList); i++ {
                    temp := ruleList[i].Rules // temp为一组完整规则 在此需要判断规则是否是联动规则
                    if len(temp) > 0 {
                        if ruleList[i].SetType == "linkTask" {
                            // groupId中含有link则为联动任务
                            LinkTask(args, ruleList[i], taskId,message)
                        } else {
                            // 独立任务的处理
                            RunRule(args, ruleList[i], taskId,message)
                        }
                    }
        for _, group := range taskGroup.GroupRules {
            //logger.Println("------------------------------任务规则：",taskRule)
            taskId := taskGroup.TaskId
            //logger.Println("------------本组任务下的规则组的数量：",len(ruleList))
            temp := group.Rules // temp为一组完整规则 在此需要判断规则是否是联动规则
            if len(temp) > 0 {
                if group.SetType == "linkTask" {
                    // groupId中含有link则为联动任务
                    LinkTask(args, group, taskId, message)
                } else {
                    // 独立任务的处理
                    RunRule(args, group, taskId, message)
                }
            }
        }
    }
}

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) bool {
    defer func() {
        if err := recover(); err != nil {
            logger.Error("比对规则有误", err.(string))
@@ -157,9 +153,9 @@
            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)
                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)
@@ -292,9 +288,9 @@
                    }
                }
            }
            logger.Debug("------locations的内容：",locations)
            logger.Debug("------locations的内容：", locations)
            if sdkNames != "" {
                args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkNames, groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, locations,polygonId})
                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 {
@@ -311,13 +307,13 @@
                    if ipcId == sdkData.IpcId {
                        for _, areaMap := range sdkData.AreaMapList {
                            // 去开启一个定时器
                            duration(groupRule.Rules[j], groupRule.GroupId, areaMap, args,message)
                            duration(groupRule.Rules[j], groupRule.GroupId, areaMap, args, message)
                        }
                    }
                }
            }
            // 进行定时器的处理和判断
            timeFlag := TimerAlarm(args,groupRule.GroupId,result.(bool))
            timeFlag := TimerAlarm(args, groupRule.GroupId, result.(bool))
            if timeFlag == "01" || timeFlag == "10" || timeFlag == "11" { // 满足定时器条件
                return true
            } else {
@@ -325,7 +321,7 @@
            }
        } else {
            // 结果为假时也要走，有时候为假的状态反转数据也需要记录下来
            timeFlag := TimerAlarm(args,groupRule.GroupId,result.(bool))
            timeFlag := TimerAlarm(args, groupRule.GroupId, result.(bool))
            fmt.Println(timeFlag)
            return false
        }
@@ -333,7 +329,6 @@
        return false
    }
}


func putFaceToResult(am *AreaMap) []Arg {
    faces := []Arg{}
@@ -359,7 +354,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) {
    // new一个定时器，如果以此groupId为标志的定时器不存在的话
    logger.Info("------------------------------------------当前是联动任务，规则是：", groupRule.GroupText)
    var flag bool = true
@@ -389,7 +384,7 @@
        }
    }
    // 往数组里赋值
    isOk := RunRule(args, groupRule, taskId,message)
    isOk := RunRule(args, groupRule, taskId, message)
    if isOk {
        logger.Info("这帧图像在任务下的一整条规则下（联动任务下就是跟本摄像机像相关的小规则）的判断结果为true")
        // 根据cameraId去更新或者插入结果,然后判断是否数组是否可以得出报警的结论
@@ -422,7 +417,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)))
@@ -452,7 +447,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" && rule.SdkArgAlias != "compareBase"{
            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("规则配置的阈值非法")
@@ -548,7 +543,7 @@
                }
                // 先清空过滤后的数据，再往里塞本次过滤后的数据
                am.filterData = am.filterData[0:0]
                logger.Debug("看看args：：：：：",args)
                logger.Debug("看看args：：：：：", args)
                for _, arg := range args {
                    var formula string
                    if rule.SdkArgAlias == "score" {
@@ -585,7 +580,7 @@
}

// 如果有持续时间条件维护开启一个定时器
func duration(rule *protomsg.Rule, groupId string, am *AreaMap, args *SdkDatas,message *protomsg.SdkMessage) {
func duration(rule *protomsg.Rule, groupId string, am *AreaMap, args *SdkDatas, message *protomsg.SdkMessage) {
    if rule.PolygonId == am.areaId { // 首先规则所对应的区域id要跟区域数据的id对的上  配置的算法要对的上
        if rule.SdkArgAlias == "duration" { //
            // 先看看定时器元素队列中是否有这个摄像机这个区域的定时器,如果有就不能再次创建了
@@ -599,7 +594,7 @@

            if flag {
                timeLength, _ := strconv.Atoi(rule.SdkArgValue)
                timeEle := TimeElement{N: timeLength, InitN: timeLength, AlarmFlag: false,BufferFlag:10, CacheSdkData: ResultMsg{message,args.RuleResult}} // 扔进去一个定时器元素（并缓存当前画面帧数据）
                timeEle := TimeElement{N: timeLength, InitN: timeLength, AlarmFlag: false, BufferFlag: 10, CacheSdkData: ResultMsg{message, args.RuleResult}} // 扔进去一个定时器元素（并缓存当前画面帧数据）
                //TimeEleList = make(map[string]timeElement)
                TimeEleList[groupId+" "+rule.Id] = &timeEle // 定时器元素以摄像机id拼接区域id为键
                logger.Info("创建了计数器并且计数器集合为：", TimeEleList)
@@ -700,5 +695,3 @@
    }
    return LittleRuleResult{}
}