新建目标数据存入方法

panlei

2019-11-15 72b7bd50772b4e9a466d5a7b30350639b61a9ffb

新建目标数据存入方法

 insertdata/insertDataToEs.go

@@ -180,6 +180,7 @@
    personAction = "http://" + localConfig1.AlarmIp + ":" + strconv.Itoa(int(localConfig1.AlarmPort)) + "/" + EsInfo.EsIndex.Personaction.IndexName + "/" + EsInfo.EsIndex.Personaction.IndexType
    InsertFace(msg)
    InsertYolo(msg)
    InsertTarget(msg)
}

// 往es中插入人脸数据
@@ -286,7 +287,7 @@
                } else {
                    logger.Info("插入es返回的信息(人脸)：", resp1)
                    // 发出录像信号
                    ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: face.Uuid, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, VideoUrl: msg.Push.VideoUrl, ImgId: i.Id, SdkIds: []string{}, Type: 1})
                    ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: face.Uuid, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, VideoUrl: msg.Push.VideoUrl, ImgId: i.Id, SdkIds: []string{"-1"}, Type: 1})
                }
            }
        }
@@ -350,12 +351,174 @@
            }
        }
        if flag {
            logger.Info("往ES插yolo数据")
                logger.Info("往ES插yolo数据")
                var sdkNames string = ""
                alarmRules := []AlarmRule{}
                var targetInfos []Target
                url := []string{}
                for _, yoloResult := range msg.RuleResult["yolo"].([]structure.Result) {
                    if yoloResult.Others.TimeLabel == "01" || yoloResult.Others.TimeLabel == "10" {
                        // 拼出sdkname
                        //logger.Info("应该进来才对的")
                        sdkNames = sdkNames + yoloResult.SdkName
                        alarm := ChangeToString(yoloResult.DefenceState, yoloResult.AlarmLevel)
                        linkInfo := ""
                        if yoloResult.IsLink {
                            linkInfo = "联动任务"
                        }
                        alarmRules = append(alarmRules, AlarmRule{yoloResult.RuleGroupId, alarm, yoloResult.RuleText, yoloResult.DefenceState, linkInfo})
                        // 上传缓存数据的图片拿到url
                        if yoloResult.Others.CacheData != nil {
                            //InsertYolo(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))
                            // 把缓存的数据上传后得到地址存进去
                            // 解压缩并上传图片
                            msgs := yoloResult.Others.CacheData
                            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.DrawPolygonOnImageForYolo(msg1.Cid, i, msg1.RuleResult["yolo"].([]structure.Result), weedfsUrl)
                                if err1 != nil {
                                    logger.Error("缓存数据画框或上传图片服务器出错", err)
                                } else {
                                    logger.Info("上传的图片信息：", resp1)
                                }
                                if resp1["fileUrl"] != nil {
                                    url = append(url, resp1["fileUrl"].(string))
                                }
                            }
                        }
                        // 装配目标信息数据
                        for _, target := range yoloResult.AlarmObj {
                            // 去重添加
                            var flag = true
                            for _, selectTarget := range targetInfos {
                                if strconv.FormatUint(target.Id, 10) == selectTarget.TargetId {
                                    flag = false
                                    break
                                }
                            }
                            if flag {
                                var target1 = new(Target)
                                target1.TargetId = strconv.FormatUint(target.Id, 10)
                                target1.TargetScore = target.Score
                                target1.TargetLocation = Points{TopLeft: Point{target.Location.X, target.Location.Y}, BottomRight: Point{target.Location.X + target.Location.Width, target.Location.Y + target.Location.Height}}
                                targetInfos = append(targetInfos, *target1)
                            }
                        }
                    }
                }
                // 联动图像的处理
                linkTagInfos := []*LinkInfo{}
                for _, yoloResult := range msg.RuleResult["yolo"].([]structure.Result) {
                    if (yoloResult.Others.TimeLabel == "01" || yoloResult.Others.TimeLabel == "10") && yoloResult.Others.LinkCache != nil && len(yoloResult.Others.LinkCache) > 1 {
                        for _, msg2 := range yoloResult.Others.LinkCache {
                            // 把msg2的数据装配成一个PerVideoPicture结构体
                            if msg2.Cid != msg.Cid {
                                linkTagInfos = append(linkTagInfos, msg2PersonVideo(msg2))
                            }
                        }
                    }
                }
                linkTag := ""
                if len(linkTagInfos) > 0 {
                    linkTag = "联动任务"
                }
                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.DrawPolygonOnImageForYolo(msg.Cid, i, msg.RuleResult["yolo"].([]structure.Result), weedfsUrl)
                    if err != nil {
                        logger.Error("画框或上传图片服务器出错", err)
                        return
                    } else {
                        logger.Info("上传的图片信息：", resp)
                    }
                } else {
                    isAlarm = 0
                    // 不是报警数据不存
                    return
                }
                if resp["fileUrl"] != nil {
                    url = append(url, resp["fileUrl"].(string))
                    //esDataId := uuid.NewV4().String()
                    peraction := Personaction{
                        msg.Push.PushId,
                        msg.Cid,
                        msg.Push.Cam.Name,
                        msg.Push.Cam.Addr,
                        msg.Tasklab.Taskid,
                        msg.Tasklab.Taskname,
                        sdkNames,
                        "",
                        alarmRules,
                        msg.Push.ServerId,
                        msg.Push.ServerName,
                        msg.Push.LocalIp,
                        "",
                        url,
                        i.Timestamp,
                        "",
                        isAlarm,
                        0,
                        0,
                        0,
                        targetInfos,
                        linkTag,
                        linkTagInfos,
                    }
                    requstbody, err := json.Marshal(peraction)

                    if len(linkTagInfos)>0 {
                        logger.Info("联动任务1111")
                    }
                    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返回的数据信息是（yolo）：", resp1)
                        // 发出录像信号
                        ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: msg.Push.PushId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, VideoUrl: msg.Push.VideoUrl, ImgId: i.Id, SdkIds: []string{"-1"}, Type: 2})
                        for index,link := range linkTagInfos {
                            logger.Info("联动任务的录像信号：",index)
                            ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: msg.Push.PushId, CameraId: link.CameraId, TaskId: msg.Tasklab.Taskid, VideoUrl: msg.Push.VideoUrl, ImgId: i.Id, SdkIds: []string{strconv.Itoa(index)}, Type: 2})
                        }
                        logger.Warn("__________________________________________往ES插入yolo数据成功")
                        //os.Exit(1)
                    }
                }
            }
        } else {
            logger.Debug("timeLabel条件都不符合！")
    }
}

// 插入目标持续时间数据
func InsertTarget1(msg structure.ResultMsg) {
    if msg.RuleResult["target"] != nil && len(msg.RuleResult["target"].([]structure.Result)) > 0 {
        // 先判断一下数据带的规则标签是否有可以插入的
            logger.Info("往ES插target数据")
            var sdkNames string = ""
            alarmRules := []AlarmRule{}
            var targetInfos []Target
            url := []string{}
            for _, yoloResult := range msg.RuleResult["yolo"].([]structure.Result) {
            //url := []string{}
            for _, yoloResult := range msg.RuleResult["target"].([]structure.Result) {
                if yoloResult.Others.TimeLabel == "01" || yoloResult.Others.TimeLabel == "10" {
                    // 拼出sdkname
                    //logger.Info("应该进来才对的")
@@ -367,29 +530,29 @@
                    }
                    alarmRules = append(alarmRules, AlarmRule{yoloResult.RuleGroupId, alarm, yoloResult.RuleText, yoloResult.DefenceState, linkInfo})
                    // 上传缓存数据的图片拿到url
                    if yoloResult.Others.CacheData != nil {
                        //InsertYolo(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))
                        // 把缓存的数据上传后得到地址存进去
                        // 解压缩并上传图片
                        msgs := yoloResult.Others.CacheData
                        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.DrawPolygonOnImageForYolo(msg1.Cid, i, msg1.RuleResult["yolo"].([]structure.Result), weedfsUrl)
                            if err1 != nil {
                                logger.Error("缓存数据画框或上传图片服务器出错", err)
                            } else {
                                logger.Info("上传的图片信息：", resp1)
                            }
                            if resp1["fileUrl"] != nil {
                                url = append(url, resp1["fileUrl"].(string))
                            }
                        }
                    }
                    //if yoloResult.Others.CacheData != nil {
                    //    //InsertYolo(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))
                    //    // 把缓存的数据上传后得到地址存进去
                    //    // 解压缩并上传图片
                    //    msgs := yoloResult.Others.CacheData
                    //    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.DrawPolygonOnImageForYolo(msg1.Cid, i, msg1.RuleResult["target"].([]structure.Result), weedfsUrl)
                    //        if err1 != nil {
                    //            logger.Error("缓存数据画框或上传图片服务器出错", err)
                    //        } else {
                    //            logger.Info("上传的图片信息：", resp1)
                    //        }
                    //        if resp1["fileUrl"] != nil {
                    //            url = append(url, resp1["fileUrl"].(string))
                    //        }
                    //    }
                    //}
                    // 装配目标信息数据
                    for _, target := range yoloResult.AlarmObj {
                        // 去重添加
@@ -410,9 +573,9 @@
                    }
                }
            }

            // 联动图像的处理
            linkTagInfos := []*LinkInfo{}
            for _, yoloResult := range msg.RuleResult["yolo"].([]structure.Result) {
            for _, yoloResult := range msg.RuleResult["target"].([]structure.Result) {
                if (yoloResult.Others.TimeLabel == "01" || yoloResult.Others.TimeLabel == "10") && yoloResult.Others.LinkCache != nil && len(yoloResult.Others.LinkCache) > 1 {
                    for _, msg2 := range yoloResult.Others.LinkCache {
                        // 把msg2的数据装配成一个PerVideoPicture结构体
@@ -438,7 +601,7 @@
            if len(alarmRules) > 0 {
                isAlarm = 1
                //resp, err = util.PostFormBufferData(weedfsUrl, i, uuid.NewV4().String())
                resp, err = util.DrawPolygonOnImageForYolo(msg.Cid, i, msg.RuleResult["yolo"].([]structure.Result), weedfsUrl)
                resp, err = util.DrawPolygonOnImageForYolo(msg.Cid, i, msg.RuleResult["target"].([]structure.Result), weedfsUrl)
                if err != nil {
                    logger.Error("画框或上传图片服务器出错", err)
                    return
@@ -450,64 +613,214 @@
                // 不是报警数据不存
                return
            }
            if resp["fileUrl"] != nil {
                url = append(url, resp["fileUrl"].(string))
                //esDataId := uuid.NewV4().String()
                peraction := Personaction{
                    msg.Push.PushId,
                    msg.Cid,
                    msg.Push.Cam.Name,
                    msg.Push.Cam.Addr,
                    msg.Tasklab.Taskid,
                    msg.Tasklab.Taskname,
                    sdkNames,
                    "",
                    alarmRules,
                    msg.Push.ServerId,
                    msg.Push.ServerName,
                    msg.Push.LocalIp,
                    "",
                    url,
                    i.Timestamp,
                    "",
                    isAlarm,
                    0,
                    0,
                    0,
                    targetInfos,
                    linkTag,
                    linkTagInfos,
                }
                requstbody, err := json.Marshal(peraction)

                if len(linkTagInfos)>0 {
                    logger.Info("联动任务1111")
                }
                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返回的数据信息是（yolo）：", resp1)
                    // 发出录像信号
                    ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: msg.Push.PushId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, VideoUrl: msg.Push.VideoUrl, ImgId: i.Id, SdkIds: []string{"-1"}, Type: 2})
                    for index,link := range linkTagInfos {
                        logger.Info("联动任务的录像信号：",index)
                        ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: msg.Push.PushId, CameraId: link.CameraId, TaskId: msg.Tasklab.Taskid, VideoUrl: msg.Push.VideoUrl, ImgId: i.Id, SdkIds: []string{strconv.Itoa(index)}, Type: 2})
            for _, yoloResult := range msg.RuleResult["target"].([]structure.Result) {
                for _, yolo := range yoloResult.AlarmObj {
                    //InsertYolo(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))
                    // 把缓存的数据上传后得到地址存进去
                    // 解压缩并上传图片
                    urls := []string{}
                    msg1 := yolo.CacheData
                    bdata, err := util.UnCompress(msg1.Data)
                    if err != nil {
                        panic("解压缩图片时出现错误")
                    }
                    logger.Warn("__________________________________________往ES插入yolo数据成功")
                    //os.Exit(1)
                    i := protomsg.Image{}
                    err = proto.Unmarshal(bdata, &i)
                    resp1, err1 := util.DrawPolygonOnImageForYolo(msg1.Cid, i, msg1.RuleResult["target"].([]structure.Result), weedfsUrl)
                    if err1 != nil {
                        logger.Error("缓存数据画框或上传图片服务器出错", err)
                    } else {
                        logger.Info("上传的图片信息：", resp1)
                    }
                    if resp1["fileUrl"] != nil {
                        urls = append(urls, resp1["fileUrl"].(string))
                    }
                    if resp["fileUrl"] != nil {
                        urls = append(urls, resp["fileUrl"].(string))
                        //esDataId := uuid.NewV4().String()
                        peraction := Personaction{
                            msg.Push.PushId,
                            msg.Cid,
                            msg.Push.Cam.Name,
                            msg.Push.Cam.Addr,
                            msg.Tasklab.Taskid,
                            msg.Tasklab.Taskname,
                            sdkNames,
                            "",
                            alarmRules,
                            msg.Push.ServerId,
                            msg.Push.ServerName,
                            msg.Push.LocalIp,
                            "",
                            urls,
                            i.Timestamp,
                            "",
                            isAlarm,
                            0,
                            0,
                            0,
                            targetInfos,
                            linkTag,
                            linkTagInfos,
                        }
                        requstbody, err := json.Marshal(peraction)

                        if len(linkTagInfos)>0 {
                            logger.Info("联动任务1111")
                        }
                        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返回的数据信息是（target）：", resp1)
                            // 发出录像信号
                            ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: msg.Push.PushId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, VideoUrl: msg.Push.VideoUrl, ImgId: i.Id, SdkIds: []string{"-1"}, Type: 2})
                            for index,link := range linkTagInfos {
                                logger.Info("联动任务的录像信号：",index)
                                ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: msg.Push.PushId, CameraId: link.CameraId, TaskId: msg.Tasklab.Taskid, VideoUrl: msg.Push.VideoUrl, ImgId: i.Id, SdkIds: []string{strconv.Itoa(index)}, Type: 2})
                            }
                            logger.Warn("__________________________________________往ES插入yolo数据成功")
                            //os.Exit(1)
                        }
                    }
                }
            }
        } else {
            logger.Debug("timeLabel条件都不符合！")

        }
}

func InsertTarget(msg structure.ResultMsg) {
    if msg.RuleResult["target"] != nil && len(msg.RuleResult["target"].([]structure.Result)) > 0 {
        // 先判断一下数据带的规则标签是否有可以插入的
        for _, yoloResult := range msg.RuleResult["target"].([]structure.Result) {
            for _, tar := range yoloResult.AlarmObj {
                // 装载目标信息
                var target = new(Target)
                target.TargetId = strconv.FormatUint(tar.Id, 10)
                target.TargetScore = tar.Score
                target.TargetLocation = Points{TopLeft: Point{tar.Location.X, tar.Location.Y}, BottomRight: Point{tar.Location.X + tar.Location.Width, tar.Location.Y + tar.Location.Height}}
                //logger.Info("人脸的id:",strconv.FormatUint(face.Id, 10))
                var targetInfos []Target
                targetInfos = append(targetInfos, *target)
                // 获取目标缓存图片
                url := []string{}
                //InsertYolo(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))
                // 把缓存的数据上传后得到地址存进去
                // 解压缩并上传图片
                url1 := uploadImg(tar.CacheData)
                url = append(url,url1)
                // 添加报警规则组
                sdkNames := ""
                alarmRules := []AlarmRule{}
                sdkNames = sdkNames + yoloResult.SdkName
                alarm := ChangeToString(yoloResult.DefenceState, yoloResult.AlarmLevel)
                linkInfo := ""
                if yoloResult.IsLink {
                    linkInfo = "联动任务"
                }
                alarmRules = append(alarmRules, AlarmRule{yoloResult.RuleGroupId, alarm, yoloResult.RuleText, yoloResult.DefenceState, linkInfo})
                // 联动图像的处理
                linkTagInfos := []*LinkInfo{}
                for _, yoloResult := range msg.RuleResult["target"].([]structure.Result) {
                    if (yoloResult.Others.TimeLabel == "01" || yoloResult.Others.TimeLabel == "10") && yoloResult.Others.LinkCache != nil && len(yoloResult.Others.LinkCache) > 1 {
                        for _, msg2 := range yoloResult.Others.LinkCache {
                            // 把msg2的数据装配成一个PerVideoPicture结构体
                            if msg2.Cid != msg.Cid {
                                linkTagInfos = append(linkTagInfos, msg2PersonVideo(msg2))
                            }
                        }
                    }
                }
                linkTag := ""
                if len(linkTagInfos) > 0 {
                    linkTag = "联动任务"
                }
                isAlarm := 0
                resp := make(map[string]interface{})
                // 解压缩并上传本帧数据图片
                bdata1, err := util.UnCompress(msg.Data)
                if err != nil {
                    panic("解压缩图片时出现错误")
                }
                i := protomsg.Image{}
                err = proto.Unmarshal(bdata1, &i)
                if len(alarmRules) > 0 {
                    isAlarm = 1
                    //resp, err = util.PostFormBufferData(weedfsUrl, i, uuid.NewV4().String())
                    resp, err = util.DrawPolygonOnImageForYolo(msg.Cid, i, msg.RuleResult["target"].([]structure.Result), weedfsUrl)
                    if err != nil {
                        logger.Error("画框或上传图片服务器出错", err)
                        return
                    } else {
                        logger.Info("上传的图片信息：", resp)
                    }
                } else {
                    isAlarm = 0
                    // 不是报警数据不存
                    return
                }
                if resp["fileUrl"] != nil {
                    url = append(url, resp["fileUrl"].(string))
                    //esDataId := uuid.NewV4().String()
                    peraction := Personaction{
                        tar.Uuid,
                        msg.Cid,
                        msg.Push.Cam.Name,
                        msg.Push.Cam.Addr,
                        msg.Tasklab.Taskid,
                        msg.Tasklab.Taskname,
                        sdkNames,
                        "",
                        alarmRules,
                        msg.Push.ServerId,
                        msg.Push.ServerName,
                        msg.Push.LocalIp,
                        "",
                        url,
                        i.Timestamp,
                        "",
                        isAlarm,
                        0,
                        0,
                        0,
                        targetInfos,
                        linkTag,
                        linkTagInfos,
                    }
                    requstbody, err := json.Marshal(peraction)

                    if len(linkTagInfos)>0 {
                        logger.Info("联动任务1111")
                    }
                    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返回的数据信息是（target）：", resp1)
                        // 发出录像信号
                        ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: msg.Push.PushId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, VideoUrl: msg.Push.VideoUrl, ImgId: i.Id, SdkIds: []string{"-1"}, Type: 2})
                        for index,link := range linkTagInfos {
                            logger.Info("联动任务的录像信号：",index)
                            ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: msg.Push.PushId, CameraId: link.CameraId, TaskId: msg.Tasklab.Taskid, VideoUrl: msg.Push.VideoUrl, ImgId: i.Id, SdkIds: []string{strconv.Itoa(index)}, Type: 2})
                        }
                        logger.Warn("__________________________________________往ES插入target数据成功")
                        //os.Exit(1)
                    }
                }


            }
        }
    }
}

// 获取本机ip
func GetLocalIP() (ipv4 string, err error) {
    var (
@@ -562,6 +875,25 @@
    return alarm
}

func uploadImg(msg structure.ResultMsg) string{
    bdata, err := util.UnCompress(msg.Data)
    if err != nil {
        panic("解压缩图片时出现错误")
    }
    i := protomsg.Image{}
    err = proto.Unmarshal(bdata, &i)
    resp1, err1 := util.DrawPolygonOnImageForYolo(msg.Cid, i, msg.RuleResult["target"].([]structure.Result), weedfsUrl)
    if err1 != nil {
        logger.Error("缓存数据画框或上传图片服务器出错", err)
    } else {
        logger.Info("上传的图片信息：", resp1)
    }
    if resp1["fileUrl"] != nil {
        return resp1["fileUrl"].(string)
    } else {
        return ""
    }
}
//获取年龄描述
func getDescription(age int32) string {
    ageInfo := "青年"

 ruleserver/ruleToformula.go

@@ -175,16 +175,16 @@
            }
            logger.Debug("------locations的内容：", yolos)
            // 处理目标定时数据
            //targets := []*structure.Arg{}
            //for _, sdkData := range args.Sdkdata {
            //    if sdkData.IpcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && sdkNames != "" { // 把yolo数据的各个目标的坐标输出方便后面画框
            //        for _, areaMap := range sdkData.AreaMapList {
            //            if areaMap.IsEffective {
            //                yolos = append(yolos, putTargetsToResult(areaMap)...)
            //            }
            //        }
            //    }
            //}
            targets := []*structure.Arg{}
            for _, sdkData := range args.Sdkdata {
                if sdkData.IpcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && sdkNames != "" { // 把yolo数据的各个目标的坐标输出方便后面画框
                    for _, areaMap := range sdkData.AreaMapList {
                        if areaMap.IsEffective {
                            targets = append(targets, putTargetsToResult(areaMap)...)
                        }
                    }
                }
            }
            var islink bool
            if groupRule.SetType == "linkTask" {
                islink = true
@@ -202,11 +202,11 @@
                //logger.Info("-------------------face结果标签", len(args.RuleResult["face"].([]FaceResult)))
                labelTypes = append(labelTypes,1)
            }
            //if len(targets) > 0 {
            //    args.RuleResult["target"] = append(args.RuleResult["target"].([]structure.Result), structure.Result{taskId, sdkNames, groupRule.GroupId, groupRule.DefenceState, groupRule.AlarmLevel, groupRule.GroupText, targets, polygonId, islink,label})
            //    //logger.Info("-------------------目标持续结果标签", len(args.RuleResult["face"].([]FaceResult)))
            //    //labelTypes = append(labelTypes,2)
            //}
            if len(targets) > 0 {
                args.RuleResult["target"] = append(args.RuleResult["target"].([]structure.Result), structure.Result{taskId, sdkNames, groupRule.GroupId, groupRule.DefenceState, groupRule.AlarmLevel, groupRule.GroupText, targets, polygonId, islink,label})
                //logger.Info("-------------------目标持续结果标签", len(args.RuleResult["face"].([]FaceResult)))
                //labelTypes = append(labelTypes,2)
            }
            // 给持续时间的第一张赋予缓存数据（遍历复制）
            if cacheId != "" { // 有这帧数据的缓存
                tempMap := make(map[string]interface{})