YOLO5 V6.2 - OPenCV4.5.5- 易语言5.9.3 调用

z13228604287 · 发表于 2022-1-30 08:52:40

窗口程序集名	保留	保留	备注
程序集1

子程序名	返回值类型	公开	备注
_启动子程序	整数型		本子程序在程序启动后最先执行

变量名	类型	静态	数组	备注
img_path	文本型
model_path	文本型
test	Yolo
net	网络类
color	标量类		0
R	整数型
G	整数型
B	整数型
i	整数型
result	输出		0
img	多维矩阵类

img_path ＝ “D:\Desktop\zidane.jpg”
model_path ＝ “D:\Desktop\yolov5n.onnx”

如果 (test.读模型 (net, model_path, 真))

视觉_控制台输出 (“读取网络成功！”)

返回 (-1)
视觉_种子_随机 (取启动时间 ())

计次循环首 (80, i)

B ＝视觉_随机 () ％ 256

G ＝视觉_随机 () ％ 256

R ＝视觉_随机 () ％ 256

加入成员 (color, 标量 (B, G, R))

计次循环尾 ()
img ＝视觉_图像读取 (img_path, 1)

如果 (test.检测 (img, net, result))

test.绘制预测结果 (img, result, color)

视觉_控制台输出 (“Detect Failed!”)

视觉_控制台命令 (“pause”)
返回 (0) ' 可以根据您的需要返回任意数值

i支持库列表	支持库注释
OpenCV	(未知支持库)

窗口程序集名	保留	保留	备注
Yolo
变量名	类型	数组	备注
网络宽	整数型
网络高	整数型
类名集	文本型	0
网络Anchors	小数型	3,6
网络Stride	小数型	3
最大抑制阈值	小数型
预测框阈值	小数型
类ID阈值	小数型

子程序名	返回值类型	公开	备注
_初始化			当基于本类的对象被创建后，此方法会被自动调用

网络Anchors [1] [1] ＝ 10
网络Anchors [1] [2] ＝ 13
网络Anchors [1] [3] ＝ 16
网络Anchors [1] [4] ＝ 30
网络Anchors [1] [5] ＝ 33
网络Anchors [1] [6] ＝ 23
网络Anchors [2] [1] ＝ 30
网络Anchors [2] [2] ＝ 61
网络Anchors [2] [3] ＝ 62
网络Anchors [2] [4] ＝ 45
网络Anchors [2] [5] ＝ 59
网络Anchors [2] [6] ＝ 119
网络Anchors [3] [1] ＝ 116
网络Anchors [3] [2] ＝ 90
网络Anchors [3] [3] ＝ 156
网络Anchors [3] [4] ＝ 198
网络Anchors [3] [5] ＝ 373
网络Anchors [3] [6] ＝ 326
网络Stride ＝ { 8, 16, 32 }
网络宽＝ 640
网络高＝ 640
最大抑制阈值＝ 0.45
预测框阈值＝ 0.25
类ID阈值＝ 0.25
类名集＝ { “person”, “bicycle”, “car”, “motorcycle”, “airplane”, “bus”, “train”, “truck”, “boat”, “traffic light”, “fire hydrant”, “stop sign”, “parking meter”, “bench”, “bird”, “cat”, “dog”, “horse”, “sheep”, “cow”, “elephant”, “bear”, “zebra”, “giraffe”, “backpack”, “umbrella”, “handbag”, “tie”, “suitcase”, “frisbee”, “skis”, “snowboard”, “sports ball”, “kite”, “baseball bat”, “baseball glove”, “skateboard”, “surfboard”, “tennis racket”, “bottle”, “wine glass”, “cup”, “fork”, “knife”, “spoon”, “bowl”, “banana”, “apple”, “sandwich”, “orange”, “broccoli”, “carrot”, “hot dog”, “pizza”, “donut”, “cake”, “chair”, “couch”, “potted plant”, “bed”, “dining table”, “toilet”, “tv”, “laptop”, “mouse”, “remote”, “keyboard”, “cell phone”, “microwave”, “oven”, “toaster”, “sink”, “refrigerator”, “book”, “clock”, “vase”, “scissors”, “teddy bear”, “hair drier”, “toothbrush” }

子程序名	返回值类型	公开	备注
_销毁			当基于本类的对象被销毁前，此方法会被自动调用

子程序名	返回值类型	公开	备注
读模型	逻辑型
参数名	类型	参考	可空	数组	备注
net	网络类
netPath	文本型
isCuda	逻辑型

net ＝视觉_读取网络 (netPath, , “”)

判断 (isCuda) ' cuda

net.设置首选后端 ( #网络_后端_CUDA )

net.设置首选目标 ( #网络_目标_CUDA_FP16 )

' cpu

net.设置首选后端 ( #网络_后端_默认 )

net.设置首选目标 ( #网络_目标_CPU )

返回 (真)

子程序名	返回值类型	公开	备注
检测	逻辑型
参数名	类型	参考	可空	数组	备注
输入图片	多维矩阵类
网络	网络类
output	输出

变量名	类型	静态	数组	备注
前景目标	多维矩阵类
列数	整数型
行数	整数型
最大长	整数型
网络输入图	多维矩阵类
返回尺寸图	多维矩阵类
网络输出图	多维矩阵类		0
类ID集	整数型		0	结果id数组
置信度集	小数型		0	结果每个id对应置信度数组
预测框集	矩形2i类		0	每个id矩形框
高比率	小数型
宽比率	小数型
网络宽度	整数型
矩阵数据指针	整数型
步数	整数型
网格_x	整数型
网格_y	整数型
anchor	整数型
anchor_宽	小数型
anchor_高	小数型
i	整数型
预测框_分数	小数型
j	整数型
对象分数	多维矩阵类
类ID坐标	点2i类
最大_类_分数	双精度小数型
x	小数型
y	小数型
w	小数型
h	小数型
左边	整数型
顶边	整数型
最大抑制结果	整数型		0
结果	输出
idx	整数型

列数＝输入图片.列数 ()
行数＝输入图片.行数 ()
最大长＝取最大 (列数, 行数)
网络输入图＝输入图片.克隆 ()

如果真 (最大长＞ 1.2 × 列数或最大长＞ 1.2 × 行数)

返回尺寸图＝矩阵 (最大长, 最大长, #八位无符号整数_三通道, )

输入图片.复制 (返回尺寸图.感兴区域 (矩形2i (0, 0, 列数, 行数)), )

网络输入图＝返回尺寸图
前景目标＝视觉_来自图像的目标 (网络输入图, 1 ÷ 255, 尺寸2i (网络宽, 网络高), 标量 (104, 117, 123), 真, 假, 5)
网络.设置输入 (前景目标, “”, 1, )
网络.向前 (网络输出图, 网络.获取未连接的输出层名称 ())
高比率＝网络输入图.行数 () ÷ 网络高
宽比率＝网络输入图.列数 () ÷ 网络宽
网络宽度＝取数组成员数 (类名集) ＋ 5 ' 输出的网络宽度是类别数+5
矩阵数据指针＝网络输出图 [1].数据指针 ()

计次循环首 (3, 步数)

网格_x ＝网络宽 ÷ 网络Stride [步数]

网格_y ＝网络高 ÷ 网络Stride [步数]

计次循环首 (3, anchor)

anchor_宽＝网络Anchors [步数] [anchor × 2 － 1]

anchor_高＝网络Anchors [步数] [anchor × 2]

计次循环首 (网格_y, i)

计次循环首 (网格_y, j)

预测框_分数＝指针到小数 (矩阵数据指针＋ 16) ' 等价于[ 矩阵数据指针[4] 类型小数型] 获取每一行的box框中含有某个物体的概率

如果真 (预测框_分数＞预测框阈值)

如果真 (预测框_分数＞类ID阈值)

对象分数＝矩阵 (1, 取数组成员数 (类名集), #三十二位浮点数_单通道, 到整数 (矩阵数据指针＋ 20))

视觉_最小最大位置 (对象分数, , 最大_类_分数, , 类ID坐标, )

如果真 (最大_类_分数＞类ID阈值)

' 矩形2i [x,y,w,h] 预测矩形框

x ＝指针到小数 (矩阵数据指针) ' //等价于[ 矩阵数据指针[0] 指针类型小数型]

y ＝指针到小数 (矩阵数据指针＋ 4) ' //等价于[ 矩阵数据指针[1] 指针类型小数型]

w ＝指针到小数 (矩阵数据指针＋ 8) ' //等价于[ 矩阵数据指针[2] 指针类型小数型]

h ＝指针到小数 (矩阵数据指针＋ 12) ' //等价于[ 矩阵数据指针[3] 指针类型小数型]

左边＝ (x － 0.5 × w) × 宽比率

顶边＝ (y － 0.5 × h) × 高比率

加入成员 (类ID集, 类ID坐标.左边)

加入成员 (置信度集, 最大_类_分数 × 预测框_分数)

加入成员 (预测框集, 矩形2i (左边, 顶边, w × 宽比率, h × 高比率))

矩阵数据指针＝网络宽度 × 4 ＋矩阵数据指针 ' //等价于[ 矩阵数据指针+=网络宽度指针类型小数型] 下一行

计次循环尾 ()

计次循环尾 ()
' 执行非最大抑制以消除具有较低置信度的冗余重叠框（NMS）
视觉_非最大抑制 (预测框集, 置信度集, 类ID阈值, 最大抑制阈值, 最大抑制结果, 1, 0)

计次循环首 (取数组成员数 (最大抑制结果), i)

idx ＝最大抑制结果 [i] － 1

结果.类别id ＝类ID集 [idx] ＋ 1

结果.置信度＝置信度集 [idx ＋ 2]

结果.预测框＝预测框集 [idx ＋ 2]

加入成员 (output, 结果)

计次循环尾 ()

如果 (取数组成员数 (output) ＞ 0)

返回 (真)

返回 (假)

子程序名	返回值类型	公开	备注
取最大	整数型
参数名	类型	参考	可空	数组	备注
v1	整数型
v2	整数型

如果 (v1 ＞ v2)

返回 (v1)

返回 (v2)

子程序名	返回值类型	公开	备注
绘制预测结果
参数名	类型	参考	可空	数组	备注
图像	多维矩阵类
返回结果	输出
颜色	标量类

变量名	类型	静态	数组	备注
i	整数型
左边	整数型
顶边	整数型
颜色索引	整数型
标签	文本型
基线	整数型
标签尺寸	尺寸2i类

计次循环首 (取数组成员数 (返回结果), i)

左边＝返回结果 [i].预测框.左边

顶边＝返回结果 [i].预测框.顶边

颜色索引＝ i

视觉_矩形 (图像, 返回结果 [i].预测框, 颜色 [返回结果 [i].类别id], 2, 8, 0)

标签＝类名集 [返回结果 [i].类别id] ＋ “:” ＋到文本 (返回结果 [i].置信度)

标签尺寸＝视觉_获取文本尺寸 (标签, #字体_衬线_简单, 0.5, 1, 基线)

顶边＝取最大 (顶边, 标签尺寸.高)

' //rectangle(frame, Point(left, top - int(1.5 * labelSize.height)), Point(left + int(1.5 * labelSize.width), top + baseLine), Scalar(0, 255, 0), FILLED);

视觉_放置文本 (图像, 标签, 点2i (左边, 顶边), #字体_衬线_简单, 1, 颜色 [返回结果 [i].类别id], 2, 8, 假)

计次循环尾 ()
视觉_显示图像 (“YOLO5”, 图像)
' //imwrite("out.bmp", img);
视觉_等待按键 (0)
' //destroyAllWindows();

i支持库列表	支持库注释
OpenCV	(未知支持库)

.版本 2<br />
.支持库 OpenCV<br />
<br />
.程序集 Yolo<br />
.程序集变量 网络宽, 整数型<br />
.程序集变量 网络高, 整数型<br />
.程序集变量 类名集, 文本型, , "0"<br />
.程序集变量 网络Anchors, 小数型, , "3,6"<br />
.程序集变量 网络Stride, 小数型, , "3"<br />
.程序集变量 最大抑制阈值, 小数型<br />
.程序集变量 预测框阈值, 小数型<br />
.程序集变量 类ID阈值, 小数型<br />
<br />
.子程序 _初始化, , , 当基于本类的对象被创建后，此方法会被自动调用<br />
<br />
网络Anchors [1] [1] ＝ 10<br />
网络Anchors [1] [2] ＝ 13<br />
网络Anchors [1] [3] ＝ 16<br />
网络Anchors [1] [4] ＝ 30<br />
网络Anchors [1] [5] ＝ 33<br />
网络Anchors [1] [6] ＝ 23<br />
网络Anchors [2] [1] ＝ 30<br />
网络Anchors [2] [2] ＝ 61<br />
网络Anchors [2] [3] ＝ 62<br />
网络Anchors [2] [4] ＝ 45<br />
网络Anchors [2] [5] ＝ 59<br />
网络Anchors [2] [6] ＝ 119<br />
网络Anchors [3] [1] ＝ 116<br />
网络Anchors [3] [2] ＝ 90<br />
网络Anchors [3] [3] ＝ 156<br />
网络Anchors [3] [4] ＝ 198<br />
网络Anchors [3] [5] ＝ 373<br />
网络Anchors [3] [6] ＝ 326<br />
网络Stride ＝ { 8, 16, 32 }<br />
网络宽 ＝ 640<br />
网络高 ＝ 640<br />
最大抑制阈值 ＝ 0.45<br />
预测框阈值 ＝ 0.25<br />
类ID阈值 ＝ 0.25<br />
类名集 ＝ { “person”, “bicycle”, “car”, “motorcycle”, “airplane”, “bus”, “train”, “truck”, “boat”, “traffic light”, “fire hydrant”, “stop sign”, “parking meter”, “bench”, “bird”, “cat”, “dog”, “horse”, “sheep”, “cow”, “elephant”, “bear”, “zebra”, “giraffe”, “backpack”, “umbrella”, “handbag”, “tie”, “suitcase”, “frisbee”, “skis”, “snowboard”, “sports ball”, “kite”, “baseball bat”, “baseball glove”, “skateboard”, “surfboard”, “tennis racket”, “bottle”, “wine glass”, “cup”, “fork”, “knife”, “spoon”, “bowl”, “banana”, “apple”, “sandwich”, “orange”, “broccoli”, “carrot”, “hot dog”, “pizza”, “donut”, “cake”, “chair”, “couch”, “potted plant”, “bed”, “dining table”, “toilet”, “tv”, “laptop”, “mouse”, “remote”, “keyboard”, “cell phone”, “microwave”, “oven”, “toaster”, “sink”, “refrigerator”, “book”, “clock”, “vase”, “scissors”, “teddy bear”, “hair drier”, “toothbrush” }<br />
<br />
.子程序 _销毁, , , 当基于本类的对象被销毁前，此方法会被自动调用<br />
<br />
<br />
<br />
.子程序 读模型, 逻辑型, 公开<br />
.参数 net, 网络类<br />
.参数 netPath, 文本型<br />
.参数 isCuda, 逻辑型<br />
<br />
<br />
net ＝ 视觉_读取网络 (netPath, , “”)<br />
<br />
.判断开始 (isCuda)  ' cuda<br />
    net.设置首选后端 (#网络_后端_CUDA)<br />
    net.设置首选目标 (#网络_目标_CUDA_FP16)<br />
.默认<br />
    ' cpu<br />
    net.设置首选后端 (#网络_后端_默认)<br />
    net.设置首选目标 (#网络_目标_CPU)<br />
.判断结束<br />
<br />
<br />
<br />
返回 (真)<br />
<br />
.子程序 检测, 逻辑型, 公开<br />
.参数 输入图片, 多维矩阵类<br />
.参数 网络, 网络类<br />
.参数 output, 输出, 数组<br />
.局部变量 前景目标, 多维矩阵类<br />
.局部变量 列数, 整数型<br />
.局部变量 行数, 整数型<br />
.局部变量 最大长, 整数型<br />
.局部变量 网络输入图, 多维矩阵类<br />
.局部变量 返回尺寸图, 多维矩阵类<br />
.局部变量 网络输出图, 多维矩阵类, , "0"<br />
.局部变量 类ID集, 整数型, , "0", 结果id数组<br />
.局部变量 置信度集, 小数型, , "0", 结果每个id对应置信度数组<br />
.局部变量 预测框集, 矩形2i类, , "0", 每个id矩形框<br />
.局部变量 高比率, 小数型<br />
.局部变量 宽比率, 小数型<br />
.局部变量 网络宽度, 整数型<br />
.局部变量 矩阵数据指针, 整数型<br />
.局部变量 步数, 整数型<br />
.局部变量 网格_x, 整数型<br />
.局部变量 网格_y, 整数型<br />
.局部变量 anchor, 整数型<br />
.局部变量 anchor_宽, 小数型<br />
.局部变量 anchor_高, 小数型<br />
.局部变量 i, 整数型<br />
.局部变量 预测框_分数, 小数型<br />
.局部变量 j, 整数型<br />
.局部变量 对象分数, 多维矩阵类<br />
.局部变量 类ID坐标, 点2i类<br />
.局部变量 最大_类_分数, 双精度小数型<br />
.局部变量 x, 小数型<br />
.局部变量 y, 小数型<br />
.局部变量 w, 小数型<br />
.局部变量 h, 小数型<br />
.局部变量 左边, 整数型<br />
.局部变量 顶边, 整数型<br />
.局部变量 最大抑制结果, 整数型, , "0"<br />
.局部变量 结果, 输出<br />
.局部变量 idx, 整数型<br />
<br />
列数 ＝ 输入图片.列数 ()<br />
行数 ＝ 输入图片.行数 ()<br />
最大长 ＝ 取最大 (列数, 行数)<br />
网络输入图 ＝ 输入图片.克隆 ()<br />
.如果真 (最大长 ＞ 1.2 × 列数 或 最大长 ＞ 1.2 × 行数)<br />
    返回尺寸图 ＝ 矩阵 (最大长, 最大长, #八位无符号整数_三通道, )<br />
    输入图片.复制 (返回尺寸图.感兴区域 (矩形2i (0, 0, 列数, 行数)), )<br />
    网络输入图 ＝ 返回尺寸图<br />
.如果真结束<br />
前景目标 ＝ 视觉_来自图像的目标 (网络输入图, 1 ÷ 255, 尺寸2i (网络宽, 网络高), 标量 (104, 117, 123), 真, 假, 5)<br />
网络.设置输入 (前景目标, “”, 1, )<br />
网络.向前 (网络输出图, 网络.获取未连接的输出层名称 ())<br />
高比率 ＝ 网络输入图.行数 () ÷ 网络高<br />
宽比率 ＝ 网络输入图.列数 () ÷ 网络宽<br />
网络宽度 ＝ 取数组成员数 (类名集) ＋ 5  ' 输出的网络宽度是类别数+5<br />
矩阵数据指针 ＝ 网络输出图 [1].数据指针 ()<br />
.计次循环首 (3, 步数)<br />
    网格_x ＝ 网络宽 ÷ 网络Stride [步数]<br />
    网格_y ＝ 网络高 ÷ 网络Stride [步数]<br />
    .计次循环首 (3, anchor)<br />
        anchor_宽 ＝ 网络Anchors [步数] [anchor × 2 － 1]<br />
        anchor_高 ＝ 网络Anchors [步数] [anchor × 2]<br />
        .计次循环首 (网格_y, i)<br />
            .计次循环首 (网格_y, j)<br />
                预测框_分数 ＝ 指针到小数 (矩阵数据指针 ＋ 16)  ' 等价于[ 矩阵数据指针[4]  类型小数型] 获取每一行的box框中含有某个物体的概率<br />
                .如果真 (预测框_分数 ＞ 预测框阈值)<br />
                    .如果真 (预测框_分数 ＞ 类ID阈值)<br />
                        对象分数 ＝ 矩阵 (1, 取数组成员数 (类名集), #三十二位浮点数_单通道, 到整数 (矩阵数据指针 ＋ 20))<br />
                        视觉_最小最大位置 (对象分数, , 最大_类_分数, , 类ID坐标, )<br />
                        .如果真 (最大_类_分数 ＞ 类ID阈值)<br />
                            ' 矩形2i [x,y,w,h]   预测矩形框<br />
                            x ＝ 指针到小数 (矩阵数据指针)  ' //等价于[ 矩阵数据指针[0]  指针类型小数型]<br />
                            y ＝ 指针到小数 (矩阵数据指针 ＋ 4)  ' //等价于[ 矩阵数据指针[1]  指针类型小数型]<br />
                            w ＝ 指针到小数 (矩阵数据指针 ＋ 8)  ' //等价于[ 矩阵数据指针[2]  指针类型小数型]<br />
                            h ＝ 指针到小数 (矩阵数据指针 ＋ 12)  ' //等价于[ 矩阵数据指针[3]  指针类型小数型]<br />
                            左边 ＝ (x － 0.5 × w) × 宽比率<br />
                            顶边 ＝ (y － 0.5 × h) × 高比率<br />
                            加入成员 (类ID集, 类ID坐标.左边)<br />
                            加入成员 (置信度集, 最大_类_分数 × 预测框_分数)<br />
                            加入成员 (预测框集, 矩形2i (左边, 顶边, w × 宽比率, h × 高比率))<br />
                        .如果真结束<br />
<br />
                    .如果真结束<br />
<br />
                .如果真结束<br />
                矩阵数据指针 ＝ 网络宽度 × 4 ＋ 矩阵数据指针  ' //等价于[ 矩阵数据指针+=网络宽度   指针类型小数型]    下一行<br />
            .计次循环尾 ()<br />
        .计次循环尾 ()<br />
    .计次循环尾 ()<br />
.计次循环尾 ()<br />
' 执行非最大抑制以消除具有较低置信度的冗余重叠框（NMS）<br />
视觉_非最大抑制 (预测框集, 置信度集, 类ID阈值, 最大抑制阈值, 最大抑制结果, 1, 0)<br />
.计次循环首 (取数组成员数 (最大抑制结果), i)<br />
    idx ＝ 最大抑制结果 <i> － 1<br />
    结果.类别id ＝ 类ID集 [idx] ＋ 1<br />
    结果.置信度 ＝ 置信度集 [idx ＋ 2]<br />
    结果.预测框 ＝ 预测框集 [idx ＋ 2]<br />
    加入成员 (output, 结果)<br />
.计次循环尾 ()<br />
.如果 (取数组成员数 (output) ＞ 0)<br />
    返回 (真)<br />
.否则<br />
    返回 (假)<br />
.如果结束<br />
<br />
<br />
.子程序 取最大, 整数型<br />
.参数 v1, 整数型<br />
.参数 v2, 整数型<br />
<br />
.如果 (v1 ＞ v2)<br />
    返回 (v1)<br />
.否则<br />
    返回 (v2)<br />
.如果结束<br />
<br />
<br />
.子程序 绘制预测结果, , 公开<br />
.参数 图像, 多维矩阵类<br />
.参数 返回结果, 输出, 数组<br />
.参数 颜色, 标量类, 数组<br />
.局部变量 i, 整数型<br />
.局部变量 左边, 整数型<br />
.局部变量 顶边, 整数型<br />
.局部变量 颜色索引, 整数型<br />
.局部变量 标签, 文本型<br />
.局部变量 基线, 整数型<br />
.局部变量 标签尺寸, 尺寸2i类<br />
<br />
.计次循环首 (取数组成员数 (返回结果), i)<br />
    左边 ＝ 返回结果 <i>.预测框.左边<br />
    顶边 ＝ 返回结果 <i>.预测框.顶边<br />
    颜色索引 ＝ i<br />
    视觉_矩形 (图像, 返回结果 <i>.预测框, 颜色 [返回结果 <i>.类别id], 2, 8, 0)<br />
    标签 ＝ 类名集 [返回结果 <i>.类别id] ＋ “:” ＋ 到文本 (返回结果 <i>.置信度)<br />
    标签尺寸 ＝ 视觉_获取文本尺寸 (标签, #字体_衬线_简单, 0.5, 1, 基线)<br />
    顶边 ＝ 取最大 (顶边, 标签尺寸.高)<br />
    ' //rectangle(frame, Point(left, top - int(1.5 * labelSize.height)), Point(left + int(1.5 * labelSize.width), top + baseLine), Scalar(0, 255, 0), FILLED);<br />
    视觉_放置文本 (图像, 标签, 点2i (左边, 顶边), #字体_衬线_简单, 1, 颜色 [返回结果 <i>.类别id], 2, 8, 假)<br />
.计次循环尾 ()<br />
视觉_显示图像 (“YOLO5”, 图像)<br />
' //imwrite("out.bmp", img);<br />
视觉_等待按键 (0)<br />
' //destroyAllWindows();

jh6666 · 发表于 4 天前

66666666666666666666666啊

zx7420 · 发表于 5 天前

6666666666666666666666啊

zhangyongjian · 发表于 2024-3-26 09:33:20

666666666666666666

huang9585 · 发表于 2024-3-20 10:55:28

66666666666666666666666

clhehy · 发表于 2024-3-14 21:56:43

6666666666666666666666666666

kuailaixyj · 发表于 2024-2-27 22:15:15

看看啊老板

295311002 · 发表于 2023-10-6 11:16:52

66666666666666666666666666666666666666

q1599273319 · 发表于 2023-10-5 15:37:36

百熙 · 发表于 2023-10-2 01:34:22

回复一下看看能不能看到大佬的分享

		自动登录	找回密码
密码			注册

[技术专题] YOLO5 V6.2 - OPenCV4.5.5- 易语言5.9.3 调用

本帖被以下淘专辑推荐: