---

panlei

2019-11-15 0e3b3f245284f493a81e38595c1bc3f812c84baf

---

 insertdata/insertDataToEs.go

@@ -510,195 +510,15 @@
}

// 插入目标持续时间数据
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["target"].([]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["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 {
                        // 去重添加
                        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["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{})
            // 解压缩并上传图片
            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["target"].([]structure.Result), weedfsUrl)
                if err != nil {
                    logger.Error("画框或上传图片服务器出错", err)
                    return
                } else {
                    logger.Info("上传的图片信息：", resp)
                }
            } else {
                isAlarm = 0
                // 不是报警数据不存
                return
            }
            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("解压缩图片时出现错误")
                    }
                    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)
                        }
                    }
                }
            }

        }
}

func InsertTarget(msg structure.ResultMsg) {
    if msg.RuleResult["target"] != nil && len(msg.RuleResult["target"].([]structure.Result)) > 0 {
        // 先判断一下数据带的规则标签是否有可以插入的
        logger.Info("插入定时目标信息：",len(msg.RuleResult["target"].([]structure.Result)))
        for _, yoloResult := range msg.RuleResult["target"].([]structure.Result) {
            for _, tar := range yoloResult.AlarmObj {
                // 装载目标信息
                logger.Info("报警目标个数：",len(yoloResult.AlarmObj))
                var target = new(Target)
                target.TargetId = strconv.FormatUint(tar.Id, 10)
                target.TargetScore = tar.Score

 ruleserver/ruleToformula.go

@@ -204,7 +204,7 @@
            }
            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)))
                logger.Info("-------------------目标持续结果标签", len(args.RuleResult["target"].([]structure.Result)))
                //labelTypes = append(labelTypes,2)
            }
            // 给持续时间的第一张赋予缓存数据（遍历复制）