CameraWidget.h

#ifndef CAMERAWIDGET_H
#define CAMERAWIDGET_H

#include <memory>

#include <QAction>
#include <QCamera>
#include <QCameraInfo>
#include <QFont>
#include <QLineF>
#include <QMainWindow>
#include <QMessageBox>
#include <QMouseEvent>
#include <QPainter>
#include <QThread>

#include "ERWidget.h"

#include "opencv2/calib3d.hpp"
#include "opencv2/imgproc.hpp"

#include "Camera.h"
#include "CameraCalibration.h"
#include "EyeImageProcessor.h"
#include "FieldImageProcessor.h"
#include "ImageProcessor.h"

#include "DataRecorder.h"

#include "Synchronizer.h"

#include "utils.h"

#include "Overlay.h"

namespace Ui {
class CameraWidget;
}

class CameraWidget : public ERWidget, InputWidget {
    Q_OBJECT

public:
    CameraWidget(QString id, ImageProcessor::Type type, QWidget* parent = nullptr);
    ~CameraWidget() override;

signals:
    void setCamera(QCameraInfo cameraInfo);
    void newROI(QPointF sROI, QPointF eROI);
    void newMaxRadius(double maxRadius);
    void newData(EyeData data);
    void newData(FieldData data);
    void newClick(Timestamp, QPoint, QSize);
    void injectFrame(Timestamp t, const cv::Mat& frame);

public slots:
    void preview(Timestamp t, const cv::Mat& frame);
    void preview(EyeData data);
    void preview(FieldData data);
    void preview(const DataTuple& data);
    void options(QAction* action);
    void noCamera(QString msg);

    void startRecording() override;
    void stopRecording() override;
    void startRecordingWithoutVideo();

    void mousePressEvent(QMouseEvent* event) override;
    void mouseReleaseEvent(QMouseEvent* event) override;
    void mouseMoveEvent(QMouseEvent* event) override;

    void validatePoint(QPointF& point);

    void requestCameraCalibrationSample() { cameraCalibrationSampleRequested = true; }
    void sendCameraCalibrationSample(const cv::Mat& frame);
    void onCameraCalibrationFinished(bool success);

    void cameraChanged(QCameraInfo currentCamera, QCameraViewfinderSettings viewFinderSettings);

private:
    ImageProcessor::Type type;

    Ui::CameraWidget* ui;

    Camera* camera;
    QThread* cameraThread;

    ImageProcessor* imageProcessor;
    QThread* processorThread;

    DataRecorderThread* recorder;
    QThread* recorderThread;

    QActionGroup* optionsGroup;
    QAction* optionAction;

    MovingAverage<Timestamp> dtEstimator;
    Timestamp lastTimestamp;
    Timestamp lastFrameRateUpdate;
    void updateFrameRate(Timestamp t);

    QPointF sROI, eROI;
    void setROI(const QPointF& s, const QPointF& e)
    {
        sROI = s;
        eROI = e;
        emit newROI(sROI, eROI);
    }

    QLineF userMaxPupilRadius;
    double userMaxPupilRatio;

    Timestamp lastUpdate;
    Timestamp updateIntervalMs;
    Timestamp maxAgeMs;
    bool shouldUpdate(Timestamp t);
    bool isDataRecent(Timestamp t);

    QImage previewImage(const cv::Mat& frame);

    std::shared_ptr<CameraCalibration> cameraCalibration;
    bool cameraCalibrationSampleRequested;

    QString intrinsicsFileName;

    QSize frameSize = { 0, 0 };
    void updateWidgetSize(const int& width, const int& height);

    // Drawing functionality
    cv::Mat rgb, resized;
    EyeOverlay eyeOverlay;
    FieldOverlay fieldOverlay;
};

#endif // CAMERAWIDGET_H