追踪

panlei

2019-07-27 29ec0580c1300d63ccb0f9fcf491515f4fa1fc23

追踪

 insertdata/insertDataToEs.go

@@ -104,9 +104,10 @@
}

type AlarmRule struct {
    GroupId    string `json:"groupId"`
    AlarmLevel string `json:"alarmLevel"`
    RuleText   string `json:"ruleText"`
    GroupId      string `json:"groupId"`
    AlarmLevel   string `json:"alarmLevel"`
    RuleText     string `json:"ruleText"`
    DefenceState bool   `json:"defenceState"`
}

// 往ES插数据
@@ -145,8 +146,8 @@
                    panic("解压缩图片时出现错误")
                }
                alarmRules := []AlarmRule{}
                alarm := ChangeToString(faceResult.DefenceState,faceResult.AlarmLevel)
                alarmRules = append(alarmRules, AlarmRule{faceResult.RuleGroupId, alarm, faceResult.RuleText})
                alarm := ChangeToString(faceResult.DefenceState, faceResult.AlarmLevel)
                alarmRules = append(alarmRules, AlarmRule{faceResult.RuleGroupId, alarm, faceResult.RuleText,faceResult.DefenceState})
                i := protomsg.Image{}
                err = proto.Unmarshal(bdata, &i)
                bigPhotoUrl := make(map[string]interface{})
@@ -222,7 +223,7 @@
                } else {
                    logger.Info("插入es返回的信息：", resp1)
                    // 发出录像信号
                    ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: esDataId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, ImgId: i.Id, SdkIds: []string{}, Type:1})
                    ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: esDataId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, ImgId: i.Id, SdkIds: []string{}, Type: 1})
                }
            }
        }
@@ -299,7 +300,7 @@
    } else {
        logger.Info("插入es返回的信息：", resp1)
        // 发出录像信号
        ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: esDataId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, ImgId: i.Id, SdkIds: []string{}, Type:1 })
        ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: esDataId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, ImgId: i.Id, SdkIds: []string{}, Type: 1})
    }
    //if msg.RuleResult["cacheData"] != nil {
    //    InsertFace(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))
@@ -314,8 +315,8 @@
        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})
            alarm := ChangeToString(yoloResult.DefenceState, yoloResult.AlarmLevel)
            alarmRules = append(alarmRules, AlarmRule{yoloResult.RuleGroupId, alarm, yoloResult.RuleText,yoloResult.DefenceState})
        }
        isAlarm := 0
        resp := make(map[string]interface{})
@@ -409,7 +410,7 @@
        } 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 })
            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)
        }
@@ -480,7 +481,7 @@
    } else {
        logger.Info("插入es返回的信息：", resp1)
        // 发出录像信号
        ruleserver.AddLxMessage(&protomsg.VideotapeInfo{EsDataId: esDataId, CameraId: msg.Cid, TaskId: msg.Tasklab.Taskid, ImgId: i.Id, SdkIds: []string{}, Type:2 })
        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)
    }
@@ -515,7 +516,7 @@
}

// 把报警等级转化成汉字
func ChangeToString(defenceState bool,i int32) string {
func ChangeToString(defenceState bool, i int32) string {
    alarm := ""
    if defenceState {
        if i == 1 {

 ruleserver/personTrack.go

@@ -9,86 +9,86 @@
var TrackPond = make(map[string]*PersonTrack)

type PersonTrack struct {
    Face  int // 人脸的id数组  改为数量
    Yolo  int // yolo对象的id数组 改为数量
    Face int // 人脸的id数组  改为数量
    Yolo int // yolo对象的id数组 改为数量
}

// 检查是否前后两次的数据id是否完全相同（人脸和yolo）     改为直接检查数量是否一致
func IsSame(msg *protomsg.SdkMessage) {
    logger.Debug("+++++++++++++++++++++追踪开始+++++++++++++++摄像机id为：",msg.Cid)
    logger.Debug("---------------------缓存池--------------------------：",TrackPond)
    logger.Debug("+++++++++++++++++++++追踪开始+++++++++++++++摄像机id为：", msg.Cid)
    logger.Debug("---------------------缓存池--------------------------：", TrackPond)
    for _, sdkinfo := range msg.Tasklab.Sdkinfos { // 遍历各算法的sdkData
        if sdkinfo.Sdktype == "FaceDetect" { // 人脸检测
            if len(sdkinfo.Sdkdata) > 1 {
                faceParam := protomsg.ParamFacePos{}
                err := proto.Unmarshal(sdkinfo.Sdkdata, &faceParam)
                if err != nil {
                    logger.Info("解析face sdk数据时出现错误", err)
                    continue
                }
                if TrackPond[msg.Cid] != nil {
                    logger.Info("================追踪之前人脸的个数：",len(faceParam.Faces),"现在缓存池中记录的个数：",TrackPond[msg.Cid].Face)
                } else {
                    logger.Info("================追踪之前人脸的个数：",len(faceParam.Faces),"还没有这个摄像机的缓存")
                }
                if faceParam.Faces != nil && TrackPond[msg.Cid] != nil  && len(faceParam.Faces) == TrackPond[msg.Cid].Face { // yolo的如果数量相同则视为不变、把yolo的sdkData清空
                    faceParam.Faces = (faceParam.Faces)[0:0]
                    sdkinfo.Sdkdata,err = proto.Marshal(&faceParam)
                    if err != nil {
                        logger.Error("人脸序列化错误",err)
                    }
                    logger.Info("===================追踪中途人脸的个数",len(faceParam.Faces))
                } else {
                    if TrackPond[msg.Cid] != nil {
                        logger.Info("更新当前摄像机缓存池中的人脸个数：",len(faceParam.Faces))
                        TrackPond[msg.Cid].Face = len(faceParam.Faces)
                    } else {
                        logger.Info("新建当前摄像机缓存池中的人脸个数：",len(faceParam.Faces))
                        TrackPond[msg.Cid] = &PersonTrack{Face:len(faceParam.Faces)}
                    }
                }
            } else {
            //if len(sdkinfo.Sdkdata) > 1 {
            faceParam := protomsg.ParamFacePos{}
            err := proto.Unmarshal(sdkinfo.Sdkdata, &faceParam)
            if err != nil {
                logger.Info("解析face sdk数据时出现错误", err)
                continue
            }
            if TrackPond[msg.Cid] != nil {
                logger.Info("================追踪之前人脸的个数：", len(faceParam.Faces), "现在缓存池中记录的个数：", TrackPond[msg.Cid].Face)
            } else {
                logger.Info("================追踪之前人脸的个数：", len(faceParam.Faces), "还没有这个摄像机的缓存")
            }
            if faceParam.Faces != nil && TrackPond[msg.Cid] != nil && len(faceParam.Faces) == TrackPond[msg.Cid].Face { // yolo的如果数量相同则视为不变、把yolo的sdkData清空
                faceParam.Faces = (faceParam.Faces)[0:0]
                sdkinfo.Sdkdata, err = proto.Marshal(&faceParam)
                if err != nil {
                    logger.Error("人脸序列化错误", err)
                }
                logger.Info("===================追踪中途人脸的个数", len(faceParam.Faces))
            } else {
                if TrackPond[msg.Cid] != nil {
                    logger.Info("更新当前摄像机缓存池中的人脸个数：", len(faceParam.Faces))
                    TrackPond[msg.Cid].Face = len(faceParam.Faces)
                } else {
                    logger.Info("新建当前摄像机缓存池中的人脸个数：", len(faceParam.Faces))
                    TrackPond[msg.Cid] = &PersonTrack{Face: len(faceParam.Faces)}
                }
            }
            //} else {
            //    continue
            //}
        }
        if sdkinfo.Sdktype == "Yolo" {
            if len(sdkinfo.Sdkdata) > 1 {
                yoloParam := protomsg.ParamYoloObj{}
                err := proto.Unmarshal(sdkinfo.Sdkdata, &yoloParam)
                if err != nil {
                    logger.Info("解析yolo数据时出现错误", err)
                    continue
                }
                var yoloNum int = 0
                for i := 0;i < len(yoloParam.Infos); i++ {
                    if yoloParam.Infos[i].Typ == 0 {
                        yoloNum++
                    }
                }
                if TrackPond[msg.Cid] != nil {
                    logger.Info("================追踪之前yolo的个数：",yoloNum,"现在缓存池中记录的个数：",TrackPond[msg.Cid].Yolo)
                } else {
                    logger.Info("================追踪之前yolo的个数：",yoloNum,"还没有这个摄像机的缓存")
                }
                if yoloParam.Infos != nil && TrackPond[msg.Cid] != nil && yoloNum == TrackPond[msg.Cid].Yolo { // yolo的如果数量相同则视为不变、把yolo的sdkData清空
                    yoloParam.Infos = (yoloParam.Infos)[0:0]
                    sdkinfo.Sdkdata,err = proto.Marshal(&yoloParam)
                    if err != nil {
                        logger.Error("yolo序列化错误",err)
                    }
                    logger.Info("跟之前相同，清空yolo数据")
                } else {
                    if TrackPond[msg.Cid] != nil {
                        logger.Info("更新当前摄像机缓存池中的yolo个数：",yoloNum)
                        TrackPond[msg.Cid].Yolo = yoloNum
                    } else {
                        logger.Info("新建当前摄像机缓存池中的yolo个数：",yoloNum)
                        TrackPond[msg.Cid] = &PersonTrack{Yolo:yoloNum}
                    }
                }
            } else {
            //if len(sdkinfo.Sdkdata) > 1 {
            yoloParam := protomsg.ParamYoloObj{}
            err := proto.Unmarshal(sdkinfo.Sdkdata, &yoloParam)
            if err != nil {
                logger.Info("解析yolo数据时出现错误", err)
                continue
            }
            var yoloNum int = 0
            for i := 0; i < len(yoloParam.Infos); i++ {
                if yoloParam.Infos[i].Typ == 0 {
                    yoloNum++
                }
            }
            if TrackPond[msg.Cid] != nil {
                logger.Info("================追踪之前yolo的个数：", yoloNum, "现在缓存池中记录的个数：", TrackPond[msg.Cid].Yolo)
            } else {
                logger.Info("================追踪之前yolo的个数：", yoloNum, "还没有这个摄像机的缓存")
            }
            if yoloParam.Infos != nil && TrackPond[msg.Cid] != nil && yoloNum == TrackPond[msg.Cid].Yolo { // yolo的如果数量相同则视为不变、把yolo的sdkData清空
                yoloParam.Infos = (yoloParam.Infos)[0:0]
                sdkinfo.Sdkdata, err = proto.Marshal(&yoloParam)
                if err != nil {
                    logger.Error("yolo序列化错误", err)
                }
                logger.Info("跟之前相同，清空yolo数据")
            } else {
                if TrackPond[msg.Cid] != nil {
                    logger.Info("更新当前摄像机缓存池中的yolo个数：", yoloNum)
                    TrackPond[msg.Cid].Yolo = yoloNum
                } else {
                    logger.Info("新建当前摄像机缓存池中的yolo个数：", yoloNum)
                    TrackPond[msg.Cid] = &PersonTrack{Yolo: yoloNum}
                }
            }
            //} else {
            //    continue
            //}
        }
    }
    logger.Debug("---------------------------------------追踪结束--------------------------------------")