src/imageprocessor.h - master - SM_DAMIR/limb

src/imageprocessor.h
214 строк7 KB
DamirSM
chore: init
16 июл 2026, 12:14
16 июл 2026, 12:14bb10094
#ifndef IMAGEPROCESSOR_H
#define IMAGEPROCESSOR_H

#include <QObject>
#include <QThread>
#include <QImage>
#include <QStack>
#include <QQmlEngine>

#include "processingworker.h"
#include "resultimageprovider.h"

class ImageProcessor : public QObject
{
    Q_OBJECT

    Q_PROPERTY(QString resultSource
               READ resultSource
               NOTIFY resultSourceChanged)
    Q_PROPERTY(bool processing
               READ processing
               NOTIFY processingChanged)
    Q_PROPERTY(int progress
               READ progress
               NOTIFY progressChanged)
    Q_PROPERTY(QString errorMessage
               READ errorMessage
               NOTIFY errorMessageChanged)
    Q_PROPERTY(QString imagePath
               READ imagePath
               NOTIFY imagePathChanged)
    Q_PROPERTY(bool canUndo
               READ canUndo
               NOTIFY canUndoChanged)
    Q_PROPERTY(bool canRedo
               READ canRedo
               NOTIFY canRedoChanged)
    Q_PROPERTY(int styleStrength
               READ styleStrength
               WRITE setStyleStrength
               NOTIFY styleStrengthChanged)
    Q_PROPERTY(int styleIndex
               READ styleIndex
               NOTIFY styleIndexChanged)
    Q_PROPERTY(bool hasChanges
               READ hasChanges
               NOTIFY hasChangesChanged)
	Q_PROPERTY(QString lastTiming READ lastTiming NOTIFY lastTimingChanged)

public:
    struct HistoryState {
        QImage image;
        QImage base;
        int  brightness    = 0;
        int  contrast      = 0;
        int  whiteBalance  = 0;
        int  styleIndex    = -1;
        int  styleStrength = 100;
        bool useZeroDCE    = false;
    };

    explicit ImageProcessor(QObject *parent = nullptr);
    ~ImageProcessor();

    QString resultSource() const { return m_resultSource; }
    bool    processing()   const { return m_processing;   }
    int     progress()     const { return m_progress;     }
    QString errorMessage() const { return m_errorMessage; }
    QString imagePath()    const { return m_imagePath;    }
    bool    canUndo()    const { return m_history.size() > 1;   }
    bool    canRedo()    const { return !m_redoStack.isEmpty(); }
    int     styleStrength() const { return m_styleStrength;     }
    int     styleIndex()    const { return m_currentStyleIndex; }
    bool    hasChanges()    const { return m_hasChanges;        }

    void registerProvider(QQmlEngine *engine);
	
	QString lastTiming() const { return m_lastTiming; }

public slots:
    Q_INVOKABLE void loadImage(const QString &filePath);
    Q_INVOKABLE void resetToOriginal();
    Q_INVOKABLE void cancelProcessing();

    Q_INVOKABLE void undoLastAction();
    Q_INVOKABLE void redoLastAction();

    Q_INVOKABLE void setStyleStrength(int value);
    Q_INVOKABLE void applyStyle(int styleIndex);

    Q_INVOKABLE void removeBackground(int objectType = 0);
    Q_INVOKABLE void blurBackground(int objectType = 0,
                                     int radius = 12);
    Q_INVOKABLE void colorBackground(int objectType = 0,
                                      int r = 0, int g = 0,
                                      int b = 0);
    Q_INVOKABLE void gradientBackground(
        int objectType = 0,
        int r1 = 30,  int g1 = 30,  int b1 = 80,
        int r2 = 200, int g2 = 100, int b2 = 200);

    Q_INVOKABLE void applyEnhancement(int brightness,
                                       int contrast,
                                       int whiteBalance);
    Q_INVOKABLE void applyZeroDCE();

    Q_INVOKABLE bool saveToGallery(
        const QString &destPath = QString());

    Q_INVOKABLE void detectObject(int objectType);

signals:
    void resultSourceChanged();
    void processingChanged();
    void progressChanged();
    void errorMessageChanged();
    void imagePathChanged();
    void canUndoChanged();
    void canRedoChanged();
    void styleStrengthChanged();
    void styleIndexChanged(int index);
    void savedToGallery(const QString &path);
    void hasChangesChanged();

    void parametersRestored(int brightness,
                            int contrast,
                            int whiteBalance,
                            int styleIndex,
                            int styleStrength,
                            bool useZeroDCE);

    void loadImageRequested(const QString &path);
    void removeBackgroundRequested(int objectType);
    void blurBackgroundRequested(int objectType, int radius);
    void colorBackgroundRequested(int objectType,
                                   int r, int g, int b);
    void gradientBackgroundRequested(int objectType,
        int r1, int g1, int b1,
        int r2, int g2, int b2);
    void enhancementRequested(int brightness,
                               int contrast,
                               int whiteBalance);
    void zeroDCERequested();
    void styleRequested(int styleIndex, int strength);
    void resetRequested();
    void detectObjectRequested(int objectType);
    void cancelRequested(const QImage &baseImage,
                               int brightness,
                               int contrast,
                               int whiteBalance,
                               int styleIndex,
                               int styleStrength,
                               bool useZeroDCE);
    void restoreStateRequested(const QImage &baseImage,
                               int brightness,
                               int contrast,
                               int whiteBalance,
                               int styleIndex,
                               int styleStrength,
                               bool useZeroDCE);
	void lastTimingChanged();

private slots:
    void handleImageLoaded(const QImage &image);
    void handleProcessingFinished(const QImage &result,
                                   const QImage &base);
    void handlePreviewFinished(const QImage &preview);
    void handleProgress(int percent);
    void handleError(const QString &message);
    void handleTiming(const QString &stage, qint64 ms);

private:
    void setProcessing(bool value);
    void updateResultSource();
    bool pushHistory(const QImage &image,
                     const QImage &base);
    void restoreStateToUiAndWorker(
        const HistoryState &state);
    void emitCurrentParameters();
    void setHasChanges(bool value);

    ProcessingWorker    *m_worker   = nullptr;
    ResultImageProvider *m_provider = nullptr;
    QThread              m_thread;

    QString m_resultSource;
    QString m_imagePath;
    QString m_errorMessage;

    bool m_processing   = false;
    int  m_progress     = 0;
    int  m_version      = 0;
    bool m_hasChanges   = false;

    int  m_styleStrength        = 100;
    int  m_brightness           = 0;
    int  m_contrast             = 0;
    int  m_whiteBalance         = 0;
    int  m_currentStyleIndex    = -1;
    int  m_currentStyleStrength = 100;
    bool m_useZeroDCE           = false;

    int  m_restoringCount = 0;
    bool m_cancelled      = false;

    QStack<HistoryState> m_history;
    QStack<HistoryState> m_redoStack;

    static const int MAX_HISTORY = 10;
	
	QString m_lastTiming;
};

#endif