修正报警区域，拆分代码

panlei

2019-07-11 6622f4a2288429d2868ec47d9cd968bace55b37d

修正报警区域，拆分代码

 insertdata/insertDataToEs.go

@@ -101,7 +101,6 @@
func InsertToEs(msg ruleserver.ResultMsg) {

    // 直接从规则的标签数据里拿符合规则的人脸结果
    //logger.Info("------------------------------------从配置文件读取的值：",weedfsUrl)
    if msg.RuleResult["face"] != nil && len(msg.RuleResult["face"].([]ruleserver.Arg)) > 0 {
        logger.Info("往ES插人脸数据")
        for _, face := range msg.RuleResult["face"].([]ruleserver.Arg) {
@@ -135,7 +134,6 @@
                }
                i := protomsg.Image{}
                err = proto.Unmarshal(bdata, &i)
                logger.Info("-------------------------------------------看下宽和高", int(face.Location.X),int(face.Location.Y),int(face.Location.X+face.Location.Width),int(face.Location.Y+face.Location.Height))
                bytes := util.SubImg(i, int(face.Location.X), int(face.Location.Y), int(face.Location.X+face.Location.Width), int(face.Location.Y+face.Location.Height))
                resp, err := util.PostFormBufferData1(weedfsUrl, bytes, uuid.NewV4().String())
                if err != nil {
@@ -268,9 +266,7 @@

                }
                err = EsReq("POST", "http://192.168.1.182:9200/videopersons/perVideoPicture", requstbody)
                logger.Info("跟底库的相似数据---------：", face.Liker)

                fmt.Println("------------------------------------------哈哈哈哈，底库有人")
                logger.Info("------------------------------------------哈哈哈哈，底库有人")

            }
        }

 ruleserver/ruleToformula.go

@@ -89,8 +89,8 @@
    triggerLine   string
    directionLine string
    targetNum     int    // 区域内目标数量
    args          []*Arg  // 区域内目标集合
    filterData    []*Arg  // 过滤后区域内目标集合
    args          []*Arg // 区域内目标集合
    filterData    []*Arg // 过滤后区域内目标集合
    time          string // 当前时间（用以匹配时间规则）
    keepRight     bool   // 是否靠右行
    isStatic      bool   // 是否静止
@@ -115,7 +115,7 @@
    IsStatic    bool       // 是否静止
    ImageWidth  int        // 摄像机拍摄的图像宽 像素
    ImageHeight int        // 摄像机拍摄的图像高 像素
    AreaMapList []*AreaMap  // 本sdk提取的数据按照区域划分后的数据集合
    AreaMapList []*AreaMap // 本sdk提取的数据按照区域划分后的数据集合
}

// 从算法模块儿拿来的对一帧图像各个算法提取的数据集合
@@ -135,12 +135,13 @@

// 过规则库打上的标签
type Result struct {
    TaskId      string // 任务id
    SdkName     string
    RuleGroupId string // 规则组id
    AlarmLevel  int32  // 报警等级
    RuleText    string // 文字版规则组
    Location    []Rect
    TaskId       string // 任务id
    SdkName      string
    RuleGroupId  string // 规则组id
    AlarmLevel   int32  // 报警等级
    RuleText     string // 文字版规则组
    Location     []Rect // 目标的坐标
    AlarmPolygon string // 触发的报警框
}
type LittleRuleResult struct {
    SdkName string // 记录下此结果是哪个sdk的结果
@@ -222,7 +223,9 @@
        }
    }
}
func (arg *Arg) fillLiker(){

// 给目标填充liker
func (arg *Arg) fillLiker() {
    bytes := bigCache.Getdbpersonmsg("", arg.Feature, true)
    var m map[string]float32
    err1 := json.Unmarshal(bytes, &m)
@@ -277,26 +280,13 @@
                                if compareFlag == 2 {
                                    array := strings.Split(tableIds, ",")
                                    for i := 0; i < len(array)-1; i++ {
                                        bytes := bigCache.Getdbpersonmsg(array[i], arg.Feature, true)
                                        var m map[string]float32
                                        err1 := json.Unmarshal(bytes, &m)
                                        if err1 != nil {
                                            logger.Error("getBaseInfo解压错误", err1)
                                        }
                                        for key, val := range m {
                                            baseinfo, err1 := esutil.Dbpersoninfosbyid(key)
                                            if err1 != nil {
                                                logger.Error("查询底库人员信息出错", err1)
                                            }
                                            baseinfo.CompareScore = val
                                            arg.Liker = append(arg.Liker, &baseinfo)
                                        }
                                        arg.fillLiker()
                                    }
                                }
                                logger.Info("-------------------成功给liker赋值,长度为：", len(arg.Liker))
                            }
                            areaMap.filterData = areaMap.args
                            logger.Info("=======第一次看args：",areaMap.filterData)
                            //logger.Info("=======第一次看args：",(areaMap.filterData))
                        }
                    }
                }
@@ -314,6 +304,7 @@
    Compare(args, groupRule)
    resultSplice := []*LittleRuleResult{}
    sdkNames := ""
    polygonId := ""
    // 先过完条件规则
    for j := 0; j < len(groupRule.Rules); j++ {
        for _, sdkData := range args.Sdkdata {
@@ -324,16 +315,20 @@
            }
            ipcId := sdk.IpcId
            sdkName := sdk.SdkName
            logger.Info("规则的ipcId与sdkData的IpcId:",ipcId,"===",sdkData.IpcId)
            logger.Info("规则的ipcId与sdkData的IpcId:", ipcId, "===", sdkData.IpcId)
            if ipcId == sdkData.IpcId {
                logger.Info("当前走的规则的算法是--：", sdkName, "---")
                for _, areaMap := range sdkData.AreaMapList {
                    ruleResult := filterRule(groupRule.Rules[j], areaMap)
                    if ruleResult.Result != "" {
                        logger.Info("条件规则结果：", ruleResult.Result)
                        // 如果此结果为真且当前过的是yolo算法，应记下此规则所对应的sdkName,另外，还要去重
                        if ruleResult.Result == "true" && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                        // 如果此结果为真且当前过的是yolo算法，应记下此规则所对应的sdkName,另外，还要去重 (后加：把此条触碰的区域id也记录下来)
                        if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                            sdkNames = sdkName + ","
                            polygonId = groupRule.Rules[j].PolygonId + ","
                        }
                        if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(polygonId, groupRule.Rules[j].PolygonId) {
                            polygonId = groupRule.Rules[j].PolygonId + ","
                        }
                        resultSplice = append(resultSplice, &ruleResult)
                    }
@@ -357,8 +352,11 @@
                    ruleResult := transferParameters(groupRule.Rules[j], areaMap)
                    if ruleResult.Result != "" {
                        logger.Info("数量规则结果：", ruleResult.Result)
                        if ruleResult.Result == "true" && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                        if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                            sdkNames = sdkName + ","
                        }
                        if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(polygonId, groupRule.Rules[j].PolygonId) {
                            polygonId = groupRule.Rules[j].PolygonId + ","
                        }
                        resultSplice = append(resultSplice, &ruleResult)
                    }
@@ -380,8 +378,11 @@
                    ruleResult := timeRuleResult(groupRule.Rules[j], areaMap)
                    if ruleResult.Result != "" {
                        logger.Info("时间规则结果：", ruleResult.Result)
                        if ruleResult.Result == "true" && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                        if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                            sdkNames = sdkName + ","
                        }
                        if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(polygonId, groupRule.Rules[j].PolygonId) {
                            polygonId = groupRule.Rules[j].PolygonId + ","
                        }
                        resultSplice = append(resultSplice, &ruleResult)
                    }
@@ -485,7 +486,7 @@
                    }
                }
                if sdkNames != "" {
                    args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkNames, groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, locations})
                    args.RuleResult["yolo"] = append(args.RuleResult["yolo"].([]Result), Result{taskId, sdkNames, groupRule.GroupId, groupRule.AlarmLevel, groupRule.GroupText, locations,polygonId})
                    logger.Info("-------------------yolo结果标签", args.RuleResult["yolo"].([]Result))
                }
                if args.RuleResult["face"] != nil {
@@ -500,7 +501,7 @@
        return false
    }
}
func TimerAlarm(groupId string) (int){
func TimerAlarm(groupId string) (int) {
    var flagTime int = 0
    for k, timeEle := range TimeEleList {
        if strings.Contains(k, groupId) {
@@ -657,7 +658,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)))

 util/simpleCV.go

@@ -3,21 +3,14 @@
import (
    "basic.com/pubsub/protomsg.git"
    "bufio"
    "bytes"
    "encoding/json"
    "errors"
    "fmt"
    "gocv.io/x/gocv"
    "image"
    "image/color"
    "io"
    "log"
    "mime/multipart"
    "net/http"
    "os"
    "ruleprocess/cache"
    "ruleprocess/ruleserver"
    "time"
    "strings"
)

func CvRTSP() {
@@ -168,83 +161,27 @@
    defer rook.Close()

    red := color.RGBA{255, 0, 0, 0}
    // 查到摄像机所有的区域并画框
    var cameraPolygons []protomsg.CameraPolygon
    cameraPolygons = cache.GetPolygonsByCameraId(cameraId)
    for _, polygon := range cameraPolygons {
        points := ruleserver.Json2points(polygon.Polygon)
        for index := 0; index < len(points); index++ {
            if index == len(points)-1 { // 闭合图形
                gocv.Line(&rook, image.Pt(int(points[index].X), int(points[index].Y)), image.Pt(int(points[0].X), int(points[0].Y)), red, 2)
            } else {
                gocv.Line(&rook, image.Pt(int(points[index].X), int(points[index].Y)), image.Pt(int(points[index+1].X), int(points[index+1].Y)), red, 2)
            }
    green := color.RGBA{0, 255, 0, 0}

    // 分割区域id集合并根据id查询区域然后画框
    for _,result := range results  {
        polygonIds := strings.Split(result.AlarmPolygon,"")
        for i := 0; i < len(polygonIds)-1; i++ {
            polygon := getPolygonById(polygonIds[i],cameraId)
            if polygon.Polygon != "" {
                DrawAPolygon(&rook,polygon.Polygon,red)
            }
        }
    }
    // 把目标框出来
    for _,result := range results  {
        for _,rect := range result.Location {
            gocv.Rectangle(&rook, image.Rect(int(rect.X), int(rect.Y), int(rect.X+rect.Width), int(rect.Y+rect.Height)), red, 1)
            gocv.Rectangle(&rook, image.Rect(int(rect.X), int(rect.Y), int(rect.X+rect.Width), int(rect.Y+rect.Height)), green, 1)
        }
    }
    //return nil,nil
    // 上传
    fdata, _ := gocv.IMEncode(".jpg", rook)
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    _, err1 := writer.CreateFormFile("file", "fasjuierf")
    if err1 != nil {
        return nil, err1
    }
    boundary := writer.Boundary()
    //close_string := fmt.Sprintf("\r\n--%s--\r\n", boundary)
    close_buf := bytes.NewBufferString(fmt.Sprintf("\r\n--%s--\r\n", boundary))
    file := bytes.NewBuffer(fdata)
    request_reader := io.MultiReader(body, file, close_buf)
    //_, err = io.Copy(part, file)
    //writer.WriteField(key, val)
    request, err := http.NewRequest("POST", "http://192.168.1.182:6333/submit", request_reader)
    request.Header.Add("Content-Type", writer.FormDataContentType())
    timeout := time.Duration(5 * time.Second) //超时时间50ms
    client := &http.Client{Timeout: timeout}
    resp, err := client.Do(request)
    if err != nil {
        log.Fatal(err)
        return nil, err
    }
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("panic的内容%v\n", r)
            msg := "上传图片服务器异常"
            if _, ok := r.(error); ok {
                msg = r.(error).Error()
                fmt.Println("panic--recover()得到的是error类型")
            }
            if _, ok := r.(string); ok {
                msg = r.(string)
                fmt.Println("panic--recover()得到的是string类型")
            }
            err0 = errors.New(msg)
        }
    }()
    defer resp.Body.Close()
    {
        body := &bytes.Buffer{}
        _, err := body.ReadFrom(resp.Body)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println(resp.StatusCode)
        //fmt.Println(resp.Header)
        fmt.Println(body)
        //decoder := json.NewDecoder(strings.NewReader(body.String()))
        decoder := make(map[string]interface{})
        if err := json.Unmarshal([]byte(body.String()), &decoder); err != nil {
            return nil, err
        }
        return decoder, nil
    }
    maps,err0 = UploadFromMat(rook)
    return
}

// 把图片转成二进制流
@@ -269,3 +206,26 @@

    return bytes, err
}
// 根据id去缓存里查询多边形
func getPolygonById(polygonId string, cameraId string) (protomsg.CameraPolygon){
    // 查到摄像机所有的区域并画框
    var cameraPolygons []protomsg.CameraPolygon
    cameraPolygons = cache.GetPolygonsByCameraId(cameraId)
    for _, polygon := range cameraPolygons {
        if polygon.Id == polygonId {
            return polygon
        }
    }
    return protomsg.CameraPolygon{}
}
// 在图上画一个框
func DrawAPolygon(rook *gocv.Mat,polygonString string, color color.RGBA) {
    points := ruleserver.Json2points(polygonString)
    for index := 0; index < len(points); index++ {
        if index == len(points)-1 { // 闭合图形
            gocv.Line(rook, image.Pt(int(points[index].X), int(points[index].Y)), image.Pt(int(points[0].X), int(points[0].Y)), color, 2)
        } else {
            gocv.Line(rook, image.Pt(int(points[index].X), int(points[index].Y)), image.Pt(int(points[index+1].X), int(points[index+1].Y)), color, 2)
        }
    }
}

 util/upload.go

@@ -135,4 +135,63 @@
        }
        return decoder, nil
    }
}

func UploadFromMat(rook gocv.Mat)(maps map[string]interface{}, err0 error){
    // 上传
    fdata, _ := gocv.IMEncode(".jpg", rook)
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    _, err1 := writer.CreateFormFile("file", "fasjuierf")
    if err1 != nil {
        return nil, err1
    }
    boundary := writer.Boundary()
    //close_string := fmt.Sprintf("\r\n--%s--\r\n", boundary)
    close_buf := bytes.NewBufferString(fmt.Sprintf("\r\n--%s--\r\n", boundary))
    file := bytes.NewBuffer(fdata)
    request_reader := io.MultiReader(body, file, close_buf)
    //_, err = io.Copy(part, file)
    //writer.WriteField(key, val)
    request, err := http.NewRequest("POST", "http://192.168.1.182:6333/submit", request_reader)
    request.Header.Add("Content-Type", writer.FormDataContentType())
    timeout := time.Duration(5 * time.Second) //超时时间50ms
    client := &http.Client{Timeout: timeout}
    resp, err := client.Do(request)
    if err != nil {
        log.Fatal(err)
        return nil, err
    }
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("panic的内容%v\n", r)
            msg := "上传图片服务器异常"
            if _, ok := r.(error); ok {
                msg = r.(error).Error()
                fmt.Println("panic--recover()得到的是error类型")
            }
            if _, ok := r.(string); ok {
                msg = r.(string)
                fmt.Println("panic--recover()得到的是string类型")
            }
            err0 = errors.New(msg)
        }
    }()
    defer resp.Body.Close()
    {
        body := &bytes.Buffer{}
        _, err := body.ReadFrom(resp.Body)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println(resp.StatusCode)
        //fmt.Println(resp.Header)
        fmt.Println(body)
        //decoder := json.NewDecoder(strings.NewReader(body.String()))
        decoder := make(map[string]interface{})
        if err := json.Unmarshal([]byte(body.String()), &decoder); err != nil {
            return nil, err
        }
        return decoder, nil
    }
}