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类来实现线程存储图像，具体操作可以参考以下代码：

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

class ImageThread : public QThread
{
    Q_OBJECT

public:
    ImageThread(cv::Mat image, QString filename)
        : m_image(image), m_filename(filename)
    {}

signals:
    void imageSaved(QString filename);

protected:
    void run() override
    {
        // 在子线程中进行图像处理
        cv::cvtColor(m_image, m_image, cv::COLOR_BGR2GRAY);

        // 存储图像
        cv::imwrite(m_filename.toStdString(), m_image);

        // 发送信号通知主线程图像已保存
        emit imageSaved(m_filename);
    }

private:
    cv::Mat m_image;
    QString m_filename;
};

在主线程中，可以这样使用：

cv::Mat image = cv::imread("image.jpg");

ImageThread* thread = new ImageThread(image, "image_gray.jpg");
connect(thread, &ImageThread::imageSaved, [=](QString filename) {
    qDebug() << "Image saved:" << filename;
});

thread->start();

这样就可以在子线程中进行图像处理和存储，而不会阻塞主线程。