• 基于YOLO算法与intel深度相机三维测量（工件尺寸和物体尺寸）

    目录

    1.简介

     1.1 intel D4系列深度相机 (D455)

    1.2 yolo算法

    2.功能实现 

    2.1构思：

    2.2 主代码

    这篇文章还是接着前面的几篇文章的项目延申，这个是最初的方案，因为太贵被否了。

    1.简介

     1.1 intel D4系列深度相机 (D455)

    Intel RealSense D435、D455等D4系列：

    Intel D4系列深度相机是由英特尔（Intel）公司推出的一款深度感知摄像头，专为实现计算机视觉和深度学习应用而设计。这款相机使用了英特尔的深度感知技术，结合了摄像头和红外（IR）传感器，可以提供高质量的深度图像和 RGB 彩色图像，为开发者提供了丰富的数据源，用于各种应用，包括虚拟现实（VR）、增强现实（AR）、手势识别、人脸识别、姿势识别、3D 扫描等。

    以下是Intel D4系列深度相机的一些主要特点和优势：
    1. 深度感知技术：
    D4系列相机具备高质量的深度感知功能，能够获取场景中各个物体的精确距离信息，而不仅仅是RGB图像。
    2. 多模式操作：
    相机支持多种操作模式，包括手势识别、人脸识别、物体追踪等。这使得它非常适合于需要人机交互的应用领域。
    3. 低光环境适应：
    D4系列深度相机在低光环境下也能够提供准确的深度信息，这使得它在各种不同的环境中都能够稳定工作。
    4. 易于集成：
    相机提供了丰富的软件开发工具，开发者可以方便地将其集成到自己的应用中，快速开发深度感知应用。
    5. 多平台支持：
    D4系列深度相机支持多种操作系统，包括Windows、Linux等，也提供了各种开发语言的API，方便开发者在不同平台上使用。
    6. 精准度和稳定性：
    相机具有高精度和稳定性，能够在不同距离范围内提供准确的深度信息，这对于需要精确度的应用非常重要。

    1.2 yolo算法

    YOLO（You Only Look Once）是一种实时目标检测算法，它的主要思想是将目标检测问题转化为一个回归问题。相较于传统的目标检测算法，YOLO具有更快的处理速度和较高的准确性。

    YOLO算法的基本原理如下：

    将输入图像划分为一个固定大小的网格。每个网格负责预测该网格中是否包含目标以及目标的边界框。

    每个网格预测多个边界框（一般为5个）以适应不同形状的目标。

    每个边界框预测目标类别的概率。

    对每个边界框的位置和类别进行综合预测。

    使用非极大值抑制（NMS）处理重叠的边界框，以获取最终的目标检测结果。

    YOLO算法相较于其他目标检测算法的优势在于其端到端的设计，能够实现实时目标检测，并且减少了检测过程中的多次重复计算。然而，由于YOLO将图像划分为网格，对于小尺寸目标和密集目标的检测效果可能会稍差。

    此外，YOLO还有不同版本的改进，如YOLOv2、YOLOv3和YOLOv4等，这些改进版本在准确性和速度方面有所提升，同时也引入了一些新的技术和网络结构，如多尺度预测、锚框、Darknet-19等。

    2.功能实现 

    这是实验室的一个项目，用于未来试智能立体停车场的视觉部分，需要检测车俩位置信息和尺寸信息，摄像头在库的顶上，俯拍视角，图如下：

    2.1构思：

    因为是俯拍，所以这里就考虑了用2D框实现的可行性，通过yolo拿到粗定位框，将框手动扩大一点，确保物体完全包裹，对框内区域提取轮廓在进行多边形拟合，使用拟合后数据重新画框，拿到角点坐标，进行坐标变换，将像素坐标转为真实坐标，求出距离。（仅限俯拍情况，如果是其他场景，框的坐标和现实坐标不在一个面上，这样就需要用三维目标检测算法画框）

    2.2 主代码

    这里就不完全开源了，因为这个项目还在做，不过有底子的道友，可以参考我前面有一篇opencv里dnn推理yolov5的代码，结合一下下面这个代码就可以用了。

    1. import pyrealsense2 as rs
    2. # import numpy as np
    3. # import cv2
    4. import random
    5. # import torch
    6. from ours import *
    7. import time
    8.  
    9. # model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
    10. #
    11. # model = torch.hub.load('ultralytics/yolov5', 'yolov5l6')
    12. # model.conf = 0.5
    13. def get_mid_pos(frame,box,depth_data,randnum):
    14.     distance_list = []
    15.     mid_pos = [(box[0] + box[2])//2, (box[1] + box[3])//2] #确定索引深度的中心像素位置
    16.     min_val = min(abs(box[2] - box[0]), abs(box[3] - box[1])) #确定深度搜索范围
    17.     #print(box,)
    18.     for i in range(randnum):
    19.         bias = random.randint(-min_val//4, min_val//4)
    20.         dist = depth_data[int(mid_pos[1] + bias), int(mid_pos[0] + bias)]
    21.         cv2.circle(frame, (int(mid_pos[0] + bias), int(mid_pos[1] + bias)), 4, (255,0,0), -1)
    22.  
    23.         #print(int(mid_pos[1] + bias), int(mid_pos[0] + bias))
    24.         if dist:
    25.             distance_list.append(dist)
    26.     distance_list = np.array(distance_list)
    27.     distance_list = np.sort(distance_list)[randnum//2-randnum//4:randnum//2+randnum//4] #冒泡排序+中值滤波
    28.     cv2.imshow('1', frame)
    29.  
    30.  
    31.  
    32.  
    33.     return np.mean(distance_list)
    34. def dectshow(org_img, boxs,depth_data):
    35.     img = org_img.copy()
    36.     for box in boxs:
    37.         cv2.rectangle(img, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])), (0, 255, 0), 2)
    38.         intrinsics = depth_frame.profile.as_video_stream_profile().intrinsics
    39.         #
    40.         # x1, y1 = (box[0] ,box[1])
    41.         # print((x1,y1))
    42.         # x1, y2 = (box[1] ,box[1])
    43.         # x2, y1 = (box[0] ,box[1])
    44.         # x2, y2 = (box[0] ,box[1])
    45.  
    46.         x1 = box[0]
    47.         y1 = box[1]
    48.         x2 = box[2]
    49.         y2 = box[3]
    50.  
    51.         cv2.circle(img, (x1, y1), 5, (0, 0, 255), -1)  # 红色圆点
    52.         cv2.circle(img, (x2, y1), 5, (0, 255, 0), -1)  # 绿色圆点
    53.         cv2.circle(img, (x2, y2), 5, (255, 0, 0), -1)  # 蓝色圆点
    54.  
    55.         depth1 = depth_frame.get_distance(x1, y1)  # 获取第一个点的深度值
    56.         depth2 = depth_frame.get_distance(x2, y1)  # 获取第二个点的深度值
    57.         depth3 = depth_frame.get_distance(x2, y2)  # 获取第三个点的深度值
    58.  
    59.         point1 = rs.rs2_deproject_pixel_to_point(intrinsics, [x1, y1], depth1)
    60.         point2 = rs.rs2_deproject_pixel_to_point(intrinsics, [x2, y1], depth2)
    61.         point3 = rs.rs2_deproject_pixel_to_point(intrinsics, [x2, y2], depth3)
    62.  
    63.         cv2.imshow('1', img)
    64.  
    65.         # 计算两点之间的距离
    66.         width = np.linalg.norm(np.array(point2) - np.array(point1))
    67.         height = np.linalg.norm(np.array(point3) - np.array(point2))
    68.         print("宽 is:", width, "m")
    69.         print("长 is:", height, "m")
    70.  
    71.         cv2.putText(img, f'W: {str(width)[:4] }m H: {str(height)[:4]}m', (int(box[0]), int(box[1]) - 40), cv2.FONT_HERSHEY_SIMPLEX, 0.5,
    72.                     (0, 255, 0), 2)
    73.         # if not depth_frame.is_depth_frame():
    74.         #     continue
    75.         #
    76.         # # 确定坐标值是否在depth_image的范围之内
    77.         # if x1 >= 0 and x1 < depth_image.shape[1] and y1 >= 0 and y1 < depth_image.shape[0]:
    78.         #     depth1 = depth_frame.get_distance(x1, y1)  # 获取第一个点的深度值
    79.         #     continue
    80.         # else:
    81.         #     depth1 = None
    82.         #
    83.         #
    84.         # # 确定坐标值是否在depth_image的范围之内
    85.         # if x2 >= 0 and x2 < depth_image.shape[1] and y1 >= 0 and y1 < depth_image.shape[0]:
    86.         #     depth2 = depth_frame.get_distance(x2, y1)  # 获取第二个点的深度值
    87.         #     continue
    88.         # else:
    89.         #     depth2 = None
    90.         #
    91.         # # 确定坐标值是否在depth_image的范围之内
    92.         # if x2 >= 0 and x2 < depth_image.shape[1] and y2 >= 0 and y2 < depth_image.shape[0]:
    93.         #     depth3 = depth_frame.get_distance(x2, y2)  # 获取第三个点的深度值
    94.         #     continue
    95.         # else:
    96.         #     depth3 = None
    97.  
    98.         # if x1 < 0 or x1 >= depth_image.shape[1] or y1 < 0 or y1 >= depth_image.shape[0]:
    99.         #     # 处理超出范围的情况
    100.         #     continue  # 跳过该点的处理
    101.         # if x2 < 0 or x2 >= depth_image.shape[1] or y2 < 0 or y2 >= depth_image.shape[0]:
    102.         #     # 处理超出范围的情况
    103.         #     continue  # 跳过该点的处理
    104.  
    105.  
    106.  
    107.         dist = get_mid_pos(org_img, box, depth_data, 24)
    108.         cv2.putText(img, box[4] + ' ' + str(dist / 1000)[:4] + 'm' ,
    109.                     (int(box[0]), int(box[1])), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
    110.         # if not depth_frame.is_depth_frame():
    111.         #     continue
    112.         #
    113.         # # 确定坐标值是否在depth_image的范围之内
    114.         # if x1 >= 0 and x1 < depth_image.shape[1] and y1 >= 0 and y1 < depth_image.shape[0]:
    115.         #     depth1 = depth_frame.get_distance(x1, y1)  # 获取第一个点的深度值
    116.         #     continue
    117.         # else:
    118.         #     depth1 = None
    119.         #
    120.         #
    121.         # # 确定坐标值是否在depth_image的范围之内
    122.         # if x2 >= 0 and x2 < depth_image.shape[1] and y1 >= 0 and y1 < depth_image.shape[0]:
    123.         #     depth2 = depth_frame.get_distance(x2, y1)  # 获取第二个点的深度值
    124.         #     continue
    125.         # else:
    126.         #     depth2 = None
    127.         #
    128.         # # 确定坐标值是否在depth_image的范围之内
    129.         # if x2 >= 0 and x2 < depth_image.shape[1] and y2 >= 0 and y2 < depth_image.shape[0]:
    130.         #     depth3 = depth_frame.get_distance(x2, y2)  # 获取第三个点的深度值
    131.         #     continue
    132.         # else:
    133.         #     depth3 = None
    134.         if x1 < 0 or x1 >= depth_image.shape[1] or y1 < 0 or y1 >= depth_image.shape[0]:
    135.             # 处理超出范围的情况
    136.             continue  # 跳过该点的处理
    137.         if x2 < 0 or x2 >= depth_image.shape[1] or y2 < 0 or y2 >= depth_image.shape[0]:
    138.             # 处理超出范围的情况
    139.             continue  # 跳过该点的处理
    140.     cv2.imshow('dec_img', img)
    141.  
    142.  
    143. if __name__ == "__main__":
    144.     # Configure depth and color streams
    145.     onnx_path = 'yolov5s.onnx'
    146.     model = Yolov5ONNX(onnx_path)
    147.     pipeline = rs.pipeline()
    148.     config = rs.config()
    149.     config.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 60)
    150.     config.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8, 60)
    151.     # Start streaming
    152.     pipeline.start(config)
    153.     pTime = 0
    154.     try:
    155.         while True:
    156.             # Wait for a coherent pair of frames: depth and color
    157.             frames = pipeline.wait_for_frames()
    158.             depth_frame = frames.get_depth_frame()
    159.             color_frame = frames.get_color_frame()
    160.             depth_intrinsics = depth_frame.profile.as_video_stream_profile().intrinsics
    161.             if not depth_frame or not color_frame:
    162.                 continue
    163.             # Convert images to numpy arrays
    164.  
    165.             depth_image = np.asanyarray(depth_frame.get_data())
    166.  
    167.             color_image = np.asanyarray(color_frame.get_data())
    168.  
    169.             im = color_image.copy()    # 备份原图
    170.  
    171.  
    172.             cTime = time.time()
    173.             fps = 1 / (cTime - pTime)
    174.             pTime = cTime
    175.             cv2.putText(color_image, str(int(fps)), (10, 70), cv2.FONT_HERSHEY_PLAIN, 3,
    176.                         (255, 0, 255), 3)
    177.  
    178.  
    179.  
    180.             results , boxs = model.detect(color_image)
    181.  
    182.             dectshow(im, boxs, depth_image)
    183.  
    184.             # Apply colormap on depth image (image must be converted to 8-bit per pixel first)
    185.             depth_colormap = cv2.applyColorMap(cv2.convertScaleAbs(depth_image, alpha=0.03), cv2.COLORMAP_JET)
    186.             # Stack both images horizontally
    187.             images = np.hstack((color_image, depth_colormap))
    188.             # Show images
    189.             cv2.namedWindow('RealSense', cv2.WINDOW_AUTOSIZE)
    190.             cv2.imshow('RealSense', images)
    191.             key = cv2.waitKey(1)
    192.             # Press esc or 'q' to close the image window
    193.             if key & 0xFF == ord('q') or key == 27:
    194.                 cv2.destroyAllWindows()
    195.                 break
    196.     finally:
    197.         # Stop streaming
    198.         pipeline.stop()

    请忽略yolo这个笨蛋把他识别错了，但是效果还是可以的，精度也没问题，关键是很省事，就是相机费钱。这个方案被否了。

  • 相关阅读:
    swift-类结构源码探寻(二)
    系统缓存设计
    壳聚糖(CS)/京尼平(GP)/明胶(G)/β-甘油磷酸钠(β-GP)共混的温敏性水凝胶/壳聚糖载银水凝胶的研究制备
    如何在 Azure 容器应用程序上部署具有 Elastic Observability 的 Hello World Web 应用程序
    express学习6-express参数中get参数的获取
    挂耳耳机十大品牌排行榜哪个好，目前排行靠前的五款耳机推荐
    网站优化搜索引擎与关键词
    登录注册页面的模拟
    Linux-Centos中配置docker
    教程图文详解 - 局域网与城城网（第四章）
  • 原文地址：https://blog.csdn.net/weixin_45303602/article/details/133795966