algorithmcontroller.h

#ifndef ALGORITHMCONTROLLER_H
#define ALGORITHMCONTROLLER_H
 
#include <QObject>
#include <QtConcurrent/QtConcurrent>
#include <QFutureWatcher>
#include <QTimer>
#include <QElapsedTimer>
 
#include "DataManager.h"
#include "algorithmexecutor.h"
 
#include "view/progressdialog.h"
#include "view/samplingwidget.h"
 
#include "plugin/algorithmmanager.h"
#include "plugin/transformmanager.h"
 
#define NO_IMAGE -1
#define NO_TRANSFORM -1
 
// wait the specified amount of milliseconds before displaying the progress dialog when running an algorithm.
// This is done to avoid popup and immediate closing of the dialog on very fast algorithms such as NthFrame.
// If the algorithm is faster than the PROGRESS_DIALOG_DELAY_MS, then the dialog is not shown at all.
#define PROGRESS_DIALOG_DELAY_MS 500
 
class AlgorithmController: public QObject
{
    Q_OBJECT
public:
    explicit AlgorithmController(DataManager* dataManager, SamplingWidget* samplingWidget);
    ~AlgorithmController();
 
public slots:
    void slot_selectAlgorithm(int idx);
    void slot_selectTransform(int idx);
    void slot_startAlgorithm();
    void slot_showProgessDialog();
    void slot_startGenerateSettings();
    void slot_algorithmFinished(int idx);
    void slot_algorithmAborted();
 
signals:
    void sig_hasStatusMessage(QString message);
    void sig_stopPlay();
 
 
    void sig_algorithmFinished(int index);
 
    void sig_keyframesChangedByPlugin(QString name);
 
public slots:
    void slot_updateKeyframes(QString pluginName, std::vector<uint> keyframes);
    void slot_updateBuffer(QString pluginName, QMap<QString, QVariant> buffer);
 
private slots:
    void slot_previewStateChanged(bool enabled);
 
 
private:
    enum PluginType{
        Transform,
        Algorithm
    };
    DataManager* m_dataManager;
    SamplingWidget *m_samplingWidget;
    AlgorithmExecutor* m_algExec;
    ProgressDialog* m_algorithmProgressDialog;
 
    // used to compute transformation in separate thread using QtConcurrent
    QFutureWatcher<std::vector<cv::Mat*>> m_fWatcher;   // QFutureWatcher waiting for transformation to finish
    // <image, image_id, transform_idx>
    std::tuple<cv::Mat*,int, int> m_future;             // image currently in transformation
    std::tuple<cv::Mat*,int, int> m_fQueue;             // Queue for next transformation to perform
    void startNextTransform();                          // starts transformation of m_fQueue
 
    // selected plugin
    int m_pluginIdx;
    PluginType m_pluginType;
 
    // plugin runtime
    QElapsedTimer m_timer;
 
    bool m_processRunning = false;
    bool m_progressDialogActivated = false;
};
#endif // ALGORITHMCONTROLLER_H