关于c++:Qtopencv调用camera的简单应用

最近须要应用 opencv，就简略写了一个测试示例并记录下来。
其中 QCamera 等相干的类同样能够实现以后性能。

仓库

性能

• 反对有线或 IP 摄像头连贯
• 反对视频流播放
• 反对多分辨率设置
• 反对视频录制
• 反对拍照
• 视频抽帧、拍照、录制等由独单线程解决

测试可用的视频流

CCTV1  高清 http://ivi.bupt.edu.cn/hls/cctv1hd.m3u8
CCTV3  高清 http://ivi.bupt.edu.cn/hls/cctv3hd.m3u8
CCTV5+ 高清 http://ivi.bupt.edu.cn/hls/cctv5phd.m3u8
CCTV6  高清 http://ivi.bupt.edu.cn/hls/cctv6hd.m3u8

camara.h

#ifndef CAMARA_H
#define CAMARA_H

#include <QImage>
#include <QObject>
#include <QThread>
#include <QTimer>

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

Q_DECLARE_METATYPE(QImage);

/*
 *@brief Camara 在独自线程中实现视频抽帧、拍照及录像性能
 *@brief open、close 等是耗时操作，请保障在 Camara 线程工夫中实现调用（可思考异步槽函数、QMetaObject::invokeMethod）*/

class Camara : public QObject
{
    Q_OBJECT

public:
    Camara();
    ~Camara();

    bool isOpened()        const;
    bool isTakevideoed()   const;
    QString getSavePath()  const;
    QSize getResolutions() const;
    bool isTakeVideo()     const;

signals:
    void updateImage(QImage);
    void statusChanged(bool isOpen);

public slots:
    void openCamara(const QString &url);
    void openCamara(int index);
    void closeCamara();
    void takePicture();
    void takeVideo();
    void setSavePath(const QString &path);
    void setResolutions(const QSize &size);

private slots:
    void tbegin();
    void tend();
    void captureCamara();

private:
    QString m_savepath;
    QAtomicInteger<bool> m_isTakepicture = false;
    QAtomicInteger<bool> m_isTakevideo   = false;
    QAtomicInteger<bool> m_isflip        = false;

    QScopedPointer<cv::VideoCapture> m_capture;
    QScopedPointer<cv::VideoWriter>  m_writer;

    QTimer  *m_timer = nullptr;
    QThread m_thread;
};

#endif // CAMARA_H

#include "camara.h"

#include <QDateTime>

Camara::Camara()
{moveToThread(&m_thread);

    connect(&m_thread, &QThread::started,  this, &Camara::tbegin);
    connect(&m_thread, &QThread::finished, this, &Camara::tend);

    m_thread.start(QThread::HighPriority);
}

Camara::~Camara()
{m_thread.quit();
    m_thread.wait();}

void Camara::tbegin()
{m_capture.reset(new cv::VideoCapture);
    m_writer.reset(new cv::VideoWriter);
    m_timer = new QTimer(this);

    m_timer->setTimerType(Qt::PreciseTimer);

    connect(m_timer, &QTimer::timeout, this, &Camara::captureCamara);
}

void Camara::tend()
{closeCamara();
}

void Camara::openCamara(const QString &url)
{if (!m_capture->isOpened() && m_capture->open(url.toLatin1().data()))
    {
        m_isflip = false;

        m_timer->start(33);

        emit statusChanged(true);
    }
    else
    {emit statusChanged(false);
    }
}

void Camara::openCamara(int index)
{if (!m_capture->isOpened() && m_capture->open(index))
    {
        m_isflip = true;

        m_timer->start(33);

        emit statusChanged(true);
    }
    else
    {emit statusChanged(false);
    }
}

void Camara::closeCamara()
{m_timer->stop();

    if (m_writer->isOpened())
        m_writer->release();

    if (m_capture->isOpened())
        m_capture->release();}

void Camara::captureCamara()
{
    cv::Mat originalframe;
    cv::Mat flipframe;

    *m_capture >> originalframe;

    if (m_isflip)
        cv::flip(originalframe, flipframe, 1);
    else
        flipframe = originalframe;

    QImage img = QImage(flipframe.data, flipframe.cols, flipframe.rows, QImage::Format_RGB888).rgbSwapped();

    if (!img.isNull())
    {if (m_isTakepicture)
        {
            m_isTakepicture = !m_isTakepicture;

            QString name = m_savepath + QDateTime::currentDateTime().toString("yyyy-MM-hh hh_mm_ss") + ".jpeg";

            img.save(name, "jpeg");
        }

        if (m_isTakevideo)
        {*m_writer << flipframe;}

        updateImage(img);
    }

    originalframe.release();
    flipframe.release();}

void Camara::takePicture()
{m_isTakepicture = true;}

void Camara::takeVideo()
{if (!m_isTakevideo)
    {QString name =  m_savepath + QDateTime::currentDateTime().toString("yyyy-MM-hh hh_mm_ss") + ".avi";

        if (m_writer->open(name.toLatin1().data(), cv::VideoWriter::fourcc('M', 'J', 'P', 'G'), 30.0, cv::Size(m_capture->get(cv::CAP_PROP_FRAME_WIDTH), m_capture->get(cv::CAP_PROP_FRAME_HEIGHT)), true))
        {m_isTakevideo = true;}
    }
    else
    {
        m_isTakevideo = false;

        m_writer->release();}
}

void Camara::setSavePath(const QString &path)
{m_savepath = path + '/';}

void Camara::setResolutions(const QSize &size)
{if (m_capture->isOpened())
    {m_capture->set(cv::CAP_PROP_FRAME_WIDTH, size.width());
        m_capture->set(cv::CAP_PROP_FRAME_HEIGHT, size.height());
    }
}

QString Camara::getSavePath() const
{return m_savepath;}

bool Camara::isOpened() const
{return m_capture->isOpened();
}

bool Camara::isTakevideoed() const
{return m_isTakevideo;}

QSize Camara::getResolutions()  const
{
    QSize ret;

    ret.setWidth(m_capture->get(cv::CAP_PROP_FRAME_WIDTH));
    ret.setHeight(m_capture->get(cv::CAP_PROP_FRAME_HEIGHT));

    return ret;
}

bool Camara::isTakeVideo() const
{return m_writer->isOpened();
}