cory/zmkgC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始

Browse Source
This commit is contained in:
罗成
2025-07-07 20:11:59 +08:00
parent ab0fdbc447
commit 06e3aa2eb3
2009 changed files with 193082 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
third/arithmetic/SpartaApi/entity.go Normal file
View File

@ -0,0 +1,34 @@
package SpartaApi
//type UniversalEntity struct {
// code string `json:"code" dc:"200:业务处理成功；40x:访问权限错误；50x:系统错误。"`
// msg string `json:"msg" dc:"结果消息提示，如：success"`
// data string `json:"leftTopPoint" dc:"业务执行结果(obj/arr)"`
//}
type TokenEntity struct {
Token string `json:"token" dc:"token"`
ExpiresAt int `json:"expires_at" dc:"过期时间"`
}
type RecognizeReq struct {
CapUrl string `json:"capUrl" v:"required" dc:"v-在线图片地址"`
RecType string `json:"recType" v:"required" dc:"v-识别算法模型"`
Async string `json:"async" dc:"是否异步处理：false：默认值，算法识别完后同步返回，接口请求会等待（适用于识别时间较长的模型）；true: 收到请求后，算法服务器会异步识别"`
CallBackUrl string `json:"callBackUrl" dc:"若为异步，则需要此参数，系统会将结果post到这个接口中"`
AreaHigh string `json:"area_high" dc:"若为异步，则需要此参数，系统会将结果post到这个接口中"`
}
type RecognizeRes struct {
HasTarget int `json:"hasTarget" dc:"是否监测到目标：1：是；0：否"`
OriginalImgSize []int `json:"originalImgSize" dc:"原始图片尺寸（[宽,高]），ex：[1920,1080]"`
Targets []TargetsEntity `json:"targets" dc:"目标信息"`
}
type TargetsEntity struct {
PhoNumber int `json:"pho_number" dc:"在光伏板检测的时候会多输出一个参数代表光伏板的数量"`
Type string `json:"type" dc:"目标信息"`
Size []float64 `json:"size" dc:"目标外接矩形像素"`
LeftTopPoint []float64 `json:"leftTopPoint" dc:"目标在画面中左上角位置信息"`
Score float64 `json:"score" dc:"置信度得分（0~1）"`
}

635
third/arithmetic/SpartaApi/entrance.go Normal file
View File

@ -0,0 +1,635 @@
package SpartaApi
import (
"context"
"encoding/json"
"errors"
"fmt"
"github.com/tiger1103/gfast/v3/library/liberr"
"io"
"log"
"net/url"
"os"
"strings"
"time"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gctx"
"github.com/tiger1103/gfast-cache/cache"
"github.com/tiger1103/gfast/v3/api/v1/common/coryCommon"
commonService "github.com/tiger1103/gfast/v3/internal/app/common/service"
)
const (
Sensitivity = 0.6 // 识别灵敏度 //AI工单（摄像头）
CAMERA = "head smoke" // AI工单（摄像头）
UAV_MATRIX = "pho hole shelves pile" // 方阵内容
UAV_MACHINE = "excavator Roller Truck_crane Loader Submersible_drilling_rig Sprinkler Truck_mounted_crane Truck" // 大型机械
//远界
YJCAMERA = "fire,hardhat,smoking"
)
var Url = g.Cfg().MustGet(gctx.New(), "spartaApi.Url").String()
var yjUrl = g.Cfg().MustGet(gctx.New(), "yjSpartaApi.Url").String()
// 定义一个映射来存储不同的类型及其对应的描述
var typeDescriptions = map[string]string{
"head": "未带安全帽",
"smoke": "吸烟",
"belt": "未系安全带",
"excavator": "挖掘机",
"Roller": "压路机",
"Truck_crane": "汽车吊",
"Loader": "装载机",
"Submersible_drilling_rig": "潜挖钻机",
"Sprinkler": "沙水车",
"Truck_mounted_crane": "随车吊",
"Truck": "货车",
//远界
"nohelmet": "未戴安全帽",
"cigarette": "吸烟",
"fire": "火灾",
"smoggy": "烟雾",
}
// @Title GetDescription 2024/8/7 17:34:00
// @Description 可复用的函数，根据输入的类型返回对应的描述
// @Auth Cory
func GetDescription(tp string) string {
if description, exists := typeDescriptions[tp]; exists {
return description
}
return "未知类型"
}
//func init() {
// fmt.Println("斯巴达----------------")
// token, _ := spartaApiTokenFunc()
// fmt.Println("token----------------", token)
//}
// @Title spartaApiTokenFunc 2024/8/7 17:35:00
// @Description 登录获取身份凭证
// @Auth Cory
func spartaApiTokenFunc() (token string, err error) {
key := "arithmetic:token"
ctx := gctx.New()
prefix := g.Cfg().MustGet(ctx, "system.cache.prefix").String()
gfCache := cache.New(prefix)
get, err := g.Redis().Get(ctx, gfCache.CachePrefix+key)
if err != nil && get.String() != "" {
token = get.String()
return token, err
} else {
clientId := g.Cfg().MustGet(gctx.New(), "spartaApi.key")
clientSecret := g.Cfg().MustGet(gctx.New(), "spartaApi.secret")
uri := Url + "/token?clientId=" + clientId.String() + "&clientSecret=" + clientSecret.String()
response, err := g.Client().Get(gctx.New(), uri)
if err != nil {
return "", err
}
var tk *TokenEntity
err = json.Unmarshal([]byte(response.ReadAllString()), &tk)
if err != nil {
return "", err
} else {
tk.Token = "Basic " + tk.Token
}
// 将token存储到redis中，tiken默认时间为秒，(这里少5000秒,防止token过期还存在redis中)
commonService.Cache().Set(ctx, key, tk.Token, time.Duration(tk.ExpiresAt-5000)*time.Second)
token = tk.Token
return token, err
}
}
//// @Title CommonAlgorithmTwoFunc 2024/8/7 17:06:00
//// @Description 提供算法得到的目标信息
//// @Auth Cory
//func CommonAlgorithmTwoFunc(ctx context.Context, recognize *RecognizeReq) (result *RecognizeRes, flag bool, err error) {
// result = new(RecognizeRes)
// flag = false
// // 1、调用算法
// body, err := ObjectIdentificationFunc(ctx, recognize)
// if err != nil {
// return
// }
// // 2、组装数据
// err = json.Unmarshal(body, &result)
// if err != nil {
// return
// }
// // 3、布尔值
// if len(result.Targets) == 0 { // 表示无违规操作
// return
// } else { // 表述有违规操作
// flag = true
// return
// }
//}
// @Title CommonAlgorithmTwoUav 2024/8/7 17:06:00
// @Description 提供算法得到的目标信息【飞机专用】
// @Auth Cory
func CommonAlgorithmTwoUav(ctx context.Context, recognize *RecognizeReq) (result *RecognizeRes, flag bool, err error) {
result = new(RecognizeRes)
flag = false
//// 1、调用算法
//body, err := ObjectIdentificationFunc(ctx, recognize)
//if err != nil {
// return
//}
recognizeResult := `{
"hasTarget": 1,
"originalImgSize": [1920, 1080],
"targets": [
{
"type": "pho",
"size": [282, 274],
"leftTopPoint": [3192, 2758],
"score": 0.6154276132583618
},
{
"type": "pho",
"size": [343, 139],
"leftTopPoint": [4577, 2836],
"score": 0.722245454788208
},
{
"type": "pho",
"size": [372, 158],
"leftTopPoint": [4554, 3761],
"score": 0.7273581027984619
},
{
"type": "pho",
"size": [351, 129],
"leftTopPoint": [4124, 2251],
"score": 0.749356746673584
},
{
"type": "pho",
"size": [336, 152],
"leftTopPoint": [4211, 2379],
"score": 0.7633119225502014
},
{
"type": "pho",
"size": [343, 147],
"leftTopPoint": [4321, 2515],
"score": 0.7663174867630005
},
{
"type": "pho",
"size": [333, 152],
"leftTopPoint": [4933, 2771],
"score": 0.7939081192016602
},
{
"type": "pho",
"size": [334, 143],
"leftTopPoint": [4574, 2966],
"score": 0.8044442534446716
},
{
"type": "pho",
"size": [332, 138],
"leftTopPoint": [4243, 2921],
"score": 0.8075516819953918
},
{
"type": "pho",
"size": [315, 156],
"leftTopPoint": [3628, 2535],
"score": 0.8091028332710266
},
{
"type": "pho",
"size": [336, 129],
"leftTopPoint": [3913, 3655],
"score": 0.8116179704666138
},
{
"type": "pho",
"size": [342, 139],
"leftTopPoint": [4471, 2290],
"score": 0.814013659954071
},
{
"type": "pho",
"size": [350, 143],
"leftTopPoint": [4528, 2432],
"score": 0.8172851800918579
},
{
"type": "pho",
"size": [342, 171],
"leftTopPoint": [3992, 2469],
"score": 0.8185974359512329
},
{
"type": "pho",
"size": [338, 149],
"leftTopPoint": [4433, 3345],
"score": 0.8222267031669617
},
{
"type": "pho",
"size": [332, 134],
"leftTopPoint": [4284, 2660],
"score": 0.8247078657150269
},
{
"type": "pho",
"size": [328, 134],
"leftTopPoint": [4616, 2713],
"score": 0.8274019956588745
},
{
"type": "pho",
"size": [350, 139],
"leftTopPoint": [4928, 3685],
"score": 0.8295787572860718
},
{
"type": "pho",
"size": [339, 136],
"leftTopPoint": [4908, 2905],
"score": 0.8317150473594666
},
{
"type": "pho",
"size": [339, 135],
"leftTopPoint": [4232, 3708],
"score": 0.8319769501686096
},
{
"type": "pho",
"size": [323, 141],
"leftTopPoint": [3461, 3167],
"score": 0.8382804989814758
},
{
"type": "pho",
"size": [368, 132],
"leftTopPoint": [3761, 3219],
"score": 0.8471034169197083
},
{
"type": "pho",
"size": [338, 140],
"leftTopPoint": [3894, 2986],
"score": 0.8511925339698792
},
{
"type": "pho",
"size": [337, 144],
"leftTopPoint": [3580, 2942],
"score": 0.8524681329727173
},
{
"type": "pho",
"size": [348, 142],
"leftTopPoint": [3620, 3467],
"score": 0.8603440523147583
},
{
"type": "pho",
"size": [352, 145],
"leftTopPoint": [4632, 2584],
"score": 0.8645903468132019
},
{
"type": "pho",
"size": [365, 139],
"leftTopPoint": [4585, 3633],
"score": 0.8663488626480103
},
{
"type": "pho",
"size": [323, 138],
"leftTopPoint": [3919, 2847],
"score": 0.8686794638633728
},
{
"type": "pho",
"size": [394, 155],
"leftTopPoint": [3644, 3335],
"score": 0.8729261755943298
},
{
"type": "pho",
"size": [328, 143],
"leftTopPoint": [4274, 3576],
"score": 0.8783137798309326
},
{
"type": "pho",
"size": [300, 314],
"leftTopPoint": [3247, 2571],
"score": 0.879583477973938
},
{
"type": "pho",
"size": [660, 217],
"leftTopPoint": [4903, 3817],
"score": 0.8797935843467712
},
{
"type": "pho",
"size": [331, 170],
"leftTopPoint": [3923, 2713],
"score": 0.8806164264678955
},
{
"type": "pho",
"size": [332, 140],
"leftTopPoint": [4240, 2782],
"score": 0.8832747936248779
},
{
"type": "pho",
"size": [318, 143],
"leftTopPoint": [4129, 3295],
"score": 0.8922125101089478
},
{
"type": "pho",
"size": [349, 143],
"leftTopPoint": [3867, 3116],
"score": 0.8925455808639526
},
{
"type": "pho",
"size": [333, 138],
"leftTopPoint": [4016, 3404],
"score": 0.8939041495323181
},
{
"type": "pho",
"size": [353, 158],
"leftTopPoint": [3942, 2604],
"score": 0.8950177431106567
},
{
"type": "pho",
"size": [350, 148],
"leftTopPoint": [4655, 3507],
"score": 0.9090152382850647
},
{
"type": "pho",
"size": [322, 153],
"leftTopPoint": [3587, 2792],
"score": 0.9102197289466858
},
{
"type": "pho",
"size": [348, 159],
"leftTopPoint": [4777, 3397],
"score": 0.9125684499740601
}
],
"pho_number": 41
}`
body := []byte(recognizeResult)
// 2、组装数据
err = json.Unmarshal(body, &result)
if err != nil {
fmt.Println("Error:", err)
return
}
// 3、布尔值
if len(result.Targets) == 0 { // 表示无违规操作
flag = false
} else { // 表述有违规操作
flag = true
}
//绘图
replace := strings.Replace(recognize.CapUrl, coryCommon.GlobalPath, "", 1)
imgPath := coryCommon.FileToFunc(replace, 2)
num := 0
mp := make(map[string]string)
entity := coryCommon.TestDrawRectTextEntity{
ImPath: imgPath,
}
var zuobiao []*coryCommon.CoordinatesListEntity
for _, data := range result.Targets {
if data.Score >= Sensitivity {
tp := data.Type
mp[tp] = GetDescription(tp)
flag = true
num = num + 1
zuobiao = append(zuobiao, &coryCommon.CoordinatesListEntity{
X: data.LeftTopPoint[0],
Y: data.LeftTopPoint[1],
W: data.Size[0],
H: data.Size[1],
})
}
}
entity.Coordinates = zuobiao
coryCommon.TestDrawRectTextFunc(&entity)
return
}
/*
hat：安全帽识别；
head：不戴安全帽识别；
smoke：吸烟识别；
belt : 安全带识别；
waste ：工程垃圾识别（暂无）
excavator：挖掘机；
Roller：压路机；
Truck_crane：汽车吊；
Loader：装载机；
Submersible_drilling_rig：潜挖钻机；
Sprinkler：洒水车；
Truck_mounted_crane：随车吊；
Truck：货车
pho：光伏板
hole:洞
shelves：架子
*/
func ObjectIdentificationFunc(ctx context.Context, recognize *RecognizeReq) (body []byte, err error) {
// 1、获取token
token, err := spartaApiTokenFunc()
if err != nil {
err = errors.New("获取斯巴达token错误！" + err.Error())
return
}
// 2、设置请求数据
uri := Url + "/api/recognize?capUrl=" + recognize.CapUrl +
"&recType=" + url.QueryEscape(recognize.RecType) +
"&async=" + recognize.Async +
"&callBackUrl=" + recognize.CallBackUrl +
"&area_high=" + recognize.AreaHigh
response, err := g.Client().ContentJson().SetHeaderMap(map[string]string{
"Authorization": token,
}).Get(gctx.New(), uri)
defer response.Body.Close()
// 3、返回数据
body, err = io.ReadAll(response.Body)
fmt.Println("请求的URL ", uri)
return
}
// @Title CommonAlgorithmFunc 2024/8/7 17:07:00
// @Description 调用算法，得到目标信息，然后圈出来
// @Auth Cory
func CommonAlgorithmFunc(ctx context.Context, recognize *RecognizeReq) (mp map[string]string, flag bool, num int, err error) {
flag = false
num = 0
// 0、记录绝对路径，以便后续操作 //absolutePath := "C:\\Users\\MSI\\Pictures\\222.png"
absolutePath := recognize.CapUrl
prefix := g.Cfg().MustGet(gctx.New(), "spartaApi.prefix")
recognize.CapUrl = replacePrefix(recognize.CapUrl, "/resource/public/", prefix.String()+"/file/")
// 1、调用算法
body, err := ObjectIdentificationFunc(ctx, recognize)
if err != nil {
return
}
// 2、组装数据
var data []json.RawMessage
err = json.Unmarshal(body, &data)
if err != nil {
fmt.Println("Error:", err)
return
}
var result RecognizeRes
for i, rawMsg := range data {
switch i {
case 0:
err = json.Unmarshal(rawMsg, &result.HasTarget)
case 1:
err = json.Unmarshal(rawMsg, &result.OriginalImgSize)
default:
var target TargetsEntity
err = json.Unmarshal(rawMsg, &target)
if err == nil {
result.Targets = append(result.Targets, target)
}
}
if err != nil {
fmt.Println("Error:", err)
return
}
}
// 3、遍历数据，然后在数据中绘画矩形框
if result.HasTarget == 0 {
return
}
mp = make(map[string]string)
for _, data := range result.Targets {
if data.Score >= Sensitivity {
tp := data.Type
mp[tp] = GetDescription(tp)
flag = true
num = num + 1
coryCommon.Test_draw_rect_text(absolutePath, data.LeftTopPoint[0], data.LeftTopPoint[1], data.Size[0], data.Size[1])
}
}
return
}
// replacePrefix 将路径中指定前缀及其之前的部分替换成新的前缀
func replacePrefix(originalPath, prefixToReplace, newPrefix string) string {
// 查找要替换的前缀的位置
index := strings.Index(originalPath, prefixToReplace)
// 如果找到前缀
if index != -1 {
// 保留前缀之后的部分
remainingPath := originalPath[index+len(prefixToReplace):]
// 拼接新的路径
newPath := newPrefix + remainingPath
return newPath
}
// 如果未找到前缀，返回原始路径
return originalPath
}
/*
=============================================================================
远界算法
=============================================================================
*/
func CORYAInit(ctx context.Context) {
req := RecognizeReq{
CapUrl: "http://xny.yj-3d.com:7363/file/temporary/2025-06-22/sxt_1750583729497_972.jpg",
RecType: YJCAMERA,
}
now := time.Now()
marshal, _ := json.Marshal(req)
fmt.Println("------------", string(marshal))
fmt.Println("------------", now)
result, flag, err := CommonAlgorithmTwoFunc(gctx.New(), &req)
now2 := time.Now()
fmt.Println("result", result, flag, err)
fmt.Println("===========用时", now2.Sub(now))
fmt.Println("===========")
}
// @Title CommonAlgorithmTwoFunc 2024/8/7 17:06:00
// @Description 提供算法得到的目标信息（远界版本）
// @Auth Cory
func CommonAlgorithmTwoFunc(ctx context.Context, recognize *RecognizeReq) (result *RecognizeRes, flag bool, err error) {
err = g.Try(ctx, func(ctx context.Context) {
result = new(RecognizeRes)
flag = false
// 1、调用算法
postData := map[string]interface{}{
"type": recognize.RecType,
"url": recognize.CapUrl,
"extract": false,
}
response, err := g.Client().ContentJson().Post(ctx, yjUrl, postData)
fmt.Println("1请求的URL ", err)
liberr.ErrIsNil(ctx, err, "远界算法请求失败")
defer response.Body.Close()
body, err := io.ReadAll(response.Body)
fmt.Println("2请求的URL ", err)
liberr.ErrIsNil(ctx, err, "远界算法数据获取失败")
fmt.Println("返回的数据为 ", string(body))
// 2、组装数据
err = json.Unmarshal(body, &result)
if err != nil {
return
}
//=======================
//=======================
//1、本地创建一个text来记录日志
// 定义文件路径
filePath := coryCommon.GetCWD() + "/coryLogs/logs/ai_log.txt"
// 打开文件，如果文件不存在则创建
file, err := os.OpenFile(filePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
log.Fatal(err)
}
defer file.Close()
// 写入日志信息
marshal, _ := json.Marshal(result)
marshal2, _ := json.Marshal(postData)
_, err = file.WriteString(fmt.Sprintf("参数：%s,==================结果：%s\n", string(marshal), string(marshal2)))
if err != nil {
log.Fatal(err)
}
// 3、布尔值
if len(result.Targets) == 0 { // 表示无违规操作
return
} else { // 表述有违规操作
flag = true
return
}
})
return
}