使用 QImage::scanLine 会强制进行深度复制，因此至少应该使用 constScanLine，或者更好的方法是将槽的签名更改为：
void widget::set_image(const QImage & image);
当然，你面临的问题变成了另外一件事情：QImage实例指向在另一个线程中存在并且可能会随时更改的帧数据。
有一个解决方案：需要使用分配在堆上的新鲜帧，并且需要在QImage中捕获帧。使用QScopedPointer防止内存泄漏，直到QImage拥有该帧。
static void matDeleter(void* mat) { delete static_cast<cv::Mat*>(mat); }
class capture {
Q_OBJECT
bool m_enable;
...
public:
Q_SIGNAL void image_ready(const QImage &);
...
};
void capture::start_process() {
m_enable = true;
while(m_enable) {
QScopedPointer<cv::Mat> frame(new cv::Mat);
if (!m_video_handle->read(*frame)) {
break;
}
cv::cvtColor(*frame, *frame, CV_BGR2RGB);
const QImage image(frame->data, frame->cols, frame->rows, frame->step,
QImage::Format_RGB888, matDeleter, frame.take());
emit image_ready(image);
cv::waitKey(30);
}
}
当然，由于Qt在一个QThread中默认提供本地消息分发和Qt事件循环，因此使用QObject进行捕获处理非常简单。以下是一个完整的、经过测试的示例。
捕获、转换和查看器都在自己的线程中运行。由于cv::Mat是一个具有原子、线程安全访问的隐式共享类，因此被用作这样。
转换器可以选择不处理陈旧的帧——如果只为显示目的进行转换，则非常有用。
查看器在GUI线程中运行，并正确丢弃陈旧的帧。查看器永远不需要处理陈旧的帧。
如果您要收集数据以保存到磁盘上，应该以高优先级运行捕获线程。您还应该检查OpenCV api，看看是否有一种方法可以将本机相机数据转储到磁盘上。
为了加速转换，您可以使用OpenCV中的gpu加速类。
下面的示例确保仅在必要时才重新分配内存以进行复制：Capture类维护其自己的帧缓冲区，该缓冲区在每个后续帧中重复使用，Converter也是如此，ImageViewer也是如此。
除了在cv::VideoCatprure::read内部发生的任何事情之外，图像数据还进行了两次深度复制：
1.复制到转换器的QImage中。
2.复制到ImageViewer的QImage中。
这两个副本都需要确保线程之间的解耦，并防止由于需要分离引用计数大于1的cv::Mat或QImage而导致数据重新分配。在现代架构上，内存复制非常快。
由于所有图像缓冲区都保持在相同的内存位置，因此它们的性能是最优的——它们保持分页并缓存。
AddressTracker用于跟踪内存重新分配以进行调试。
#include <QtWidgets>
#include <algorithm>
#include <opencv2/opencv.hpp>
Q_DECLARE_METATYPE(cv::Mat)
struct AddressTracker {
const void *address = {};
int reallocs = 0;
void track(const cv::Mat &m) { track(m.data); }
void track(const QImage &img) { track(img.bits()); }
void track(const void *data) {
if (data && data != address) {
address = data;
reallocs ++;
}
}
};
Capture 类会将捕获到的帧填充至内部帧缓冲区，同时通知帧变更。该类的用户属性为帧。
class Capture : public QObject {
Q_OBJECT
Q_PROPERTY(cv::Mat frame READ frame NOTIFY frameReady USER true)
cv::Mat m_frame;
QBasicTimer m_timer;
QScopedPointer<cv::VideoCapture> m_videoCapture;
AddressTracker m_track;
public:
Capture(QObject *parent = {}) : QObject(parent) {}
~Capture() { qDebug() << __FUNCTION__ << "reallocations" << m_track.reallocs; }
Q_SIGNAL void started();
Q_SLOT void start(int cam = {}) {
if (!m_videoCapture)
m_videoCapture.reset(new cv::VideoCapture(cam));
if (m_videoCapture->isOpened()) {
m_timer.start(0, this);
emit started();
}
}
Q_SLOT void stop() { m_timer.stop(); }
Q_SIGNAL void frameReady(const cv::Mat &);
cv::Mat frame() const { return m_frame; }
private:
void timerEvent(QTimerEvent * ev) {
if (ev->timerId() != m_timer.timerId()) return;
if (!m_videoCapture->read(m_frame)) {
m_timer.stop();
return;
}
m_track.track(m_frame);
emit frameReady(m_frame);
}
};
Converter类将传入的帧转换为缩小的QImage用户属性。它会通知图像更新。为了防止内存重新分配，图像被保留下来。processAll属性选择是否转换所有帧，或者只转换最近的一个，如果有多个被排队。
class Converter : public QObject {
Q_OBJECT
Q_PROPERTY(QImage image READ image NOTIFY imageReady USER true)
Q_PROPERTY(bool processAll READ processAll WRITE setProcessAll)
QBasicTimer m_timer;
cv::Mat m_frame;
QImage m_image;
bool m_processAll = true;
AddressTracker m_track;
void queue(const cv::Mat &frame) {
if (!m_frame.empty()) qDebug() << "Converter dropped frame!";
m_frame = frame;
if (! m_timer.isActive()) m_timer.start(0, this);
}
void process(const cv::Mat &frame) {
Q_ASSERT(frame.type() == CV_8UC3);
int w = frame.cols / 3.0, h = frame.rows / 3.0;
if (m_image.size() != QSize{w,h})
m_image = QImage(w, h, QImage::Format_RGB888);
cv::Mat mat(h, w, CV_8UC3, m_image.bits(), m_image.bytesPerLine());
cv::resize(frame, mat, mat.size(), 0, 0, cv::INTER_AREA);
cv::cvtColor(mat, mat, CV_BGR2RGB);
emit imageReady(m_image);
}
void timerEvent(QTimerEvent *ev) {
if (ev->timerId() != m_timer.timerId()) return;
process(m_frame);
m_frame.release();
m_track.track(m_frame);
m_timer.stop();
}
public:
explicit Converter(QObject * parent = nullptr) : QObject(parent) {}
~Converter() { qDebug() << __FUNCTION__ << "reallocations" << m_track.reallocs; }
bool processAll() const { return m_processAll; }
void setProcessAll(bool all) { m_processAll = all; }
Q_SIGNAL void imageReady(const QImage &);
QImage image() const { return m_image; }
Q_SLOT void processFrame(const cv::Mat &frame) {
if (m_processAll) process(frame); else queue(frame);
}
};
ImageViewer控件相当于存储pixmap的QLabel。图像是查看器的用户属性。传入的图像将被深度复制到用户属性中，以防止内存重新分配。
class ImageViewer : public QWidget {
Q_OBJECT
Q_PROPERTY(QImage image READ image WRITE setImage USER true)
bool painted = true;
QImage m_img;
AddressTracker m_track;
void paintEvent(QPaintEvent *) {
QPainter p(this);
if (!m_img.isNull()) {
setAttribute(Qt::WA_OpaquePaintEvent);
p.drawImage(0, 0, m_img);
painted = true;
}
}
public:
ImageViewer(QWidget * parent = nullptr) : QWidget(parent) {}
~ImageViewer() { qDebug() << __FUNCTION__ << "reallocations" << m_track.reallocs; }
Q_SLOT void setImage(const QImage &img) {
if (!painted) qDebug() << "Viewer dropped frame!";
if (m_img.size() == img.size() && m_img.format() == img.format()
&& m_img.bytesPerLine() == img.bytesPerLine())
std::copy_n(img.bits(), img.sizeInBytes(), m_img.bits());
else
m_img = img.copy();
painted = false;
if (m_img.size() != size()) setFixedSize(m_img.size());
m_track.track(m_img);
update();
}
QImage image() const { return m_img; }
};
演示实例化了上面描述的类，并在专用线程中运行捕获和转换操作。
class Thread final : public QThread { public: ~Thread() { quit(); wait(); } };
int main(int argc, char *argv[])
{
qRegisterMetaType<cv::Mat>();
QApplication app(argc, argv);
ImageViewer view;
Capture capture;
Converter converter;
Thread captureThread, converterThread;
converter.setProcessAll(false);
captureThread.start();
converterThread.start();
capture.moveToThread(&captureThread);
converter.moveToThread(&converterThread);
QObject::connect(&capture, &Capture::frameReady, &converter, &Converter::processFrame);
QObject::connect(&converter, &Converter::imageReady, &view, &ImageViewer::setImage);
view.show();
QObject::connect(&capture, &Capture::started, [](){ qDebug() << "Capture started."; });
QMetaObject::invokeMethod(&capture, "start");
return app.exec();
}
#include "main.moc"
这是完整示例的结束。请注意：之前版本的答案不必要地重新分配了图像缓冲区。
