colmapwrapper.h

#ifndef LIB3D_OTS_COLMAPWRAPPER_H
#define LIB3D_OTS_COLMAPWRAPPER_H
 
// std
#include <memory>
#include <map>
#include <vector>
#include <functional>
#include <chrono>
#include <thread>
 
// Qt
#include <QSettings>
#include <QObject>
#include <QDialog>
#include <QAction>
#include <QToolButton>
#include <QPushButton>
#include <QProcess>
#include <QString>
#include <QTimer>
#include <QTemporaryDir>
#include <QTemporaryFile>
#include <QtConcurrent>
#include <QCryptographicHash>
 
// OpenCV
#include <opencv2/core.hpp>
 
// lib3d_ots
#include "global.h"
 
namespace lib3d {
namespace ots {
 
namespace ui {
 
  // forward decleration
  class ColmapWrapperControlsFactory;
 
  namespace colmapwrapper {
    class SettingsDialog;
    class ViewWidget;
    class NewProductDialog;
  }
}
 
class ColmapWrapper : public QObject
{
    Q_OBJECT
 
    //--- ENUM DECLERATION ---//
 
  public:
 
    enum EConnectionType {
      LOCAL = 0, 
      SSH        
    };
 
    enum EJobState {
      JOB_DONE = 0, 
      JOB_RUNNING,  
      JOB_PENDING,   
      JOB_FAILED   
    };
 
    enum EWorkerState {
      WORKER_IDLE = 0,  
      WORKER_RUNNING,   
      WORKER_FAILED     
    };
 
    enum EProductType {
      CAMERA_POSES = 0, 
      DENSE_CLOUD,      
      MESHED_MODEL,      
      CUSTOM_COMMAND  
    };
 
    enum ESetupTestResult {
        TEST_PENDING = 0,
        TEST_SUCCESSFUL,
        TEST_FAILED
    };
 
    //--- STRUCT DECLERATION ---//
 
  public:
 
    struct SJob {
 
        std::string sequenceName;
 
        std::string displayName;
 
        EProductType product;
 
        std::map<std::string, std::string> parameters;
 
        EJobState state = JOB_PENDING;
 
        uint progress = 0;
 
        uint step = 0;
 
        uint eta = 0;
    };
 
    struct SWorker {
 
        EWorkerState state = WORKER_IDLE;
 
        SJob *currentlyRunningJob = nullptr;
    };
 
    struct SProduct {
 
        EProductType type;
 
        bool isFinished;
    };
 
    struct SSequence
    {
        std::string name;
 
        std::string imagePath;
 
        std::vector<SProduct> products;
    };
 
    struct SSettings
    {
        QString localColmapBinPath;
 
        QString remoteColmapBinPath;
 
        QString localOpenMVSBinPath;
 
        QString remoteOpenMVSBinPath;
 
        QString localWorkspacePath;
 
        QString remoteWorkspacePath;
 
        QString mntPntRemoteWorkspacePath;
 
        EConnectionType connectionType;
 
        QString remoteAddr;
 
        QString remoteUsr;
 
        QList<QPair<QString, QString>> customCommands;
 
        int syncInterval;
    };
 
    struct SSetupResults
    {
        QPair<ESetupTestResult,QString> localColmapBinPath = {TEST_PENDING, ""};
 
        QPair<ESetupTestResult,QString> remoteColmapBinPath = {TEST_PENDING, ""};
 
        QPair<ESetupTestResult,QString> localOpenMVSBinPath = {TEST_PENDING, ""};
 
        QPair<ESetupTestResult,QString> remoteOpenMVSBinPath = {TEST_PENDING, ""};
 
        QPair<ESetupTestResult,QString> localWorkspacePath = {TEST_PENDING, ""};
 
        QPair<ESetupTestResult,QString> remoteWorkspacePath = {TEST_PENDING, ""};
 
        QPair<ESetupTestResult,QString> mntPntRemoteWorkspacePath = {TEST_PENDING, ""};
 
        QPair<ESetupTestResult,QString> sshConnection = {TEST_PENDING, ""};
 
        QPair<ESetupTestResult,QString> fileSystemMount = {TEST_PENDING, ""};
    };
 
    //--- METHOD DECLERATION ---//
 
  public:
 
    explicit ColmapWrapper(const QString iSettingsFile = "lib3D_ColmapWrapper.ini",
                           const bool iSettingsOnly = false);
 
    virtual ~ColmapWrapper();
 
    void init();
 
    bool testSettings(const SSettings* settings, SSetupResults* results);
 
    void findColmap();
 
    void restoreDefaultSettings();
 
    void loadDefaultSettings();
 
    QMultiMap<QString,QString> imageSequencePaths() const;
 
    QString localColmapBinPath() const;
 
    QString localOpenMVSBinPath() const;
 
    QString remoteColmapBinPath() const;
 
    QString remoteOpenMVSBinPath() const;
 
    QString localWorkspacePath() const;
 
    QString remoteWorkspacePath() const;
 
    QString mntPntRemoteWorkspacePath() const;
 
    QList<QPair<QString, QString>> customCommands() const;
 
    EConnectionType connectionType() const;
 
    QString remoteAddr() const;
 
    QString remoteUsr() const;
 
    int syncInterval() const;
 
    bool getSetupSuccessful();
 
    void setChecksDisabled(const bool noChecks);
 
    bool areChecksDisabled() const;
 
    bool useRobustMode();
 
    bool setUseRobustMode() const;
 
    bool isRemoteWorkspaceMounted(QString iRemoteWorkspacePath) const;
 
    ui::ColmapWrapperControlsFactory *getOrCreateUiControlsFactory();
 
    void applySettings(const SSettings *settings);
 
  signals:
 
    void sequenceListUpdate();
 
    void jobListUpdate();
 
    void workerStateUpdate();
 
    void workspaceStatusUpdate();
 
    void setupStatusUpdate();
 
    void settingsTested(bool valid);
 
    void settingsApplied();
 
  public slots:
    void setLocalPresetSequence(QString name, QString path);
    void setLocalColmapBinPath(const QString &colmapBinPath);
 
    void setLocalOpenMVSBinPath(const QString &openMVSBinPath);
 
    void setRemoteColmapBinPath(const QString &remoteColmapBinPath);
 
    void setRemoteOpenMVSBinPath(const QString &openMVSBinPath);
 
    void setLocalWorkspacePath(const QString &localWorkspacePath);
 
    void setRemoteWorkspacePath(const QString &remoteWorkspacePath);
 
    void setMntPntRemoteWorkspacePath(const QString &mntPntRemoteWorkspacePath);
 
    void setConnectionType(const EConnectionType &connection);
 
    void setRemoteAddr(const QString &remoteAddr);
 
    void setRemoteUsr(const QString &remoteUsr);
 
    void setSyncInterval(int intervalInSeconds);
 
    void setUseRobustMode(bool useRobustMode);
 
    void setCustomCommands(QList<QPair<QString, QString>> customCommands);
 
    bool checkWorkerState();
 
    void addJob(const SJob &iJob);
 
    void addJobList( const std::vector<SJob> &iJobList);
 
    bool moveJobOneUp(const SJob &iJob);
 
    bool moveJobOneDown(const SJob &iJob);
 
    bool deleteJob(const SJob &iJob);
 
    SJob* getJobPtrAtIdx(int iIdx);
 
    int getNumJobs() const;
 
    int removeFinishedJobs();
 
    void clearAvailableSequenceList();
 
    std::vector<SSequence> getFinishedSequenceList() const;
 
    SSequence getLocalPresetSequence() const;
    std::vector<SJob> getJobList() const;
 
    EWorkerState getWorkerState() const;
 
    QString getProductFilePath(QString iSeqName, const EProductType& iProdType);
 
    void startProcessing();
 
    void openColmapLogFile();
 
    void installScriptFilesIntoWorkspace();
 
    bool hasScriptFilesInstalled();
 
    void readSettings();
 
    void writeSettings();
 
    void writeWorkQueueToFile();
 
    void clearWorkerStateFile();
 
    QString getFirstMatchingFileNameWithWildcard(const QString& path, QString baseName) const;
 
    void readWorkQueueFromFile();
 
    void readWorkerStateFromFile();
 
    void afterSettingsChanged();
 
 
  private:
 
    void exportJobs(cv::FileStorage &ioFileStorage) const;
 
    void exportJob(cv::FileStorage &ioFileStorage, const SJob &iJob) const;
 
    void importJob(const cv::FileNode &iFileNode, SJob &oJob) const;
 
    bool hasSequence(const std::string iSeqName) const;
 
    bool hasProduct(const std::string iSeqName, const ColmapWrapper::EProductType iPdctType) const;
 
    void moveJobInQueue(const int fromidx, const int toIdx);
 
    int getIndexOfJob(const SJob &iJob);
 
    //--- FUNCTION DECLERATION ---//
 
  public:
 
    static QString EProductType2QString(const ColmapWrapper::EProductType iType);
 
    static ColmapWrapper::EProductType QString2EProductType(const QString iStr);
 
    QString mLocalWorkspacePath;
 
    QString mRemoteWorkspacePath;
 
    //--- MEMBER DECLERATION ---//
 
  private:
 
 
    QSettings mSettings;
 
    bool mNoChecks;
 
    bool mUseRobustMode;
 
    QList<QPair<QString, QString>> mCustomCommands;
 
    QTemporaryDir* mpTempDir;
 
    QProcess* mpPyWorkerProcess;
 
    QProcess* mpMountProcess;
 
    QTimer mCheckWorkerTimer;
 
    SWorker mPyWorker;
 
    QStringList mPyWorkerArguments;
 
    QString mLocalColmapBinPath;
 
    QString mLocalOpenMVSBinPath;
 
    QString mRemoteColmapBinPath;
 
    QString mRemoteOpenMVSBinPath;
 
    QString mMntPntRemoteWorkspacePath;
 
    EConnectionType mConnectionType;
 
    QString mRemoteAddr;
 
    QString mRemoteUsr;
 
    int mSyncInterval;
 
    std::vector<SSequence> mAvailableSequences;
 
    ColmapWrapper::SSequence mLocalPresetSequence;
 
    std::vector<SJob> mJobs;
 
    ui::ColmapWrapperControlsFactory*    mpUiControls;
 
    bool mSetupSuccessful = false;
 
};
 
namespace ui {
 
  class ColmapWrapperControlsFactory : public QObject
  {
      Q_OBJECT
 
    public:
      friend class lib3d::ots::ColmapWrapper;
 
      QPushButton* createNewProductPushButton(ETheme iTheme = LIGHT,
                                              QWidget* parent = nullptr, QPushButton* rhs = nullptr);
 
      QToolButton* createNewProductToolButton(ETheme iTheme = LIGHT,
                                    QWidget* parent = nullptr, QToolButton* rhs = nullptr);
 
      QPushButton* createSettingsPushButton(ETheme iTheme = LIGHT,
                                    QWidget* parent = nullptr, QPushButton* rhs = nullptr);
 
      QToolButton* createSettingsToolButton(ETheme iTheme = LIGHT,
                                    QWidget* parent = nullptr, QToolButton* rhs = nullptr);
 
      QAction* createSettingsAction(ETheme iTheme = LIGHT,
                                    QWidget* parent = nullptr, QAction* rhs = nullptr);
 
      QWidget* createViewWidget(QWidget* parent = nullptr);
 
      void updateIconTheme(ETheme iTheme);
 
    signals:
 
      void updateToLightTheme();
 
      void updateToDarkTheme();
 
      void enableNewProductButtons(bool enabled);
 
  public slots:
      void onQuit();
 
    private:
 
      ColmapWrapperControlsFactory(lib3d::ots::ColmapWrapper* ipColmapWrapper);
 
    private slots:
 
      void showSettingsDialog();
 
      void showNewProductDialog();
 
      void onSetupChanged();
 
    private:
      lib3d::ots::ColmapWrapper* mpMsWrapper = nullptr;
 
      QSharedPointer<colmapwrapper::NewProductDialog> mpMsWrapperNewProductDialog = nullptr;
 
      QSharedPointer<colmapwrapper::SettingsDialog> mpMsWrapperSettingsDialog = nullptr;
  };
 
} // namespace ui
 
} // namespace ots
} // namespace lib3d
 
#endif // LIB3D_OTS_COLMAPWRAPPER_H