devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【yolov3目标检测】(3) opencv+yolov3 检测交通路况，附python完整代码_depth = self.depth_image[int(yolo_center_point_y)]

作者：不正经 | 2024-04-23 13:22:09

赞

踩

depth = self.depth_image[int(yolo_center_point_y)][int(yolo_center_point_x)]

各位同学好，今天和大家分享一下如何使用 opencv 调用 yolov3 模型，加载网络权重，很方便地实现 yolov3 目标检测。先放张图看效果。

使用的网上找的行车记录仪视频做测试，数据集采用COCO数据集，检测效果还是不错的。

1. 预先准备

首先需要导入 COCO 数据集的分类名文件 'coco.names'，以及yolov3的网络结构 'yolo.cfg'，网络的权重参数 'yolo.weights'，这些文件以及本案例的代码我给大家都提供好了，有需要的自取。

链接：https://pan.baidu.com/s/12iPJTjiN7SIBJ7hpHomn_w 

提取码：p548

yolov3 使用 Darknet53 网络模型，这个网络我之前复现过，感兴趣的可以看一下：https://blog.csdn.net/dgvv4/article/details/121997986

使用 cv2.dnn.readNetFromDarknet() 从opencv中读取网络模型，传入网络结构和权重参数。

由于我这个视频比较短，因此设置视频重复播放，使用 cv2.CAP_PROP_POS_FRAMES 获取当前视频所在第几帧，使用 cv2.CAP_PROP_FRAME_COUNT 获取该视频一共有多少帧。如果播放到了最后一帧，那就让当前帧=0，从头开始。

代码如下，net 配置完成，播放视频图像。

  1. import numpy as np
  2. import cv2
  3. import time
  4.  
  5. #（1）加载预训练的COCO数据集
  6. classesFile = 'coco.names'  # 指定coco数据集分类名所在路径
  7. classNames = []  # 创建列表，存放coco数据集的分类名称
  8.  
  9. # 打开数据集名称的文件
  10. with open(classesFile, 'rt') as f:  #读取文本文件
  11.     classNames = f.read().rstrip('\n').split('\n')  # 通过换行符来拆分，再读入
  12.  
  13. # 加载yolov3结构cfg文件
  14. modelConfiguration = 'yolov3.cfg'
  15. # 加载yolov3网络权重
  16. modelWeights = 'yolov3.weights'
  17.  
  18. #（2）构建网络结构
  19. # 导入darknet53网络，传入cfg文件和网络权重
  20. net = cv2.dnn.readNetFromDarknet(modelConfiguration, modelWeights)
  21. # 申明使用opencv作为后端
  22. net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
  23. # 申明使用CPU计算
  24. net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)
  25.  
  26. #（3）获取摄像头
  27. videoFile = 'C:\\GameDownload\\Deep Learning\\yolov3video.mp4'
  28. cap = cv2.VideoCapture(videoFile) # 0代表电脑自带的摄像头,代表外接摄像头 
  29.  
  30. pTime = 0  # 设置第一帧开始处理的起始时间
  31.  
  32. #（4）处理帧图像
  33. while True:
  34.     
  35.     # 接收图片是否导入成功、帧图像
  36.     success, img = cap.read()
  37.     
  38.     # 改变图像大小
  39.     img = cv2.resize(img, (1280,720))
  40.     
  41.     # 视频较短，循环播放
  42.     if cap.get(cv2.CAP_PROP_POS_FRAMES) == cap.get(cv2.CAP_PROP_FRAME_COUNT):
  43.         
  44.         # 如果当前帧==总帧数，那就重置当前帧为0
  45.         cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
  46.     
  47.     #（5）显示图像
  48.     # 查看FPS
  49.     cTime = time.time() #处理完一帧图像的时间
  50.     fps = 1/(cTime-pTime)
  51.     pTime = cTime  #重置起始时间
  52.     
  53.     # 在视频上显示fps信息，先转换成整数再变成字符串形式，文本显示坐标，文本字体，文本大小
  54.     cv2.putText(img, str(int(fps)), (70,50), cv2.FONT_HERSHEY_PLAIN, 3, (255,0,0), 3)  
  55.     
  56.     # 显示图像，输入窗口名及图像数据
  57.     cv2.imshow('img', img)    
  58.     if cv2.waitKey(20) & 0xFF==27:  #每帧滞留20毫秒后消失，ESC键退出
  59.         break
  60.  
  61. # 释放视频资源
  62. cap.release()
  63. cv2.destroyAllWindows()

2. 获取检测框信息

2.1 确定输入及输出

先看下面代码中的第（6）步，图像传入神经网络之前先进行预处理 cv2.dnn.blobFromImage()，包括减均值，比例缩放，裁剪，交换通道等，返回一个4通道的blob（blob可以简单理解为一个N维的数组）。之后使用 net.setInput() 将blob类型图像作为网络输入。

  1. cv2.dnn.blobFromImage(img, scalefactor, size, mean, swapRB, crop, ddepth)
  2.  
  3. '''
  4. image： 输入图像
  5. scalefactor： 图像各通道数值的缩放比例，默认=1
  6. size： 输出图像的空间尺寸,如size=(200,300)表示高h=300,宽w=200
  7. mean： 用于各通道减去的值，以降低光照的影响，
  8.        例：(image为BGR的3通道的图像，mean=[104.0, 177.0, 123.0]，表示B通道的值-104，G-177，R-123)
  9. swapRB： 交换RB通道，默认为False。(cv2.imread读取的是彩图是BGR通道)
  10. crop： 图像裁剪，默认为False。当值为True时，先按比例缩放，然后从中心裁剪成size尺寸
  11. ddepth： 输出的图像深度，可选CV_32F 或者 CV_8U.
  12. '''

由下图的 Darknet53 网络结构图可知，网络有三个输出层，输出的shape分别为 [52,52,255] 用于预测小目标，[26,26,255] 用于预测中等大小的目标，[13,13,255] 用于预测大目标。因此我们通过 net.getUnconnectedOutLayers() 就能知道这三个输出层处于网络中的第几层，得到的返回结果是 [200, 227, 254]。通过 net.getLayerNames() 只要输入层的索引就能得到该索引所对应的层的名称。得到输出层的层名称后，将其传入 net.forward() 中，就能找到输出层的输出结果。

到这里就完成了网络模型的输入 blob，得到了模型的三个输出 outputs，打印输出结果的相关信息如下。以 outputs[0].shape =（300，85）为例， 300代表检测框的数量，85代表：中心点坐标 x，y；框的宽高 w，h；置信度 c；80 个分类各自的概率

  1. print(outputs[0].shape)  # (300, 85) 
  2. print(outputs[1].shape)  # (1200, 85)
  3. print(outputs[2].shape)  # (4800, 85)
  4. print(outputs[0][0])  # 打印第0个检测框所包含的信息
  5.  
  6. '''
  7. (300, 85)
  8. (1200, 85)
  9. (4800, 85)
  10. [4.9195103e-02 5.5935599e-02 6.5290880e-01 1.8459144e-01 8.2010246e-08
  11.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  12.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  13.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  14.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  15.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  16.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  17.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  18.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  19.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  20.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  21.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  22.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  23.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  24.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  25.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00
  26.  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00]
  27. '''

2.2 获取检测框信息

接下来我们就看到下面代码中的第（4）步，现在有了每个区域的预测结果 outputs，需要从中找到和每个物体对应的最合适的检测框。

注意一下，img.shape 是先指定图像的高，再指定宽，(h, w, c)，不要搞错了。

其中 output 遍历三个输出层，每个输出层包含n个检测框，每个框包含85项信息。det 遍历每一层的n个检测框，det 包含85项信息。我们需要找到每个框属于哪个分类，以及该框属于该分类的概率 confidence。如果该分类概率大于阈值 confThreshold 证明找到了，这时候就将该框的左上角坐标(x,y)，框的宽w和高h，及置信度 confidence 保存下来。

这里需要注意的是，每个框的85项信息中的其四个信息：中心坐标和宽高，都是归一化之后的比例坐标和比例宽高。需要将比例宽高乘上原图像宽高才能得到检测框的真实宽高。

在第二节的代码中补充。

  1. import numpy as np
  2. import cv2
  3. import time
  4.  
  5. #（1）加载预训练的COCO数据集
  6. classesFile = 'coco.names'  # 指定coco数据集分类名所在路径
  7. classNames = []  # 创建列表，存放coco数据集的分类名称
  8.  
  9. # 打开数据集名称的文件
  10. with open(classesFile, 'rt') as f:  #读取文本文件
  11.     classNames = f.read().rstrip('\n').split('\n')  # 通过换行符来拆分，再读入
  12.  
  13. # 加载yolov3结构cfg文件
  14. modelConfiguration = 'yolov3.cfg'
  15. # 加载yolov3网络权重
  16. modelWeights = 'yolov3.weights'
  17.  
  18. # 确定输入图像的宽和高
  19. wInput, hInput = 320, 320
  20.  
  21. # 自定义目标检测的最小置信度
  22. confThreshold = 0.5
  23.  
  24. #（2）构建网络结构
  25. # 导入darknet53网络，传入cfg文件和网络权重
  26. net = cv2.dnn.readNetFromDarknet(modelConfiguration, modelWeights)
  27. # 申明使用opencv作为后端
  28. net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
  29. # 申明使用CPU计算
  30. net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)
  31.  
  32. #（3）获取摄像头
  33. videoFile = 'C:\\GameDownload\\Deep Learning\\trafficvideo2.mp4'
  34. cap = cv2.VideoCapture(videoFile) # 0代表电脑自带的摄像头,代表外接摄像头 
  35.  
  36. pTime = 0  # 设置第一帧开始处理的起始时间
  37.  
  38. #（4）定义函数用于检测目标，获取检测框信息，以及分类类别
  39. def findObjects(outputs, img):
  40.     
  41.     # 图像的高度、宽度、通道数
  42.     hT, wT, cT = img.shape
  43.     
  44.     # 定义一个列表存放检测框的中心点坐标和宽高
  45.     bbox = []
  46.     # 定义列表存放分类的名称的索引
  47.     classIds = []
  48.     # 定义列表存放置信度
  49.     confs = [] # 如果找到目标了，就将检测框的信息存放起来
  50.     
  51.     # 遍历三个输出层
  52.     for output in outputs:
  53.         
  54.         # 遍历输出层的85项信息
  55.         for det in output:  # det是数组类型
  56.             
  57.             # 在80个分类中找到哪个分类的值是最高的
  58.             score = det[5:]  # 忽略检测框的x,y,w,h,c
  59.             
  60.             # 找到分类值最大对应的索引号
  61.             classId = np.argmax(score)
  62.             
  63.             # 找到分类概率最大值的索引对应的值
  64.             confidence = score[classId]
  65.             
  66.             # 如果检测置信度大于规定的阈值，表明检测到了物体
  67.             if confidence > confThreshold:
  68.                 
  69.                 # 记录检测框的宽和高，这里的宽高是归一化之后的比例宽度和高度
  70.                 w, h = int(det[2]*wT), int(det[3]*hT)  # 比例宽高转为像素宽高，像素宽高是整数
  71.                 
  72.                 # 记录检测框的左上角坐标
  73.                 x, y = det[0]*wT-w//2, det[1]*hT-h//2
  74.                 
  75.                 # 将检测框的信息保存起来
  76.                 bbox.append([x, y, w, h])
  77.                 # 将目标属于哪个类别的索引保存下来
  78.                 classIds.append(classId)
  79.                 # 保存检测框的置信度，检测出某个目标的概率
  80.                 confs.append(float(confidence))
  81.     
  82.     # 打印检测框信息
  83.     print('classids:', classIds, 'confidence:', confs, 'bbox:', bbox)
  84.     
  85. #（5）处理帧图像
  86. while True:
  87.     
  88.     # 接收图片是否导入成功、帧图像
  89.     success, img = cap.read()
  90.     
  91.     # 改变图像大小
  92.     img = cv2.resize(img, (1280,720))
  93.     
  94.     # 视频较短，循环播放
  95.     if cap.get(cv2.CAP_PROP_POS_FRAMES) == cap.get(cv2.CAP_PROP_FRAME_COUNT):
  96.         
  97.         # 如果当前帧==总帧数，那就重置当前帧为0
  98.         cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
  99.     
  100.     #（6）将img图片转换成blob块类型，网络只接受这种类型
  101.     # 输入img图像，，图像宽w高h，默认参数[0,0,0]，，
  102.     blob = cv2.dnn.blobFromImage(img, 1/255, (wInput,hInput), [0,0,0], 1, crop=False)
  103.     
  104.     # 将转换类型后的图像作为输入数据
  105.     net.setInput(blob)
  106.     
  107.     # 获得网络各层的名称，由于网络会输出最后三层的结果，用于定位输出层
  108.     layerNames = net.getLayerNames()  # 得到网络所有层的名称
  109.     
  110.     # 提取输出层，返回输出层是第几层，层数是从1开始，索引是从0开始
  111.     # net.getUnconnectedOutLayers()  # [200, 227, 254]
  112.     
  113.     outputNames = []  # 存放输出层名称
  114.     
  115.     # 得到输出层在网络中属于第几层
  116.     for outindex in net.getUnconnectedOutLayers():
  117.         
  118.         # 得到输出层的名称，outindex是第几层（从1开始），传入的是索引（从0开始）
  119.         outputNames.append(layerNames[outindex-1])
  120.     
  121.     # 获取输出层返回结果
  122.     outputs = net.forward(outputNames)
  123.     
  124.     print(outputs[0].shape)  # (300, 85)  300代表检测框的数量，85代表：中心点坐标x,y,框的宽高w,h,置信度c,80个分类各自的概率
  125.     print(outputs[1].shape)  # (1200, 85)
  126.     print(outputs[2].shape)  # (4800, 85)
  127.     print(outputs[0][0])  # 打印第0个检测框所包含的信息
  128.     
  129.     #（7）目标检测
  130.     findObjects(outputs, img)    
  131.     
  132.     #（8）显示图像
  133.     # 查看FPS
  134.     cTime = time.time() #处理完一帧图像的时间
  135.     fps = 1/(cTime-pTime)
  136.     pTime = cTime  #重置起始时间
  137.     
  138.     # 在视频上显示fps信息，先转换成整数再变成字符串形式，文本显示坐标，文本字体，文本大小
  139.     cv2.putText(img, str(int(fps)), (70,50), cv2.FONT_HERSHEY_PLAIN, 3, (255,0,0), 3)  
  140.     
  141.     # 显示图像，输入窗口名及图像数据
  142.     cv2.namedWindow("img", 0)  # 窗口大小可调整
  143.     cv2.imshow('img', img)    
  144.     if cv2.waitKey(20) & 0xFF==27:  #每帧滞留20毫秒后消失，ESC键退出
  145.         break
  146.  
  147. # 释放视频资源
  148. cap.release()
  149. cv2.destroyAllWindows()

打印得到的检测框信息

  1. classids: [2, 7, 7, 2, 2, 2, 2, 2, 2] 
  2. confidence: [0.8474083542823792, 0.6886539459228516, 0.7003887891769409, 0.9768345952033997, 0.7150803804397583, 0.7982962131500244, 0.7913717031478882, 0.9718230962753296, 0.8747612833976746] 
  3. bbox: [[769.3665313720703, 398.1743869781494, 110, 88], [348.8137969970703, 387.51572608947754, 98, 70], [347.2083282470703, 388.56964111328125, 101, 71], [453.0018081665039, 409.030611038208, 32, 26], [625.3595275878906, 397.98907947540283, 67, 57], [681.5968627929688, 405.41797828674316, 37, 36], [694.1919250488281, 410.92028617858887, 37, 30], [760.8668212890625, 402.86146450042725, 124, 75], [777.7303924560547, 401.2068338394165, 112, 77]]

3. 显示预测框，完成目标检测

进行完上面的操作后，我们现在得到一个物体上可能有很多的检测框都满足条件，接下来采用 NMS 非极大值抑制 cv2.dnn.NMSBoxes()，搜索出局部最大值，将置信度最大的框保存，其余剔除，确保每个目标至少有一个框。

  1. cv2.dnn.NMSBoxes(bboxes, scores, score_threshold, nms_threshold, eta=None, top_k=None)
  2.  
  3. '''
  4. bboxes：检测框信息 [x,y,w,h]
  5. scores：每个待处理检测框的置信度
  6. score_threshold：用于过滤检测框的置信度阈值
  7. nms_threshold：NMS阈值
  8. eta：自适应阈值公式中的相关系数
  9. top_k: 如果 top_k>0，则保留最多 top_k 个边界框索引值
  10. '''

接下去就能使用矩形框绘制函数 cv2.rectangle() 把每个检测框绘制出来。

在上一节的代码中补充。

  1. import numpy as np
  2. import cv2
  3. import time
  4.  
  5. #（1）加载预训练的COCO数据集
  6. classesFile = 'C:\\Users\\admin\\.spyder-py3\\test\\机器视觉\\yolov3\\coco.names'  # 指定coco数据集分类名所在路径
  7. classNames = []  # 创建列表，存放coco数据集的分类名称
  8.  
  9. # 打开数据集名称的文件
  10. with open(classesFile, 'rt') as f:  #读取文本文件
  11.     classNames = f.read().rstrip('\n').split('\n')  # 通过换行符来拆分，再读入
  12.  
  13. # 加载yolov3结构cfg文件
  14. modelConfiguration = 'yolov3.cfg'
  15. # 加载yolov3网络权重
  16. modelWeights = 'yolov3.weights'
  17.  
  18. # 确定输入图像的宽和高
  19. wInput, hInput = 320, 320
  20.  
  21. # 自定义目标检测的最小置信度
  22. confThreshold = 0.5
  23.  
  24. # 自定义非极大值抑制的参数
  25. nms_threshold = 0.3
  26.  
  27. #（2）构建网络结构
  28. # 导入darknet53网络，传入cfg文件和网络权重
  29. net = cv2.dnn.readNetFromDarknet(modelConfiguration, modelWeights)
  30. # 申明使用opencv作为后端
  31. net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
  32. # 申明使用CPU计算
  33. net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)
  34.  
  35. #（3）获取摄像头
  36. videoFile = 'C:\\GameDownload\\Deep Learning\\trafficvideo1.mp4'
  37. cap = cv2.VideoCapture(videoFile) # 0代表电脑自带的摄像头,代表外接摄像头 
  38.  
  39. #（4）定义函数用于检测目标，获取检测框信息，以及分类类别
  40. def findObjects(outputs, img):
  41.     
  42.     # 图像的高度、宽度、通道数
  43.     hT, wT, cT = img.shape  # 先保存高度，再保存宽度
  44.     
  45.     # 定义一个列表存放检测框的中心点坐标和宽高
  46.     bbox = []
  47.     # 定义列表存放分类的名称的索引
  48.     classIds = []
  49.     # 定义列表存放置信度
  50.     confs = [] # 如果找到目标了，就将检测框的信息存放起来
  51.     
  52.     # 遍历三个输出层
  53.     for output in outputs:
  54.         
  55.         # 遍历输出层的85项信息
  56.         for det in output:  # det是数组类型
  57.             
  58.             # 在80个分类中找到哪个分类的值是最高的
  59.             score = det[5:]  # 忽略检测框的x,y,w,h,c
  60.             
  61.             # 找到分类值最大对应的索引号
  62.             classId = np.argmax(score)
  63.             
  64.             # 找到分类概率最大值的索引对应的值
  65.             confidence = score[classId]
  66.             
  67.             # 如果检测置信度大于规定的阈值，表明检测到了物体
  68.             if confidence > confThreshold:
  69.                 
  70.                 # 记录检测框的宽和高，这里的宽高是归一化之后的比例宽度和高度
  71.                 w, h = int(det[2]*wT), int(det[3]*hT)  # 比例宽高转为像素宽高，像素宽高是整数
  72.                 
  73.                 # 记录检测框的左上角坐标
  74.                 x, y = int(det[0]*wT-w/2), int(det[1]*hT-h/2)
  75.                 
  76.                 # 将检测框的信息保存起来
  77.                 bbox.append([x, y, w, h])
  78.                 # 将目标属于哪个类别的索引保存下来
  79.                 classIds.append(classId)
  80.                 # 保存检测框的置信度，检测出某个目标的概率
  81.                 confs.append(float(confidence))
  82.  
  83.     #（5）消除重叠的矩形框，非极大值抑制
  84.     indices = cv2.dnn.NMSBoxes(bbox, confs, confThreshold, nms_threshold)  # 返回检测框的索引 
  85.     
  86.     # 遍历索引绘制矩形框
  87.     for i in indices:
  88.   
  89.         # 在所有包含目标的矩形框中找到最符合的矩形框
  90.         box = bbox[i]
  91.         
  92.         # 提取矩形框的信息
  93.         x, y, w, h = box[0], box[1], box[2], box[3]
  94.         
  95.         # 绘制矩形框
  96.         cv2.rectangle(img, (x,y), (x+w,y+h), (255,255,0), 2)
  97.         
  98.         # 显示文本
  99.         cv2.putText(img, f'{classNames[classIds[i]]}',
  100.                     (x,y+h+18), cv2.FONT_HERSHEY_COMPLEX, 0.8, (0,255,0), 2)
  101.         
  102.         cv2.putText(img, f'{int(confs[i]*100)}%',
  103.                     (x,y-8), cv2.FONT_HERSHEY_COMPLEX, 0.8, (0,0,255), 2)  
  104.  
  105. #（6）处理帧图像
  106. while True:
  107.     
  108.     # 接收图片是否导入成功、帧图像
  109.     success, img = cap.read()
  110.     
  111.     # 改变图像大小
  112.     img = cv2.resize(img, (1280,720))
  113.     
  114.     # 视频较短，循环播放
  115.     if cap.get(cv2.CAP_PROP_POS_FRAMES) == cap.get(cv2.CAP_PROP_FRAME_COUNT):
  116.         
  117.         # 如果当前帧==总帧数，那就重置当前帧为0
  118.         cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
  119.     
  120.     #（7）将img图片转换成blob块类型，网络只接受这种类型
  121.     # 输入img图像，，图像宽w高h，默认参数[0,0,0]，，
  122.     blob = cv2.dnn.blobFromImage(img, 1/255, (wInput,hInput), [0,0,0], 1, crop=False)
  123.     
  124.     # 将转换类型后的图像作为输入数据
  125.     net.setInput(blob)
  126.     
  127.     # 获得网络各层的名称，由于网络会输出最后三层的结果，用于定位输出层
  128.     layerNames = net.getLayerNames()  # 得到网络所有层的名称
  129.     
  130.     # 提取输出层，返回输出层是第几层，层数是从1开始，索引是从0开始
  131.     # net.getUnconnectedOutLayers()  # [200, 227, 254]
  132.     
  133.     outputNames = []  # 存放输出层名称
  134.     
  135.     # 得到输出层在网络中属于第几层
  136.     for outindex in net.getUnconnectedOutLayers():
  137.         
  138.         # 得到输出层的名称，outindex是第几层（从1开始），传入的是索引（从0开始）
  139.         outputNames.append(layerNames[outindex-1])
  140.     
  141.     # 获取输出层返回结果
  142.     outputs = net.forward(outputNames)
  143.     
  144.     #（8）目标检测
  145.     findObjects(outputs, img)    
  146.     
  147.     #（9）显示图像    
  148.     # 显示图像，输入窗口名及图像数据
  149.     cv2.namedWindow("img", 0)  # 窗口大小可调整
  150.     cv2.imshow('img', img)    
  151.     if cv2.waitKey(1) & 0xFF==27:  #每帧滞留20毫秒后消失，ESC键退出
  152.         break
  153.  
  154. # 释放视频资源
  155. cap.release()
  156. cv2.destroyAllWindows()

检测结果如下：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/474083
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号