merge master

panlei

2019-11-07 6e8ebf781ac457b7ec77f7e4c9ade4c3d36002bc

merge master

 algorithm/face/face.go

@@ -2,8 +2,8 @@

import (
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/logger.git"
    "github.com/knetic/govaluate"
    "ruleprocess/logger"
    "ruleprocess/structure"
    "strconv"
)
@@ -15,42 +15,48 @@

// 过滤规则先筛选出符合条件的目标数量
func filterRule(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
    if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" || rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
        // 处理的是人脸算法 如果这条规则配置的是人脸算法，过滤完条件之后直接得出结果，因为肯定没有数量条件，自己拼接
        //logger.Info("规则的算法id和区域的算法id：", rule.SdkId, "===", am.sdkId)
        if rule.PolygonId == am.AreaId { // 算法和区域都得对的上

            if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && rule.SdkArgAlias != "time_rule"{ // 人脸比对
                //logger.Debug("当前小规则是：",rule)
                flag := "false"
                // 把没有相似者的人脸从filterData中删除
                for index := 0; index < len(am.FilterData); {
                    // 将达不到阈值的相似者从相似者数组中删除
                    logger.Info("看看相似者人数：",len(am.FilterData[index].Liker))
                    if len(am.FilterData[index].Liker) == 0 {
                        // Go 语言中切片删除元素的本质是：以被删除元素为分界点，将前后两个部分的内存重新连接起来。不用怀疑，数组删除元素就这么坑爹
                        am.FilterData = append(am.FilterData[:index], am.FilterData[index+1:]...)
                    } else {
                        index++
            if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && rule.SdkArgAlias != "time_rule" {
                if rule.RuleWithPre == "||" {
                    return structure.LittleRuleResult{}
                } else {
                    //logger.Debug("当前小规则是：",rule)
                    flag := "false"
                    // 把没有相似者的人脸从filterData中删除
                    for index := 0; index < len(am.FilterData); {
                        // 将达不到阈值的相似者从相似者数组中删除
                        logger.Info("看看相似者人数：",len(am.FilterData[index].Liker))
                        if len(am.FilterData[index].Liker) == 0 {
                            // Go 语言中切片删除元素的本质是：以被删除元素为分界点，将前后两个部分的内存重新连接起来。不用怀疑，数组删除元素就这么坑爹
                            am.FilterData = append(am.FilterData[:index], am.FilterData[index+1:]...)
                        } else {
                            index++
                        }
                    }
                    if len(am.FilterData) > 0 {
                        flag = "true"
                    }
                    logger.Info("---------人脸比对符合条件的数量为：",len(am.FilterData))
                    return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort}
                }
                if len(am.FilterData) > 0 {
                    flag = "true"
                }
                logger.Info("---------人脸比对符合条件的数量为：",len(am.FilterData))
                return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort}
            }
            if rule.SdkId == "812b674b-2375-4589-919a-5c1c3278a97e" { // 人脸检测
                //logger.Debug("当前小规则是：",rule)
                if rule.Operator == "==" || rule.Operator == ">=" || rule.Operator == "<=" || rule.Operator == "<" || rule.Operator == ">" || rule.Operator == "!=" {
                    // 如果是不规矩的连接符统统返回false 规则也只能判断人脸的相似度，所以不存在别的连接符
                    if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
                        logger.Info("-----------------------过规则之前区域内的人脸数量为：",am.TargetNum,"--区域--",am.AreaJson)
                        logger.Info("-----------------------过规则之前区域内的人脸数量为：",am.TargetNum)
                        var args []*structure.Arg
                        if rule.RuleWithPre == "&&" {
                            args = am.FilterData
                            //logger.Info("过滤后的args的长度为：",len(args))
                        } else {
                            args = am.Args
                            //不清空之前的过滤数据，继续塞
                            //logger.Info("没过滤的args的长度为：",len(args))
                        }
                        // 先清空过滤后的数据，再往里塞本次过滤后的数据
@@ -82,16 +88,16 @@
                        } else {
                            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
                        }
                    } else {
                        return structure.LittleRuleResult{}
                    }
                } else {
                    return structure.LittleRuleResult{}
                } else if rule.SdkArgAlias == "" { // 什么参数都不配的情况
                    if am.TargetNum > 0 {
                        return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
                    } else {
                        return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
                    }
                }
            } else {
                return structure.LittleRuleResult{}
            }
        } else {
            return structure.LittleRuleResult{}
        }
    }
    return structure.LittleRuleResult{}
}

 algorithm/intrusion/intrusion.go

@@ -2,8 +2,8 @@

import (
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/logger.git"
    "github.com/knetic/govaluate"
    "ruleprocess/logger"
    "ruleprocess/structure"
    "strconv"
)
@@ -11,12 +11,7 @@
//入侵算法
func Entrance(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
    if rule.PolygonId == am.AreaId { // 首先这条规则得是这个算法的规则，其次规则所对应的区域id要跟区域数据的id对的上
        if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
            logger.Debug("---------走了入侵算法",rule.Id,rule.SdkArgAlias,rule.Operator,rule.SdkArgValue,am.AreaId)
            return filterRule(rule, am)
        } else {
            return structure.LittleRuleResult{}
        }
        return filterRule(rule, am)
    } else {
        return structure.LittleRuleResult{}
    }
@@ -25,37 +20,48 @@
// 过滤规则先筛选出符合条件的目标数量
func filterRule(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
    // 处理的都是yolo数据
    var args []*structure.Arg
    if rule.RuleWithPre == "&&" {
        args = am.FilterData
    } else {
        args = am.Args
    }
    // 先清空过滤后的数据，再往里塞本次过滤后的数据
    am.FilterData = am.FilterData[0:0]
    //logger.Debug("看看args：：：：：", args)
    for _, arg := range args {
        var formula string
        if rule.SdkArgAlias == "score" {
            formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
            logger.Info("当前相似度小公式：", formula)
        } else if rule.SdkArgAlias == "proportion" {
            formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
            logger.Info("当前占比小公式：", formula)
    if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
        logger.Debug("---------走了入侵算法",rule.Id,rule.SdkArgAlias,rule.Operator,rule.SdkArgValue,am.AreaId)
        var args []*structure.Arg
        if rule.RuleWithPre == "&&" {
            args = am.FilterData
        } else {
            formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
            logger.Info("当前尺寸小公式：", formula)
            args = am.Args
        }
        expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
        result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
        if result.(bool) {
            am.FilterData = append(am.FilterData, arg) // 得到符合条件的过滤数据
        // 先清空过滤后的数据，再往里塞本次过滤后的数据
        am.FilterData = am.FilterData[0:0]
        //logger.Debug("看看args：：：：：", args)
        for _, arg := range args {
            var formula string
            if rule.SdkArgAlias == "score" {
                formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                logger.Info("当前相似度小公式：", formula)
            } else if rule.SdkArgAlias == "proportion" {
                formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                logger.Info("当前占比小公式：", formula)
            } else {
                formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                logger.Info("当前尺寸小公式：", formula)
            }
            expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
            result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
            if result.(bool) {
                am.FilterData = append(am.FilterData, arg) // 得到符合条件的过滤数据
            }
        }
        am.TargetNum = len(am.FilterData) // 把符合条件的目标数量更新到targetNum字段
        if am.TargetNum > 0 {
            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
        } else {
            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
        }

    } else if rule.SdkArgAlias == "" {
        if am.TargetNum > 0 {
            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
        } else {
            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
        }
    }
    am.TargetNum = len(am.FilterData) // 把符合条件的目标数量更新到targetNum字段
    if am.TargetNum > 0 {
        return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
    } else {
        return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
    }
    return structure.LittleRuleResult{}
}

 algorithm/middleware/middleware.go

@@ -2,11 +2,11 @@

import (
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/logger.git"
    "encoding/json"
    "github.com/knetic/govaluate"
    "plugin"
    "ruleprocess/cache"
    "ruleprocess/logger"
    "ruleprocess/structure"
    "strings"
    "time"
@@ -40,11 +40,10 @@
                            }
                            // 如果此结果为真且当前过的是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 + ","
                                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 + ","
                                polygonId = groupRule.Rules[j].PolygonId + " "
                            }
                            resultSplice = append(resultSplice, &ruleResult)
                        }
@@ -76,11 +75,10 @@
                            }
                            // 如果此结果为真且当前过的是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 + ","
                                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 + ","
                                polygonId = groupRule.Rules[j].PolygonId + " "
                            }
                            resultSplice = append(resultSplice, &ruleResult)
                        }
@@ -109,10 +107,10 @@
                            }
                            logger.Info("数量规则结果：", ruleResult.Result)
                            if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                                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 + ","
                                polygonId = groupRule.Rules[j].PolygonId + " "
                            }
                            resultSplice = append(resultSplice, &ruleResult)
                        }
@@ -139,10 +137,10 @@
                        }
                        logger.Info("时间规则结果：", ruleResult.Result)
                        if strings.Contains(ruleResult.Result, "true") && ipcId == "02D54B61-0F16-C604-8567-FC4BE493C523" && !strings.Contains(sdkNames, sdkName) {
                            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 + ","
                            polygonId = groupRule.Rules[j].PolygonId + " "
                        }
                        resultSplice = append(resultSplice, &ruleResult)
                    }

 algorithm/personUnsual/personUnsual.go

@@ -2,8 +2,8 @@

import (
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/logger.git"
    "github.com/knetic/govaluate"
    "ruleprocess/logger"
    "ruleprocess/structure"
    "strconv"
)
@@ -27,39 +27,51 @@
// 过滤规则先筛选出符合条件的目标数量
func filterRule(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
    // 处理的都是yolo数据
    var args []*structure.Arg
    if rule.RuleWithPre == "&&" {
        args = am.FilterData
    } else {
        args = am.Args
    }
    // 先清空过滤后的数据，再往里塞本次过滤后的数据
    am.FilterData = am.FilterData[0:0]
    //logger.Debug("看看args：：：：：", args)
    for _, arg := range args {
        var formula string
        if rule.SdkArgAlias == "score" {
            formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
            logger.Info("当前相似度小公式：", formula)
        } else if rule.SdkArgAlias == "proportion" {
            formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
            logger.Info("当前占比小公式：", formula)
        } else {
            formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
            logger.Info("当前尺寸小公式：", formula)
        }
        expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
        result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
        if result.(bool) {
            am.FilterData = append(am.FilterData, arg) // 得到符合条件的过滤数据
    if rule.PolygonId == am.AreaId { // 首先这条规则得是这个算法的规则，其次规则所对应的区域id要跟区域数据的id对的上
        if rule.SdkArgAlias == "score" || rule.SdkArgAlias == "proportion" || rule.SdkArgAlias == "size" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
            var args []*structure.Arg
            if rule.RuleWithPre == "&&" {
                args = am.FilterData
            } else {
                args = am.Args
            }
            // 先清空过滤后的数据，再往里塞本次过滤后的数据
            am.FilterData = am.FilterData[0:0]
            //logger.Debug("看看args：：：：：", args)
            for _, arg := range args {
                var formula string
                if rule.SdkArgAlias == "score" {
                    formula = strconv.FormatFloat(arg.Score, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                    logger.Info("当前相似度小公式：", formula)
                } else if rule.SdkArgAlias == "proportion" {
                    formula = strconv.FormatFloat(arg.Proportion, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                    logger.Info("当前占比小公式：", formula)
                } else {
                    formula = strconv.FormatFloat(arg.Size, 'f', -1, 64) + " " + rule.Operator + " " + rule.SdkArgValue // 得到字符串公式
                    logger.Info("当前尺寸小公式：", formula)
                }
                expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
                result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
                if result.(bool) {
                    am.FilterData = append(am.FilterData, arg) // 得到符合条件的过滤数据
                }
            }
            am.TargetNum = len(am.FilterData) // 把符合条件的目标数量更新到targetNum字段
            if am.TargetNum > 0 {
                return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
            } else {
                return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
            }

        } else if rule.SdkArgAlias == "" {
            if am.TargetNum > 0 {
                return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
            } else {
                return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
            }
        }
    }
    am.TargetNum = len(am.FilterData) // 把符合条件的目标数量更新到targetNum字段
    if am.TargetNum > 0 {
        return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "true", rule.Sort}
    } else {
        return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + "false", rule.Sort}
    }
    return structure.LittleRuleResult{}
}

// 给数据库的规则表达式代参 args: 一条子规则，区域数据

 algorithm/static/static.go

@@ -2,8 +2,8 @@

import (
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/logger.git"
    "github.com/knetic/govaluate"
    "ruleprocess/logger"
    "ruleprocess/ruleserver"
    "ruleprocess/structure"
    "strconv"

 algorithm/timeSlot/timeSlot.go

@@ -2,10 +2,10 @@

import (
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/logger.git"
    "encoding/json"
    "github.com/knetic/govaluate"
    "ruleprocess/cache"
    "ruleprocess/logger"
    "ruleprocess/structure"
    "time"
)

 cache/cache.go

@@ -5,11 +5,11 @@
    "basic.com/pubsub/cache.git/shardmap"
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/gopherdiscovery.git"
    "basic.com/valib/logger.git"
    "errors"
    "fmt"
    "github.com/gogo/protobuf/proto"
    "github.com/satori/go.uuid"
    "ruleprocess/logger"
    "strconv"
)
const (

 insertdata/EsClient.go

@@ -1,17 +1,16 @@
package insertdata

import (
    "bytes"
    "encoding/json"
    "errors"
    "fmt"
    "io"
    "io/ioutil"
    "net/http"
    "ruleprocess/logger"
    "strconv"
    "strings"
    "time"
    "bytes"
)

type Reps struct {

 insertdata/insertDataToEs.go

@@ -1,6 +1,7 @@
package insertdata

import (
    "basic.com/valib/logger.git"
    "encoding/base64"
    "encoding/json"
    "errors"
@@ -15,7 +16,6 @@
    "github.com/satori/go.uuid"
    "ruleprocess/ruleserver"
    "ruleprocess/util"
    "ruleprocess/structure"
)

var weedfsUrl, videoPersonUrl, personAction string
@@ -162,7 +162,6 @@
                    panic("解压缩图片时出现错误")
                }
                alarmRules := []AlarmRule{}
                //logger.Warn("人脸id为：", face.Id, "人脸的规则长度为：", len(face.rules))
                //os.Exit(1)
                for _, faceResult := range face.rules {
                    alarm := ChangeToString(faceResult.DefenceState, faceResult.AlarmLevel)
@@ -204,6 +203,7 @@
                target.TargetScore = face.Score
                target.TargetLocation = Points{TopLeft:Point{face.Location.X,face.Location.Y},BottomRight:Point{face.Location.X+face.Location.Width,face.Location.Y+face.Location.Height}}
                //logger.Info("人脸的id:",strconv.FormatUint(face.Id, 10))

                pervideo := PerVideoPicture{
                    msg.Push.PushId,
                    msg.Cid,
@@ -357,7 +357,6 @@
                    // 装配目标信息数据
                    for _,target := range yoloResult.Location  {
                        // 去重添加
                        //logger.Info("装配前的原始数据是：",target)
                        var flag = true
                        for _,selectTarget := range targetInfos  {
                            if strconv.FormatUint(target.TargetId, 10) == selectTarget.TargetId {

 labelFilter/readyDataForLabel.go

@@ -1,7 +1,7 @@
package labelFilter

import (
    "ruleprocess/logger"
    "basic.com/valib/logger.git"
    "ruleprocess/cache"
    "ruleprocess/structure"
    "time"

 labelFilter/req.go

@@ -4,11 +4,13 @@
    "basic.com/dbapi.git"
    "basic.com/valib/logger.git"
    "fmt"
    "github.com/golang/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"
    "ruleprocess/structure"
    "time"
)

@@ -81,6 +83,7 @@
}

func GoPush(url string) {

    var err error
    var msg []byte
    var sock mangos.Socket

 labelFilter/ruleForLabel.go

@@ -6,18 +6,11 @@
    "basic.com/valib/logger.git"
    "github.com/golang/protobuf/proto"
    "github.com/knetic/govaluate"
<<<<<<< HEAD
    "ruleprocess/logger"
=======
>>>>>>> master
    "ruleprocess/structure"
    "strconv"
    "time"
)

<<<<<<< HEAD
func Judge(msg structure.ResultMsg) {
=======
func PushSomthing(msg structure.ResultMsg) {
    defer func() {
        if err := recover(); err != nil {
@@ -25,7 +18,6 @@
        }
    }()
    start := time.Now()
>>>>>>> master
    // 装配成自己可以识别的数据
    label := new(Label)
    label.DataFormatToLabel(msg)

 main.go

@@ -17,9 +17,12 @@
    "fmt"
    "github.com/golang/protobuf/proto"
    "github.com/spf13/viper"
    "basic.com/valib/logger.git"

    "ruleprocess/cache"
    "ruleprocess/ruleserver"
    "sync"
    "github.com/spf13/viper"
)

var dbIp = flag.String("dbIp", "127.0.0.1", "dbserver ip")

 ruleserver/geoPolygon.go

@@ -20,10 +20,30 @@
    return num1
}

//Point 坐标点
type Point struct {
    X float64 `json:"x"`
    Y float64 `json:"y"`
}

//Rect 检测目标
type Rect struct {
    X      float64
    Y      float64
    Width  float64
    Height float64
}

//Pointfloat 坐标点
type Pointfloat struct {
    X float64 `json:"x"`
    Y float64 `json:"y"`
}

//PintIsInPolygon 判断点是否在多边形内部
//point为要判断的坐标点
//polygon是多边形各点数组
func pintIsInPolygon(point structure.Pointfloat, polygon []structure.Point, widthScale float64, heightScale float64) bool {
func pintIsInPolygon(point Pointfloat, polygon []Point, widthScale float64, heightScale float64) bool {
    var nCross int = 0
    for i := 0; i < len(polygon); i++ {

@@ -53,21 +73,17 @@
}

//GetLocation 将一个给定起始坐标，宽度长度的矩形区域均分为n方份并返回中心坐标（n为单边平分数值）和面积
<<<<<<< HEAD
func getLocation(rect structure.Rect, n int) ([]structure.Pointfloat, float64) {
=======
func getLocation(rect structure.Rect, n int) ([]Pointfloat, float64) {
>>>>>>> master
    xArr := make([]float64, n) // 用切片不用数组，数组不能用变量定义长度
    yArr := make([]float64, n)
    pointArr := make([]structure.Pointfloat, 0, n*n)
    pointArr := make([]Pointfloat, 0, n*n)
    for i := 0; i < n; i++ {
        xArr[i] = rect.X + (rect.Width/float64(2*n))*float64(2*i+1)
        yArr[i] = rect.Y + (rect.Height/float64(2*n))*float64(2*i+1)
    }
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            point := structure.Pointfloat{X: xArr[i], Y: yArr[j]}
            point := Pointfloat{X: xArr[i], Y: yArr[j]}
            pointArr = append(pointArr, point)
        }
    }
@@ -76,7 +92,7 @@
}

//ComputePolygonArea 计算任意多边形面积
func computePolygonArea(polygon []structure.Point) float64 {
func computePolygonArea(polygon []Point) float64 {
    pointNum := len(polygon)
    var s float64 = 0
    if pointNum < 3 {
@@ -90,11 +106,7 @@
}

//PgsInterPercent calculate percent of two polygon intersection  计算两个多边形的重叠占比
<<<<<<< HEAD
func PgsInterPercent(pgpts []structure.Point, box structure.Rect, widthScale float64, heightScale float64) (percent float64) {
=======
func PgsInterPercent(pgpts []Point, box structure.Rect, widthScale float64, heightScale float64) (percent float64) {
>>>>>>> master

    areapts, areaBox := getLocation(box, 10)
    var count = 0

 ruleserver/personTrack.go

@@ -2,8 +2,8 @@

import (
    "basic.com/pubsub/protomsg.git"
    "ruleprocess/logger"
    "github.com/golang/protobuf/proto"
    "basic.com/valib/logger.git"
    "ruleprocess/structure"
    "sync"
)
@@ -97,7 +97,6 @@
                        logger.Info("新建当前摄像机缓存池中的yolo个数：", yoloNum)
                        TrackPond[msg.Cid] = &PersonTrack{Yolo: yoloNum}
                    }
                    logger.Debug("---------------------------------人体追踪结束--------------------------------------")
                    return false
                }
            } else {
@@ -171,7 +170,6 @@
            }
        }
        logger.Info("反序列化重新装配之前人脸的个数：", len(faceParam.Faces))

        logger.Info("临时存储的新来数据：")
        for _, temp := range facesTemp {
            logger.Info("临时存储的新来的的face数据：", temp.Pos.FaceID, temp.Pos.FAngle.Confidence)

 ruleserver/readyDataForRule.go

@@ -3,6 +3,7 @@
import (
    "basic.com/dbapi.git"
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/logger.git"
    "encoding/json"
    "errors"
    "fmt"
@@ -13,7 +14,6 @@
    "nanomsg.org/go-mangos/transport/tcp"
    "net"
    "ruleprocess/cache"
    "ruleprocess/logger"
    "ruleprocess/structure"
    "strconv"
    "time"
@@ -123,14 +123,14 @@


// 将字符串格式的坐标序列化为Point格式
func Json2points(areaPoints string) []structure.Point {
    var pts []structure.Point
func Json2points(areaPoints string) []Point {
    var pts []Point
    if areaPoints == "[]" || areaPoints == "" {
        logger.Error("=====================此区域为全部区域")
        pts = append(pts, structure.Point{0, 0})
        pts = append(pts, structure.Point{0, 540})
        pts = append(pts, structure.Point{960, 540})
        pts = append(pts, structure.Point{960, 0})
        pts = append(pts, Point{0, 0})
        pts = append(pts, Point{0, 540})
        pts = append(pts, Point{960, 540})
        pts = append(pts, Point{960, 0})
    } else {
        err := json.Unmarshal([]byte(areaPoints), &pts)
        if err != nil {

 ruleserver/ruleToformula.go

@@ -1,6 +1,9 @@
package ruleserver

import (
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/logger.git"
    "github.com/knetic/govaluate"
    "plugin"
    "ruleprocess/cache"
    "ruleprocess/structure"
@@ -78,30 +81,6 @@
            }
        }
    }
}

func CallSo(sdkId string,rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult{
    // 根据sdkId查出其对应的sdk的soName，调用相应so的Entrance方法
    var soName = ""
    if sdkId == "812b674b-2375-4589-919a-5c1c3278a97e" {
        soName = "face.so"
    } else if sdkId == "812b674b-2375-4589-919a-5c1c3278a975"{
        soName = "intrusion.so"
    } else if sdkId == "812b674b-2375-4589-919a-5c1c3278a976" {
        soName = "personUnsual.so"
    } else if sdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
        soName = "faceCompare.so"
    }
    p,err :=  plugin.Open("./algorithm/"+soName)
    if err != nil {
        panic(err)
    }
    f,err1 := p.Lookup("Entrance")
    if err1 != nil {
        panic("没有找到入口函数")
    }
    ruleResult := f.(func(rule *protomsg.Rule, am *structure.AreaMap)structure.LittleRuleResult)(rule,am)
    return ruleResult
}

func CallMiddleware(args *structure.SdkDatas,rule protomsg.GroupRule) ([]*structure.LittleRuleResult, string, string){
@@ -484,59 +463,3 @@
    return cacheId
}

func timeRuleResult(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
    if rule.PolygonId == am.AreaId { // 首先规则所对应的区域id要跟区域数据的id对的上
        if rule.SdkArgAlias == "time_rule" { // 判断是否符合时间规
            //logger.Info("----------当前时间规则：---------", rule)
            // 根据放值字段里存的时间规则的id去另一个表里查需要比对的时间段（比如当前时间是周三，应根据区域id查出其周三的几个布防时间段，数组）
            //logger.Info("时间规则的测试")
            now := time.Now()
            index := getIndexOfWeek(now.Weekday().String())
            timeList := GetTimeById(rule.SdkArgValue, index)
            //logger.Info("当天的时间段集合：----------", timeList)
            //logger.Info("从数据库中查出的时间规则：", timeList)
            // 判断图片数据的时间是否符合当前规则 在一个即为true，全不在为false

            if rule.Operator == "satisfy" || rule.Operator == "==" { // 满足所选的时间规则
                flag := "false"
                for _, timeSlot := range timeList {
                    formula := "'" + timeSlot.Start + "'" + "<" + "'" + am.Time + "'"
                    expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
                    result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果

                    formula1 := "'" + timeSlot.End + "'" + ">" + "'" + am.Time + "'"
                    expression1, _ := govaluate.NewEvaluableExpression(formula1) // 得到数学公式
                    result1, _ := expression1.Evaluate(nil)                      // 得到数学公式的结果
                    //logger.Info("看看这两尊大神", result, result1)
                    if result.(bool) && result1.(bool) {
                        flag = "true"
                        break
                    }
                }
                return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort}
            }

            if rule.Operator == "unsatisfy" || rule.Operator == "!=" { // 不满足所选的时间规则
                flag := "true"
                for _, timeSlot := range timeList {
                    formula := "'" + timeSlot.Start + "'" + " < " + "'" + am.Time + "'"
                    //logger.Info("-----------------时间规则不满足的公式start：", formula)
                    expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
                    result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果

                    formula1 := "'" + timeSlot.End + "'" + " > " + "'" + am.Time + "'"
                    //logger.Info("-----------------时间规则不满足的公式end：", formula1)
                    expression1, _ := govaluate.NewEvaluableExpression(formula1) // 得到数学公式
                    result1, _ := expression1.Evaluate(nil)                      // 得到数学公式的结果
                    if result.(bool) && result1.(bool) {
                        flag = "false"
                        break
                    }
                }
                return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort}
            }

        }
    }
    return structure.LittleRuleResult{}
}

 ruleserver/server.go

@@ -4,7 +4,7 @@
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/gopherdiscovery.git"
    "github.com/gogo/protobuf/proto"
    "ruleprocess/logger"
    "basic.com/valib/logger.git"
    "time"
)

@@ -14,7 +14,7 @@

const (
    Discovery_Server = "tcp://0.0.0.0:40009"
    Discovery_UrlPubSub = "tcp://0.0.0.0:50009"
    Discovery_UrlPubSub = "tcp://0.0.0.0:50009"
)

//启动discovery的server

 ruleserver/timeTicker.go

@@ -2,7 +2,7 @@

import (
    "fmt"
    "ruleprocess/logger"
    "basic.com/valib/logger.git"
    "ruleprocess/structure"
    "strings"
    "time"

 structure/gragh.go

@@ -18,5 +18,4 @@
type Pointfloat struct {
    X float64 `json:"x"`
    Y float64 `json:"y"`
}

}

 util/simpleCV.go

@@ -156,7 +156,10 @@
    }
}

<<<<<<< HEAD

=======
>>>>>>> a87978244bbb81f2fa7610560ed190acbaa422f8
func DrawPolygonOnImageForYolo(cameraId string, img protomsg.Image, results []structure.Result,url string) (maps map[string]interface{}, err0 error) {

    rook, _ := gocv.NewMatFromBytes(int(img.Height), int(img.Width), gocv.MatTypeCV8UC3, img.Data)
@@ -173,7 +176,12 @@
        for i := 0; i < len(polygonIds); i++ {
            polygon := getPolygonById(polygonIds[i],cameraId)
            if polygon.Polygon != "[]" && polygon.Polygon != ""{
<<<<<<< HEAD
                DrawAPolygon(&rook,polygon.Polygon,yellow,scale)
=======
                logger.Debug("所画区域：",polygon.Polygon)
                DrawAPolygon(&rook,polygon.Polygon,yellow)
>>>>>>> a87978244bbb81f2fa7610560ed190acbaa422f8
            }
        }
    }
@@ -195,6 +203,7 @@
    defer rook.Close()

    yellow := color.RGBA{255, 255, 0, 0}
<<<<<<< HEAD
    scale := float64(img.Width) / 960 // 画图比例
    // 分割区域id集合并根据id查询区域然后画框
    for _,result := range results  {
@@ -203,6 +212,18 @@
            polygon := getPolygonById(polygonIds[i],cameraId)
            if polygon.Polygon != "[]" && polygon.Polygon != ""{
                DrawAPolygon(&rook,polygon.Polygon,yellow,scale)
=======

    // 分割区域id集合并根据id查询区域然后画框
    for _,result := range results  {
        polygonIds := strings.Split(result.AlarmPolygon,",")
        logger.Info("-----------------------看看报警区域id：",polygonIds)
        for i := 0; i < len(polygonIds)-1; i++ {
            polygon := getPolygonById(polygonIds[i],cameraId)
            if polygon.Polygon != "[]" && polygon.Polygon != ""{
                logger.Debug("所画区域：",polygon.Polygon)
                DrawAPolygon(&rook,polygon.Polygon,yellow)
>>>>>>> a87978244bbb81f2fa7610560ed190acbaa422f8
            }
        }
    }