File mainwindow.h

File List > src > mainwindow.h

Go to the documentation of this file

/*******************************************************
 * Author: Intelligent Medical Systems
 * License: see LICENSE.md file
 *******************************************************/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QApplication>
#include <QCloseEvent>
#include <QGraphicsScene>
#include <QMainWindow>
#include <boost/asio.hpp>
#include <boost/thread.hpp>

#include "cameraInterface.h"
#include "display.h"
#include "widgets.h"
#include "xiAPIWrapper.h"

namespace Ui
{
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

  public:
    explicit MainWindow(QWidget *parent = nullptr, const std::shared_ptr<XiAPIWrapper> &xiAPIWrapper = nullptr);

    ~MainWindow() override;

    bool GetNormalize() const;

    virtual unsigned GetBand() const;

    virtual int GetSaturationMinValue() const;

    virtual int GetSaturationMaxValue() const;

    unsigned GetBGRNorm() const;

    void EnableUi(bool enable) const;

    void SetUpCustomUiComponents() const;

    static void EnableWidgetsInLayout(const QLayout *layout, bool enable);

    void WriteLogHeader() const;

    QString LogMessage(const QString &message, const QString &logFile, bool logTime) const;

    QString GetLogFilePath(const QString &logFile) const;

    QMap<QString, float> GetCameraTemperature() const;

    void DisplayCameraTemperature() const;

    void ScheduleTemperatureThread();

    void StartTemperatureThread();

    void StopTemperatureThread();

    void HandleTemperatureTimer(const boost::system::error_code &error);

    void StopSnapshotsThread();

    void UpdateFPSLCDDisplay() const;

    void UpdateRawViewerImage(const QImage &image);

    void ViewerWorkerThreadFunc();

    static void UpdateImage(QImage image, const QGraphicsView *view, std::unique_ptr<QGraphicsPixmapItem> &pixmapItem,
                            QGraphicsScene *scene);

    bool IsSaturationButtonChecked() const;

    Ui::MainWindow *GetUI() const
    {
        return ui;
    }

    void SetRecordedCount(int count);

    void DisplayRecordCount() const;

  protected:
    Ui::MainWindow *ui;

    b2nd_array_t *m_viewerNDArray = nullptr;

    void closeEvent(QCloseEvent *event) override;

  signals:
    void ViewerImageProcessingComplete(QImage image);

  public slots:
    void UpdateRGBImage(const QImage &image);

    void UpdateRawImage(const QImage &image);

    void UpdateSaturationPercentageLCDDisplays(double percentageBelowThreshold, double percentageAboveThreshold) const;

  private slots:

    void HandleSnapshotToolButtonClicked();

    void HandleExposureValueChanged(int value) const;

    void HandleViewerImageSliderValueChanged(int value);

    void HandleRecordButtonClicked(bool clicked);

    void SetRecordButtonIcons(bool isRecording) const;

    void HandleBaseFolderButtonClicked();

    void HandleViewerFileButtonClicked();

    void HandleFileNameLineEditTextEdited(const QString &newText);

    void HandleAutoexposureToolButtonClicked(bool setAutoexposure) const;

    void HandleBandSelectorToolButtonClicked() const;

    void HandleRGBNormToolButtonClicked() const;

    void HandleSnapshotToolButtonArrowClicked() const;

    void HandleWhiteBalanceButtonClicked();

    void HandleDarkCorrectionButtonClicked();

    void HandleLogTextLineEditTextEdited(const QString &newText) const;

    void HandleLogTextLineEditReturnPressed();

    void HandleSkipFramesSpinBoxValueChanged() const;

    void HandleCameraListComboBoxCurrentIndexChanged(int index);

    void HandleReloadCamerasToolButtonClicked();

    int HandleFileNameSnapshotsLineEditTextEdited(const QString &newText);

    void HandleBaseFolderLineEditTextEdited(const QString &newText);

    void HandleViewerFileLineEditTextEdited(const QString &newText) const;

    void HandleViewerFileLineEditReturnPressed();

    void HandleReloadViewerFileToolButtonClicked();

    void HandleSaturationToolButtonArrowClicked() const;

    void HandleSaturationMinValueChanged(int value) const;

    void HandleSaturationMaxValueChanged(int value) const;

    void HandleSaturationDarkColorChanged(const QColor &color) const;

    void HandleSaturationSaturatedColorChanged(const QColor &color) const;

    void HandleRgbChannelToolButtonClicked() const;

    void HandleAboutActionTriggered();

    static void HandleDocumentationActionTriggered();

    void HandleHowToCiteActionTriggered();

  private:
    void SetUpConnections();

    static void HandleConnectionResult(bool status, const char *file, int line, const char *func);

    void RecordReferenceImages(const QString &referenceType);

    void StopReferenceRecordingThread();

    static void UpdateComponentEditedStyle(QLineEdit *lineEdit, const QString &newString,
                                           const QString &originalString);

    static void RestoreLineEditStyle(QLineEdit *lineEdit);

    void Display();

    void StartRecording();

    void StopRecording();

    void StartPollingThread();

    void StopPollingThread();

    static void CreateFolderIfNecessary(const QString &folder);

    void RecordImage(bool ignoreSkipping);

    void ThreadedRecordImage();

    void InitializeImageFileRecorder(std::string subFolder = "", std::string fileName = "");

    static bool ImageShouldBeRecorded(int nSkipFrames, long ImageID);

    void CountImages();

    void UpdateTimer();

    void StopTimer() const;

    void RecordSnapshots();

    void CaptureAndStoreSnapshotImage(FileImage &snapshotsFile, int currentIndex, int totalImages);

    std::unique_ptr<FileImage> OpenFileForSnapshots(const QString &filePath);

    static void ShowErrorDialog(const QString &text, const QString &informativeText);

    void ToggleSnapshotUI(bool enabled) const;

    void ResetSnapshotUI() const;

    void UpdateExposure() const;

    void HandleElementsWhileRecording(bool recordingInProgress) const;

    QString GetWritingFolder() const;

    QString GetFullFilenameStandardFormat(std::string &&fileName, const std::string &extension,
                                          std::string &&subFolder) const;

    QString GetBaseFolder() const;

    void StartImageAcquisition(QString cameraIdentifier);

    void StopImageAcquisition();

    static QString FormatTimeStamp(const QString &timestamp);

    void OpenFileInViewer(const QString &filePath);

    void ProcessViewerImageSliderValueChanged(int value);

    void SetGraphicsViewScene() const;

    void RegisterTimeImageRecorded();

    static void ShowPopupOnToolButtonInteraction(const QWidget *button, QWidget *popup, int popupWidth, int popupHeight,
                                                 bool centerAlign);

    void HandleCameraSpecificUiComponents(const QString &cameraType, const QString &cameraModel) const;

    QString m_fileName;

    QString m_triggerText;

    QString m_baseFolderPath;

    QString m_viewerFilePath;

    QString m_labelExp;

    QString m_snapshotsFileName;

    QElapsedTimer m_elapsedTimer;

    double m_elapsedTime;

    QString m_elapsedTimeText;

    QTextStream m_elapsedTimeTextStream;

    QString m_minVhb;

    QString m_maxVhb;

    QString m_minSao2;

    QString m_maxSao2;

    ImageContainer m_imageContainer;

    CameraInterface m_cameraInterface;

    std::shared_ptr<XiAPIWrapper> m_xiAPIWrapper = std::make_shared<XiAPIWrapper>();

    Displayer *m_display;

    bool m_testMode;

    boost::thread m_imageContainerThread;

    boost::thread m_viewerThread;

    std::queue<int> m_viewerSliderQueue;

    boost::mutex m_mutexImageViewer;

    boost::condition_variable m_viewerQueueCondition;

    bool m_viewerThreadRunning;

    boost::asio::io_service m_IOService;

    std::unique_ptr<boost::asio::io_service::work> m_IOWork;

    boost::asio::io_service m_temperatureIOService;

    std::unique_ptr<boost::asio::io_service::work> m_temperatureIOWork;

    boost::thread_group m_threadGroup;

    boost::mutex m_mutexImageRecording;

    boost::thread m_temperatureThread;

    boost::thread m_snapshotsThread;

    boost::thread m_referenceRecordingThread;

    std::shared_ptr<boost::asio::steady_timer> m_temperatureThreadTimer;

    std::atomic<unsigned long> m_recordedCount;

    std::atomic<unsigned long> m_imageCounter;

    std::atomic<unsigned long> m_skippedCounter;

    std::deque<std::chrono::steady_clock::time_point> m_recordedTimestamps;

    std::unique_ptr<QGraphicsScene> m_rgbScene = std::make_unique<QGraphicsScene>(this);

    std::unique_ptr<QGraphicsScene> m_rawScene = std::make_unique<QGraphicsScene>(this);

    std::unique_ptr<QGraphicsScene> m_rawViewerScene = std::make_unique<QGraphicsScene>(this);

    std::unique_ptr<QGraphicsPixmapItem> m_rgbPixMapItem;

    std::unique_ptr<QGraphicsPixmapItem> m_rawPixMapItem;

    std::unique_ptr<QGraphicsPixmapItem> m_rawViewerPixMapItem;

    QTimer *m_updateFPSDisplayTimer;

    QSliderPopup *m_bandSelectorSliderPopup;

    QSliderPopup *m_rgbNormSliderPopup;

    QLineSpinPopup *m_snapshotPopup;

    QDoubleSpinBoxesWithColorPickersPopup *m_saturationSpinBoxesPopup;

    QRgbChannelSpinBoxesPopup *m_rgbChannelSpinBoxesPopup;
};

#endif // MAINWINDOW_H