add video support

BrainATUMtome/BrainATUMtome.pro

@@ -29,14 +29,22 @@ SOURCES += \
     driverepos.cpp \
     driverserialport.cpp \
     driversyringe.cpp \
-    drivermicrotome.cpp
+    drivermicrotome.cpp \
+    videoproducer.cpp \
+    videoconverter.cpp \
+    videoviewer.cpp \
+    videowriter.cpp
 
 HEADERS += \
         mainwindow.h \
     driverepos.h \
     driverserialport.h \
     driversyringe.h \
-    drivermicrotome.h
+    drivermicrotome.h \
+    videoproducer.h \
+    videoconverter.h \
+    videoviewer.h \
+    videowriter.h
 
 FORMS += \
         mainwindow.ui

BrainATUMtome/mainwindow.cpp

@@ -108,6 +108,36 @@ MainWindow::MainWindow(QWidget *parent) :
     connect(ui->pushButton_dsy_pump, &QPushButton::clicked, m_driverSyringe, &DriverSyringe::on_uirequest_pump);
 
 
+    /* --- configure VideoProducer --- */
+    m_videoProducer =  new VideoProducer(nullptr);
+    m_thread_videoProducer = new QThread(this);
+    m_videoProducer->moveToThread(m_thread_videoProducer);
+    connect(m_thread_videoProducer, &QThread::finished, m_videoProducer, &VideoProducer::deleteLater);
+    m_thread_videoProducer->start();
+
+
+    /* --- configure VideoConverter --- */
+    m_videoConverter = new VideoConverter(nullptr);
+    m_thread_videoConverter = new QThread(this);
+    m_videoConverter->moveToThread(m_thread_videoConverter);
+    connect(m_thread_videoConverter, &QThread::finished, m_videoConverter, &VideoConverter::deleteLater);
+    m_thread_videoConverter->start();
+
+    /* --- configure VideoWriter --- */
+    m_videoWriter = new VideoWriter(nullptr);
+    m_thread_videoWriter = new QThread(this);
+    m_videoWriter->moveToThread(m_thread_videoWriter);
+    connect(m_thread_videoWriter, &QThread::finished, m_videoWriter, &VideoWriter::deleteLater);
+    m_thread_videoWriter->start();
+
+    /* --- connect Video Signal/Slots --- */
+    connect(ui->pushButton_dvs_record, &QPushButton::clicked, m_videoProducer, &VideoProducer::start);
+    connect(ui->pushButton_dvs_snap, &QPushButton::clicked, m_videoProducer, &VideoProducer::stop);
+    connect(m_videoProducer, &VideoProducer::frameReady, m_videoConverter, &VideoConverter::on_convertFrame);
+    connect(m_videoConverter, &VideoConverter::pixmapReady, ui->widget_videoViewer, &VideoViewer::on_pixmapReady);
+
+    //connect(m_videoProducer, &VideoProducer::error, this, &MainWindow::on_error_throw);
+    //connect(m_videoWriter, &VideoWriter::error, this, &MainWindow::on_error_throw);
 
 }
 
@@ -125,6 +155,18 @@ MainWindow::~MainWindow()
     m_thread_driverSyringe->quit();
     m_thread_driverSyringe->wait();
 
+    // destroy VideoProducer thread
+    m_thread_videoProducer->quit();
+    m_thread_videoProducer->wait();
+
+    // destroy VideoConverter thread
+    m_thread_videoConverter->quit();
+    m_thread_videoConverter->wait();
+
+    // destroy VideoWriter thread
+    m_thread_videoWriter->quit();
+    m_thread_videoWriter->wait();
+
     delete ui;
 }
 
@@ -202,3 +244,9 @@ void MainWindow::on_lineEdit_dep_velocity_returnPressed()
 
     command_DriverEpos(true);
 }
+
+
+void MainWindow::on_error_throw(const QString &errorSource, const QString &errorMessage)
+{
+    qDebug() << errorSource << "::Error, " << errorMessage;
+}

BrainATUMtome/mainwindow.h

@@ -9,6 +9,10 @@
 #include "driverepos.h"
 #include "drivermicrotome.h"
 #include "driversyringe.h"
+#include "videoproducer.h"
+#include "videoconverter.h"
+#include "videowriter.h"
+#include "videoviewer.h"
 
 namespace Ui {
 class MainWindow;
@@ -28,20 +32,23 @@ class MainWindow : public QMainWindow
     DriverEpos *m_driverEpos;
     DriverMicrotome *m_driverMicrotome;
     DriverSyringe *m_driverSyringe;
+    VideoProducer *m_videoProducer;
+    VideoConverter *m_videoConverter;
+    VideoWriter *m_videoWriter;
 
     QThread *m_thread_driverEpos;
     QThread *m_thread_driverMicrotome;
     QThread *m_thread_driverSyringe;
-
-
-
+    QThread *m_thread_videoProducer;
+    QThread *m_thread_videoConverter;
+    QThread *m_thread_videoWriter;
 
     void command_DriverEpos(bool state);
 
 private slots:
+    void on_error_throw(const QString &errorSource, const QString &errorMessage);
     void on_pushButton_dep_run_clicked();
     void on_pushButton_dmt_cut_clicked();
-
     void on_lineEdit_dep_velocity_returnPressed();
 
 signals:

BrainATUMtome/mainwindow.ui

@@ -191,7 +191,7 @@
      </widget>
     </item>
     <item row="0" column="1" rowspan="2">
-     <widget class="QWidget" name="widget" native="true"/>
+     <widget class="VideoViewer" name="widget_videoViewer" native="true"/>
     </item>
     <item row="1" column="0">
      <widget class="QGroupBox" name="groupBox_microtome">
@@ -481,6 +481,14 @@
   <widget class="QStatusBar" name="statusBar"/>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
+ <customwidgets>
+  <customwidget>
+   <class>VideoViewer</class>
+   <extends>QWidget</extends>
+   <header>videoviewer.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
  <resources/>
  <connections/>
 </ui>

BrainATUMtome/videoconverter.cpp

@@ -0,0 +1,26 @@
+#include "videoconverter.h"
+
+VideoConverter::VideoConverter(QObject *parent) : QObject(parent)
+{
+
+}
+
+void VideoConverter::on_convertFrame(const cv::Mat &frame)
+{
+    cv::Mat frame_cv = frame;
+    QPixmap pixmap;
+
+    cv::resize(frame_cv, frame_cv, cv::Size(), 0.5, 0.5, cv::INTER_AREA);
+    cv::cvtColor(frame_cv, frame_cv, CV_BGR2RGB);
+    const QImage frame_qt(frame_cv.data,
+                          frame_cv.cols,
+                          frame_cv.rows,
+                          static_cast<int>(frame_cv.step),
+                          QImage::Format_RGB888);
+
+
+    pixmap = QPixmap::fromImage(frame_qt);
+
+    //emit imageReady(frame_qt);
+    emit pixmapReady(pixmap);
+}

BrainATUMtome/videoconverter.h

@@ -0,0 +1,25 @@
+#ifndef VIDEOCONVERTER_H
+#define VIDEOCONVERTER_H
+
+#include <QObject>
+#include <QImage>
+#include <QPixmap>
+#include <opencv2/opencv.hpp>
+
+class VideoConverter : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit VideoConverter(QObject *parent = nullptr);
+
+public slots:
+    void on_convertFrame(const cv::Mat &frame);
+
+signals:
+    //void imageReady(const QImage &frame);
+    void pixmapReady(const QPixmap &pixmap);
+
+};
+
+#endif // VIDEOCONVERTER_H

BrainATUMtome/videoproducer.cpp

@@ -0,0 +1,69 @@
+#include "videoproducer.h"
+
+VideoProducer::VideoProducer(QObject *parent) : QObject(parent),
+    m_frameIndex(0),
+    m_frameWidth(0),
+    m_frameHeight(0),
+    m_fps(0.0)
+{
+    qRegisterMetaType<cv::Mat>();
+
+    // configure state machine
+    m_producer = new QStateMachine(this);
+    QState *state_idle = new QState(m_producer);
+    QState *state_acquire = new QState(m_producer);
+    state_idle->addTransition(this, &VideoProducer::start, state_acquire);
+    state_acquire->addTransition(this, &VideoProducer::stop, state_idle);
+    state_acquire->addTransition(this, &VideoProducer::frameReady, state_acquire);
+    connect(state_acquire, &QState::entered, this, &VideoProducer::on_readFrame);
+    m_producer->setInitialState(state_idle);
+    m_producer->start();
+
+    // configure video capture
+    m_videoCapture = new cv::VideoCapture(0);
+    if (!m_videoCapture->isOpened())
+    {
+        m_producer->stop();
+        error("VideoProducer", "failed to open video capture device");
+        return;
+    }
+
+    // share frame properties
+    m_fps = m_videoCapture->get(CV_CAP_PROP_FPS);
+    m_frameWidth = static_cast<qint32>(m_videoCapture->get(CV_CAP_PROP_FRAME_WIDTH));
+    m_frameHeight = static_cast<qint32>(m_videoCapture->get(CV_CAP_PROP_FRAME_HEIGHT));
+    connect(this, &VideoProducer::start, [this](){emit frameProperties(m_fps, m_frameWidth, m_frameHeight);});
+}
+
+
+
+VideoProducer::~VideoProducer()
+{
+    if (m_producer->isRunning())
+        m_producer->stop();
+
+    if (m_videoCapture->isOpened())
+        m_videoCapture->release();
+    delete m_videoCapture;
+}
+
+
+
+void VideoProducer::on_readFrame()
+{
+    cv::Mat frame;
+
+    QCoreApplication::processEvents();
+
+    if (!m_videoCapture->read(frame))
+    {
+        m_producer->stop();
+        error("VideoProducer", "failed to read next frame");
+        return;
+    }
+
+    m_frameIndex++;
+
+    emit frameIndex(m_frameIndex);
+    emit frameReady(frame);
+}

BrainATUMtome/videoproducer.h

@@ -0,0 +1,40 @@
+#ifndef VIDEOPRODUCER_H
+#define VIDEOPRODUCER_H
+
+#include <QObject>
+#include <QCoreApplication>
+#include <QStateMachine>
+#include <opencv2/opencv.hpp>
+#include <QDebug>
+
+class VideoProducer : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit VideoProducer(QObject *parent = nullptr);
+    ~VideoProducer();
+
+private:
+    quint32 m_frameIndex;
+    qint32 m_frameWidth;
+    qint32 m_frameHeight;
+    double m_fps;
+    cv::VideoCapture *m_videoCapture;
+    QStateMachine *m_producer;
+
+private slots:
+    void on_readFrame();
+
+signals:
+    void start();
+    void stop();
+    void frameIndex(quint32 index);
+    void frameReady(const cv::Mat &frame);
+    void frameProperties(double fps, int width, int height);
+    void error(const QString &errorSource, const QString &errorMessage);
+};
+
+Q_DECLARE_METATYPE(cv::Mat)
+
+#endif // VIDEOPRODUCER_H

BrainATUMtome/videoviewer.cpp

@@ -0,0 +1,15 @@
+#include "videoviewer.h"
+
+VideoViewer::VideoViewer(QWidget *parent) : QGraphicsView (parent)
+{
+    m_scene = new QGraphicsScene(this);
+    m_pixmap = new QGraphicsPixmapItem();
+    this->setScene(m_scene);
+    m_scene->addItem(m_pixmap);
+}
+
+void VideoViewer::on_pixmapReady(const QPixmap &pixmap)
+{
+    m_pixmap->setPixmap(pixmap);
+    this->fitInView(m_pixmap, Qt::KeepAspectRatio);
+}

BrainATUMtome/videoviewer.h

@@ -0,0 +1,26 @@
+#ifndef VIDEOVIEWER_H
+#define VIDEOVIEWER_H
+
+#include <QObject>
+#include <QWidget>
+#include <QGraphicsView>
+#include <QGraphicsScene>
+#include <QGraphicsPixmapItem>
+
+class VideoViewer : public QGraphicsView
+{
+    Q_OBJECT
+
+public:
+    explicit VideoViewer(QWidget *parent = nullptr);
+
+private:
+    QGraphicsScene *m_scene;
+    QGraphicsPixmapItem *m_pixmap;
+
+public slots:
+    void on_pixmapReady(const QPixmap &image);
+
+};
+
+#endif // VIDEOVIEWER_H