抽出入侵和人员异常算法

panlei

2019-08-15 09da5bfd5f39f6e49e35f4c08a425680b317861b

抽出入侵和人员异常算法

 algorithm/intrusion/intrusion.go

@@ -7,81 +7,53 @@
    "ruleprocess/structure"
    "strconv"
)

func Entrance() {

}

// 过滤规则先筛选出符合条件的目标数量
func filterRule(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
    // 处理的都是yolo数据
//入侵算法
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" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
            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}
            }

            return filterRule(rule,am)
        } else {
            return structure.LittleRuleResult{}
        }

    } else {
        return structure.LittleRuleResult{}
    }
}

// 给数据库的规则表达式代参 args: 一条子规则，区域数据
func transferParameters(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
    if rule.PolygonId == am.AreaId { // 首先规则所对应的区域id要跟区域数据的id对的上
        if rule.SdkArgAlias == "objCount" { // 如果参数是要区域内目标数量 即yolo 人脸不会有数量
            //logger.Info("当前小规则是：---------", rule)
            //logger.Info("得出结果阶段", "比较的规则是：", rule)
            if rule.Operator == "" {
                return structure.LittleRuleResult{am.SdkName, strconv.Itoa(am.TargetNum) + "" + rule.RuleWithPre, rule.Sort} // 如果后面不跟操作符就直接返回数量  比如要跟下一个区域比较数量的就直接返回本区域的数量
            }
            //args := am.targetNum     targetNum 已成所有目标的总数量，这里只算yolo的
            var num int = 0
            for _, data := range am.FilterData {
                if data.IsYolo {
                    num++
                }
            }
            formula := strconv.Itoa(num) + " " + rule.Operator + " " + rule.SdkArgValue
            expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
            result, _ := expression.Evaluate(nil)          // 得到数学公式的结果
            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + " " + strconv.FormatBool(result.(bool)), rule.Sort}
            // 加上关于算法的判断条件，不能只有关于规则的，有的算法本身就是一个规则，如个体静止，靠右行,所以，拿到当前子规则的sdkid来判断是否是那些特殊的规则
// 过滤规则先筛选出符合条件的目标数量
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) // 得到符合条件的过滤数据
        }
    }
    return structure.LittleRuleResult{}
    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}
    }
}

 algorithm/personUnsual/personUnsual.go

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

import (
    "basic.com/pubsub/protomsg.git"
    "github.com/knetic/govaluate"
    "ruleprocess/logger"
    "ruleprocess/structure"
    "strconv"
)
// 人员异常算法
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" { // 判断的是相似值，占比，尺寸等过滤条件，如果再有，还可以再加
            return filterRule(rule,am)
        } else if rule.SdkArgAlias == "objCount" {
            return transferParameters(rule,am)
        } else {
            return structure.LittleRuleResult{}
        }
    } else {
        return structure.LittleRuleResult{}
    }
}

// 过滤规则先筛选出符合条件的目标数量
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) // 得到符合条件的过滤数据
        }
    }
    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}
    }
}

// 给数据库的规则表达式代参 args: 一条子规则，区域数据
func transferParameters(rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult {
    //logger.Info("当前小规则是：---------", rule)
    //logger.Info("得出结果阶段", "比较的规则是：", rule)
    if rule.Operator == "" {
        return structure.LittleRuleResult{am.SdkName, strconv.Itoa(am.TargetNum) + "" + rule.RuleWithPre, rule.Sort} // 如果后面不跟操作符就直接返回数量  比如要跟下一个区域比较数量的就直接返回本区域的数量
    }
    //args := am.targetNum     targetNum 已成所有目标的总数量，这里只算yolo的
    var num int = 0
    for _, data := range am.FilterData {
        if data.IsYolo {
            num++
        }
    }
    formula := strconv.Itoa(num) + " " + rule.Operator + " " + rule.SdkArgValue
    expression, _ := govaluate.NewEvaluableExpression(formula) // 得到数学公式
    result, _ := expression.Evaluate(nil)                      // 得到数学公式的结果
    return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + " " + strconv.FormatBool(result.(bool)), rule.Sort}
    // 加上关于算法的判断条件，不能只有关于规则的，有的算法本身就是一个规则，如个体静止，靠右行,所以，拿到当前子规则的sdkid来判断是否是那些特殊的规则
}

 ruleserver/ruleToformula.go

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

import (
    "plugin"
    "ruleprocess/cache"
    "ruleprocess/logger"
    "ruleprocess/structure"
@@ -63,6 +64,72 @@
    }
}

func RunRule1(args *structure.SdkDatas, groupRule *protomsg.GroupRule, taskId string, message *protomsg.SdkMessage, label structure.Others) bool {
    defer func() {
        if err := recover(); err != nil {
            logger.Error("比对规则有误", err)
        }
    }()
    logger.Info("+++++++++++规则开始运行+++++++++++++++++当前大规则--：", (*groupRule).GroupText)
    //logger.Warn("传进去之后是什么德行：",args.RuleResult["yolo"])
    Compare(args, groupRule)
    resultSplice := []*structure.LittleRuleResult{}
    sdkNames := ""
    polygonId := ""
    // 先过完条件规则
    for j := 0; j < len(groupRule.Rules); j++ {
        for _, sdkData := range args.Sdkdata {
            // 根据规则的sdkId查出其对应的ipcId，用ipcId去找该比对的数据
            sdk, err := cache.GetSdkById(groupRule.Rules[j].SdkId)
            if err != nil {
                logger.Error("没查到sdk的信息---", err)
            }
            ipcId := sdk.IpcId
            sdkName := sdk.SdkName
            //logger.Info("规则的ipcId与sdkData的IpcId:", ipcId, "===", sdkData.IpcId)
            if ipcId == sdkData.IpcId {
                //logger.Info("当前走的规则是--：", sdkName, "---","")
                for _, areaMap := range sdkData.AreaMapList {
                    ruleResult := CallSo(sdk.Id,groupRule.Rules[j],areaMap)
                    //ruleResult := filterRule(groupRule.Rules[j], areaMap)
                    if ruleResult.Result != "" {
                        logger.Info("条件规则结果：", ruleResult.Result)
                        // 如果结果为真，把这条规则中的区域置为有效
                        if strings.Contains(ruleResult.Result, "true") {
                            areaMap.IsEffective = true
                        }
                        // 如果此结果为真且当前过的是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)
                    }
                }
            }
        }
    }

}

func CallSo(sdkId string,rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult{
    // 根据sdkId查出其对应的sdk的soName，调用相应so的Entrance方法
    var soName = "intrusion.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))(rule,am)
    return ruleResult
}

func RunRule(args *structure.SdkDatas, groupRule *protomsg.GroupRule, taskId string, message *protomsg.SdkMessage, label structure.Others) bool {
    defer func() {
        if err := recover(); err != nil {