加一个req，持续时间两帧图片画框问题

panlei

2019-07-30 44441d5439df4e81d641b115c94b079ace31a5c6

加一个req，持续时间两帧图片画框问题

 insertdata/insertDataToEs.go

@@ -356,9 +356,8 @@
        }
        serverIp, err := GetLocalIP()
        url := []string{}
        url = append(url, strings.Split(resp["fileUrl"].(string), "/")[1])
        if msg.RuleResult["cacheData"] != nil {
            InsertYolo(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))
            //InsertYolo(msg.RuleResult["cacheData"].(ruleserver.ResultMsg))
            // 把缓存的数据上传后得到地址存进去
            // 解压缩并上传图片
            msg1 := msg.RuleResult["cacheData"].(ruleserver.ResultMsg)
@@ -368,7 +367,7 @@
            }
            i := protomsg.Image{}
            err = proto.Unmarshal(bdata, &i)
            resp1, err1 := util.DrawPolygonOnImage(msg.Cid, i, msg.RuleResult["yolo"].([]ruleserver.Result), weedfsUrl)
            resp1, err1 := util.DrawPolygonOnImage(msg1.Cid, i, msg1.RuleResult["yolo"].([]ruleserver.Result), weedfsUrl)
            if err1 != nil {
                logger.Error("缓存数据画框或上传图片服务器出错", err)
            } else {
@@ -376,6 +375,7 @@
            }
            url = append(url, strings.Split(resp1["fileUrl"].(string), "/")[1])
        }
        url = append(url, strings.Split(resp["fileUrl"].(string), "/")[1])
        esDataId := uuid.NewV4().String()
        peraction := Personaction{
            esDataId,

 labelFilter/readyDataForLabel.go

@@ -29,7 +29,7 @@
        label.Persons = append(label.Persons,faceGroup)
        label.DefenceLevel = append(label.DefenceLevel,faceGroup.AlarmLevel)
    }
    for _,yoloGroup := range result.RuleResult["yolo"].([]ruleserver.FaceResult) {
    for _,yoloGroup := range result.RuleResult["yolo"].([]ruleserver.Result) {
        label.DefenceLevel = append(label.DefenceLevel,yoloGroup.AlarmLevel)
    }
    Judge(label,result)

 labelFilter/req.go

New file
@@ -0,0 +1,82 @@
package labelFilter

import (
    "fmt"
    "github.com/gogo/protobuf/proto"
    "nanomsg.org/go-mangos"
    "nanomsg.org/go-mangos/protocol/rep"
    "nanomsg.org/go-mangos/protocol/req"
    "nanomsg.org/go-mangos/transport/ipc"
    "nanomsg.org/go-mangos/transport/tcp"
    "os"
    "ruleprocess/logger"
    "ruleprocess/ruleserver"
    "time"
)

func Die(format string, v ...interface{}) {
    fmt.Fprintln(os.Stderr, fmt.Sprintf(format, v...))
    logger.Info("+++++++",format)
    os.Exit(1)
}

func date() string {
    return time.Now().Format(time.ANSIC)
}

func Node0(url string) {
    var sock mangos.Socket
    var err error
    var msg []byte
    if sock, err = rep.NewSocket(); err != nil {
        Die("can't get new rep socket: %s", err)
    }
    sock.AddTransport(ipc.NewTransport())
    sock.AddTransport(tcp.NewTransport())
    if err = sock.Listen(url); err != nil {
        Die("can't listen on rep socket: %s", err.Error())
    }
    for {
        // Could also use sock.RecvMsg to get header
        msg, err = sock.Recv()
        if string(msg) == "DATE" { // no need to terminate
            fmt.Println("NODE0: RECEIVED DATE REQUEST")
            d := date()
            fmt.Printf("NODE0: SENDING DATE %s\n", d)
            err = sock.Send([]byte(d))
            if err != nil {
                Die("can't send reply: %s", err.Error())
            }
        }
    }
}

func Push(url string,data ruleserver.ResultMsg) {
    var sock mangos.Socket
    var err error
    var msg []byte

    if sock, err = req.NewSocket(); err != nil {
        Die("创建请求socket失败: %s", err.Error())
    }
    //sock.AddTransport(ipc.NewTransport())
    sock.AddTransport(tcp.NewTransport())
    if err = sock.Dial(url); err != nil {
        Die("请求socket拨号失败: %s", err.Error())
    }
    logger.Debug("推送数据")
    bytes,err := proto.Marshal(data)
    if err = sock.Send(bytes); err != nil {
        Die("推送socket发送数据失败: %s", err.Error())
    }
    if msg, err = sock.Recv(); err != nil {
        Die("接收响应失败: %s", err.Error())
    }
    logger.Debug("数据推送成功！收到响应",string(msg))
    sock.Close()
}

//func main() {
//    url := "tcp://192.168.1.123:40011"
//    Push(url,"hahahaha")
//}

 labelFilter/ruleForLabel.go

@@ -19,50 +19,53 @@
    }
    //遍历所有的规则组，看看符合哪个规则组，就把数据插入到哪个规则组的目标机器上
    for _,ruleGroup := range allRules {
        // 先过时间规则
        timeJudge(label,ruleGroup)
        result := ""
        var Connector string
        if ruleGroup.IsSatisfyAll {
            Connector = "&&"
        } else {
            Connector = "||"
        }
        for _,rule := range ruleGroup.Rules {
            // 过每一个小规则
            if rule.TopicType == "camera" {
                result = Connector + cameraJudge(label,rule)
            }
            if rule.TopicType == "baseLibrary" {
                result = Connector + baseJudge(label,rule)
            }
            if rule.TopicType == "task" {
                result = Connector + taskJudge(label,rule)
            }
            if rule.TopicType == "person" {
                result = Connector + taskJudge(label,rule)
            }
            if rule.TopicType == "defence" {
                result = Connector + defenceJudge(label,rule)
            }
        }
        // 得出总的判断结果
        if result != "" {
            result = result[2:] // 把前两位字符去掉
            expression, err:= govaluate.NewEvaluableExpression(result);
            if err != nil {
                logger.Error("表达式有误，请检查！")
            }
            result, err1:= expression.Evaluate(nil)
            if err1 != nil {
                logger.Error("带入参数有误")
            }
            if result.(bool) {
                logger.Info("通过规则，表达式为：",result)
                // 推送服务器
                pushData(ruleGroup.IpPorts,result.(ruleserver.ResultMsg))
        if ruleGroup.Enable {  // 大规则开关开启状态
            // 先过时间规则
            timeJudge(label,ruleGroup)
            result := ""
            var Connector string
            if ruleGroup.IsSatisfyAll {
                Connector = "&&"
            } else {
                logger.Info("没通过规则,表达式为：",result)
                Connector = "||"
            }
            for _,rule := range ruleGroup.Rules {
                // 过每一个小规则
                if rule.TopicType == "camera" {
                    result = Connector + cameraJudge(label,rule)
                }
                if rule.TopicType == "baseLibrary" {
                    result = Connector + baseJudge(label,rule)
                }
                if rule.TopicType == "task" {
                    result = Connector + taskJudge(label,rule)
                }
                if rule.TopicType == "person" {
                    result = Connector + taskJudge(label,rule)
                }
                if rule.TopicType == "defence" {
                    result = Connector + defenceJudge(label,rule)
                }
            }
            // 得出总的判断结果
            if result != "" {
                result = result[2:] // 把前两位字符去掉
                expression, err:= govaluate.NewEvaluableExpression(result);
                if err != nil {
                    logger.Error("表达式有误，请检查！")
                }
                result, err1:= expression.Evaluate(nil)
                if err1 != nil {
                    logger.Error("带入参数有误")
                }
                logger.Warn("规则判断结果是：",)
                if result.(bool) {
                    logger.Info("通过规则，表达式为：",result)
                    // 推送服务器
                    pushData(ruleGroup.Urls,result.(ruleserver.ResultMsg))
                } else {
                    logger.Info("没通过规则,表达式为：",result)
                }
            }
        }
    }
@@ -187,6 +190,6 @@
    return "false"
}
// 调用目标服务器的插入接口
func pushData (urls []*protomsg.PushIpPort, data ruleserver.ResultMsg){
func pushData (urls []*protomsg.PushUrl, data ruleserver.ResultMsg){

}