c++ opencv添加线程存储图像

可以使用C++11的std::thread库来实现多线程存储图像，具体代码如下：

#include <iostream>
#include <thread>
#include <opencv2/opencv.hpp>

using namespace std;
using namespace cv;

void saveImage(Mat image, string filename) {
    imwrite(filename, image);
}

int main() {
    Mat image = imread("test.jpg");
    thread t(saveImage, image, "test_thread.jpg");
    t.join();
    return 0;
}

在这个例子中，我们使用了OpenCV库来读取图像，然后使用std::thread库来创建一个新的线程来保存图像。我们将保存图像的函数作为线程的入口点，并将图像和文件名作为参数传递给该函数。最后，我们使用join()函数等待线程完成。

相关问题

c++ qt opencv利用线程存储图像

可以使用Qt的QThread类来实现线程，利用OpenCV的VideoCapture类获取摄像头的图像，然后将图像存储到一个缓冲区中，最后在主线程中将缓冲区中的图像显示出来。以下是示例代码：

#include <QThread>
#include <QMutex>
#include <QImage>
#include <opencv2/opencv.hpp>

class CameraThread : public QThread
{
    Q_OBJECT

public:
    CameraThread(QObject *parent = nullptr);
    ~CameraThread();

    void stop();

signals:
    void imageReady(const QImage &image);

protected:
    void run() override;

private:
    QMutex m_mutex;
    bool m_stopped;
};

CameraThread::CameraThread(QObject *parent)
    : QThread(parent)
    , m_stopped(false)
{
}

CameraThread::~CameraThread()
{
    stop();
    wait();
}

void CameraThread::stop()
{
    m_mutex.lock();
    m_stopped = true;
    m_mutex.unlock();
}

void CameraThread::run()
{
    cv::VideoCapture cap(0);
    if (!cap.isOpened()) {
        qDebug() << "Failed to open camera";
        return;
    }

    while (true) {
        m_mutex.lock();
        if (m_stopped) {
            m_mutex.unlock();
            break;
        }
        m_mutex.unlock();

        cv::Mat frame;
        cap >> frame;
        if (frame.empty()) {
            qDebug() << "Failed to capture frame";
            continue;
        }

        QImage image(frame.data, frame.cols, frame.rows, frame.step, QImage::Format_RGB888);
        image = image.rgbSwapped();
        emit imageReady(image);
    }
}

在主线程中，可以将CameraThread的imageReady信号连接到一个槽函数中，将图像显示出来：

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void onImageReady(const QImage &image);

private:
    Ui::MainWindow *ui;
    CameraThread *m_cameraThread;
};

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
    , m_cameraThread(new CameraThread(this))
{
    ui->setupUi(this);

    connect(m_cameraThread, &CameraThread::imageReady, this, &MainWindow::onImageReady);

    m_cameraThread->start();
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::onImageReady(const QImage &image)
{
    ui->label->setPixmap(QPixmap::fromImage(image));
}

这样就可以利用线程存储图像并显示了。

c++ qt opencv读图后对图像进行操作利用线程存储图像

可以使用Qt的QThread类来实现多线程读取和处理图像，同时利用OpenCV库对图像进行操作。以下是一个简单的示例代码：

#include <QApplication>
#include <QThread>
#include <QMutex>
#include <QImage>
#include <opencv2/opencv.hpp>

class ImageProcessor : public QObject
{
    Q_OBJECT

public:
    ImageProcessor(QObject *parent = nullptr) : QObject(parent) {}

public slots:
    void processImage(const QString &filename)
    {
        cv::Mat image = cv::imread(filename.toStdString());

        // 对图像进行操作
        cv::cvtColor(image, image, cv::COLOR_BGR2GRAY);
        cv::GaussianBlur(image, image, cv::Size(5, 5), 0);

        // 将处理后的图像转换为QImage格式
        QImage qimage(image.data, image.cols, image.rows, image.step, QImage::Format_Grayscale8);

        emit imageProcessed(qimage);
    }

signals:
    void imageProcessed(const QImage &image);
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    ImageProcessor processor;
    QThread thread;
    processor.moveToThread(&thread);
    thread.start();

    QObject::connect(&processor, &ImageProcessor::imageProcessed, [](const QImage &image) {
        // 在主线程中显示图像
        QLabel label;
        label.setPixmap(QPixmap::fromImage(image));
        label.show();
    });

    // 在主线程中发送图像处理请求
    QMetaObject::invokeMethod(&processor, "processImage", Qt::QueuedConnection, Q_ARG(QString, "image.jpg"));

    return app.exec();
}

#include "main.moc"

这个例子中，我们创建了一个ImageProcessor类，它继承自QObject，并包含一个processImage()槽函数，用于读取和处理图像。在主函数中，我们创建了一个QThread对象，并将ImageProcessor对象移动到该线程中。然后，我们连接了ImageProcessor对象的imageProcessed()信号到一个lambda表达式中，用于在主线程中显示处理后的图像。最后，我们使用QMetaObject::invokeMethod()函数在主线程中发送图像处理请求。