videoplayercontroller.h

#ifndef VIDEOPLAYERCONTROLLER_H
#define VIDEOPLAYERCONTROLLER_H
 
#include <QObject>  // used for signals and slots
#include <QTimer>   // used for periodic timer events to update displayed image
#include <QMessageBox>  // used to display error messages
 
#include <set>
#include <memory>
 
#include "DataManager.h"  // used to access image data for displaying and manipulation
 
#include "view/videoplayer.h"   // used to display images
#include "view/timeline.h"      // used to visualize keyframe distribution
 
#include "controller/ModelInputIterator.h"  // used to iterate over given image data
 
#include "controller/imageiterator.h"
#include "controller/modelinputiteratorfactory.h"
#include "view/reallydeletedialog.h"
 
#include "model/asyncimageloader.h"
#include "plugin/pluginthread.h"
 
#include "ipreview.h"
 
#include "cvmat_qmetadata.h"
 
#define ERROR_MSG_APPROX_COUNT 5
#define BOUDNARY_STATIONARY_DURATION 1000 // in ms
 
class VideoPlayerController : public QObject
{
    Q_OBJECT  // used to enable signals and slots for this class
 
public:
    explicit VideoPlayerController(QObject *parent = nullptr, VideoPlayer *player = nullptr, Timeline *timeline = nullptr, DataManager *dataManager = nullptr, std::shared_ptr<PluginThread> pluginThread = nullptr);
 
    ~VideoPlayerController();
 
    unsigned int getImageIndexOnScreen();
 
    void resetLayout();
 
    void setPreviewPlugin(const QString& previewPluginName);
 
    void clearPreviewPlugin();
 
public slots:
    void slot_play();
 
    void slot_showFirstImage();
 
    void slot_showLastImage();
 
    void slot_showPreviousImage();
 
    void slot_showNextImage();
 
    void slot_toggleKeyframe();
 
    void slot_toggleKeyframesOnly(bool checked);
 
    void slot_changeStepSize(unsigned int stepsize);
 
    void slot_changeIndex(unsigned int index);
 
    void slot_mipChanged();
 
    void slot_deleteKeyframes();
 
    void slot_deleteAllKeyframes();
 
    void slot_stopPlay();
 
    void slot_updateBoundaries(QPoint boundaries);
 
    void slot_resetBoundaries();
 
    void slot_redraw();
 
    void slot_refreshPreview(bool clearOldPreview);
 
signals:
 
    void sig_hasStatusMessage(QString message);
 
    void sig_toggleKeyframe(uint idx, bool isNowKeyframe);
 
    void sig_deleteKeyframes();
 
    void sig_deleteAllKeyframes();
 
    void sig_disablePreview();
 
private slots:
    void slot_timerNextImage();
    void slot_boundaryStopped();
    void slot_receiveImage(const ImageRequest &request, const ImageResult &result);
    void slot_receiveVisualization(const PreviewResult& result);
 
private:
    VideoPlayer *m_videoPlayer;
    Timeline *m_timeline;
    DataManager *m_dataManager;
    QTimer *m_frametimer;
    QTimer *m_boundaryMoveTimer;
 
    // current image data
    cv::Mat m_currentImage;
    QRect m_roi;
    QRect m_sceneBoundaries;
 
    unsigned int m_imageIndex;
    unsigned int m_imageIndexOnScreen;
    unsigned int m_stepsize;
    bool m_keyframesOnly;
    bool m_playing;
    ModelInputIterator *m_iterator;
 
    const int m_frametime = 33; //ms between frames
 
    std::set<int> m_foundCorruptedFrames = {};
 
    void showImage();
 
    std::unique_ptr<AsyncImageLoader> m_asyncImageLoader;
    std::shared_ptr<PluginThread> m_pluginThread;
    std::optional<QString> m_currentPreviewPlugin;
 
};
 
#endif // VIDEOPLAYERCONTROLLER_H