精华内容
下载资源
问答
  • 硬背景:19年1月份购入两台1920x1080usb摄像头,闲置了很久,两个月前带回家以备不时之需,中途放在书包里可能有挤压置坏的可能性。 软背景:在linux下编译apriltag(计算机视觉二位合作目标检测)开源代码,测试代码...

    硬背景:19年1月份购入两台1920x1080usb摄像头,闲置了很久,两个月前带回家以备不时之需,中途放在书包里可能有挤压置坏的可能性。

    软背景:在linux下编译apriltag(计算机视觉二位合作目标检测)开源代码,测试代码opencv_demo需要用到摄像头,插上usb摄像头之后,运行可执行程序显示要输入timeout时间,就很奇怪,直接用内置软件cheeze发现打不开摄像头;出来windows发现能识别驱动,potplayer和camera均能识别到usb摄像头就是输出不了图像,如下图

    使用Qt或matlab识别到的摄像头信息(一个是自带的一个是usb外接的):

    在camera中点击拍摄出现了以下错误代码。 

    错误代码0xA00F4292

    在经历了一系列百度搜索之后,出现最频繁的还是0xA00F4244等错误代码,显有完全一致的错误代码,转手Google了一下:

    Google_camera_error

    完全吊打baidu搜索引擎。具体解决方案都有下列几种:

    • 重启
    • 软件错误,换个软件
    • 设置里打开摄像头支持软件
    • 下载或更新最新驱动
    • 设置防火墙或杀毒软件
    • 系统资源缺失,sfc /scannow修复

    修复摄像头0xA00F4292(PhotoCaptureStartTimeout)错误连接内容非常详细具体,对有类似问题的朋友们可能有帮助。

    但是!我的还是不行啊,不知道硬件会不会出问题,如果各位有过类似的情况能否分享一下经验啊。。。。

    展开全文
  • 项目中用到 USB 摄像头,需要根据情况进行图像抓拍,查了半天资料,比较多的是使用 WPFMediaKit 和 AForge 。 但是由于项目要求不显示 USB 摄像头拍摄的画面,最终确定使用 AForge 解决。 下面用一个测试程序记录...
  • 我正在尝试使用MacOS 10.11访问openCV中的多个USB摄像头 . 我的目标是通过USB四通道扩展...问题是:opencv是否始终从usb摄像头流式传输实时视频,或者抓取()将图像存储在摄像头上,可以使用retrieve()进行检索?我...

    我正在尝试使用MacOS 10.11访问openCV中的多个USB摄像头 . 我的目标是通过USB四通道扩展将最多20台摄像机连接到电脑并拍摄单张图像 . 我不需要直播 .

    我尝试使用以下代码,我可以从所有摄像头拍摄一张图像(目前只有3张,通过一个USB控制器) .

    问题是:opencv是否始终从usb摄像头流式传输实时视频,或者抓取()将图像存储在摄像头上,可以使用retrieve()进行检索?

    我无法找到这些信息,opencv在其内部视频缓冲区或摄像头上使用了grab()命令 .

    int main(int argument_number, char* argument[])

    {

    std::vector cameraIDs{0,1,2};

    std::vector<:videocapture> cameraCaptures;

    std::vector<:string> nameCaptures{"a","b","c"};

    //Load all cameras

    for (int i = 0;i

    {

    cv::VideoCapture camera(cameraIDs[i]);

    if(!camera.isOpened()) return 1;

    camera.set(CV_CAP_PROP_FRAME_WIDTH, 640);

    camera.set(CV_CAP_PROP_FRAME_HEIGHT, 480);

    cameraCaptures.push_back(camera);

    }

    cv::namedWindow("a");

    while(true) {

    int c = cvWaitKey(2);

    if(27 == char(c)){ //if esc pressed. grab new image and display it.

    for (std::vector<:videocapture>::iterator it=cameraCaptures.begin();it!=cameraCaptures.end();it++)

    {

    (*it).grab();

    }

    int i=0;

    for (std::vector<:videocapture>::iterator it=cameraCaptures.begin();it!=cameraCaptures.end();it++)

    {

    cv::Mat3b frame;

    (*it).retrieve(frame);

    cv::imshow(nameCaptures[i++], frame);

    }

    }

    }

    return 0;

    }

    展开全文
  • uvc的usb摄像头笔记

    千次阅读 2017-05-03 17:25:06
    前者是压缩图像格式的视频,系统资源占用少(因为不用解码),不需要解码器,缺点是帧率稍慢(受限于USB分配的带宽), 后者是相当于JPEG图像压缩格式,优点是帧率高(视频开启快,曝光快),缺点是影像有马赛克,...
    YUY2和MJPG视频编码格式区别
    标签: 编码视频
    
    现在绝大多数摄像头所采用的是免驱摄像头,一般有两种传输格式,YUY2和MJPG,
    前者是无压缩图像格式的视频,系统资源占用少(因为不用解码),不需要解码器,缺点是帧率稍慢(受限于USB分配的带宽),
    后者是相当于JPEG图像压缩格式,优点是帧率高(视频开启快,曝光快),缺点是影像有马赛克,并且需要解码器,会占用PC系统资源。
    
    
    
    
    
    
    
    
    插入usb摄像头自动生成设备文件/dev/video0,或者接入cmos摄像头后装载驱动后自动生成/dev/video0设备文件
    通过dmesg可以查看内核打印信息
    
    视频会议摄像头通用uvc驱动,输出yuy2原始数据
    在hisi3536平台中内核打印如下
    usb 1-1: USB disconnect, device number 2
    usb 1-1: new high-speed USB device number 3 using hiusb-ehci
    uvcvideo: Found UVC 1.00 device USB3.0 FULL HD PTZ (045e:8888)
    input: USB3.0 FULL HD PTZ as /devices/platform/hiusb-ehci.0/usb1/1-1/1-1:1.0/input/input1
    usb 1-1: USB disconnect, device number 3
    usb 1-1: new high-speed USB device number 4 using hiusb-ehci
    uvcvideo: Found UVC 1.00 device USB3.0 FULL HD PTZ (045e:8888)
    input: USB3.0 FULL HD PTZ as /devices/platform/hiusb-ehci.0/usb1/1-1/1-1:1.0/input/input2
    
    
    测试工具:
    ./v4l2
    现在把采集到每帧的数据(每张图片)保存到fp文件中,就是视频数据流,
    有可能在nfs文件系统中操作,采集到的视频流每帧出现花屏现象,可以在开发板中的tmpfs中操作,在内存中操作就不会出现这个问题。
    
    
    
    
    =====================================================================================
    由于cmos摄像头模组或者usb摄像头采集的数据为yuy2格式的视频数据,所以需要安装一个yuy2的播放器播放这种格式的视频数据,
    由于公司关闭了上传功能,不能上传这个软件,大家搜索软件名YUVPlayer.exe下载
    /*============================================================================
    FileName: v4l2.c
    #         Desc: this program aim to get video file from USB camera or cmos ovxx,
    #               used the V4L2 interface.
    #       Author: LiangJianhui
    #        Email: 
    #     HomePage: 
    #      Version: 0.0.1
    #   LastChange: 20170503
    #      History:
    
    
    w 打开只写文件,若文件存在则文件长度清为0,即该文件内容会消失。若文件不存在则建立该文件。
    w+ 打开可读写文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则建立该文件。
    a 以附加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被保留。(EOF符保留)
    a+ 以附加方式打开可读写的文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾后,即文件原先的内容会被保留。 (原来的EOF符不保留)
    
    在进行V4L2开发中,常用的命令标志符如下(some are optional): 
    ?    VIDIOC_REQBUFS:分配内存 
    ?    VIDIOC_QUERYBUF:把VIDIOC_REQBUFS中分配的数据缓存转换成物理地址 
    ?    VIDIOC_QUERYCAP:查询驱动功能 
    ?    VIDIOC_ENUM_FMT:获取当前驱动支持的视频格式 
    ?    VIDIOC_S_FMT:设置当前驱动的频捕获格式 
    ?    VIDIOC_G_FMT:读取当前驱动的频捕获格式 
    ?    VIDIOC_TRY_FMT:验证当前驱动的显示格式 
    ?    VIDIOC_CROPCAP:查询驱动的修剪能力 
    ?    VIDIOC_S_CROP:设置视频信号的边框 
    ?    VIDIOC_G_CROP:读取视频信号的边框 
    ?    VIDIOC_QBUF:把数据从缓存中读取出来 
    ?    VIDIOC_DQBUF:把数据放回缓存队列 
    ?    VIDIOC_STREAMON:开始视频显示函数 
    ?    VIDIOC_STREAMOFF:结束视频显示函数 
    ?    VIDIOC_QUERYSTD:检查当前视频设备支持的标准,例如PAL或NTSC。
    
    =============================================================================*/
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <sys/ioctl.h>
    #include <stdlib.h>
    #include <linux/types.h>
    #include <linux/videodev2.h>
    #include <malloc.h>
    #include <math.h>
    #include <string.h>
    #include <sys/mman.h>
    #include <errno.h>
    #include <assert.h>
    
    
    
     
    #define FILE_VIDEO  "/dev/video0"
    #define JPG         "./image%d.yuv"
    
    
     
    typedef struct{
        void *start;
        int length;
    }   BUFTYPE;
    BUFTYPE *usr_buf;
    
    
    static unsigned int n_buffer = 0;
     
    //set video capture ways(mmap)
    int init_mmap(int fd)
    {
        //to request frame cache, contain requested counts
        struct v4l2_requestbuffers reqbufs;
    
        //request V4L2 driver allocation video cache
        //this cache is locate in kernel and need mmap mapping
        memset(&reqbufs, 0, sizeof(reqbufs));
        reqbufs.count = 4;
        reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        reqbufs.memory = V4L2_MEMORY_MMAP;
        
        
        if(-1 == ioctl(fd,VIDIOC_REQBUFS,&reqbufs)){
            perror("Fail to ioctl 'VIDIOC_REQBUFS'");
            exit(EXIT_FAILURE);
        }
     
        n_buffer = reqbufs.count;
        printf("n_buffer = %d\n", n_buffer);
        usr_buf = calloc(reqbufs.count, sizeof(BUFTYPE));
        if(usr_buf == NULL){
            printf("Out of memory\n");
            exit(-1);
        }
     
        //map kernel cache to user process 
        for(n_buffer = 0; n_buffer < reqbufs.count; ++n_buffer){
            //stand for a frame
            struct v4l2_buffer buf;
            memset(&buf, 0, sizeof(buf));
            buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            buf.memory = V4L2_MEMORY_MMAP;
            buf.index = n_buffer;
             
            //check the information of the kernel cache requested 
            if(-1 == ioctl(fd,VIDIOC_QUERYBUF,&buf))
            {
                perror("Fail to ioctl : VIDIOC_QUERYBUF");
                exit(EXIT_FAILURE);
            }
     
            usr_buf[n_buffer].length = buf.length;
            printf("buf.length=%d\n",buf.length);
            printf("buf.m.offset=%d\n\n",buf.m.offset);       
            //printf("fd=%d\n\n",fd); 
            
            usr_buf[n_buffer].start = 
    /*  
              (char *)mmap(
                        NULL,
                        buf.length,
                        PROT_READ | PROT_WRITE,
                        MAP_PRIVATE,
                        fd,
                        buf.m.offset
                    );
    */
    
              (char *)mmap(
                        NULL,
                        buf.length,
                        PROT_READ | PROT_WRITE,
                        MAP_SHARED,//MAP_PRIVATE,
                        fd,
                        buf.m.offset
                    );
    
    
    
            printf("usr_buf[%d].start=0x%x\n",n_buffer,usr_buf[n_buffer].start); 
    
            if(MAP_FAILED == usr_buf[n_buffer].start)
            {
                perror("Fail to mmap");
                exit(EXIT_FAILURE);
            }
    
            printf("usr_buf %d: address=0x%x, length=%d\n", n_buffer, (unsigned int)usr_buf[n_buffer].start, usr_buf[n_buffer].length);
    
        }
        return 0;
    }
    
    
     
    //initial camera device 
    int init_camera_device(int fd)
    {
        //decive fuction, such as video input
        struct v4l2_capability cap;
        //video standard,such as PAL,NTSC
        struct v4l2_standard std;
        //frame format
        struct v4l2_format tv_fmt;
        //check control
        struct v4l2_queryctrl query;
        //detail control value
        struct v4l2_fmtdesc fmt;
        int ret;
        //get the format of video supply
        memset(&fmt, 0, sizeof(fmt));
        fmt.index = 0;
        //supply to image capture
        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        // show all format of supply
        printf("Support format:\n");
    
    
       
        while(ioctl(fd, VIDIOC_ENUM_FMT, &fmt) == 0)
        {
            fmt.index++;
            printf("pixelformat = ''%c%c%c%c''\ndescription = ''%s''\n",fmt.pixelformat & 0xFF, (fmt.pixelformat >> 8) & 0xFF,(fmt.pixelformat >> 16) & 0xFF,                   (fmt.pixelformat    >> 24) & 0xFF,fmt.description);
        }
    
    
    
        //check video decive driver capability
        ret = ioctl(fd, VIDIOC_QUERYCAP, &cap);
        if(ret < 0){
            perror("Fail to ioctl VIDEO_QUERYCAP");
            exit(EXIT_FAILURE);
        }
    
    
        // Print capability infomations
        printf("Capability Informations:\n");
        printf(" driver: %s\n", cap.driver);
        printf(" card: %s\n", cap.card);
        printf(" bus_info: %s\n", cap.bus_info);
        printf(" version: %08X\n", cap.version);
        printf(" capabilities: %08X\n", cap.capabilities);
     
        printf("----------------------------\n");
    
     
        //judge wherher or not to be a video-get device
        if(!(cap.capabilities & V4L2_BUF_TYPE_VIDEO_CAPTURE))
        {
            printf("The Current device is not a video capture device\n");
            exit(-1);
        }
     
        //judge whether or not to supply the form of video stream
        if(!(cap.capabilities & V4L2_CAP_STREAMING))
        {
            printf("The Current device does not support streaming i/o\n");
            exit(EXIT_FAILURE);
        }
    
     
    
    
        
        //set the form of camera capture data
        memset(&fmt, 0, sizeof(tv_fmt));    // very important!must clear 0
        tv_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        tv_fmt.fmt.pix.width = 640;     //1280;    //680;
        tv_fmt.fmt.pix.height = 480;    //720;    //480;
        tv_fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; //V4L2_PIX_FMT_YUYV;
        tv_fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
        if (ioctl(fd, VIDIOC_S_FMT, &tv_fmt)< 0) {
            printf("VIDIOC_S_FMT FAIL!\n");
            exit(-1);
            close(fd);
        }
    
    
    
        if(ioctl(fd, VIDIOC_G_FMT, &tv_fmt) < 0)
        {
            printf("VIDIOC_G_FMT FAIL!\n");
            exit(-1);
            close(fd);
        
        }
    
        // Print Stream Format
        printf("Stream Format Informations:\n");
        printf(" type: %d\n", tv_fmt.type);
        printf(" width: %d\n", tv_fmt.fmt.pix.width);
        printf(" height: %d\n", tv_fmt.fmt.pix.height);
        char fmtstr[8];
        memset(fmtstr, 0, 8);
        memcpy(fmtstr, &tv_fmt.fmt.pix.pixelformat, 4);
        printf(" pixelformat: %s\n", fmtstr);
        printf(" field: %d\n", tv_fmt.fmt.pix.field);
        printf(" bytesperline: %d\n", tv_fmt.fmt.pix.bytesperline);
        printf(" sizeimage: %d\n", tv_fmt.fmt.pix.sizeimage);
        printf(" colorspace: %d\n", tv_fmt.fmt.pix.colorspace);
        printf(" priv: %d\n", tv_fmt.fmt.pix.priv);
        printf(" raw_date: %s\n", tv_fmt.fmt.raw_data);
    
    
    
        //initial video capture way(mmap)
        init_mmap(fd);
    
    
        return 0;
    }
     
    int open_camera_device()
    {
        int fd;
        //open video device with block
        fd = open(FILE_VIDEO, O_RDWR,0);
        if(fd < 0){
            perror(FILE_VIDEO);
            exit(EXIT_FAILURE);
        }
        return fd;
    }
     
    int start_capture(int fd)
    {
        unsigned int i;
        enum v4l2_buf_type type;
    
    
        //place the kernel cache to a queue
        for(i = 0; i < n_buffer; i++){
            struct v4l2_buffer buf;
            memset(&buf, 0, sizeof(buf));
    
            buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            buf.memory = V4L2_MEMORY_MMAP;
            buf.index = i;
     
            if(-1 == ioctl(fd, VIDIOC_QBUF, &buf)){
                perror("Fail to ioctl 'VIDIOC_QBUF'");
                exit(EXIT_FAILURE);
            }
        }
     
        //start capture data
        type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        if(-1 == ioctl(fd, VIDIOC_STREAMON, &type)){
            printf("i=%d.\n", i);
            perror("VIDIOC_STREAMON");
            close(fd);
            exit(EXIT_FAILURE);
        }
        return 0;
    }
     
    
    
    
    
    
    #if 0
    int process_image(void *addr, int length)
    {
        FILE *fp;
        static int num = 0;
        char image_name[20];
     
        sprintf(image_name, JPG, num++);
        if((fp = fopen(image_name, "w")) == NULL){
            perror("Fail to fopen");
            exit(EXIT_FAILURE);
        }
        fwrite(addr, length, 1, fp);
        usleep(500);
        fclose(fp);
        return 0;
    }
    
    
    
    
    #else
    
    int process_image(void *addr, int length)
    {
        FILE *fp;
        FILE *fptest;
        int tmp=0;
        static int num = 0;
        char image_name[20]="abc";
    
     
        //sprintf(image_name, JPG, num++);
        //printf("image_name=%s\n",image_name);
    
        if((fp = fopen(image_name, "a+")) == NULL){
            perror("Fail to fopen");
            exit(EXIT_FAILURE);
        }
    
    
    //
    #if 0
    //debug    
        if((fptest = fopen("test.img", "w")) == NULL){
            perror("Fail to fopen");
            exit(EXIT_FAILURE);
        }
        if(length != fwrite(addr, 1,length, fptest))
        {
            printf("debugfwrite a frame image fail!\n");
        }
        usleep(500);
        fclose(fptest);
    #endif
    //
    
    
        tmp = fwrite(addr, 1,length, fp);
        printf("tmp=0x%x\n",tmp);
        if(length != tmp)
        {
            printf("fwrite a frame image fail!\n");
        }
    
        usleep(500);
        fclose(fp);
        return 0;
    }
    #endif
     
    int read_frame(int fd)
    {
        struct v4l2_buffer buf;
        unsigned int i;
        memset(&buf, 0, sizeof(buf));
    
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        
    
        //put cache from queue
        if(-1 == ioctl(fd, VIDIOC_DQBUF,&buf)){
            perror("Fail to ioctl 'VIDIOC_DQBUF'");
            exit(EXIT_FAILURE);
        }
     
        assert(buf.index < n_buffer);
        printf("buf.index=%d,n_buffer=%d\n",buf.index,n_buffer);
        printf(" usr_buf[%d].start=0x%x,usr_buf[%d].length=0x%x\n", buf.index,usr_buf[buf.index].start,buf.index,usr_buf[buf.index].length);
     
    
    
        //read process space's data to a file
        process_image(usr_buf[buf.index].start, usr_buf[buf.index].length);
    
        if(-1 == ioctl(fd, VIDIOC_QBUF,&buf))
        {
            perror("Fail to ioctl 'VIDIOC_QBUF'");
            exit(EXIT_FAILURE);
        }
    
        return 1;
    }
     
    int mainloop(int fd)
    { 
        int count = 1000;
     
        while(count-- > 0)
        {
            for(;;)
            {
                fd_set fds;
                struct timeval tv;
                int r;
     
                FD_ZERO(&fds);
                FD_SET(fd,&fds);
     
                /*Timeout*/
                tv.tv_sec = 2;
                tv.tv_usec = 0;
                r = select(fd + 1,&fds,NULL,NULL,&tv);
     
                if(-1 == r)
                {
                    if(EINTR == errno)
                        continue;
                    perror("Fail to select");
                    exit(EXIT_FAILURE);
                }
     
                if(0 == r)
                {
                    fprintf(stderr,"select Timeout\n");
                    exit(-1);
                }
     
                if(read_frame(fd))
                    break;
            }
        }
        return 0;
    }
     
    void stop_capture(int fd)
    {
        enum v4l2_buf_type type;
        type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        if(-1 == ioctl(fd,VIDIOC_STREAMOFF,&type))
        {
            perror("Fail to ioctl 'VIDIOC_STREAMOFF'");
            exit(EXIT_FAILURE);
        }
        return;
    }
     
    void close_camera_device(int fd)
    {
        unsigned int i;
        for(i = 0;i < n_buffer; i++)
        {
            if(-1 == munmap(usr_buf[i].start,usr_buf[i].length)){
                exit(-1);
            }
        }
        free(usr_buf);
     
        if(-1 == close(fd))
        {
            perror("Fail to close fd");
            exit(EXIT_FAILURE);
        }
        return;
    }
     
     int fd;
    
    int main()
    {
       
    
        fd = open_camera_device();
    
        init_camera_device(fd);
    
        start_capture(fd);
    
        mainloop(fd);
     
        stop_capture(fd);
    
        close_camera_device(fd);
    
        return 0;
    }
    
    
    #endif

    展开全文
  • 项目中用到 USB 摄像头,需要根据情况进行图像抓拍,查了半天资料,比较多的是使用 WPFMediaKit 和 AForge 。 但是由于项目要求不显示 USB 摄像头拍摄的画面,最终确定使用 AForge 解决。 下面用一个测试程序记录...

    项目中用到 USB 摄像头,需要根据情况进行图像抓拍,查了半天资料,比较多的是使用 WPFMediaKit 和 AForge 。
    但是由于项目要求不显示 USB 摄像头拍摄的画面,最终确定使用 AForge 解决。
    下面用一个测试程序记录一下。

    一、无预览拍照

    首先建立一个 WPF 项目,我的就叫 AForgeTest,你们随意就好:

    新建项目

    然后在 NuGet 包管理器中安装 AForge 库:

    这里写图片描述

    我只安装了图中打勾的几个库,这个根据自己项目需要安装就好。
    不过用 USB 摄像头拍照必须安装:
    AForge.Video
    AForge.Control
    AForge.Video.DirectShow
    这三个库文件。

    不习惯使用 NuGet 也可以到 AForge 的 .NET lib 下载页面下载。

    在 MainWindow.xaml 文件中添加两个按钮:

    <Window x:Class="AForgeTest.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:AForgeTest"
            mc:Ignorable="d"
            Title="MainWindow" Height="300" Width="300"
            Closing="Window_Closing">
        <StackPanel>
            <Button Name="btnCapture" Click="btnCapture_Click">拍照</Button>
            <Button Name="btnOpenCamera" Click="btnOpenCamera_Click">打开</Button>
        </StackPanel>
    </Window>
    

    后台交互逻辑如下:

    using System;
    using System.Windows;
    
    namespace AForgeTest
    {
        /// <summary>
        /// MainWindow.xaml 的交互逻辑
        /// </summary>
        public partial class MainWindow : Window
        {
            public MainWindow()
            {
                InitializeComponent();
            }
    
            private void btnOpenCamera_Click(object sender, EventArgs e)
            {
                CameraHelper.UpdateCameraDevices();
                if (CameraHelper.CameraDevices.Count > 0)
                {
                    CameraHelper.SetCameraDevice(0);
                }
            }
    
            private void btnCapture_Click(object sender, EventArgs e)
            {
                CameraHelper.CaptureImage(@"E:\1");
            }
    
            private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
            {
                CameraHelper.CloseDevice();
            }
        }
    }
    

    CameraHelper 类代码如下:

    using System;
    using AForge.Video.DirectShow;
    using AForge.Controls;
    using System.Windows;
    using System.IO;
    using System.Drawing;
    using System.Drawing.Imaging;
    
    namespace AForgeTest
    {
        public static class CameraHelper
        {
            private static FilterInfoCollection _cameraDevices;
            private static VideoCaptureDevice div = null;
            private static VideoSourcePlayer sourcePlayer = new VideoSourcePlayer();
            private static bool _isDisplay = false;
            //指示_isDisplay设置为true后,是否设置了其他的sourcePlayer,若未设置则_isDisplay重设为false
            private static bool isSet = false;
    
            /// <summary>
            /// 获取或设置摄像头设备,无设备为null
            /// </summary>
            public static FilterInfoCollection CameraDevices
            {
                get
                {
                    return _cameraDevices;
                }
                set
                {
                    _cameraDevices = value;
                }
            }
            /// <summary>
            /// 指示是否显示摄像头视频画面
            /// 默认false
            /// </summary>
            public static bool IsDisplay
            {
                get { return _isDisplay; }
                set { _isDisplay = value; }
            }
            /// <summary>
            /// 获取或设置VideoSourcePlayer控件,
            /// 只有当IsDisplay设置为true时,该属性才可以设置成功
            /// </summary>
            public static VideoSourcePlayer SourcePlayer
            {
                get { return sourcePlayer; }
                set
                {
                    if (_isDisplay)
                    {
                        sourcePlayer = value;
                        isSet = true;
                    }
    
                }
            }
            /// <summary>
            /// 更新摄像头设备信息
            /// </summary>
            public static void UpdateCameraDevices()
            {
                _cameraDevices = new FilterInfoCollection(FilterCategory.VideoInputDevice);
            }
            /// <summary>
            /// 设置使用的摄像头设备
            /// </summary>
            /// <param name="index">设备在CameraDevices中的索引</param>
            /// <returns><see cref="bool"/></returns>
            public static bool SetCameraDevice(int index)
            {
                if (!isSet) _isDisplay = false;
                //无设备,返回false
                if (_cameraDevices.Count <= 0 || index < 0) return false;
                if (index > _cameraDevices.Count - 1) return false;
                // 设定初始视频设备
                div = new VideoCaptureDevice(_cameraDevices[index].MonikerString);
                sourcePlayer.VideoSource = div;
                div.Start();
                sourcePlayer.Start();
                return true;
            }
            /// <summary>
            /// 截取一帧图像并保存
            /// </summary>
            /// <param name="filePath">图像保存路径</param>
            /// <param name="fileName">保存的图像文件名</param>
            public static void CaptureImage(string filePath, string fileName = null)
            {
                if (sourcePlayer.VideoSource == null) return;
                if (!Directory.Exists(filePath))
                {
                    Directory.CreateDirectory(filePath);
                }
                try
                {
                    //sourcePlayer.Start();
                    Image bitmap = sourcePlayer.GetCurrentVideoFrame();
                    if(fileName == null) fileName = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss");
                    bitmap.Save(filePath + @"\" + fileName + "-cap.jpg", ImageFormat.Jpeg);
                    bitmap.Dispose();
                    //sourcePlayer.Stop();
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.Message.ToString());
                }
            }
            /// <summary>
            /// 关闭摄像头设备
            /// </summary>
            public static void CloseDevice()
            {
                if (div != null && div.IsRunning)
                {
                    sourcePlayer.Stop();
                    div.SignalToStop();
                    div = null;
                    _cameraDevices = null;
                }
            }
        }
    }
    
    

    最终效果如下:

    这里写图片描述

    首先单击打开按钮,然后单击拍照按钮,就会在指定路径下生成一个 jpg 文件。

    单击打开按钮之后需要等待 2s 以上才能点击拍照(需要等待连接到摄像头),否则会报出异常,如下图:

    这里写图片描述

    二、显示摄像头拍摄画面和截取的图片

    首先添加 System.Windows.Forms 和 WindowsFormsIntegration 的引用。
    然后在 MainWindows.xmal 文件中加命名空间:

    xmlns:wfi ="clr-namespace:System.Windows.Forms.Integration;assembly=WindowsFormsIntegration"
    xmlns:aforge ="clr-namespace:AForge.Controls;assembly=AForge.Controls"

    添加 VideoSourcePlayer 和 Image 控件:

    <wfi:WindowsFormsHost Grid.Row="0">
        <aforge:VideoSourcePlayer x:Name="player" Height="480" Width="640"/>
    </wfi:WindowsFormsHost>
    <Image Grid.Row="0" Grid.Column="1" Name="imgCapture" Stretch="Fill" Height="480" Width="640"/>

    这里有个小细节,注意对 VideoSourcePlayer 命名时,一定要使用 x:Name 不要省略 x: ,否则无法在后台代码中使用(不要问我是怎么知道的)。

    对 CameraHelper.cs 中的 CaptureImage 函数做一点修改:

            /// <summary>
            /// 截取一帧图像并保存
            /// </summary>
            /// <param name="filePath">图像保存路径</param>
            /// <param name="fileName">保存的图像文件名</param>
            /// <returns>如果保存成功,则返回完整路径,否则为 null</returns>
            public static string CaptureImage(string filePath, string fileName = null)
            {
                if (sourcePlayer.VideoSource == null) return null;
                if (!Directory.Exists(filePath))
                {
                    Directory.CreateDirectory(filePath);
                }
                try
                {
                    Image bitmap = sourcePlayer.GetCurrentVideoFrame();
                    if(fileName == null) fileName = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss");
                    string fullPath = Path.Combine(filePath, fileName + "-cap.jpg");
                    bitmap.Save(fullPath, ImageFormat.Jpeg);
                    bitmap.Dispose();
                    return fullPath;
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.Message.ToString());
                    return null;
                }
            }

    修改后台代码如下:

    using System;
    using System.Windows;
    using System.Windows.Media.Imaging;
    
    namespace AForgeTest
    {
        /// <summary>
        /// MainWindow.xaml 的交互逻辑
        /// </summary>
        public partial class MainWindow : Window
        {
            public MainWindow()
            {
                InitializeComponent();
                CameraHelper.IsDisplay = true;
                CameraHelper.SourcePlayer = player;
                CameraHelper.UpdateCameraDevices();
            }
    
            private void btnOpenCamera_Click(object sender, EventArgs e)
            {
                if (CameraHelper.CameraDevices.Count > 0)
                {
                    CameraHelper.SetCameraDevice(0);
                }
            }
    
            private void btnCapture_Click(object sender, EventArgs e)
            {
                string fullPath = CameraHelper.CaptureImage(AppDomain.CurrentDomain.BaseDirectory + @"\Capture");
    
                BitmapImage bit = new BitmapImage();
                bit.BeginInit();
                bit.UriSource = new Uri(fullPath);
                bit.EndInit();
                imgCapture.Source = bit;
            }
    
            private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
            {
                CameraHelper.CloseDevice();
            }
        }
    }
    

    最终结果如下:

    结果

    展开全文
  • 我购买的是涯的MT7688A开发板,所以以它来介绍,但是发现基本OpenWRT的编译固件套路是一样的,所以应该通用。 1.下载官网源码 2.编译源码 (1)./scripts/feeds ...(4)usb摄像头驱动选择 Kernel module...
  • 一款可以在XP和VISTA下使用电脑摄像头录制录像,并刻录VCD、DVD的软件,率先实现对xp sp3 和 vista下摄像头的完美支持,高性能数码摄像机太贵,所以便宜的又不想买,孩子一天天长大,不录一些生活片段,以后未免...
  • TVideoGrabber可捕获和记录来自大多数视频捕捉设备(如USB网络摄像头USB模拟捕捉设备,IP摄像头,桌面以及用作视频源的一组位图)的视频和音频流。 通过安装我们的可选RTSP DirectShow源过滤器,您可以捕获RTSP,...
  • 使用python的opencv打开摄像头的时候,虽然外置双目摄像头可以报错开启,但是图像只有一个摄像头的(通过分别遮挡左右摄像头知道) 解决 商家说因为该双目摄像头是左右摄像头图像同时输出...
  • ARM + OpenCV 抓取摄像头图像 && 一点感想

    千次阅读 热门讨论 2015-01-26 20:47:03
    使用前一篇中所述的配置方法,搭建出的基于arm-linux 的 OpenCV 对USB摄像头进行图像抓取,后面进一步会抓取视频。一开始抓取不了视频,VideoCapture 对象无法获取 /dev/video0 的设备。解决问题的思路贴下来,...
  • "MJPG-streamer",是用于从webcam摄像头采集图像,把他们以流的形式通过基于ip的网络传输到浏览器如Firehox,Cambozola,VLC播放器,Windows的移动设备或者其他拥有浏览器的移动设备。她可以利用某些webcams的硬件...
  • 网络摄像头捕获API 该库允许您直接从Java使用内置或外部网络摄像头。 它旨在抽象化常用的相机功能并支持各种捕获框架。...简单,线程安全且阻塞的API, 无需其他软件, 支持多种平台(Windows,Linu
  • 调用摄像头代码

    2021-04-06 09:16:09
    最近采购了一个“晟悦1080P高清摄像头模组USB免驱广角畸变高速60帧人脸识别抓拍”摄像头,做工业检测项目,摄像头需要自己写代码调取图像。 获取摄像头代码(C++) INCLUDEPATH += D:/softwarepackage/opencv-...
  • 数码相机多采用了高像素值的CCD感光元件和较好的光学镜头,所以拍摄动态图像的效果明显优于普通 手机的摄像头,安装起来也更为方便。如何将奥林巴斯相机用作网络摄像头值得一提的是,Olympus拥有自己的网络摄像头...
  • 低功耗4G摄像机,采用海思主控芯片(目前高端的是海思),运行LiteOS操作系统(目前只有LITE0S才做系统支持USB高速传输),实现快速启动。通过4G传输图像,并使用太阳能板和锂电池供电。可以实现APP远程快速唤醒、...
  • 给大家分享近期关注度较高的一款商品,来自于视派尔的近红外活体识别免驱USB接口高清双目摄像头模组。我们先来看看它的外包装和产品外观。 相机标配两条2.2米USB连接线(长度可选长或短),静电袋封装,内有...
  • *您只需要一个几十元的目前流行的普通USB摄像头(或电视采集卡)加上本软件就可以让您的个人电脑也拥有企业级的智能现场监控录像功能,本软件可以把录像保存为AVI,MPG,WMV,BMP,JPG,PNG等流行格式,同时还拥有非常完善...
  • USB3.0接口的工业相机应用

    千次阅读 2018-05-07 15:08:59
    随着USB3.0被消费者不断推广采用,成本还将持续降低。目前销售的PC有九成已经内置了USB3.0接口,消费者无需...图像采集卡USB3.0接口相机作为行业全新的技术规范,其推动了对带宽有更高要求的其他相关技术的发展,提...
  • USB 摄像头采用罗技—快看高手版PRO500, 它采用高品质CMOS图像传感器感应器, 130 万像素, 最大分辨率640×480, 高速USB2.0 传输接口, 另外内置麦克风, 采用Rightsound 技术, 清晰、回音的语音系统。...
  • USB摄像头连结到客户端电脑上,如果在虚拟机中,注意设置外接设备USB为3.0,且确保连接到虚拟机中而非主机当中; 如果客户端和服务器都在同一台主机上运行的话,无需修改self.TargetIP = ('127.0.0.1', 6666),...
  • mjpg-streamer是一款免费基于IP地址的视频流服务器,从webcam摄像头采集图像,把它们以流的形式通过基于ip的网络传输到浏览器端,如火狐、Cambozola和VLC播放器等。它可以利用某些webcam的硬件压缩功能来降低服务器...
  • RK3399pro 使用rknn 问题记录 日期:2020-11-13 问题1:RK3399pro使用python3读取USB摄像头数据...然而使用python3+opencv中,cv2.VideoCaptrue(),无法读取摄像头数据,会出现无图像数据的错误。 所以选择使用 [pyth
  • MarkerlessAR.zip

    2019-07-08 16:44:47
    该程序被称为“Marker less Augmented Reality”应用程序,可以识别USB摄像头拍摄的任意图像,并在其上覆盖3D模型。本文档介绍了如何使用标记AR Windows演示应用程序。相机校准,配置文件,注册标记图像,评估物体...
  • YUY2和MJPG视频编码格式区别

    万次阅读 2017-09-14 12:09:29
    现在绝大多数USB摄像头所采用的是免驱摄像头(采用UVC驱动),一般有两种传输格式,YUY2和MJPG,前者是压缩图像格式的视频(raw格式,原始图像),系统资源占用少(因为不用解码),不需要解码器,缺点是帧率稍慢...
  • 亿联UVC30 Desktop

    2020-10-29 10:06:18
    UVC30 Desktop是亿联新型 USB 网络摄像头,适用于个人PC。4K 超高清镜头具备清晰图像和准确的色彩还原,为用户带来生动面对面般的视频会议体验。支持4倍数码变焦,畸变大视角。内置人脸识别红外摄像机,优质的人脸...
  • 前言最近因为很火的一个事情就是某牌子的旗舰手机屏幕又搞混用了,而且素质有较大的差距,而辨别的方法是用微距或者说显微镜去看一看像素点排列,也因此,我正好趁着这个机会买了一个数码显微镜,用USB传输图像到...
  • 中小学学籍照片采集

    2013-06-19 23:44:26
    1.将xjphoto文件夹放在d:根目录下 ...9.本软件支持usb摄像头,1394接口标清dv(台式机需要安装采集卡)建议使用dv便于调焦,白平衡及曝光 10.身份证的同学可以在身份证号一栏手动输入后点击拍照。
  • 对于图像采集,本文使用基于USB接口的通用摄像头视频信号采集方法,采用Video for Linux标准的驱动程序配合通用应用程序。采集到的图片通过WIFI网络传输给远程平台,传输层的网络传输协议有两种:面向连接的TCP协议...

空空如也

空空如也

1 2 3
收藏数 50
精华内容 20
关键字:

usb摄像头无图像