exportthread.h

#ifndef EXPORTTHREAD_H
#define EXPORTTHREAD_H
 
#include <opencv2/core.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/imgproc.hpp>
 
#include <QThread>
#include <QFileDialog>
#include <iostream>
#include <QtConcurrent>
#include <QMutex>
#include <QMutexLocker>
#include <fstream>
#include <QFutureSynchronizer>
#include <QFile>
 
#include "logfile.h"
#include "stringcontainer.h"
#include "modelinputpictures.h"
#include "itransform.h"
#include "progressable.h"
#include "exportexif.h"
#include "imageprocessor.h"
#include "copyfilecommand.h"
#include "cropcommand.h"
#include "resizecommand.h"
#include "transformcommand.h"
#include "writetodiskcommand.h"
#include "exiftagcommand.h"
 
#define JPEG_COMPRESSION_PARAMS {cv::IMWRITE_JPEG_QUALITY, 100}
 
struct ExportConfig
{
    QString name;
    QString destination;
    QString format;
    std::optional<ROI> roi = std::nullopt;
    Resolution original_resolution;
    Resolution working_resolution;
    Resolution export_resolution;
    std::vector<ITransform *> transformations;
    bool copy_images = false;
};
 
enum class ExportResultType
{
    Success,        // all images were exported
    PartialSuccess, // some images were broken and needed to be skipped
    Aborted,        // export was aborted by the user
    Failed          // export failed due to a runtime error
};
 
struct ExportResult
{
    ExportResultType type;
    int brokenImages = 0; // Only relevant for PartialSuccess
    QString errorMessage; // Only relevant for Failed
 
    static ExportResult success()
    {
        return {ExportResultType::Success, 0, ""};
    }
    static ExportResult partialSuccess(int broken)
    {
        return {ExportResultType::PartialSuccess, broken, ""};
    }
    static ExportResult aborted()
    {
        return {ExportResultType::Aborted, 0, ""};
    }
    static ExportResult failed(const QString &msg)
    {
        return {ExportResultType::Failed, 0, msg};
    }
};
 
Q_DECLARE_METATYPE(ExportResult)
 
 
class ExportThread : public QThread
{
    Q_OBJECT
 
public:
    explicit ExportThread(Progressable *receiver, ModelInputPictures *mip, const ExportConfig &config, volatile bool *stopped, LogFile *logFile);
    ~ExportThread();
 
    ExportResult getResult() const;
 
private:
    Progressable *m_receiver;
    Reader *m_reader;
    std::vector<uint> m_keyframes;
    volatile bool *m_stopped;
    ExportConfig m_config;
    ExportResult m_result = ExportResult::success();
    LogFile *m_logFile;
    int m_progress = 0;
    ExportExif *m_exportExif;
 
    void reportProgress();
 
    volatile int m_exportProgress = 0;
    QMutex m_mutex;
    bool currentOperation(uint n);
 
protected:
    void run() override;
};
 
#endif // EXPORTTHREAD_H