maskcommand.h

#ifndef MASKCOMMAND_H
#define MASKCOMMAND_H
 
#include <QDir>
#include <QMutex>
#include <QWaitCondition>
#include <QString>
#include <atomic>
#include <condition_variable>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <vector>
 
#include <opencv2/core.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/imgproc.hpp>
 
#include <tl/expected.hpp>
 
#include "imageprocessor.h"
#include "maskstack.h"
#include "pluginthread.h"
 
class MaskCommand : public ImageCommand {
 
public:
    MaskCommand(const MaskRecord* record, Resolution exportResolution, ROI roi,
                QString folder, PluginThread* pluginThread,
                volatile bool* stopped = nullptr);
 
    std::optional<QString> execute(ImageContext& ctx) override;
 
    void onMaskFinished(const MaskGenerationResult& result);
 
private:
    const MaskRecord* m_record;
    Resolution m_exportResolution;
    ROI m_roi;
    QString m_folder;
    PluginThread* m_pluginThread;
    volatile bool* m_stopped = nullptr;
    QString m_pluginName;
    cv::Size m_exportSize;
    bool m_initialized = false;
 
    // Async mask handling
    // s_pendingMasks: Tracks the number of mask generation requests currently in flight.
    //                 This prevents the export pipeline from overwhelming the plugin thread
    //                 with requests faster than they can be processed.
    // MAX_PENDING_MASKS: Maximum allowed concurrent mask requests (3).
    //                    When this limit is reached, execute() blocks until masks complete.
    //                    This value balances latency (low = more blocking) vs. throughput.
    //                    Typical GPU operations take 100-500ms, so 3 concurrent requests
    //                    keeps a reasonable buffer without excessive memory usage.
    static std::atomic<int> s_pendingMasks;
    static constexpr int MAX_PENDING_MASKS = 3;  // Limit concurrent mask requests
 
    // Thread-safe mask result storage (using std::mutex for condition_variable compatibility)
    std::mutex m_resultMutex;
    std::map<uint, cv::Mat> m_maskResults;          // imageIndex -> mask
    std::map<uint, QString> m_maskErrors;           // imageIndex -> error message (if any)
    std::condition_variable m_maskReady;             // Signal when a mask arrives
 
    tl::expected< cv::Mat, QString > waitForMask(uint imageIndex,
                                                 int timeoutMs = 30000);
};
 
#endif  // MASKCOMMAND_H