jetson-nano qt v4l2采集 拍照 实时显示 调整曝光 zbar 二维码识别

最新推荐文章于 2024-09-03 18:57:55 发布
最新推荐文章于 2024-09-03 18:57:55 发布
阅读量1.7k 收藏 12
点赞数 2
分类专栏： Linux OpenCv nano
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ourkix/article/details/107175905
版权
Linux 同时被 3 个专栏收录
16 篇文章 2 订阅
订阅专栏
nano
8 篇文章 0 订阅
订阅专栏
OpenCv
3 篇文章 0 订阅
订阅专栏

参考自：https://www.cnblogs.com/surpassal/archive/2012/12/19/zed_webcam_lab1.html

              https://www.cnblogs.com/liusiluandzhangkun/p/8690604.html

              https://blog.csdn.net/wr132/article/details/54428144

这里默认安装了基本的环境，比如v4l2 qt opencv等其他所需依赖

一、zbar编译安装

打开zbar的官网，http://zbar.sourceforge.net/

点击download后

下载源码

下载回来是zbar-0.10.tar.bz2

解压到随便一个地方

tar -xzvf zbar-0.10.tar.bz2 ./

然后切换到zbar-0.10的目录里面

cd zbar-0.10

如果直接运行./configure会报错找不到构建目标平台，这里指定目标平台，加速编译去掉不要的组件

./configure --build=arm --without-gtk --without-qt --without-imagemagick --without-python --disable-video

还能用--prefix来指定安目录，这里默认安装路径

配置完成后

make -j4
sudo make install

这样就安装完成了

二、工程构建

这里先配置好qt的zed_YUV_camera_prj.pro文件

######################################################################
# Automatically generated by qmake (3.1) Mon Jun 22 15:37:04 2020
######################################################################

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets


TEMPLATE = app
TARGET = zed_YUV_camera_prj
INCLUDEPATH += .

# The following define makes your compiler warn you if you use any
# feature of Qt which has been marked as deprecated (the exact warnings
# depend on your compiler). Please consult the documentation of the
# deprecated API in order to know how to port your code away from it.
DEFINES += QT_DEPRECATED_WARNINGS

# You can also make your code fail to compile if you use deprecated APIs.
# In order to do so, uncomment the following line.
# You can also select to disable deprecated APIs only up to a certain version of Qt.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

# Input
HEADERS += common.h videodevice.h widget.h ui_widget.h
SOURCES += main.cpp videodevice.cpp widget.cpp

INCLUDEPATH+= ./  \
              /usr/local/include  \
              /usr/local/include/opencv \
              /usr/local/include/opencv2

LIBS+= /usr/local/lib/libopencv_highgui.so \
    /usr/local/lib/libopencv_core.so \
    /usr/local/lib/libopencv_imgproc.so \
    /usr/local/lib/libopencv_imgcodecs.so \
    /usr/local/lib/libopencv_shape.so \
    /usr/lib/aarch64-linux-gnu/libzbar.so

这里包含了头文件的目录，和动态库的路径，根据自己的更改即可

然后是头文件 common.h  一些宏定义

#ifndef COMMON_H
#define COMMON_H

// definitions
#define BYTE 	unsigned char
#define SBYTE 	signed char
#define SWORD 	signed short int
#define WORD 	unsigned short int
#define DWORD 	unsigned long int
#define SDWORD 	signed long int

#define IMG_WIDTH 640
#define IMG_HEIGTH 480


#endif // COMMON_H

main.cpp文件

#include <QApplication>
#include "widget.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Widget w;
    w.show();

    return a.exec();
}

v4l2相机操作的类 头文件 videodevice.h

#ifndef VIDEODEVICE_H
#define VIDEODEVICE_H


//#include <errno.h>


#include <QString>
#include <QObject>
#include <QTextCodec>

#define CLEAR(x) memset(&(x), 0, sizeof(x))

class VideoDevice : public QObject
{
    Q_OBJECT
public:
    VideoDevice(QString dev_name);
    ~VideoDevice();
    int get_frame(unsigned char ** yuv_buffer_pointer, unsigned int * len);
    int unget_frame();

    void setExposureAbs(int exposureAbs);// unit per 100us
    void getExposureAbs();

    void setExposureLevel(int exposurelevel);
    void getExposureLevel();

    void setExposureMode(int exposureMode);// 1 手动曝光模式     0 auto曝光模式
    void getExposureMode();

    int stop_capturing();
    int start_capturing();

private:
    int open_device();
    int init_device();

    int init_mmap();

    int uninit_device();
    int close_device();

    struct buffer
    {
        void * start;
        unsigned int length;
    };
    QString dev_name;
    int fd;//video0 file
    buffer* buffers;
    unsigned int n_buffers;
    int index;


signals:
    //void display_error(QString);

};

#endif // VIDEODEVICE_H

v4l2相机操作的类 videodevice.cpp

#include "videodevice.h"
#include "common.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <asm/types.h>
#include <linux/videodev2.h>
#include "unistd.h"

#define FILE_VIDEO 	"/dev/video0"
#define  TRUE	1
#define  FALSE	0

VideoDevice::VideoDevice(QString dev_name)
{
    this->dev_name = dev_name;
    this->fd = -1;
    this->buffers = NULL;
    this->n_buffers = 0;
    this->index = -1;

    if(open_device() == FALSE)
    {
        close_device();
    }

    if(init_device() == FALSE)
    {
        close_device();
    }

    if(start_capturing() == FALSE)
    {
        stop_capturing();
        close_device();
	printf("start capturing is faile!\n");
    }

}

VideoDevice::~VideoDevice()
{
    if(stop_capturing() == FALSE)
    {
    }
    if(uninit_device() == FALSE)
    {
    }
    if(close_device() == FALSE)
    {
    }
}
int VideoDevice::open_device()
{
    fd = open(FILE_VIDEO,O_RDWR);
    if(fd == -1)
    {
        printf("Error opening V4L interface\n");
        return FALSE;
    }
    return TRUE;
}

int VideoDevice::close_device()
{
    if( close(fd) == FALSE)
    {
        printf("Error closing V4L interface\n");
        return FALSE;
    }
    return TRUE;
}

int VideoDevice::init_device()
{
    v4l2_capability cap;
    v4l2_format fmt;
    v4l2_streamparm setfps;

    if(ioctl(fd, VIDIOC_QUERYCAP, &cap) == -1)
    {
        printf("Error opening device %s: unable to query device.\n",FILE_VIDEO);
        return FALSE;
    }
    else
    {
        printf("driver:\t\t%s\n",cap.driver);
        printf("card:\t\t%s\n",cap.card);
        printf("bus_info:\t%s\n",cap.bus_info);
        printf("version:\t%d\n",cap.version);
        printf("capabili ties:\t%x\n",cap.capabilities);

        if ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) == V4L2_CAP_VIDEO_CAPTURE)
        {
            printf("Device %s: supports capture.\n",FILE_VIDEO);
        }

        if ((cap.capabilities & V4L2_CAP_STREAMING) == V4L2_CAP_STREAMING)
        {
            printf("Device %s: supports streaming.\n",FILE_VIDEO);
        }
    }

    //set fmt
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    //fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
    fmt.fmt.pix.height = 240;
    fmt.fmt.pix.width = 320;
    fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

    if(ioctl(fd, VIDIOC_S_FMT, &fmt) == -1)
    {
            printf("Unable to set format\n");
            return FALSE;
    }
    if(ioctl(fd, VIDIOC_G_FMT, &fmt) == -1)
    {
            printf("Unable to get format\n");
            return FALSE;
    }
        printf("fmt.type:\t\t%d\n",fmt.type);
        printf("pix.pixelformat:\t%c%c%c%c\n",fmt.fmt.pix.pixelformat & 0xFF, (fmt.fmt.pix.pixelformat >> 8) & 0xFF,(fmt.fmt.pix.pixelformat >> 16) & 0xFF, (fmt.fmt.pix.pixelformat >> 24) & 0xFF);
        printf("pix.height:\t\t%d\n",fmt.fmt.pix.height);
        printf("pix.width:\t\t%d\n",fmt.fmt.pix.width);
        printf("pix.field:\t\t%d\n",fmt.fmt.pix.field);

    //set fps
    setfps.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    setfps.parm.capture.timeperframe.numerator = 1;
    setfps.parm.capture.timeperframe.denominator = 60;

    if(ioctl(fd, VIDIOC_S_PARM, &setfps) == -1)
    {
        printf("Unable to set frame rate\n");
        return FALSE;
    }
    else
    {
        printf("set fps OK!\n");
    }

    if(ioctl(fd, VIDIOC_G_PARM, &setfps) == -1)
    {
        printf("Unable to get frame rate\n");
        return FALSE;
    }
    else
    {
        printf("get fps OK!\n");
        printf("timeperframe.numerator:\t%d\n",setfps.parm.capture.timeperframe.numerator);
        printf("timeperframe.denominator:\t%d\n",setfps.parm.capture.timeperframe.denominator);

    }


//setExposureMode(1);
//setExposureAbs(85);
//setExposureMode(1);
//setExposureMode(0);
//setExposureAbs(1);

    //mmap
    if(init_mmap() == FALSE )
    {
        printf("cannot mmap!\n");
        return FALSE;

    }

    return TRUE;
}

int VideoDevice::init_mmap()
{
    v4l2_requestbuffers req;
//2
    req.count = 4;
    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    req.memory = V4L2_MEMORY_MMAP;


//printf("1\n");
    if(ioctl(fd, VIDIOC_REQBUFS, &req) == -1)
    {
	printf("request for buffers error\n");
        return FALSE;
    }
//printf("2\n");
    if(req.count < 2)
    {
        return FALSE;
    }
//printf("3\n");
    buffers = (buffer*)calloc(req.count, sizeof(*buffers));

    if(!buffers)
    {
        return FALSE;
    }
//printf("4\n");
    for(n_buffers = 0; n_buffers < req.count; n_buffers++)
    {
        v4l2_buffer buf;
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory = V4L2_MEMORY_MMAP;
        buf.index = n_buffers;

        if(ioctl(fd, VIDIOC_QUERYBUF, &buf) == -1)
        {
            return FALSE;
        }
//printf("5\n");
        buffers[n_buffers].length = buf.length;
        buffers[n_buffers].start =
                mmap(NULL, // start anywhere// allocate RAM*4
                     buf.length,
                     PROT_READ | PROT_WRITE,
                     MAP_SHARED,
                     fd, buf.m.offset);

        if(MAP_FAILED == buffers[n_buffers].start)
        {
	    printf("buffer map error\n");
            return FALSE;
        }
    }
//printf("6\n");
    return TRUE;

}

int VideoDevice::start_capturing()
{
    unsigned int i;
    for(i = 0; i < 4; i++)
    {
        v4l2_buffer buf;
        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        buf.memory =V4L2_MEMORY_MMAP;
        buf.index = i;
        if(-1 == ioctl(fd, VIDIOC_QBUF, &buf))
        {
            return FALSE;
        }
    }

    v4l2_buf_type type;
    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    if(-1 == ioctl(fd, VIDIOC_STREAMON, &type))
    {
        return FALSE;
    }
    return TRUE;
}

int VideoDevice::stop_capturing()
{
    v4l2_buf_type type;
    type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    if(ioctl(fd, VIDIOC_STREAMOFF, &type) == -1)
    {
        return FALSE;
    }  
/*
    if(fd != -1) 
    {
        close(fd);
        return (TRUE);
    }
*/

    return TRUE;
}

int VideoDevice::uninit_device()
{
    unsigned int i;

    for(i = 0; i < n_buffers; ++i)
    {
        if(-1 == munmap(buffers[i].start, buffers[i].length))
        {
            printf("munmap error\n");
            return FALSE;
        }

    }

    delete buffers;
    return TRUE;
}

int VideoDevice::get_frame(unsigned char ** yuv_buffer_pointer, unsigned int * len)
{
    v4l2_buffer queue_buf;
    //printf("get frame 1\n");

    queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    queue_buf.memory = V4L2_MEMORY_MMAP;

    if(ioctl(fd, VIDIOC_DQBUF, &queue_buf) == -1)
    {
        return FALSE;
    }

    *yuv_buffer_pointer = (unsigned char *)buffers[queue_buf.index].start;
    *len = buffers[queue_buf.index].length;
    index = queue_buf.index;

    //printf("get frame 2\n");

    return TRUE;

}

int VideoDevice::unget_frame()
{
    if(index != -1)
    {
        v4l2_buffer queue_buf;
        queue_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        queue_buf.memory = V4L2_MEMORY_MMAP;
        queue_buf.index = index;

        if(ioctl(fd, VIDIOC_QBUF, &queue_buf) == -1)
        {
            return FALSE;
        }
        return TRUE;
    }
    return FALSE;
}


void VideoDevice::getExposureMode()
{
	int ret;
	struct v4l2_control ctrl;
	//得到曝光模式
	ctrl.id = V4L2_CID_EXPOSURE_AUTO;
	ret = ioctl(fd, VIDIOC_G_CTRL, &ctrl);

	if (ret < 0)
	{
	    printf("Get exposure Mode failed\n");
	
	    //return V4L2_UTILS_GET_EXPSURE_AUTO_TYPE_ERR;
	}
	else
	{
	printf("\nGet Exposure Mode:[%d]\n", ctrl.value);
	}

	}

// 1 手动曝光模式     0 auto曝光模式
void VideoDevice::setExposureMode(int exposureMode)
{
	int ret;
	struct v4l2_control ctrl;

	ctrl.id = V4L2_CID_EXPOSURE_AUTO;
	if(exposureMode == 0)
	{
	ctrl.value = V4L2_EXPOSURE_APERTURE_PRIORITY; //V4L2_EXPOSURE_AUTO;//auto曝光模式
	}
	else
	{
	ctrl.value = V4L2_EXPOSURE_MANUAL;//手动曝光模式
	}
	
	ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
	if (ret < 0)
	{
	   printf("Set exposure Mode failed\n");
	
	   //return V4L2_UTILS_SET_EXPSURE_AUTO_TYPE_ERR;
	
	}
	else
	{
	printf("\nSet Exposure Mode Success :[%d]\n", ctrl.value);
	}

}

void VideoDevice::getExposureLevel()
{
	int ret; 
	struct v4l2_control ctrl;
	ctrl.id = V4L2_CID_EXPOSURE;//得到曝光档次，A20接受从 -4到4 共9个档次
	ret = ioctl(fd, VIDIOC_G_CTRL, &ctrl);
	if (ret < 0)
	{
	    printf("Get exposure Level failed (%d)\n", ret); 
	    //return V4L2_UTILS_GET_EXPSURE_ERR;
	}
	else
	{
	printf("\nGet Exposure Level :[%d]\n", ctrl.value);
	}


}

void VideoDevice::setExposureLevel(int exposurelevel)
{
	int ret; 
	struct v4l2_control ctrl; 
	//设置曝光档次
	ctrl.id = V4L2_CID_EXPOSURE; 
	ctrl.value = exposurelevel; 
	ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl); 
	if (ret < 0) 
	{ 
	    printf("Set exposure level failed (%d)\n", ret); 
	    //return V4L2_UTILS_SET_EXPSURE_ERR; 
	}
	else
	{
	printf("\nSet exposure level Success:[%d]\n", ctrl.value);
	} 
}

void VideoDevice::getExposureAbs()
{
	int ret;
	struct v4l2_control ctrl;
	ctrl.id = V4L2_CID_EXPOSURE_ABSOLUTE;
	ret = ioctl(fd, VIDIOC_G_CTRL, &ctrl);
	if (ret < 0) 
	{
	    printf("Get exposure Abs failed (%d)\n", ret);
	 
	    //return V4L2_UTILS_SET_EXPSURE_ERR;
	}
	else
	{
	printf("\nGet  exposure ABS Success:[%d]\n", ctrl.value);
	} 


}

void VideoDevice::setExposureAbs(int exposureAbs)
{
	int ret;
	struct v4l2_control ctrl;
	//设置曝光绝对值
	ctrl.id = V4L2_CID_EXPOSURE_ABSOLUTE;
	ctrl.value = exposureAbs;  //单位100us
	ret = ioctl(fd, VIDIOC_S_CTRL, &ctrl);
	if (ret < 0) 
	{
	    printf("Set exposure Abs failed (%d)\n", ret);
	 
	    //return V4L2_UTILS_SET_EXPSURE_ERR;

	}
	else
	{
	printf("\nSet exposure Abs Success:[%d]\n", ctrl.value);
	} 
}

这里分辨根据自己相机支持的分辨率来设置，我的相机选320*240能够上到120fps，具体是这几个参数，实际支持参数可以通过v4l2的命令行查看，注意-d2这个参数，2是指设备/dev/video2,按你自己的相机设备号来。

v4l2-ctl -d2 --list-formats-ext

 高帧数的话只能用mjpeg模式

    //fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
    fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_MJPEG;
    fmt.fmt.pix.height = 240;
    fmt.fmt.pix.width = 320;

qt窗口类 具体实现 头文件 widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QLabel>
#include <QTime>
#include <QPainter>
#include <QLineEdit>
#include "videodevice.h"

#include <string>
#include <exception>
#include <zbar.h>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>




using namespace cv;
using namespace zbar;
using namespace std;


//定义一个结构体用于存储每个码
typedef struct
{
  string type;
  string data;
  vector <Point> location;
}decodedObject;


namespace Ui {
    class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT

public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();

private:
    Ui::Widget *ui;

    QImage *frame;
    QLabel *tp;
    QByteArray *aa;
    QPixmap *pix;
    int rs;
    unsigned int len;
    int convert_yuv_to_rgb_buffer();
    void print_quartet(unsigned int i);

    VideoDevice *vd;
    FILE * yuvfile;
    unsigned char rgb_buffer[640*480*3];
    unsigned char * yuv_buffer_pointer;

    char Y_frame[640*480*2+600];


    int writejpg();
    cv::Mat scancoder(cv::Mat &image);
    QPixmap cvMatToQPixmap(const cv::Mat &inMat);
    cv::Mat QImage_to_cvMat( const QImage &image, bool inCloneImageData = true );
    QImage cvMat_to_QImage(const cv::Mat &mat );

    // 展示码
    void display(Mat &im, vector<decodedObject>&decodedObjects);
    // 对图像进行码检测
    void decode(Mat &im, vector<decodedObject>&decodedObjects);


private slots:
    void on_pushButton_start_clicked();
    void paintEvent(QPaintEvent *);
    void on_changeex_clicked();
    void on_changesize_clicked();
    //void on_pushButton_changeExposure();
};
#endif // WIDGET_H

qt窗口类 具体实现 widget.cpp

#include "ui_widget.h"
#include "widget.h"
#include "common.h"
#include "videodevice.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/stat.h>
#include <fcntl.h>



#include <stdio.h>
#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 <sys/mman.h>
#include <linux/types.h>
#include <linux/videodev2.h>








#define TOTALFRAMES 151
#define CAPTURE_IDLE 0
#define CAPTURE_START 1
#define CAPTURE_STOP 2
#define CAPTURE_COMPRESS 3

char last_state = 2;
char state = 0;
long framecnt=0;
char yuvfilename[11] = {'r','c','q','0','0','0','.','j','p','g','\0'};

static QTime timec;
static int framesc = 0;
static bool started = false;
static bool multi = false;

int imagesizes = 500;

QString m_current_fps;

 
//二维码检测和识读
vector<decodedObject> decodedObjects;



typedef struct tagBITMAPFILEHEADER{
     unsigned short	bfType;                // the flag of bmp, value is "BM"
     unsigned long   bfSize;                // size BMP file ,unit is bytes
     unsigned long    bfReserved;            // 0
     unsigned long    bfOffBits;             // must be 54

}BITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER{
     unsigned long    biSize;                // must be 0x28
     unsigned long    biWidth;           //
     unsigned long    biHeight;          //
     unsigned short		biPlanes;          // must be 1
     unsigned short		biBitCount;            //
     unsigned long    biCompression;         //
     unsigned long    biSizeImage;       //
     unsigned long    biXPelsPerMeter;   //
     unsigned long    biYPelsPerMeter;   //
     unsigned long    biClrUsed;             //
     unsigned long    biClrImportant;        //
}BITMAPINFOHEADER;

    BITMAPFILEHEADER   bf;
    BITMAPINFOHEADER   bi;
    QMatrix matrix;



Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{

    matrix.rotate(180);

    //Set BITMAPINFOHEADER
    bi.biSize = 40;
    bi.biWidth = IMG_WIDTH;
    bi.biHeight = IMG_HEIGTH;
    bi.biPlanes = 1;
    bi.biBitCount = 24;
    bi.biCompression = 0;
    bi.biSizeImage = IMG_WIDTH*IMG_HEIGTH*3;
    bi.biXPelsPerMeter = 3780;
    bi.biYPelsPerMeter = 3780;
    bi.biClrUsed = 0;
    bi.biClrImportant = 0;


    //Set BITMAPFILEHEADER
    bf.bfType = 0x4d42;
    bf.bfSize = 54 + bi.biSizeImage;
    bf.bfReserved = 0;
    bf.bfOffBits = 54;



    ui->setupUi(this);
    vd = new VideoDevice(tr("/dev/video1"));


    rs = vd->unget_frame();

    frame = new QImage(rgb_buffer,640,480,QImage::Format_RGB888);
    aa = new QByteArray();
    pix = new QPixmap();


}

Widget::~Widget()
{
    delete ui;

    //delete frame;
    //delete [] Y_frame;
    //delete [] Cr_frame;
    //delete [] Cb_frame;
}

void Widget::paintEvent(QPaintEvent *)
{
    rs = vd->get_frame((unsigned char **)(&yuv_buffer_pointer),&len);


   if(last_state==2 && state == 0)
    {
        yuvfile = fopen(yuvfilename,"wb+");
        yuvfilename[5]++;
    }

    if(state == 1)
    {
        rs = writejpg();
    printf("writejpg\n");
    }

    if(last_state==1 && state==2)
    {
	fwrite(Y_frame, len, 1, yuvfile);
        fclose(yuvfile);
    }

    last_state=state;



//MJPEG
    //qpixmap
    //pix->loadFromData(yuv_buffer_pointer,len);
    //ui->label->setPixmap(*pix);

    //qimage
    //frame->loadFromData(yuv_buffer_pointer,len);
    //ui->label->setPixmap(QPixmap::fromImage(*frame));

    frame->loadFromData(yuv_buffer_pointer,len);

    QImage swapped = *frame;
    Mat images = QImage_to_cvMat(swapped);

        int new_width,new_height,width,height,channel;
        width=images.cols;
        height=images.rows;
        channel=images.channels();
        //调整图像大小
        new_width=imagesizes;

        new_height=int(new_width*1.0/width*height);
        cv::resize(images, images, cv::Size(new_width, new_height));


    scancoder(images);
    QImage xii = cvMat_to_QImage(images);    

    ui->label->setPixmap(QPixmap::fromImage(xii));//cvMatToQPixmap(image)







    rs = vd->unget_frame();






QPainter painter(this);

 if (!started || timec.elapsed() > 1000) {
            qreal fps = framesc * 1000. / timec.elapsed();
            if (fps == 0)
                m_current_fps = "counting fps...";
            else
                m_current_fps = QString::fromLatin1("%3 FPS").arg((int) qRound(fps));

            timec.start();
            started = true;
            framesc = 0;
	//printf("fps %f\n",fps);
        } else {
            ++framesc;
	    ui->fpslabel->setText(m_current_fps);

        }


}


int Widget::writejpg()
{
    int x,y;
    long int index1 =0;

        if (yuv_buffer_pointer[0] == '\0')
        {
            return -1;
        }

        for(x=0;x<len;x++)
        {
            Y_frame[x]=yuv_buffer_pointer[x];
        }

        
        printf("writed frame %ld\n",framecnt);

	return 0;
}



/*yuv格式转换为rgb格式*/
int Widget::convert_yuv_to_rgb_buffer()
{
    unsigned long in, out = 640*480*3 - 1;
    int y0, u, y1, v;
    int r, g, b;

    for(in = 0; in < IMG_WIDTH * IMG_HEIGTH * 2; in += 4)
    {
        y0 = yuv_buffer_pointer[in + 0];
        u  = yuv_buffer_pointer[in + 1];
        y1 = yuv_buffer_pointer[in + 2];
        v  = yuv_buffer_pointer[in + 3];

        r = y0 + (1.370705 * (v-128));
        g = y0 - (0.698001 * (v-128)) - (0.337633 * (u-128));
        b = y0 + (1.732446 * (u-128));

        if(r > 255) r = 255;
        if(g > 255) g = 255;
        if(b > 255) b = 255;
        if(r < 0) r = 0;
        if(g < 0) g = 0;
        if(b < 0) b = 0;
        rgb_buffer[out--] = r;
        rgb_buffer[out--] = g;
        rgb_buffer[out--] = b;

        r = y1 + (1.370705 * (v-128));
        g = y1 - (0.698001 * (v-128)) - (0.337633 * (u-128));
        b = y1 + (1.732446 * (u-128));

        if(r > 255) r = 255;
        if(g > 255) g = 255;
        if(b > 255) b = 255;
        if(r < 0) r = 0;
        if(g < 0) g = 0;
        if(b < 0) b = 0;
        rgb_buffer[out--] = r;
        rgb_buffer[out--] = g;
        rgb_buffer[out--] = b;
    }
    return 0;
}


void Widget::on_pushButton_start_clicked()
{

    switch(state)
    {
    case 0:
        {
        ui->pushButton_start->setText("stop");
        state = 1;
        break;
        }
    case 1:
        {
        ui->pushButton_start->setText("compress");
        state = 2;
        break;
        }
    case 2:
        {
        ui->pushButton_start->setText("start");
        framecnt=0;
        state = 0;
        break;
        }
    default :break;
    }

}


void Widget::on_changeex_clicked()
{
	QString strtext = ui->edit->text();
	int a = strtext.toInt();

	vd->stop_capturing();
	vd->setExposureMode(1);
	vd->setExposureAbs(a);
	vd->start_capturing();



}

void Widget::on_changesize_clicked()
{
	QString strtext = ui->sizeedit->text();
	int a = strtext.toInt();

	imagesizes = a;

}


// 对图像进行码检测
void Widget::decode(Mat &im, vector<decodedObject>&decodedObjects)
{
  // 创建zbar扫码器
  ImageScanner scanner;
 
  // 配置扫码器参数
  scanner.set_config(ZBAR_NONE, ZBAR_CFG_ENABLE, 1);//ZBAR_NONE表示针对所有码进行检测（ZBAR_QRCODE表示只检测二维码）
 
  // 将图像转换为灰度图
  Mat imGray;
  cvtColor(im, imGray,COLOR_BGR2GRAY);
 
  // 将图像转换为zbar图像格式，即Y800格式
  Image image(im.cols, im.rows, "Y800", (uchar *)imGray.data, im.cols * im.rows);
 
  // 开始扫码
  int n = scanner.scan(image);
 
  // 输出扫码结果
  for(Image::SymbolIterator symbol = image.symbol_begin(); symbol != image.symbol_end(); ++symbol)
  {
    decodedObject obj;
 
    obj.type = symbol->get_type_name();//码类型
    obj.data = symbol->get_data();//码解析字符串
 
    // 输出结果至控制台
    //printf( "类型 : %s", obj.type);
    //printf( "   解码内容 : %s\n", obj.data);
 
    // Draw text
    putText(im, obj.data, Point(symbol->get_location_x(2),symbol->get_location_y(2)), FONT_HERSHEY_PLAIN, 1, Scalar( 110, 220, 0 ));

    // 获取码的定位坐标
    for(int i = 0; i< symbol->get_location_size(); i++)
    {
      obj.location.push_back(Point(symbol->get_location_x(i),symbol->get_location_y(i)));
    }
 
    //每个检测结果存储于decodedObjects变量
    decodedObjects.push_back(obj);
  }
}
 
// 展示码
void Widget::display(Mat &im, vector<decodedObject>&decodedObjects)
{
  // 循环每一个码
  for(int i = 0; i < decodedObjects.size(); i++)
  {
    vector<Point> points = decodedObjects[i].location;
    vector<Point> hull;//多边形
 
    // 如果超过4个点，则采用多边形进行外接框绘制
    if(points.size() > 4)
      convexHull(points, hull);
    else
      hull = points;
 
    // 获取多边形点的个数
    int n = hull.size();
 
    for(int j = 0; j < n; j++)
    {
      line(im, hull[j], hull[ (j+1) % n], Scalar(255,0,0), 3);
    }
 
  }
 
  // 显示结果
  //imshow("Results", im);
  //waitKey(0);

}


cv::Mat Widget::scancoder(cv::Mat &image)
{
	decode(image, decodedObjects);
        display(image, decodedObjects);
	decodedObjects.clear();

	return image.clone();

}



QImage Widget::cvMat_to_QImage(const cv::Mat &mat ) {
 /* switch ( mat.type() )
  {
     // 8-bit, 4 channel
     case CV_8UC4:
     {
        QImage image( mat.data, mat.cols, mat.rows, mat.step, QImage::Format_RGB32 );
        return image;
     }
 
     // 8-bit, 3 channel
     case CV_8UC3:
     {
        QImage image( mat.data, mat.cols, mat.rows, mat.step, QImage::Format_RGB888 );
        return image.rgbSwapped();
     }
 
     // 8-bit, 1 channel
     case CV_8UC1:
     {
        static QVector<QRgb>  sColorTable;
        // only create our color table once
        if ( sColorTable.isEmpty() )
        {
           for ( int i = 0; i < 256; ++i )
              sColorTable.push_back( qRgb( i, i, i ) );
        }
        QImage image( mat.data, mat.cols, mat.rows, mat.step, QImage::Format_Indexed8 );
        image.setColorTable( sColorTable );
        return image;
     }
 
     default:
         printf("Image format is not supported: depth=%d and %d channels\n", mat.depth(), mat.channels());
        //qDebug("Image format is not supported: depth=%d and %d channels\n", mat.depth(), mat.channels());
        break;
  }
  return QImage();
*/

// 8-bits unsigned, NO. OF CHANNELS = 1
    if(mat.type() == CV_8UC1)
    {
        QImage image(mat.cols, mat.rows, QImage::Format_Indexed8);
        // Set the color table (used to translate colour indexes to qRgb values)
        static QVector<QRgb>  sColorTable;
        // only create our color table once
        if ( sColorTable.isEmpty() )
        {
           for ( int i = 0; i < 256; ++i )
              sColorTable.push_back( qRgb( i, i, i ) );
        }
	image.setColorTable( sColorTable );
        // Copy input Mat
        uchar *pSrc = mat.data;
        for(int row = 0; row < mat.rows; row ++)
        {
            uchar *pDest = image.scanLine(row);
            memcpy(pDest, pSrc, mat.cols);
            pSrc += mat.step;
        }
        return image;
    }
    // 8-bits unsigned, NO. OF CHANNELS = 3
    else if(mat.type() == CV_8UC3)
    {
        // Copy input Mat
        const uchar *pSrc = (const uchar*)mat.data;
        // Create QImage with same dimensions as input Mat
        QImage image(pSrc, mat.cols, mat.rows, mat.step, QImage::Format_RGB888);
        return image.rgbSwapped();
    }
    else if(mat.type() == CV_8UC4)
    {
        // Copy input Mat
        const uchar *pSrc = (const uchar*)mat.data;
        // Create QImage with same dimensions as input Mat
        QImage image(pSrc, mat.cols, mat.rows, mat.step, QImage::Format_ARGB32);
        return image.copy();
    }
    else
    {
        return QImage();
    }

}


cv::Mat Widget::QImage_to_cvMat( const QImage &image, bool inCloneImageData) {
  switch ( image.format() )
  {
     case QImage::Format_ARGB32:
     case QImage::Format_ARGB32_Premultiplied:
     // 8-bit, 4 channel
     case QImage::Format_RGB32:
     {
        cv::Mat mat( image.height(), image.width(), CV_8UC4, const_cast<uchar*>(image.bits()), image.bytesPerLine() );
        return (inCloneImageData ? mat.clone() : mat);
     }
 
     // 8-bit, 3 channel
     case QImage::Format_RGB888:
     {
        if ( !inCloneImageData ) {
           printf(" Conversion requires cloning since we use a temporary QImage\n");
           //qWarning() << "ASM::QImageToCvMat() - Conversion requires cloning since we use a temporary QImage";
        }
        QImage swapped = image.rgbSwapped();
        return cv::Mat( swapped.height(), swapped.width(), CV_8UC3, const_cast<uchar*>(swapped.bits()), swapped.bytesPerLine() ).clone();
     }
  
     // 8-bit, 1 channel
     case QImage::Format_Indexed8:
     {
        cv::Mat  mat( image.height(), image.width(), CV_8UC1, const_cast<uchar*>(image.bits()), image.bytesPerLine() );
 
        return (inCloneImageData ? mat.clone() : mat);
     }
 
     default:
        printf("Image format is not supported: depth=%d and %d format\n", image.depth(), image.format());
        //qDebug("Image format is not supported: depth=%d and %d format\n", image.depth(), image.format();
        break;
  }
 
  return cv::Mat();
}

QPixmap Widget::cvMatToQPixmap(const cv::Mat &inMat)
{
    return QPixmap::fromImage(cvMat_to_QImage(inMat));
}

qt界面文件 ui_widget.h

/********************************************************************************
** Form generated from reading UI file 'widget.ui'
**
** Created by: Qt User Interface Compiler version 5.9.5
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/

#ifndef UI_WIDGET_H
#define UI_WIDGET_H

#include <QtCore/QVariant>
#include <QtWidgets/QAction>
#include <QtWidgets/QApplication>
#include <QtWidgets/QButtonGroup>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QLabel>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QWidget>
#include <QtWidgets/QLineEdit>

QT_BEGIN_NAMESPACE

class Ui_Widget
{
public:
    QLabel *label,*fpslabel;
    QLineEdit *edit,*sizeedit;
    QPushButton *pushButton_start,*changeex,*changesize;
    
    void setupUi(QWidget *Widget)
    {
        if (Widget->objectName().isEmpty())
            Widget->setObjectName(QStringLiteral("Widget"));
        Widget->resize(650, 620);
        Widget->setMinimumSize(QSize(650, 720));
        Widget->setMaximumSize(QSize(1280, 720));
        label = new QLabel(Widget);
        label->setObjectName(QStringLiteral("label"));
        label->setGeometry(QRect(5, 5, 640, 480));
        label->setMinimumSize(QSize(640, 480));
        label->setMaximumSize(QSize(1280, 720));
	fpslabel = new QLabel(Widget);
        fpslabel->setObjectName(QStringLiteral("fpslabel"));
        fpslabel->setGeometry(QRect(140, 500, 101, 41));
        fpslabel->setMinimumSize(QSize(101, 41));
        fpslabel->setMaximumSize(QSize(101, 41));

	edit = new QLineEdit(Widget);
	edit->setObjectName(QStringLiteral("edit"));
	edit->setPlaceholderText("Normal");
	edit->setEchoMode(QLineEdit::Normal);
	edit->setGeometry(QRect(20, 570, 101, 41));

        changeex = new QPushButton(Widget);
        changeex->setObjectName(QStringLiteral("changeex"));
        changeex->setGeometry(QRect(140, 570, 101, 41));

	sizeedit = new QLineEdit(Widget);
	sizeedit->setObjectName(QStringLiteral("sizeedit"));
	sizeedit->setPlaceholderText("Normal");
	sizeedit->setEchoMode(QLineEdit::Normal);
	sizeedit->setGeometry(QRect(20, 640, 101, 41));

        changesize = new QPushButton(Widget);
        changesize->setObjectName(QStringLiteral("changesize"));
        changesize->setGeometry(QRect(140, 640, 101, 41));

        pushButton_start = new QPushButton(Widget);
        pushButton_start->setObjectName(QStringLiteral("pushButton_start"));
        pushButton_start->setGeometry(QRect(20, 500, 101, 41));

        retranslateUi(Widget);

        QMetaObject::connectSlotsByName(Widget);
    } // setupUi

    void retranslateUi(QWidget *Widget)
    {
        Widget->setWindowTitle(QApplication::translate("Widget", "zed_camera_AVI", Q_NULLPTR));
        label->setText(QString());
	fpslabel->setText(QString());
        pushButton_start->setText(QApplication::translate("Widget", "Start", Q_NULLPTR));
	changeex->setText(QApplication::translate("Widget", "change", Q_NULLPTR));
	changesize->setText(QApplication::translate("Widget", "cgsize", Q_NULLPTR));

    } // retranslateUi

};

namespace Ui {
    class Widget: public Ui_Widget {};
} // namespace Ui

QT_END_NAMESPACE

#endif // UI_WIDGET_H

这些文件都有打包，下载下来后解压，进入执行命令编译

文件下载地址：点击下载

qmake zed_YUV_camera_prj.pro
make -j4

最后执行

./zed_YUV_camera

第一个start是获取图片保存

第二个编辑框是曝光时间 单位是100us，上面也就是1500us

第三个是改变输入zbar中识别的图片大小，越小速度越快

 

 

 

这里是采集的jpeg的格式图片，直接写入文件就是jpeg的图了，但是如果采集yuv格式转bmp，在jetson中要bmp的文件头一个一个属性分别写入才不会出错，整个结构体写入会出现问题

    //Set BITMAPINFOHEADER
    bi.biSize = 40;
    bi.biWidth = IMG_WIDTH;
    bi.biHeight = IMG_HEIGTH;
    bi.biPlanes = 1;
    bi.biBitCount = 24;
    bi.biCompression = 0;
    bi.biSizeImage = IMG_WIDTH*IMG_HEIGTH*3;
    bi.biXPelsPerMeter = 3780;
    bi.biYPelsPerMeter = 3780;
    bi.biClrUsed = 0;
    bi.biClrImportant = 0;


    //Set BITMAPFILEHEADER
    bf.bfType = 0x4d42;
    bf.bfSize = 54 + bi.biSizeImage;
    bf.bfReserved = 0;
    bf.bfOffBits = 54;


//写入就把上面的成员一个一个写入，在树莓派整个结构体写入没问题，但是jetson nano却有问题。
像这样，不过这里是伪代码，实际自己按自己用的写入函数来
write(fd1,bi.biSize)
write(fd1,bi.biWidth)
等等

 

ourkix
关注
专栏目录
linux V4L2编程拍照
05-21
linux环境下基于V4L2实现的拍照程序，包括代码和说明文档，可编译通过
ubuntu通过V4L2采集jpg并显示jpg
dong_beijing的博客
05-11 2897
用ubuntu想在写代码时，随时观察自己身后的状态，用cheese做录像太明显了，而且还得动鼠标，打算写个用的摄像头拍照的工具。用v4l2应该最容易。 头文件，包括mem，dev和ioctl相关的头文件 #include #include #include #include #include #include #include #include #include 定义一个
通过V4L2接口控制曝光模式遇到的问题
最新发布
chenaifeiwuya的博客
09-03 191
可以看到，将0x05转换成二进制为 ： 0101,按照这个表来对照的话是不支持自动曝光模式的，但是这个产品实际是支持自动曝光的，于是我找到产品代码，在其UVC相关代码中找到了返回曝光模式的GET_RES请求的代码，果然返回的是0x05,最后将这个改了应该就好用了。最近在测试曝光模式的时候遇到了一个问题：当通过V4L2接口控制产品的曝光模式为自动曝光和手动曝光的时候，可以将其设置成手动曝光，但将其设置成自动曝光却失败了。可以看到，我们传入的参数0，1，2，3最终会对应到这些项。
使用V4L2读取摄像头并在LCD上显示
qq_39545674的博客
01-30 3283
我的环境是友善之臂的fire3，Ubuntu1604，使用的是uvc免驱摄像头 大致的工作流程如下 一、获取摄像头图片 1、打开摄像头 2、获取摄像头的一些信息，比如支持的格式等等 3、设置摄像头的一些参数，比如输出格式等等 4、申请缓冲区 5、内存映射 6、开始采集 二、将图片在lcd上显示出来 1、打开lcd的设备fb0，如果没有这个，恭喜。 2、获取一些lcd的信息，如...
【Linux编程】UVC摄像头采集与显示（V4L2编程）
丨晋丨
12-08 4609
手头有一个UVC（usb video class）摄像头（也称为免驱摄像头），就顺便学习了一下V4L2编程 ，写代码的过程中参考了前辈的博客，觉得写的非常的好，特将链接贴在这里 http://www.linuxidc.com/Linux/2016-11/137067.htm 关于V4L2讲解的可以学习前辈的博客，这里只是写了一个实例代码供看了知识点还无从下手写代码的新手作为参考。 平台描述： OK210开发板。 屏幕是开发板自带的800*480的RGB32格式屏幕。 摄像头
c v4l2（拍照）
m0_59802969的博客
10-17 171
【代码】c v4l2。
qt-5.15.2-jetson-nano
05-09
jetson-nano，jetpack 是4.6.1版本。编译的qt5.15.2，带xcb, 带opengl， qml可用。 在板子上编译大概需要6小时，还会碰到各种问题，试错成本比较高。有需要的小伙伴可以省去大家编译的烦恼，节约时间。
Face-Mask-Detection-Jetson-Nano:Jetson Nano上的面罩检测
04-19
在Jetson Nano上以44-5 FPS运行的快速面罩识别。 这是在公共领域中发现的两种深度学习模型的快速C ++实现。 第一个是在ncnn框架上运行的Linzaer的面部检测器。 。 第二个是Paddle Lite遮罩检测，用于对找到的脸部...
算法部署-在Jetson-Nano上使用deepstream部署ONNX模型-附项目源码-优质项目实战.zip
05-08
在这个优质项目实战中，我们将探讨如何在Jetson-Nano开发板上使用DeepStream SDK来部署一个基于ONNX（Open Neural Network Exchange）格式的深度学习模型。这个实践过程涵盖了多个关键知识点，包括硬件平台的选择、...
Jetson Nano使用ZBar进行二维码检测和识读（C++）
钱彬的博客
01-03 2402
前一篇博文中详细讲解了Jetson Nano的安装和使用，并且介绍了如何利用Opencv4中的二维码模块进行二维码检测和识读，详见：https://blog.csdn.net/qianbin3200896/article/details/103760640。 由于Opencv4中刚加入二维码模块内容，其检测效率和稳定性均不如另一个著名的开源库ZBar。ZBar是一个开源的条形码和二维码检测算法库...
jetson-nano-image：为NVIDIA jetson nano板创建自己的图像
01-31
标题 "jetson-nano-image：为NVIDIA jetson nano板创建自己的图像" 指向的是一个项目，目的是教你如何自定义NVIDIA Jetson Nano开发板的操作系统映像。NVIDIA Jetson Nano是一款低功耗、高性能的嵌入式AI开发平台，...
Linux下V4L2拍照
zhouxinlin2009的专栏
07-16 530
一、源码test.c#include &lt;fcntl.h&gt;#include &lt;stdlib.h&gt;#include &lt;sys/mman.h&gt;#include &lt;linux/videodev2.h&gt; int main(){ ////// int fd = open("/dev/video0",O_RDWR); printf("TK-------&...
v4l2 QT MJPEG格式 视频采集+屏幕显示+图片保存
12-26
v4l2 QT MJPEG格式 视频采集+屏幕显示+图片保存
jetson nano 查看 摄像头信息
weixin_45724232的博客
04-12 1443
sudo apt install v4l-utils v4l2-ctl --list-device v4l2-ctl --device=/dev/video0 --list-formats-ext
音视频开发---linux下V4L2拍照
挥剑踏苍穹的博客
05-21 619
目录 1. 流程说明 2. 代码说明 2.1摄像头初始化 2.2 启动摄像头 2.3拍照 2.4停止摄像头 3. 参考链接 V4L2(Video4linux2),是linux中关于视频设备的内核驱动。在Linux中，我们可以像访问普通文件一样对视频设备进行操作，V4L2也为我们在用户空间操作视频设备提供了一系列接口，使得应用程序可以使用统一的AP...
V4l2 Capture Sequence
热门推荐
醉月
11-12 1万+
V4l2Capture Sequence  v4l2操作实际上就是open()设备，close()设备，以及中间过程的ioctl()操作。对于ioctl的调用，要注意对errno的判断，如果调用被其他信号中断，即errno等于EINTR的时候，要重新调用。Videocap
Jetson nano上用qt打开摄像头的问题
Tjust_do_it的博客
08-01 2123
请教一个关于Jetson nano开发板的问题。前不久刚入手的开发板。因为要做界面，要有按钮，所以安装了qt5，我用了两个qt打开摄像头的工程在qtcreator上调试运行，都出现了以下错误： Starting /home/tsx/Qt/5c868669/build-QCamera-unknown-Debug/QCamera… (QCamera:25427): GStreamer-CRITICAL **: 14:08:37.564: gst_pad_get_current_caps: assertion
jetson-nano-sd-r32.1-2019-03-18.zip
02-23
标题 "jetson-nano-sd-r32.1-2019-03-18.zip" 提供的信息表明，这是一个与NVIDIA Jetson Nano开发板相关的软件镜像文件，时间戳为2019年3月18日，版本号可能是R32.1。这种文件通常用于在Jetson Nano上预装操作系统和...
《Linux操作系统 - RK3568开发笔记》第5章 基于V4L2拍照
不问归期的博客
06-21 3292
开发环境： 主机：Ubuntu 18.04 开发板：OK3568-C开发板Video for Linuxtwo(Video4Linux2)简称V4L2，是V4L的改进版。V4L2是linux操作系统下用于采集图片、视频和音频数据的API接口，配合适当的视频采集设备和相应的驱动程序，可以实现图片、视频、音频等的采集。在远程会议、可视电话、视频监控系统和嵌入式多媒体终端中都有广泛的应用。本文将基于V4L2使用usb摄像头(UVC)拍照。1.配置内核 进入内核目录，配置linux内核 2.启用摄像头支持最后一步时
基于linux 的v4l2 拍照摄像经典应用
08-18
在嵌入式linux系统中用于拍摄摄像是基于v4l2库进行的。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值