---

panlei

2019-12-16 44d5e620bf62e4b1c70f16af980738d5c4c7d517

 algorithm/middleware/middleware.go

@@ -2,23 +2,64 @@

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

func Entrance (args *structure.SdkDatas,groupRule protomsg.GroupRule) {
func Entrance (args *structure.SdkDatas,groupRule protomsg.GroupRule,lable *structure.Others,message *protomsg.SdkMessage) (bool,string,string){
   resultSplice := []*structure.LittleRuleResult{}
   sdkNames := ""
   polygonId := ""

   // 这步过的是时间段规则（时间段等）
   for j := 0; j < len(groupRule.Rules); j++ {
      for _, sdkData := range args.Sdkdata {
         sdk, err := cache.GetSdkById(groupRule.Rules[j].SdkId)
         if err != nil {
            logger.Error("没查到sdk的信息---", err)
         }
         ipcId := sdk.IpcId
         sdkName := sdk.SdkName
         if ipcId == sdkData.IpcId {
            for _, areaMap := range sdkData.AreaMapList {
               ruleResult := timeRuleResult(groupRule.Rules[j], areaMap)
               if ruleResult.Result != "" {
                  if strings.Contains(ruleResult.Result, "false") {
                     return false,"",""  // 不符合时间规则的话直接返回，不再浪费程序执行
                  }
                  if strings.Contains(ruleResult.Result, "true") {
                     areaMap.IsEffective = true
                  }
                  //logger.Info("时间规则结果：", ruleResult.Result)
                  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)
               }
            }
         }
      }
   }
   // 先过完条件规则
   for j := 0; j < len(groupRule.Rules); j++ {
      if groupRule.Rules[j].SdkArgAlias == "score" || groupRule.Rules[j].SdkArgAlias == "proportion" || groupRule.Rules[j].SdkArgAlias == "size" || (groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && groupRule.Rules[j].SdkArgAlias != "time_rule"){

      carFlag := groupRule.Rules[j].SdkArgAlias == "license" ||  groupRule.Rules[j].SdkArgAlias == "nConfidence" || groupRule.Rules[j].SdkArgAlias == "fConfidence" ||
         groupRule.Rules[j].SdkArgAlias == "nType" || groupRule.Rules[j].SdkArgAlias == "nVehicleColor1" ||  groupRule.Rules[j].SdkArgAlias == "nVehicleBright" || groupRule.Rules[j].SdkArgAlias == "nCarColor" ||
      groupRule.Rules[j].SdkArgAlias == "fVDConf" || groupRule.Rules[j].SdkArgAlias == "nVehicleColor2" ||  groupRule.Rules[j].SdkArgAlias == "nColor" || groupRule.Rules[j].SdkArgAlias == "nPlateFlag"

      if groupRule.Rules[j].SdkArgAlias == "score" || groupRule.Rules[j].SdkArgAlias == "proportion" || groupRule.Rules[j].SdkArgAlias == "size" ||
         (groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && groupRule.Rules[j].SdkArgAlias != "time_rule") || carFlag{
         for _, sdkData := range args.Sdkdata {
            // 根据规则的sdkId查出其对应的ipcId，用ipcId去找该比对的数据
            sdk, err := cache.GetSdkById(groupRule.Rules[j].SdkId)
@@ -29,22 +70,27 @@
            sdkName := sdk.SdkName
            //logger.Info("规则的ipcId与sdkData的IpcId:", ipcId, "===", sdkData.IpcId)
            if ipcId == sdkData.IpcId {
               //logger.Info("当前走的规则是--：", sdkName, "---","")
               //logger.Info("当前走的规则是--：", groupRule.Rules[j],sdkName,groupRule.Rules[j].SdkArgAlias, "---","")
               for _, areaMap := range sdkData.AreaMapList {
                  ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap)
                  ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap,lable,args,message)
                  logger.Info("前置连接符：",groupRule.Rules[j])
                  if groupRule.Rules[j].RuleWithPre == "⊇" && len(ruleResult.Target) > 0 {
                     assembleDta(resultSplice[len(resultSplice)-1].Target,ruleResult.Target)
                     // 把当前小规则结果置空
                     ruleResult = structure.LittleRuleResult{}
                  }
                  if ruleResult.Result != "" {
                     logger.Info("条件规则结果：", 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 + ","
                        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)
                  }
@@ -53,6 +99,7 @@
         }
      }
   }
   // 人脸
   for j := 0; j < len(groupRule.Rules); j++ {
      if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a972" && groupRule.Rules[j].SdkArgAlias != "time_rule"{
         for _, sdkData := range args.Sdkdata {
@@ -67,21 +114,120 @@
            if ipcId == sdkData.IpcId {
               //logger.Info("当前走的规则是--：", sdkName, "---","")
               for _, areaMap := range sdkData.AreaMapList {
                  ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap)
                  ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap,lable,args,message)
                  if ruleResult.Result != "" {
                     logger.Info("人脸比对规则结果：", 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 + ","
                        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)
                  }
               }
            }
         }
      }
   }
   // 个体静止
   for j := 0; j < len(groupRule.Rules); j++ {
      if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a977" && groupRule.Rules[j].SdkArgAlias == "duration"{
         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("当前走的规则是--：", groupRule.Rules[j],sdkName,groupRule.Rules[j].SdkArgAlias, "---","")
               for _, areaMap := range sdkData.AreaMapList {
                  ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap,lable,args,message)
                  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 + " "
                     }
                     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)
                  }
               }
            }
         }
      }
   }
   // 车辆
   for j := 0; j < len(groupRule.Rules); j++ {
      if groupRule.Rules[j].SdkId == "812b674b-2375-4589-919a-5c1c3278a978" && (groupRule.Rules[j].SdkArgAlias == "nCarCount" || groupRule.Rules[j].SdkArgAlias == "nCarLogoCount"){
         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("当前走的规则是--：", groupRule.Rules[j],sdkName,groupRule.Rules[j].SdkArgAlias, "---","")
               for _, areaMap := range sdkData.AreaMapList {
                  ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap,lable,args,message)
                  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 + " "
                     }
                     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)
                  }
               }
            }
         }
      }
   }
   // 跨摄像机跟踪
   for j := 0; j < len(groupRule.Rules); j++ {
      if groupRule.Rules[j].SdkId == "520af340-f257-4fe2-ac3c-695c390e53dc" && groupRule.Rules[j].SdkArgAlias == "cmpThreshold"{
         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
            if ipcId == sdkData.IpcId {
               //logger.Info("当前走的规则是--：", groupRule.Rules[j],sdkName,groupRule.Rules[j].SdkArgAlias, "---","")
               for _, areaMap := range sdkData.AreaMapList {
                  ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap,lable,args,message)
                  if ruleResult.Result != "" {
                     //logger.Info("车牌结果：", ruleResult.Result)
                     // 如果结果为真，把这条规则中的区域置为有效
                     if strings.Contains(ruleResult.Result, "true") {
                        areaMap.IsEffective = true
                     }

                     resultSplice = append(resultSplice, &ruleResult)
                  }
               }
@@ -102,17 +248,17 @@
            sdkName := sdk.SdkName
            if ipcId == sdkData.IpcId {
               for _, areaMap := range sdkData.AreaMapList {
                  ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap)
                  ruleResult := CallSo(sdk.Id, groupRule.Rules[j], areaMap,lable,args,message)
                  if ruleResult.Result != "" {
                     if strings.Contains(ruleResult.Result, "true") {
                        areaMap.IsEffective = true
                     }
                     logger.Info("数量规则结果：", ruleResult.Result)
                     //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)
                  }
@@ -121,34 +267,37 @@
         }
      }
   }
   // 这步过的是时间段规则（时间段等）
   for j := 0; j < len(groupRule.Rules); j++ {
      for _, sdkData := range args.Sdkdata {
         sdk, err := cache.GetSdkById(groupRule.Rules[j].SdkId)
         if err != nil {
            logger.Error("没查到sdk的信息---", err)
         }
         ipcId := sdk.IpcId
         sdkName := sdk.SdkName
         if ipcId == sdkData.IpcId {
            for _, areaMap := range sdkData.AreaMapList {
               ruleResult := timeRuleResult(groupRule.Rules[j], areaMap)
               if ruleResult.Result != "" {
                  if strings.Contains(ruleResult.Result, "true") {
                     areaMap.IsEffective = true
                  }
                  logger.Info("时间规则结果：", ruleResult.Result)
                  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)
               }
            }
         }

   // 将数组按sort排序
   sort.Sort(ruleserver.ResultList(resultSplice))
   // 排序后取各自的结果和连接符拼出规则表达式得出结果
   completeFormula := ""
   for _, va := range resultSplice {
      completeFormula = completeFormula + va.Result
   }
   if strings.HasPrefix(completeFormula, "&&") || strings.HasPrefix(completeFormula, "||") || strings.HasPrefix(completeFormula, ">=") || strings.HasPrefix(completeFormula, "<=") || strings.HasPrefix(completeFormula, "==") || strings.HasPrefix(completeFormula, "!=") || strings.HasPrefix(completeFormula, ">") || strings.HasPrefix(completeFormula, "<") {
      // 以这些开头的基本是联动任务
      if strings.HasPrefix(completeFormula, "&&") || strings.HasPrefix(completeFormula, "||") || strings.HasPrefix(completeFormula, ">=") || strings.HasPrefix(completeFormula, "<=") || strings.HasPrefix(completeFormula, "==") || strings.HasPrefix(completeFormula, "!=") {
         completeFormula = completeFormula[2:]
      }
      if strings.HasPrefix(completeFormula, ">") || strings.HasPrefix(completeFormula, "<") {
         completeFormula = completeFormula[1:]
      }
      logger.Info("-------------------看看拔毛后的表达式：", completeFormula)
      //expression, _ := govaluate.NewEvaluableExpression(completeFormula)
      //result, _ := expression.Evaluate(nil) // 得到数学公式的结果
      //return result.(bool)
   }
   if completeFormula != "" {
      logger.Info("结果公式-----------：", completeFormula)
      expression, err2 := govaluate.NewEvaluableExpression(completeFormula)
      if strings.HasPrefix(completeFormula, "&&") || strings.HasPrefix(completeFormula, "||") || err2 != nil {
         panic("规则有误，得到的数学公式不可解析")
      }
      result, _ := expression.Evaluate(nil) // 得到数学公式的结果
      return result.(bool),sdkNames,polygonId
   } else {
      return false,sdkNames,polygonId
   }
}

@@ -181,7 +330,7 @@
                  break
               }
            }
            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort}
            return structure.LittleRuleResult{SdkName:am.SdkName, Result:rule.RuleWithPre + "" + flag, Sort:rule.Sort}
         }

         if rule.Operator == "unsatisfy" || rule.Operator == "!=" { // 不满足所选的时间规则
@@ -201,7 +350,7 @@
                  break
               }
            }
            return structure.LittleRuleResult{am.SdkName, rule.RuleWithPre + "" + flag, rule.Sort}
            return structure.LittleRuleResult{SdkName:am.SdkName, Result:rule.RuleWithPre + "" + flag, Sort:rule.Sort}
         }

      }
@@ -209,18 +358,33 @@
   return structure.LittleRuleResult{}
}

func CallSo(sdkId string,rule *protomsg.Rule, am *structure.AreaMap) structure.LittleRuleResult{
func CallSo(sdkId string,rule *protomsg.Rule, am *structure.AreaMap,lable *structure.Others,args *structure.SdkDatas,message *protomsg.SdkMessage) structure.LittleRuleResult{
   // 根据sdkId查出其对应的sdk的soName，调用相应so的Entrance方法
   var soName = ""
   if sdkId == "812b674b-2375-4589-919a-5c1c3278a97e" {

   switch sdkId {
   case "812b674b-2375-4589-919a-5c1c3278a97e":
      soName = "face.so"
   } else if sdkId == "812b674b-2375-4589-919a-5c1c3278a975"{
   case "812b674b-2375-4589-919a-5c1c3278a975":
      soName = "intrusion.so"
   } else if sdkId == "812b674b-2375-4589-919a-5c1c3278a976" {
   case "812b674b-2375-4589-919a-5c1c3278a976":
      soName = "personUnsual.so"
   } else if sdkId == "812b674b-2375-4589-919a-5c1c3278a972" {
   case "812b674b-2375-4589-919a-5c1c3278a973":
      soName = "personUnsual.so"
   case "812b674b-2375-4589-919a-5c1c3278a972":
      soName = "faceCompare.so"
   case "812b674b-2375-4589-919a-5c1c3278a977":
      soName = "static.so"
   case "812b674b-2375-4589-919a-5c1c3278a978":
      soName = "plate.so"
   case "520af340-f257-4fe2-ac3c-695c390e53dc":
      soName = "personTrack.so"
   }
   //soInfo,err := cache.GetSoInfoById(sdkId)
   //if err != nil {
   //   panic("没读到注册表")
   //}
   //soName := soInfo.SoName
   p,err :=  plugin.Open("./algorithm/"+soName)
   if err != nil {
      panic(err)
@@ -229,7 +393,8 @@
   if err1 != nil {
      panic("没有找到入口函数")
   }
   ruleResult := f.(func(rule *protomsg.Rule, am *structure.AreaMap)structure.LittleRuleResult)(rule,am)
   //logger.Info("发给so的数据：",sdkId,rule.SdkArgValue,rule.Operator,rule.SdkArgAlias)
   ruleResult := f.(func(rule *protomsg.Rule, am *structure.AreaMap,lable *structure.Others, args *structure.SdkDatas,message *protomsg.SdkMessage)structure.LittleRuleResult)(rule,am,lable,args,message)
   return ruleResult
}

@@ -259,4 +424,71 @@
      }
   }
   return 0
}
}

//// 时间段调度
//func timeDispatch(args *structure.SdkDatas,groupRule protomsg.GroupRule,resultSplice []*structure.LittleRuleResult,sdkNames,polygonId string) (bool,string,string){
//   // 这步过的是时间段规则（时间段等）
//   for j := 0; j < len(groupRule.Rules); j++ {
//      for _, sdkData := range args.Sdkdata {
//         sdk, err := cache.GetSdkById(groupRule.Rules[j].SdkId)
//         if err != nil {
//            logger.Error("没查到sdk的信息---", err)
//         }
//         ipcId := sdk.IpcId
//         sdkName := sdk.SdkName
//         if ipcId == sdkData.IpcId {
//            for _, areaMap := range sdkData.AreaMapList {
//               ruleResult := timeRuleResult(groupRule.Rules[j], areaMap)
//               if ruleResult.Result != "" {
//                  if strings.Contains(ruleResult.Result, "false") {
//                     return false,"",""  // 不符合时间规则的话直接返回，不再浪费程序执行
//                  }
//                  if strings.Contains(ruleResult.Result, "true") {
//                     areaMap.IsEffective = true
//                  }
//                  //logger.Info("时间规则结果：", ruleResult.Result)
//                  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)
//               }
//            }
//         }
//      }
//   }
//}

//func assembleData(args *structure.SdkDatas,resultSplice []*structure.LittleRuleResult,groupRule protomsg.GroupRule) {
//   for index,result := range resultSplice {
//      if strings.Contains(result.Result,"contain") {
//         assembleDta(args,groupRule.Rules[index-1],groupRule.Rules[index])
//         // 删除带有contain的规则结果
//         resultSplice = append(resultSplice[:index],resultSplice[index+1:]...)
//      }
//   }
//}
// 如果规则组中有包含符号，把规则组之后的规则对应的算法和区域提取的数据装配到前面去
func assembleDta(targets1,targets2 []*structure.Arg) {
   if len(targets1) > 0 {
      logger.Info("有人体：",len(targets1))
      for _,target := range targets1 {
         mergeArg(target,targets2)
         targets2 = nil
         return // 装配一次就可以
      }
   }
}

func mergeArg(arg *structure.Arg,targets2 []*structure.Arg) {
   for _,arg1 := range targets2 {
      logger.Info("人脸：",arg1.Location,arg1.Score)
      precent := ruleserver.PgsInterPercent(Rect2Point(arg.Location),arg1.Location,1,1)
      if precent > 99 {
         arg.AttachArg = arg1.SourceArg
      }
   }
}