精华内容
下载资源
问答
  • yolov5 调用 usb 摄像头

    千次阅读 2021-08-03 21:08:07
    文章是在yolov5 v5.0版本的detect.py所修改编写 其他v1.0-v4.0没有试过,你们可以试试。 具体用法已经写在代码里面了。 import time import cv2 import numpy as np import torch from models.experimental ...

    文章是在yolov5 v5.0版本的detect.py所修改编写

    其他v1.0-v4.0没有试过,你们可以试试。

    具体用法已经写在代码里面了。

    import time
    import cv2
    import numpy as np
    import torch
    from models.experimental import attempt_load
    from utils.datasets import letterbox
    from utils.general import check_img_size, non_max_suppression,scale_coords, xyxy2xywh,set_logging,check_requirements
    from utils.plots import colors, plot_one_box
    from utils.torch_utils import select_device,time_synchronized
    
    @torch.no_grad()
    def detect(
            #--------------------这里更改配置--------------------
            #---------------------------------------------------
               weights='runs/train/exp25/weights/best.pt',   #训练好的模型路径   (必改)
               imgsz=512,           #训练模型设置的尺寸 (必改)
               cap = 0,             #摄像头
               conf_thres=0.25,     #置信度
               iou_thres=0.45,      #NMS IOU 阈值
               max_det=1000,        #最大侦测的目标数
               device='',           #设备
               crop=True,           #显示预测框
               classes=None,        #种类
               agnostic_nms=False,  #class-agnostic NMS
               augment=False,       #是否扩充推理
               half=False,          #使用FP16半精度推理
               hide_labels=False,   #是否隐藏标签
               hide_conf=False,     #是否隐藏置信度
               line_thickness=3     #预测框的线宽
               ):
            # #--------------------这里更改配置--------------------
            #-----------------------------------------------------
        #打开摄像头
        cap = cv2.VideoCapture(cap)
    
        #-----初始化-----
        set_logging()
        #设置设备
        device = select_device(device)
        #CUDA仅支持半精度
        half &= device.type != 'cpu'  
    
        #-----加载模型-----
        #加载FP32模型
        model = attempt_load(weights, map_location=device)  
        #模型步幅
        stride = int(model.stride.max())  
        #检查图像大小
        imgsz = check_img_size(imgsz, s=stride)  
        #获取类名
        names = model.module.names if hasattr(model, 'module') else model.names  
        #toFP16
        if half:
            model.half()  
    
        #------运行推理------
        if device.type != 'cpu':
            model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters())))  # 跑一次
        
        #-----进入循环:ESC退出-----
        while(True):
            #设置labels--记录标签/概率/位置
            labels = []
            #计时
            t0 = time.time()
            ref,img0=cap.read()
            #填充调整大小
            img = letterbox(img0, imgsz, stride=stride)[0] 
            # 转换
            img = img[:, :, ::-1].transpose(2, 0, 1)  #BGR to RGB, to 3x416x416
            img = np.ascontiguousarray(img)
    
            img = torch.from_numpy(img).to(device)
            #uint8 to fp16/32
            img = img.half() if half else img.float()  
            #0 - 255 to 0.0 - 1.0
            img /= 255.0  
            if img.ndimension() == 3:
                img = img.unsqueeze(0)
    
            # 推断
            t1 = time_synchronized()
            pred = model(img, augment=augment)[0]
    
            # 添加 NMS
            pred = non_max_suppression(pred, conf_thres, iou_thres, classes, agnostic_nms, max_det=max_det)
            t2 = time_synchronized()
    
            #目标进程
            for i, det in enumerate(pred):  # 每幅图像的检测率
                s, im0 = '', img0.copy()
                #输出字符串
                s += '%gx%g ' % img.shape[2:]  
                #归一化增益
                gn = torch.tensor(im0.shape)[[1, 0, 1, 0]]  
                if len(det):
                    # 将框从img_大小重新缩放为im0大小
                    det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()
                    # 输出结果
                    for c in det[:, -1].unique():
                        #每类检测数
                        n = (det[:, -1] == c).sum()
                        #添加到字符串  
                        s += f"{n} {names[int(c)]}{'s' * (n > 1)}, "  
                    # 结果输出
                    for *xyxy, conf, cls in reversed(det):
                        #归一化xywh
                        xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist()  
                        #标签格式
                        line = (cls, *xywh, conf)  
                        #整数类
                        c = int(cls)  
                        #建立标签
                        label = None if hide_labels else (names[c] if hide_conf else f'{names[c]} {conf:.2f}')
                        #绘画预测框
                        if crop:    
                            plot_one_box(xyxy, im0, label=label, color=colors(c, True), line_thickness=line_thickness)
                        #记录标签/概率/位置
                        labels.append([names[c],conf,xyxy])
    
            #--------------------这里写/修改代码--------------------
            #-------------------------------------------------
            '''
            labels里面有该图片的标签/概率/坐标(列表)
    
            labels = [ [列表0] , [列表1] , [列表3] ,......]
                其中 列表 = [标签,概率,坐标]
    
            例如获取第一个预测框的概率值:print( float( labels[0][1])  )
            '''
            # 显示图片
            cv2.imshow("666",im0)
            #输出计算时间
            print(f'消耗时间: ({time.time() - t0:.3f}s)')
    
    
            key = cv2.waitKey(20)  
    
            #这里设置ESC退出
            if key == 27:
                break
            #--------------------END--------------------
            #-------------------------------------------------
        cv2.destroyAllWindows()
    
    if __name__ == "__main__":
        '''
        修改配置在 13-28 行
        写代码-显示输出/获取预测框位置/获取预测概率值 在121-END行
        '''
        #检测安装包--建议注释掉
        #check_requirements(exclude=('tensorboard', 'thop'))
        #运行
        detect()

    经研究发现,yolov5-master有time_synchronized 和 time_sync 两种名字,所以如果time_synchronized报错,麻烦换成time_sync

    展开全文
  • YOLOV5调用摄像头出错

    2021-08-23 16:54:16
    改完之后信息detect还会报错如下导致调用出来的摄像头好像一张图片没办法动: 错误原因:分母fps不能为0 解决办法:加if判断 为0就跳过不计算 添加红框内if指令,将上面的注释 即可 ...

    ①cv2.error: Unknown C++ exception from OpenCV code.

    这两个错误导致摄像头输出是这样的

    解决方法:

    找到datasets将

    上面框四行注释,下面框更改即可

    改完之后信息detect还会报错如下导致调用出来的摄像头好像一张图片没办法动:

    错误原因:分母fps不能为0

    解决办法:加if判断 为0就跳过不计算

    添加红框内if指令,将上面的注释 即可

    以上就是我自己的踩坑之路,希望能帮到大家更好的学习

    展开全文
  • Jetson nano + yolov5 + TensorRT加速+调用usb摄像头

    千次阅读 热门讨论 2021-05-07 19:34:31
    目录 前言 一、环境安装 1、安装虚拟环境virtualenv(可选) 2、设置cuda环境变量,解决nvcc -V找不到命令 3、更新 4、安装pytorch 和 torchvision 5、安装yolov5必须环境 二、TensorRt加速 三、调用usb摄像头 总结 ...


    前言

    因为在做毕业设计,需要将yolov5移植到嵌入式开发板。以前在Firefly-RK3399的Tengine框架上部署过Mobilenet-SSD,也玩过树莓派。这次尝试使用Jetson nano部署yolov5(4.0版本)。可惜更新换代太快,网上的教程比较旧,上个月又出了yolov5(5.0版),踩了很多坑,让我下定决心要更新一版教程。
    历时半个月,尝试了网上大多数方案,重装了八次,总结出以下最优方案。(2021-5-8)


    本文忽略镜像烧写过程,因为太简单了。

    一、环境安装

    1、安装虚拟环境virtualenv(可选)

    我除了第一次害怕环境出错外,后面几次都没有安装。主要是怕麻烦。

    sudo pip3 install virtualenv virtualenvwrapper
    

    修改环境变量

    nano ~/.bashrc
    

    添加下面三行到最下面

    export WORKON_HOME=$HOME/.virtualenvs
    export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
    export /usr/local/bin/virtualenvwrapper.sh
    

    接着创建并进入虚拟环境,与原生的OpenCV建立链接

    #创建一个叫yolov5的环境,你也可以叫其他名:
    mkvirtualenv yolov5
    #激活环境:
    workon yolov5
    #找到原生的OpenCV位置(寻找 .so 档案,大家应该都一样会在 /usr/lib/python3.6/dist-packages/cv2/python-3.6/ 里面):
    sudo find / -name cv2
    #建立链接
    ln -s /usr/lib/python3.6/dist-packages/cv2/python-3.6/cv2.cpython-36m-aarch64-linux-gnu.so ./virtualenvs/你的虚拟环境名/lib/python3.6/site-packages
    

    附上virtualenv常用命令

    #创建环境
    mkvirtualenv name #在~/.virtualenvs下安装name的需拟环境
    #激活工作环境(workon后不加任何东西可以列出所有虚拟环境)
    workon name
    #退出当前虚拟环境
    deactivate
    #删除虚拟环境,需先退出
    rmvirtualenv name
    #列出所有虚拟环境
    lsvirtualenv
    #列出所有已安装的包
    lssitepackages
    #如果想看主环境的已安装包用(在主环境下执行)
    dpkg -l | grep nvinfer
    

    2、设置cuda环境变量,解决nvcc -V找不到命令

     cd ~
     vim .bashrc
    

    末尾添加下面三行代码

    export PATH=/usr/local/cuda/bin:$PATH
    export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
    export CUDA_ROOT=/usr/local/cuda
    

    激活

    source .bashrc
    

    3、更新

    sudo apt-get update	
    

    4、安装pytorch 和 torchvision

    最好对照官网的教程操作,重点留意版本号
    https://forums.developer.nvidia.com/t/pytorch-for-jetson-version-1-8-0-now-available/72048
    这里我把官方教程搬运过来讲解:

    #先把官方的torch包下载下来,这里我是魔法上网下载的,因为实在太慢了,如果换成清华源的话找都找不到。自己下的话要注意版本号,我官方镜像自带的是python3.6.9所以是cp36,还要注意架构是Aarch64,不要下错了。就算下错了也没关系,笑死,根本装不上。
    wget https://nvidia.box.com/shared/static/p57jwntv436lfrd78inwl7iml6p13fzh.whl -O torch-1.8.0-cp36-cp36m-linux_aarch64.whl
    #安装需要的包
    sudo apt-get install python3-pip libopenblas-base libopenmpi-dev 
    pip3 install Cython
    pip3 install numpy
    #安装刚才下载的torch包
    pip3 install torch-1.8.0-cp36-cp36m-linux_aarch64.whl
    

    验证是否成功

    python3
    >>>import torch
    >>>print(torch.__version__)
    #出现版本号就算成功
    

    接下来安装torchvision。下面是对应版本号
    在这里插入图片描述

    #先安装必要的包
    sudo apt-get install libjpeg-dev zlib1g-dev libpython3-dev libavcodec-dev libavformat-dev libswscale-dev
    #原谅我这里又用了魔法上网(version是pytorch对应torchvision的版本号,我这里填的是 v0.9.0)
    git clone --branch <version> https://github.com/pytorch/vision torchvision
    #进入到上一步下载的文件夹中
    cd torchvision
    #设置临时变量(x就是你的版本号,我这里是9)
    export BUILD_VERSION=0.x.0 
    #开始安装(注意这里--user是安装在主环境,如果是虚拟环境要改为 --你的环境名)
    python3 setup.py install --user
    

    验证是否成功

    python3
    >>>import torchvision
    >>>print(torchversion.__version__)
    #出现版本号就算成功
    

    5、安装yolov5必须环境

    接着安装scipy,首先要安装前面这三样,不然会出错

    sudo apt-get install liblapack-dev
    sudo apt-get install libblas-dev
    sudo apt-get install gfortran	
    pip3 install scipy
    
    #接着安装剩下的包(超级慢)
    pip3 install matplotlib pillow pyyaml tensorboard tqdm 
    #安装seaborn时会自动安装matplotlib和pandas
    pip3 install seaborn
    

    恭喜,完成上面这几部步就可以跑yolov5了,我试过3.0 & 4.0 & 5.0 版本都可以跑。自己下载https://github.com/ultralytics/yolov5.git运行python3 detect.py试一下,这里不详细说明了。
    执行上面基本忽略使用魔法的时间就需要3.5个小时,希望你还有耐心听我讲完tensorrt的加速步骤。


    二、TensorRt加速

    我用的是tensorrtx,附上下载地址:https://github.com/wang-xinyu/tensorrtx.git
    你也可以尝试jetson-inference,我试过可以,不过安装过程繁琐,可以参考这位大神的教程:https://blog.csdn.net/qianbin3200896/article/details/108949723
    如果你想要jetson-inference,而同时又用了虚拟环境,需要注意建立jetson和虚拟环境的软链接,参考这位大神的5.4的方法三。https://blog.csdn.net/u011119817/article/details/99679350

    言归正传,
    tensorrtx上有他自己官方的教程,这里我搬运过来:

    #1、需要安装pycuda
    pip3 install pycuda
    
    #2、将tensorrtx/yolov5/gen_wts.py复制到之前(上面的第5步)你下载的yolov5文件夹中。如果你上一步没有下载,也可以现在下载
    git clone https://github.com/ultralytics/yolov5.git
    
    #3、下载官方的权重文件'yolov5s.pt',也可以用自己的。我用的是yolov5(4.0版本)训练出来的模型。
    
    #4、执行gen_wts.py生成.wts文件。
    python gen_wts.py yolov5s.pt
    
    #5、接下来去到目录tensorrtx下的yolov5文件夹
    #老规矩,创建一个build文件,并生成生成makeFile
    mkdir build
    cd build
    cmake ..
    
    #6、将yololayer.h里的CLASS_NUM修改成你的。因为官方用的是coco数据集,所以默认是80。
    
    #7、执行makeFile。(每次修改为CLASS_NUM都要make一次)
    make
    
    #8、将第4步生成的.wts文件复制到tensorrtx/yolov5里。
    
    #9、生成.engine文件(我用的是yolov5s,所以结尾用s)
    sudo ./yolov5 -s ../yolov5s.wts yolov5s.engine s
        如果你训练时是自定义depth_multiple 和 width_multiple就这样写:
    sudo ./yolov5 -s ../yolov5.wts yolov5.engine c 0.17 0.25
        在tensorrtx 5.0里也更新了yolov5的P6模型:
    sudo ./yolov5 -s ../yolov5.wts yolov5.engine s6
    
    #10、用他自带的图片(在samples里有两张图片)测试一下
    sudo ./yolov5 -d yolov5s.engine ../samples
    

    你也可以用自带的python文件来测试,不过我执行报错

    python yolov5_trt.py
    

    三、调用usb摄像头

    我写的是c++,如果你用python请参考这位大神https://blog.csdn.net/weixin_45569617/article/details/108145046

    在c++中,tensorrtx官方并没有给出调用摄像头的代码,我在github找到一位大神的代码,不过版本比较旧,于是在他的基础上稍作修改。里面我删掉了生成.engine文件的代码,需要你执行完上面的步骤生成了.engine再看下面的代码。
    用下面代码替换掉tensorrtx\yolov5\yolov5.cpp

    #include <iostream>
    #include <chrono>
    #include "cuda_utils.h"
    #include "logging.h"
    #include "common.hpp"
    #include "utils.h"
    #include "calibrator.h"
    
    #define USE_FP16  // set USE_INT8 or USE_FP16 or USE_FP32
    #define DEVICE 0  // GPU id
    #define NMS_THRESH 0.4
    #define CONF_THRESH 0.5
    #define BATCH_SIZE 1
    
    // stuff we know about the network and the input/output blobs
    static const int INPUT_H = Yolo::INPUT_H;
    static const int INPUT_W = Yolo::INPUT_W;
    static const int CLASS_NUM = Yolo::CLASS_NUM;
    static const int OUTPUT_SIZE = Yolo::MAX_OUTPUT_BBOX_COUNT * sizeof(Yolo::Detection) / sizeof(float) + 1;  // we assume the yololayer outputs no more than MAX_OUTPUT_BBOX_COUNT boxes that conf >= 0.1
    const char* INPUT_BLOB_NAME = "data";
    const char* OUTPUT_BLOB_NAME = "prob";
    static Logger gLogger;
    
    char *my_classes[]={ "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" };
    
    static int get_width(int x, float gw, int divisor = 8) {
        //return math.ceil(x / divisor) * divisor
        if (int(x * gw) % divisor == 0) {
            return int(x * gw);
        }
        return (int(x * gw / divisor) + 1) * divisor;
    }
    
    static int get_depth(int x, float gd) {
        if (x == 1) {
            return 1;
        } else {
            return round(x * gd) > 1 ? round(x * gd) : 1;
        }
    }
    
    ICudaEngine* build_engine(unsigned int maxBatchSize, IBuilder* builder, IBuilderConfig* config, DataType dt, float& gd, float& gw, std::string& wts_name) {
        INetworkDefinition* network = builder->createNetworkV2(0U);
    
        // Create input tensor of shape {3, INPUT_H, INPUT_W} with name INPUT_BLOB_NAME
        ITensor* data = network->addInput(INPUT_BLOB_NAME, dt, Dims3{ 3, INPUT_H, INPUT_W });
        assert(data);
    
        std::map<std::string, Weights> weightMap = loadWeights(wts_name);
    
        /* ------ yolov5 backbone------ */
        auto focus0 = focus(network, weightMap, *data, 3, get_width(64, gw), 3, "model.0");
        auto conv1 = convBlock(network, weightMap, *focus0->getOutput(0), get_width(128, gw), 3, 2, 1, "model.1");
        auto bottleneck_CSP2 = C3(network, weightMap, *conv1->getOutput(0), get_width(128, gw), get_width(128, gw), get_depth(3, gd), true, 1, 0.5, "model.2");
        auto conv3 = convBlock(network, weightMap, *bottleneck_CSP2->getOutput(0), get_width(256, gw), 3, 2, 1, "model.3");
        auto bottleneck_csp4 = C3(network, weightMap, *conv3->getOutput(0), get_width(256, gw), get_width(256, gw), get_depth(9, gd), true, 1, 0.5, "model.4");
        auto conv5 = convBlock(network, weightMap, *bottleneck_csp4->getOutput(0), get_width(512, gw), 3, 2, 1, "model.5");
        auto bottleneck_csp6 = C3(network, weightMap, *conv5->getOutput(0), get_width(512, gw), get_width(512, gw), get_depth(9, gd), true, 1, 0.5, "model.6");
        auto conv7 = convBlock(network, weightMap, *bottleneck_csp6->getOutput(0), get_width(1024, gw), 3, 2, 1, "model.7");
        auto spp8 = SPP(network, weightMap, *conv7->getOutput(0), get_width(1024, gw), get_width(1024, gw), 5, 9, 13, "model.8");
    
        /* ------ yolov5 head ------ */
        auto bottleneck_csp9 = C3(network, weightMap, *spp8->getOutput(0), get_width(1024, gw), get_width(1024, gw), get_depth(3, gd), false, 1, 0.5, "model.9");
        auto conv10 = convBlock(network, weightMap, *bottleneck_csp9->getOutput(0), get_width(512, gw), 1, 1, 1, "model.10");
    
        auto upsample11 = network->addResize(*conv10->getOutput(0));
        assert(upsample11);
        upsample11->setResizeMode(ResizeMode::kNEAREST);
        upsample11->setOutputDimensions(bottleneck_csp6->getOutput(0)->getDimensions());
    
        ITensor* inputTensors12[] = { upsample11->getOutput(0), bottleneck_csp6->getOutput(0) };
        auto cat12 = network->addConcatenation(inputTensors12, 2);
        auto bottleneck_csp13 = C3(network, weightMap, *cat12->getOutput(0), get_width(1024, gw), get_width(512, gw), get_depth(3, gd), false, 1, 0.5, "model.13");
        auto conv14 = convBlock(network, weightMap, *bottleneck_csp13->getOutput(0), get_width(256, gw), 1, 1, 1, "model.14");
    
        auto upsample15 = network->addResize(*conv14->getOutput(0));
        assert(upsample15);
        upsample15->setResizeMode(ResizeMode::kNEAREST);
        upsample15->setOutputDimensions(bottleneck_csp4->getOutput(0)->getDimensions());
    	
        ITensor* inputTensors16[] = { upsample15->getOutput(0), bottleneck_csp4->getOutput(0) };
        auto cat16 = network->addConcatenation(inputTensors16, 2);
    
        auto bottleneck_csp17 = C3(network, weightMap, *cat16->getOutput(0), get_width(512, gw), get_width(256, gw), get_depth(3, gd), false, 1, 0.5, "model.17");
    
        // yolo layer 0
        IConvolutionLayer* det0 = network->addConvolutionNd(*bottleneck_csp17->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap["model.24.m.0.weight"], weightMap["model.24.m.0.bias"]);
        auto conv18 = convBlock(network, weightMap, *bottleneck_csp17->getOutput(0), get_width(256, gw), 3, 2, 1, "model.18");
        ITensor* inputTensors19[] = { conv18->getOutput(0), conv14->getOutput(0) };
        auto cat19 = network->addConcatenation(inputTensors19, 2);
        auto bottleneck_csp20 = C3(network, weightMap, *cat19->getOutput(0), get_width(512, gw), get_width(512, gw), get_depth(3, gd), false, 1, 0.5, "model.20");
        //yolo layer 1
        IConvolutionLayer* det1 = network->addConvolutionNd(*bottleneck_csp20->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap["model.24.m.1.weight"], weightMap["model.24.m.1.bias"]);
        auto conv21 = convBlock(network, weightMap, *bottleneck_csp20->getOutput(0), get_width(512, gw), 3, 2, 1, "model.21");
        ITensor* inputTensors22[] = { conv21->getOutput(0), conv10->getOutput(0) };
        auto cat22 = network->addConcatenation(inputTensors22, 2);
        auto bottleneck_csp23 = C3(network, weightMap, *cat22->getOutput(0), get_width(1024, gw), get_width(1024, gw), get_depth(3, gd), false, 1, 0.5, "model.23");
        IConvolutionLayer* det2 = network->addConvolutionNd(*bottleneck_csp23->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap["model.24.m.2.weight"], weightMap["model.24.m.2.bias"]);
    
        auto yolo = addYoLoLayer(network, weightMap, det0, det1, det2);
        yolo->getOutput(0)->setName(OUTPUT_BLOB_NAME);
        network->markOutput(*yolo->getOutput(0));
    
        // Build engine
        builder->setMaxBatchSize(maxBatchSize);
        config->setMaxWorkspaceSize(16 * (1 << 20));  // 16MB
    #if defined(USE_FP16)
        config->setFlag(BuilderFlag::kFP16);
    #elif defined(USE_INT8)
        std::cout << "Your platform support int8: " << (builder->platformHasFastInt8() ? "true" : "false") << std::endl;
        assert(builder->platformHasFastInt8());
        config->setFlag(BuilderFlag::kINT8);
        Int8EntropyCalibrator2* calibrator = new Int8EntropyCalibrator2(1, INPUT_W, INPUT_H, "./coco_calib/", "int8calib.table", INPUT_BLOB_NAME);
        config->setInt8Calibrator(calibrator);
    #endif
    
        std::cout << "Building engine, please wait for a while..." << std::endl;
        ICudaEngine* engine = builder->buildEngineWithConfig(*network, *config);
        std::cout << "Build engine successfully!" << std::endl;
    
        // Don't need the network any more
        network->destroy();
    
        // Release host memory
        for (auto& mem : weightMap)
        {
            free((void*)(mem.second.values));
        }
    
        return engine;
    }
    
    ICudaEngine* build_engine_p6(unsigned int maxBatchSize, IBuilder* builder, IBuilderConfig* config, DataType dt, float& gd, float& gw, std::string& wts_name) {
        INetworkDefinition* network = builder->createNetworkV2(0U);
    
        // Create input tensor of shape {3, INPUT_H, INPUT_W} with name INPUT_BLOB_NAME
        ITensor* data = network->addInput(INPUT_BLOB_NAME, dt, Dims3{ 3, INPUT_H, INPUT_W });
        assert(data);
    
        std::map<std::string, Weights> weightMap = loadWeights(wts_name);
    
        /* ------ yolov5 backbone------ */
        auto focus0 = focus(network, weightMap, *data, 3, get_width(64, gw), 3, "model.0");
        auto conv1 = convBlock(network, weightMap, *focus0->getOutput(0), get_width(128, gw), 3, 2, 1, "model.1");
        auto c3_2 = C3(network, weightMap, *conv1->getOutput(0), get_width(128, gw), get_width(128, gw), get_depth(3, gd), true, 1, 0.5, "model.2");
        auto conv3 = convBlock(network, weightMap, *c3_2->getOutput(0), get_width(256, gw), 3, 2, 1, "model.3");
        auto c3_4 = C3(network, weightMap, *conv3->getOutput(0), get_width(256, gw), get_width(256, gw), get_depth(9, gd), true, 1, 0.5, "model.4");
        auto conv5 = convBlock(network, weightMap, *c3_4->getOutput(0), get_width(512, gw), 3, 2, 1, "model.5");
        auto c3_6 = C3(network, weightMap, *conv5->getOutput(0), get_width(512, gw), get_width(512, gw), get_depth(9, gd), true, 1, 0.5, "model.6");
        auto conv7 = convBlock(network, weightMap, *c3_6->getOutput(0), get_width(768, gw), 3, 2, 1, "model.7");
        auto c3_8 = C3(network, weightMap, *conv7->getOutput(0), get_width(768, gw), get_width(768, gw), get_depth(3, gd), true, 1, 0.5, "model.8");
        auto conv9 = convBlock(network, weightMap, *c3_8->getOutput(0), get_width(1024, gw), 3, 2, 1, "model.9");
        auto spp10 = SPP(network, weightMap, *conv9->getOutput(0), get_width(1024, gw), get_width(1024, gw), 3, 5, 7, "model.10");
        auto c3_11 = C3(network, weightMap, *spp10->getOutput(0), get_width(1024, gw), get_width(1024, gw), get_depth(3, gd), false, 1, 0.5, "model.11");
    
        /* ------ yolov5 head ------ */
        auto conv12 = convBlock(network, weightMap, *c3_11->getOutput(0), get_width(768, gw), 1, 1, 1, "model.12");
        auto upsample13 = network->addResize(*conv12->getOutput(0));
        assert(upsample13);
        upsample13->setResizeMode(ResizeMode::kNEAREST);
        upsample13->setOutputDimensions(c3_8->getOutput(0)->getDimensions());
        ITensor* inputTensors14[] = { upsample13->getOutput(0), c3_8->getOutput(0) };
        auto cat14 = network->addConcatenation(inputTensors14, 2);
        auto c3_15 = C3(network, weightMap, *cat14->getOutput(0), get_width(1536, gw), get_width(768, gw), get_depth(3, gd), false, 1, 0.5, "model.15");
    
        auto conv16 = convBlock(network, weightMap, *c3_15->getOutput(0), get_width(512, gw), 1, 1, 1, "model.16");
        auto upsample17 = network->addResize(*conv16->getOutput(0));
        assert(upsample17);
        upsample17->setResizeMode(ResizeMode::kNEAREST);
        upsample17->setOutputDimensions(c3_6->getOutput(0)->getDimensions());
        ITensor* inputTensors18[] = { upsample17->getOutput(0), c3_6->getOutput(0) };
        auto cat18 = network->addConcatenation(inputTensors18, 2);
        auto c3_19 = C3(network, weightMap, *cat18->getOutput(0), get_width(1024, gw), get_width(512, gw), get_depth(3, gd), false, 1, 0.5, "model.19");
    
        auto conv20 = convBlock(network, weightMap, *c3_19->getOutput(0), get_width(256, gw), 1, 1, 1, "model.20");
        auto upsample21 = network->addResize(*conv20->getOutput(0));
        assert(upsample21);
        upsample21->setResizeMode(ResizeMode::kNEAREST);
        upsample21->setOutputDimensions(c3_4->getOutput(0)->getDimensions());
        ITensor* inputTensors21[] = { upsample21->getOutput(0), c3_4->getOutput(0) };
        auto cat22 = network->addConcatenation(inputTensors21, 2);
        auto c3_23 = C3(network, weightMap, *cat22->getOutput(0), get_width(512, gw), get_width(256, gw), get_depth(3, gd), false, 1, 0.5, "model.23");
    
        auto conv24 = convBlock(network, weightMap, *c3_23->getOutput(0), get_width(256, gw), 3, 2, 1, "model.24");
        ITensor* inputTensors25[] = { conv24->getOutput(0), conv20->getOutput(0) };
        auto cat25 = network->addConcatenation(inputTensors25, 2);
        auto c3_26 = C3(network, weightMap, *cat25->getOutput(0), get_width(1024, gw), get_width(512, gw), get_depth(3, gd), false, 1, 0.5, "model.26");
    
        auto conv27 = convBlock(network, weightMap, *c3_26->getOutput(0), get_width(512, gw), 3, 2, 1, "model.27");
        ITensor* inputTensors28[] = { conv27->getOutput(0), conv16->getOutput(0) };
        auto cat28 = network->addConcatenation(inputTensors28, 2);
        auto c3_29 = C3(network, weightMap, *cat28->getOutput(0), get_width(1536, gw), get_width(768, gw), get_depth(3, gd), false, 1, 0.5, "model.29");
    
        auto conv30 = convBlock(network, weightMap, *c3_29->getOutput(0), get_width(768, gw), 3, 2, 1, "model.30");
        ITensor* inputTensors31[] = { conv30->getOutput(0), conv12->getOutput(0) };
        auto cat31 = network->addConcatenation(inputTensors31, 2);
        auto c3_32 = C3(network, weightMap, *cat31->getOutput(0), get_width(2048, gw), get_width(1024, gw), get_depth(3, gd), false, 1, 0.5, "model.32");
    
        /* ------ detect ------ */
        IConvolutionLayer* det0 = network->addConvolutionNd(*c3_23->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap["model.33.m.0.weight"], weightMap["model.33.m.0.bias"]);
        IConvolutionLayer* det1 = network->addConvolutionNd(*c3_26->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap["model.33.m.1.weight"], weightMap["model.33.m.1.bias"]);
        IConvolutionLayer* det2 = network->addConvolutionNd(*c3_29->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap["model.33.m.2.weight"], weightMap["model.33.m.2.bias"]);
        IConvolutionLayer* det3 = network->addConvolutionNd(*c3_32->getOutput(0), 3 * (Yolo::CLASS_NUM + 5), DimsHW{ 1, 1 }, weightMap["model.33.m.3.weight"], weightMap["model.33.m.3.bias"]);
    
        auto yolo = addYoLoLayer(network, weightMap, det0, det1, det2);
        yolo->getOutput(0)->setName(OUTPUT_BLOB_NAME);
        network->markOutput(*yolo->getOutput(0));
    
        // Build engine
        builder->setMaxBatchSize(maxBatchSize);
        config->setMaxWorkspaceSize(16 * (1 << 20));  // 16MB
    #if defined(USE_FP16)
        config->setFlag(BuilderFlag::kFP16);
    #elif defined(USE_INT8)
        std::cout << "Your platform support int8: " << (builder->platformHasFastInt8() ? "true" : "false") << std::endl;
        assert(builder->platformHasFastInt8());
        config->setFlag(BuilderFlag::kINT8);
        Int8EntropyCalibrator2* calibrator = new Int8EntropyCalibrator2(1, INPUT_W, INPUT_H, "./coco_calib/", "int8calib.table", INPUT_BLOB_NAME);
        config->setInt8Calibrator(calibrator);
    #endif
    
        std::cout << "Building engine, please wait for a while..." << std::endl;
        ICudaEngine* engine = builder->buildEngineWithConfig(*network, *config);
        std::cout << "Build engine successfully!" << std::endl;
    
        // Don't need the network any more
        network->destroy();
    
        // Release host memory
        for (auto& mem : weightMap)
        {
            free((void*)(mem.second.values));
        }
    
        return engine;
    }
    
    void APIToModel(unsigned int maxBatchSize, IHostMemory** modelStream, float& gd, float& gw, std::string& wts_name) {
        // Create builder
        IBuilder* builder = createInferBuilder(gLogger);
        IBuilderConfig* config = builder->createBuilderConfig();
    
        // Create model to populate the network, then set the outputs and create an engine
        ICudaEngine* engine = build_engine(maxBatchSize, builder, config, DataType::kFLOAT, gd, gw, wts_name);
        assert(engine != nullptr);
    
        // Serialize the engine
        (*modelStream) = engine->serialize();
    
        // Close everything down
        engine->destroy();
        builder->destroy();
        config->destroy();
    }
    
    void doInference(IExecutionContext& context, cudaStream_t& stream, void **buffers, float* input, float* output, int batchSize) {
        // DMA input batch data to device, infer on the batch asynchronously, and DMA output back to host
        CUDA_CHECK(cudaMemcpyAsync(buffers[0], input, batchSize * 3 * INPUT_H * INPUT_W * sizeof(float), cudaMemcpyHostToDevice, stream));
        context.enqueue(batchSize, buffers, stream, nullptr);
        CUDA_CHECK(cudaMemcpyAsync(output, buffers[1], batchSize * OUTPUT_SIZE * sizeof(float), cudaMemcpyDeviceToHost, stream));
        cudaStreamSynchronize(stream);
    }
    
    bool parse_args(int argc, char** argv, std::string& engine) {
        if (argc < 3) return false;
        if (std::string(argv[1]) == "-v" && argc == 3) {
            engine = std::string(argv[2]);
        } else {
            return false;
        }
        return true;
    }
    
    int main(int argc, char** argv) {
        cudaSetDevice(DEVICE);
    
        //std::string wts_name = "";
        std::string engine_name = "";
        //float gd = 0.0f, gw = 0.0f;
        //std::string img_dir;
        
    	if(!parse_args(argc,argv,engine_name)){
    		std::cerr << "arguments not right!" << std::endl;
            	std::cerr << "./yolov5 -v [.engine] // run inference with camera" << std::endl;
    		return -1;
    	}
    
    	std::ifstream file(engine_name, std::ios::binary);
            if (!file.good()) {
    		std::cerr<<" read "<<engine_name<<" error! "<<std::endl;
    		return -1;
    	}
    	char *trtModelStream{ nullptr };
    	size_t size = 0;
            file.seekg(0, file.end);
            size = file.tellg();
            file.seekg(0, file.beg);
            trtModelStream = new char[size];
            assert(trtModelStream);
            file.read(trtModelStream, size);
            file.close();
    	
    
        // prepare input data ---------------------------
        static float data[BATCH_SIZE * 3 * INPUT_H * INPUT_W];
        //for (int i = 0; i < 3 * INPUT_H * INPUT_W; i++)
        //    data[i] = 1.0;
        static float prob[BATCH_SIZE * OUTPUT_SIZE];
        IRuntime* runtime = createInferRuntime(gLogger);
        assert(runtime != nullptr);
        ICudaEngine* engine = runtime->deserializeCudaEngine(trtModelStream, size);
        assert(engine != nullptr);
        IExecutionContext* context = engine->createExecutionContext();
        assert(context != nullptr);
        delete[] trtModelStream;
        assert(engine->getNbBindings() == 2);
        void* buffers[2];
        // In order to bind the buffers, we need to know the names of the input and output tensors.
        // Note that indices are guaranteed to be less than IEngine::getNbBindings()
        const int inputIndex = engine->getBindingIndex(INPUT_BLOB_NAME);
        const int outputIndex = engine->getBindingIndex(OUTPUT_BLOB_NAME);
        assert(inputIndex == 0);
        assert(outputIndex == 1);
        // Create GPU buffers on device
        CUDA_CHECK(cudaMalloc(&buffers[inputIndex], BATCH_SIZE * 3 * INPUT_H * INPUT_W * sizeof(float)));
        CUDA_CHECK(cudaMalloc(&buffers[outputIndex], BATCH_SIZE * OUTPUT_SIZE * sizeof(float)));
        // Create stream
        cudaStream_t stream;
        CUDA_CHECK(cudaStreamCreate(&stream));
    
    
    	cv::VideoCapture capture(0);
        //cv::VideoCapture capture("../overpass.mp4");
        //int fourcc = cv::VideoWriter::fourcc('M','J','P','G');
        //capture.set(cv::CAP_PROP_FOURCC, fourcc);
        if(!capture.isOpened()){
            std::cout << "Error opening video stream or file" << std::endl;
            return -1;
        }
    
    	int key;
        int fcount = 0;
        while(1)
        {
            cv::Mat frame;
            capture >> frame;
            if(frame.empty())
            {
                std::cout << "Fail to read image from camera!" << std::endl;
                break;
            }
            fcount++;
            //if (fcount < BATCH_SIZE && f + 1 != (int)file_names.size()) continue;
            for (int b = 0; b < fcount; b++) {
                //cv::Mat img = cv::imread(img_dir + "/" + file_names[f - fcount + 1 + b]);
    			cv::Mat img = frame;
                if (img.empty()) continue;
                cv::Mat pr_img = preprocess_img(img, INPUT_W, INPUT_H); // letterbox BGR to RGB
                int i = 0;
                for (int row = 0; row < INPUT_H; ++row) {
                    uchar* uc_pixel = pr_img.data + row * pr_img.step;
                    for (int col = 0; col < INPUT_W; ++col) {
                        data[b * 3 * INPUT_H * INPUT_W + i] = (float)uc_pixel[2] / 255.0;
                        data[b * 3 * INPUT_H * INPUT_W + i + INPUT_H * INPUT_W] = (float)uc_pixel[1] / 255.0;
                        data[b * 3 * INPUT_H * INPUT_W + i + 2 * INPUT_H * INPUT_W] = (float)uc_pixel[0] / 255.0;
                        uc_pixel += 3;
                        ++i;
                    }
                }
            }
    
            // Run inference
            auto start = std::chrono::system_clock::now();
            doInference(*context, stream, buffers, data, prob, BATCH_SIZE);
            auto end = std::chrono::system_clock::now();
            //std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;
            int fps = 1000.0/std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    		std::vector<std::vector<Yolo::Detection>> batch_res(fcount);
            for (int b = 0; b < fcount; b++) {
                auto& res = batch_res[b];
                nms(res, &prob[b * OUTPUT_SIZE], CONF_THRESH, NMS_THRESH);
            }
            for (int b = 0; b < fcount; b++) {
                auto& res = batch_res[b];
                //std::cout << res.size() << std::endl;
                //cv::Mat img = cv::imread(img_dir + "/" + file_names[f - fcount + 1 + b]);
                for (size_t j = 0; j < res.size(); j++) {
                    cv::Rect r = get_rect(frame, res[j].bbox);
                    cv::rectangle(frame, r, cv::Scalar(0x27, 0xC1, 0x36), 2);
    		std::string label = my_classes[(int)res[j].class_id];
                    cv::putText(frame, label, cv::Point(r.x, r.y - 1), cv::FONT_HERSHEY_PLAIN, 1.2, cv::Scalar(0xFF, 0xFF, 0xFF), 2);
    				std::string jetson_fps = "Jetson Nano FPS: " + std::to_string(fps);
    				cv::putText(frame, jetson_fps, cv::Point(11,80), cv::FONT_HERSHEY_PLAIN, 3, cv::Scalar(0, 0, 255), 2, cv::LINE_AA);
    			}
                //cv::imwrite("_" + file_names[f - fcount + 1 + b], img);
            }
    		cv::imshow("yolov5",frame);
            key = cv::waitKey(1);
            if (key == 'q'){
                break; 
            }
            fcount = 0;
        }
    
    	capture.release();
        // Release stream and buffers
        cudaStreamDestroy(stream);
        CUDA_CHECK(cudaFree(buffers[inputIndex]));
        CUDA_CHECK(cudaFree(buffers[outputIndex]));
        // Destroy the engine
        context->destroy();
        engine->destroy();
        runtime->destroy();
    
        return 0;
    }
    
    

    改完后执行

    cd build
    make
    sudo ./yolov5 -v yolov5s.engine
    

    总结

    这些方法并不是我原创的,都是通过测试大神们的方法后总结的,完全没有创新。像在做排除法,类似于培养杂交水稻。

    展开全文
  • yolov5,使用海康安防相机,python源码,下载后就可以使用
  • 同样是 下载yolov-voc.weights,放在…\darknet-master\build\darknet\x64目录下,如果你前面已经调用过计算机上的相机就可以了。 与刚才一样右键darknet_net_cam_voc编辑。 可以看到和上面调用电脑相机差不多,...

    另有一篇记录的是从零开始训练自己的模型
    YOLO算法训练模型检测太阳位置

    环境:win10 GTX 1050 TI CUDA:10.2
    一、使用电脑相机检测自己训练的模型
    1、下载yolo-voc.weights,放在…\darknet-master\build\darknet
    https://github.com/AlexeyAB/darknet/blob/Yolo_v3/README.md
    在这里插入图片描述在这里插入图片描述
    温馨提示:Github上下载经常会遇到网速慢的情况,这个时候你可以换个浏览器试一下。实在不行就进群拿吧1128630114,群里面还有YOLO相关的其他的配置文件。
    双击darknet_web_cam_voc就可以调用自己相机加载官方的模型(这时候还不是自己的模型)。
    检测效果如下:
    在这里插入图片描述
    如果不小心看见这个窗口,不是你的操作有问题,而是你的电脑上的相机被禁了。解决的方法是按下组合键Fn+F10(F10是我自己电脑上相机的启用快捷键)
    在这里插入图片描述
    接下来要要加载自己训练的模型调用相机检测:
    首先看一下刚刚双击的darknet_web_cam_voc.cmd 这是windows下的执行文件,我们右键点击编辑打开它。
    在这里插入图片描述
    在这里插入图片描述
    可以看到第1行就是我们相机的配置文件,包含了我们刚刚下载的yolo-voc.weights权重文件,这里我们不需要改变。第二行是加载官方提供的权重文件时的执行指令,如果要加载我们自己训练得到的模型,就要更改成的.data文件、.cfg配置文件还有就是我们自己训练得到的.weights文件,比如第三行就是我实际的执行文件。
    修改完这里之后就要将yolo-obj_last.weights文件放到darknet_web_cam_voc同一目录下。然后将obj.data和yolo-obj.cfg文件放到与darknet_web_cam_voc同一文件夹下的cfg文件夹下。
    比如我自己电脑下:
    在这里插入图片描述
    在这里插入图片描述
    然后双击darknet_web_cam_voc就可以加载我们的模型调用相机进行检测。这是用手电模拟太阳。
    在这里插入图片描述
    二、使用手机相机作为网络摄像机,调用网络摄像机检测自己加载的模型。
    同样是 下载yolov-voc.weights,放在…\darknet-master\build\darknet\x64目录下,如果你前面已经调用过计算机上的相机就可以了。
    与刚才一样右键darknet_net_cam_voc编辑。
    在这里插入图片描述
    可以看到和上面调用电脑相机差不多,加入自己的权重文件和配置文件和数据文件,同样把cfg配置文件和data文件放到cfg目录下。关键是后面的一个网址是一个IP地址和端口号组成的,这里需要在手机上下载一个IP Webcam的软件。官方上面有下载连接,嫌麻烦的话还是进群直接拿1128630114。安装好软件之后滑到底部点击“开启服务器”然后相机就会打开,下面有个IPv4的网址,把对应的IP地址和端口号填号就可以了。温馨提示:手机和电脑要在同一局域网下,如果双击之后命令行显示视频流停止,那么就要检查下自己的ip地址和端口号,可能过了两天就改变了。
    在这里插入图片描述
    检测的结果:
    在这里插入图片描述

    展开全文
  • YOLOv5 调用 NVIDIA JetsonTX2 板载摄像头出错

    千次阅读 热门讨论 2021-03-23 16:26:07
    $ python3 detect.py --source 0 --exist-ok --weights yolov5s.pt 报错:AssertionError: Failed to open 0 解决方法 注意:cv2.VideoCapture(0)是打不开的!!! 需要把括号里面的0替换成 gst_str 这一长串字符...
  • 1.我希望用使用YOLO同时开启三个摄像头,进行实时监测。但我不知道YOLO开启摄像头的指令或者代码咋就本地文件的哪里。
  • yolov5接多路摄像头

    2021-09-17 09:51:26
    这里写自定义目录标题新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个...其实Yolov5 自带多路IP流。在datasets.py文件里面
  • YOLOv 4调用

    千次阅读 2020-04-25 17:59:52
    YOLOv 4调用 昨天老师发来消息说YOLO出到第四代了,让我看一下怎么用到项目里。在Github上下载下来,简单make一下,试了一下可以运行,
  • 使用YOLOv5实现多路摄像头实时目标检测

    千次阅读 多人点赞 2021-03-22 13:53:23
    在本篇博客中,我将利用yolov5模型简单的实现从摄像头端到web端的部署应用demo,为读者提供一些部署思路。 YOLOV5的强大之处 多路摄像头读取 在此篇博客中,采用了yolov5源码的datasets.py代码中的LoadStreams类进行...
  • TX2上运行YOLOv3-tiny(usb摄像头测试成功)

    千次阅读 热门讨论 2019-11-20 13:14:09
    TX2上运行YOLOv3-tiny TX2刷机、测试、环境搭建可以参考以下链接 TX2刷机、测试、更新源 1.yolo源码下载 $ git clone https://github.com/pjreddie/darknet.git $ cd darknet 2.配置编译预选项 $ gedit Makefile ...
  • 在Jetson nano上运行YOLOv5时如果使用usb摄像头可以顺利运行,但是当我换成板载的csi摄像头的时候,摄像头的结果就会无法显示,出现绿屏,并且在屏幕的右上角出现报错: system throttled due to over-current 也...
  • 一、下载源码 git clone https://github.com/AlexeyAB/darknet.git 二、编辑Makefile cd darknet ...四、将我们在windows下训练好的权重以及改好的文件复制到板子上的darknet文件夹相应位置 .....
  • yolov5项目中如何使用自带摄像机不用网络摄像机进行实时检测? 该项目地址:https://github.com/ultralytics/yolov5/tree/v5.0
  • 主要为大家详细介绍了Python通过cv2读取多个USB摄像头,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 我在jetson nano上运行yolov5的detect.py实时检测的时候,fps很低,只有2,但是我看到网上其他人运行的fps是在10左右。然后我看到摄像头的输入是2304*1536,所以我在想应该是摄像头输入的...
  • yolov5摄像头无法detect

    千次阅读 2020-12-15 20:13:28
    yolov5 detect.py 只能是摄像头,图片无法检测 代码。 if webcam: view_img = True cudnn.benchmark = True # set True to speed up constant image size inference dataset = LoadStreams(source, img_size=...
  • 之前在ubantu上做过yolov5的图片检测,实时检测与之类似,但也是耗费一周的时间,原谅我是个小白。 一、环境安装 附上無證騎士博主的博客地址: https://blog.csdn.net/hahasl555/article/details/116500763 二...
  • keras yolo v3调用笔记本本地摄像头实时监测

    千次阅读 热门讨论 2019-09-08 08:55:39
    最近在学习yolo v3,下载了yolo的keras版本,按照工程里readme中将权重下载,运行Convert后,可以进行yolo的图像检测, 图像检测命令: python yolo_video.py --image,然后在...然后,想用笔记本的自带摄像头进行...
  • IP camera 我们在手机的应用市场上搜索 IP camera就可以找到这个软件 ...点击运行IP摄像头APP , 点击下方的打开IP摄像头服务器 的选项。 点击确定 服务器开启之后,会提示你这个视频流服务器在局域网...
  • 当我们用opencv自带的接口VideoCapture 打开设备自带的摄像头或者usb连接的摄像头时。对于一些高清的摄像头画面有的时候会出现帧率很低的情况(大概是6FPS).画面获取是出现处理的第一步,太低的数据能力会对算法的...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 155
精华内容 62
关键字:

yolov5调用usb摄像头