针对D435i相机，主要是实例化realsense模块的代码（61-90行），其余为yolo目标检测的代码

    1. import argparse  # python的命令行解析的标准模块  可以让我们直接在命令行中就可以向程序中传入参数并让程序运行
    2. import os
    3. import shutil
    4. import time
    5. from pathlib import Path  # Path将str转换为Path对象 使字符串路径易于操作的模块
    7. import cv2
    8. import torch
    9. import torch.backends.cudnn as cudnn  # cuda模块
    10. from numpy import random
    11. import numpy as np
    12. import pyrealsense2 as rs  # 导入realsense的sdk模块
    14. from models.experimental import attempt_load
    15. from utils.general import (
    16.     check_img_size, non_max_suppression, apply_classifier, scale_coords,
    17.     xyxy2xywh, plot_one_box, strip_optimizer, set_logging, plot_line, plot_cross)
    18. from utils.torch_utils import select_device, load_classifier, time_synchronized
    19. from utils.datasets import letterbox
    22. def detect(save_img=False):
    23.     # 加载参数
    24.     out, source, weights, view_img, save_txt, imgsz = \
    25.         opt.save_dir, opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size
    26.     webcam = source == '0' or source.startswith(('rtsp://', 'rtmp://', 'http://')) or source.endswith('.txt')
    29.     # 初始化
    30.     set_logging()  # 生成日志
    31.     device = select_device(opt.device)  # 获取当前主机可用的设备
    32.     if os.path.exists(out):  # output dir
    33.         shutil.rmtree(out)  # delete dir
    34.     os.makedirs(out)  # make new dir
    35.     # 如果设配是GPU 就使用half(float16)  包括模型半精度和输入图片半精度
    36.     half = device.type != 'cpu'  # half precision only supported on CUDA
    38.     # 载入模型和模型参数并调整模型
    39.     model = attempt_load(weights, map_location=device)  # 加载Float32模型
    40.     imgsz = check_img_size(imgsz, s=model.stride.max())  # 确保输入图片的尺寸imgsz能整除stride=32 如果不能则调整为能被整除并返回 # stride: 模型最大的下采样率 [8, 16, 32] 所有stride一般为32
    41.     if half:  # 是否将模型从float32 -> float16  加速推理
    42.         model.half()  # to FP16
    44.     # 加载推理数据
    45.     vid_path, vid_writer = None, None
    46.     # 采用webcam数据源
    47.     view_img = True
    48.     cudnn.benchmark = True  # 加快常量图像大小推断
    49.     # dataset = LoadStreams(source, img_size=imgsz)  #load 文件夹中视频流
    51.     # 获取每个类别的名字和随机生成类别颜色
    52.     names = model.module.names if hasattr(model, 'module') else model.names
    53.     colors = [[random.randint(0, 255) for _ in range(3)] for _ in range(len(names))]
    55.     # 正式推理
    56.     t0 = time.time()  # 记录时间
    57.     # 这里先设置一个全零的Tensor进行一次前向推理 判断程序是否正常
    58.     img = torch.zeros((1, 3, imgsz, imgsz), device=device)
    59.     _ = model(img.half() if half else img) if device.type != 'cpu' else None  # run once
    61.     # 实例化realsense模块
    62.     # https://www.rs-online.com/designspark/intelpython2-nvidia-jetson-nanorealsense-d435-cn
    63.     pipeline = rs.pipeline()
    64.     # 创建 config 对象：
    65.     config = rs.config()
    66.     # 声明RGB和深度视频流
    67.     # config.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 30)
    68.     config.enable_stream(rs.stream.depth, 1280, 720, rs.format.z16, 30)
    69.     config.enable_stream(rs.stream.color, 1280, 720, rs.format.bgr8, 30)
    71.     # 启动数据流
    72.     pipeline.start(config)
    73.     align_to_color = rs.align(rs.stream.color)  # 对齐rgb和深度图
    75.     sum = 0
    76.     count = 0
    78.     while True:
    79.         start = time.time()
    80.         # Wait for a coherent pair of frames（一对连贯的帧）: depth and color
    81.         frames = pipeline.wait_for_frames()  # 等待最新的影像，wait_for_frames返回的是一個合成的影像
    82.         frames = align_to_color.process(frames)  # 将上图获取视频帧对齐
    83.         # 使用 process 來實現剛剛宣告的 align 對齊功能
    84.         # 将合成帧分开
    85.         depth_frame = frames.get_depth_frame()
    86.         color_frame = frames.get_color_frame()
    87.         # 转换成 numpy 数据
    88.         color_image = np.asanyarray(color_frame.get_data())
    89.         # print(color_image.shape)
    90.         depth_image = np.asanyarray(depth_frame.get_data())
    91.         # mask = np.zeros([color_image.shape[0], color_image.shape[1]], dtype=np.uint8)
    92.         # mask[0:480, 320:640] = 255
    94.         # 对RGB的img进行处理，送入预测模型
    95.         sources = [source]  # 数据源
    96.         imgs = [None]
    97.         path = sources  # path: 图片/视频的路径
    98.         imgs[0] = color_image
    99.         im0s = imgs.copy()  # img0s: 原尺寸的图片
    100.         img = [letterbox(x, new_shape=imgsz)[0] for x in im0s]  # img: 进行resize + pad之后的图片
    101.         print(imgsz)
    102.         img = np.stack(img, 0)  # 沿着0dim进行堆叠
    103.         img = img[:, :, :, ::-1].transpose(0, 3, 1, 2)  # BGR to RGB, to 3x416x416, uint8 to float32
    104.         img = np.ascontiguousarray(img, dtype=np.float16 if half else np.float32)
    105.         # ascontiguousarray函数将一个内存不连续存储的数组转换为内存连续存储的数组，使得运行速度更快。
    106.         img /= 255.0  # 0 - 255 to 0.0 - 1.0
    108.         # 处理每一张图片的数据格式
    109.         img = torch.from_numpy(img).to(device)  # 将numpy转为pytorch的tensor,并转移到运算设备上计算
    110.         # 如果图片是3维(RGB) 就在前面添加一个维度1当中batch_size=1
    111.         # 因为输入网络的图片需要是4为的 [batch_size, channel, w, h]
    112.         if img.ndimension() == 3:
    113.             img = img.unsqueeze(0)  # 在dim0位置添加维度1，[channel, w, h] -> [batch_size, channel, w, h]
    114.         t1 = time_synchronized()  # 精确计算当前时间  并返回当前时间
    115.         # 对每张图片/视频进行前向推理
    116.         pred = model(img, augment=opt.augment)[0]
    117.         # 进行NMS 去除多余的框
    118.         # conf_thres: 置信度阈值
    119.         # iou_thres: iou阈值
    120.         # classes: 是否只保留特定的类别 默认为None
    121.         # agnostic_nms: 进行nms是否也去除不同类别之间的框 默认False
    122.         # max_det: 每张图片的最大目标个数 默认1000
    123.         # pred: [num_obj, 6] = [5, 6]   这里的预测信息pred还是相对于 img_size(640) 的
    124.         pred = non_max_suppression(pred, opt.conf_thres, opt.iou_thres, classes=opt.classes, agnostic=opt.agnostic_nms)
    127.         # 后续保存或者打印预测信息
    128.         for i, det in enumerate(pred):  # detections per image
    129.             p, s, im0 = path[i], '%g: ' % i, im0s[i].copy()
    130.             s += '%gx%g ' % img.shape[2:]  # print string 输出信息 图片shape（w,h)
    131.             gn = torch.tensor(im0.shape)[[1, 0, 1, 0]]  # normalization gain gn=[w,h,w,h] 用于后面的归一化
    132.             if det is not None and len(det):
    133.                 # Rescale boxes from img_size to im0 size 将预测信息（相对img_size 640）映射回原图 img0 size
    134.                 det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()
    136.                 # Print results 输出信息s + 检测到的各个类别的目标个数
    137.                 for c in det[:, -1].unique():
    138.                     n = (det[:, -1] == c).sum()  # detections per class
    139.                     s += '%g %ss, ' % (n, names[int(c)])  # add to string
    141.                 # Write results 保存预测信息: img0上画框、crop_img
    142.                 for *xyxy, conf, cls in reversed(det):
    143.                     if (conf):
    144.                         count = count + 1
    145.                         sum = sum + conf
    146.                         ave = sum / count
    147.                         print('ave_conf = %.3f' % ave)
    148.                     #保存为label.txt用的，我们没保存，所以with open...也被删了，下面两行没用到
    149.                     xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist()  # 归一化为 xywh
    150.                     line = (cls, conf, *xywh) if opt.save_conf else (cls, *xywh)  # label format
    151.                     # 获取距离信息
    152.                     # print("find a pine")
    153.                     # print(xyxy)
    154.                     distance_list = []
    155.                     mid_pos = [int((int(xyxy[0]) + int(xyxy[2])) / 2),
    156.                                int((int(xyxy[1]) + int(xyxy[3])) / 2)]  # 获得预测框的中心像素位置
    157.                     min_val = min(abs(int(xyxy[2]) - int(xyxy[0])), abs(int(xyxy[3]) - int(xyxy[1])))  # 确定偏差搜索范围
    158.                     # print(box,)
    159.                     # 声明一个num为40的随机序列，同一目标预测框每个序号生成一个深度值
    160.                     randnum = 40
    161.                     for i in range(randnum):
    162.                         bias = random.randint(-min_val // 4, min_val // 4)  # 生成固定范围内的随机整数为偏差,'//'整数除法
    163.                         dist = depth_frame.get_distance(int(mid_pos[0] + bias),
    164.                                                         int(mid_pos[1] + bias))  # 从深度视频帧中获得目标点的深度信息
    165.                         # print(int(mid_pos[1] + bias), int(mid_pos[0] + bias))
    166.                         if dist:
    167.                             distance_list.append(dist)  # 添加到列表
    168.                     # 将40个深度数据进行处理
    169.                     distance_list = np.array(distance_list)
    170.                     distance_list = np.sort(distance_list)[
    171.                                     randnum // 2 - randnum // 4:randnum // 2 + randnum // 4]  # 冒泡排序实现中值滤波
    173.                     label = '%s %.2f%s' % (names[int(cls)], np.mean(distance_list), 'm')  # 最后取平均值为目标深度
    174.                     plot_one_box(xyxy, im0, label=label, color=colors[int(cls)], line_thickness=3)  # 将结果框打印回原图
    175.                     im_mid_pos = (im0.shape[1]//2,im0.shape[0]//2)
    176.                     plot_cross(im0, im_mid_pos, size=20,color=[0, 255, 0], line_thickness=2)
    177.                     plot_line(im0, im_mid_pos, tuple(mid_pos),color=colors[int(cls)], line_thickness=3)
    178.             t2 = time_synchronized()
    179.             # Print time (inference + NMS)
    180.             sec = t2 - t1
    181.             # fps = 1 / sec
    182.             print('%sDone. (%.3fs)' % (s, sec ))
    184.             # save video
    185.             # out = cv2.VideoWriter('rs.mp4', cv2.VideoWriter_fourcc(*'mp4v'), 30, (640, 480), True)
    186.             # print('writing video')
    187.             # out.write(im0)
    189.             # Stream results
    190.             if view_img:
    191.                 cv2.imshow(p, im0)
    192.                 if cv2.waitKey(1) == ord('q'):  # q to quit
    193.                     raise StopIteration
    195.     # print('Done. (%.3fs)' % (time.time() - t0))
    196. if __name__ == '__main__':
    197.     parser = argparse.ArgumentParser()
    198.     # parser.add_argument('--weights', nargs='+', type=str, default='yolov5m.pt', help='model.pt path(s)')
    199.     parser.add_argument('--weights', nargs='+', type=str,default='runs/train/exp32/weights/best.pt', help='model.pt path(s)')
    200.     parser.add_argument('--source', type=str, default='0', help='source')  # file/ folder, 0 for webcam
    201.     parser.add_argument('--img-size', type=int, default=1280, help='inference size (pixels)')
    202.     parser.add_argument('--conf-thres', type=float, default=0.35, help='object confidence threshold')
    203.     parser.add_argument('--iou-thres', type=float, default=0.45, help='IOU threshold for NMS')
    204.     parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
    205.     parser.add_argument('--view-img', action='store_true', help='display results')
    206.     parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
    207.     parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
    208.     parser.add_argument('--save-dir', type=str, default='inference/output', help='directory to save results')
    209.     parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --class 0, or --class 0 2 3')
    210.     parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
    211.     parser.add_argument('--augment', action='store_true', help='augmented inference')
    212.     parser.add_argument('--update', action='store_true', help='update all models')
    213.     opt = parser.parse_args()
    214.     print(opt)
    216.     with torch.no_grad():  # 一个上下文管理器，被该语句wrap起来的部分将不会track梯度
    217.         detect()