state_image_manager.h

Go to the documentation of this file.

 
#pragma once
 
#include "operations/operation_descriptor.h"
#include "managers/i_source_manager.h"
#include "image_processing/interfaces/i_working_image_hardware.h"
#include "operations/operation_factory.h"
#include "common/types/image_types.h"
 
#include <vector>
#include <memory>
#include <mutex>
#include <future>
#include <string_view>
#include <string>
#include <optional>
#include <thread>
#include <atomic>
#include <condition_variable>
 
 
namespace CaptureMoment::Core {
 
namespace Pipeline {
class PipelineContext;
}
 
namespace Workers {
class WorkerContext;
}
 
namespace ImageProcessing {
class WorkingImageContext;
}
 
 
namespace Managers {
 
 
class StateImageManager {
public:
    explicit StateImageManager();
 
    ~StateImageManager();
 
    // Disable copy and assignment
    StateImageManager(const StateImageManager&) = delete;
    StateImageManager& operator=(const StateImageManager&) = delete;
 
    [[nodiscard]] std::future<bool> applyOperations(std::vector<Operations::OperationDescriptor>&& ops);
 
    [[nodiscard]] bool loadImage(std::string_view path);
 
    [[nodiscard]] std::expected<void, ErrorHandling::CoreError> commitWorkingImageToSource();
 
    [[nodiscard]] std::expected<void, ErrorHandling::CoreError> resetToOriginal();
 
    [[nodiscard]] std::string getImageSourcePath() const;
 
    [[nodiscard]] Common::ImageDim getSourceWidth() const;
 
    [[nodiscard]] Common::ImageDim getSourceHeight() const;
 
    [[nodiscard]] Common::ImageChan getSourceChannels() const;
 
    [[nodiscard]] std::expected<std::unique_ptr<Common::ImageRegion>, ErrorHandling::CoreError>
    getWorkingImageAsRegion() const;
 
    [[nodiscard]] std::expected<std::unique_ptr<Common::ImageRegion>, ErrorHandling::CoreError>
    getDownsampledDisplayImage(Common::ImageDim target_width, Common::ImageDim target_height);
 
private:
    void workerLoop();
 
    [[nodiscard]] bool executeProcessing(std::vector<Operations::OperationDescriptor> ops);
 
    void waitForPendingProcessing();
 
    // ========================================================================
    // Worker Thread Synchronization
    // ========================================================================
 
    std::atomic<bool> m_stop_requested{false};
 
    mutable std::mutex m_work_mutex;
 
    std::condition_variable m_work_cv;
 
    // ========================================================================
    // State & Infrastructure
    // ========================================================================
 
    mutable std::mutex m_state_mutex;
 
    std::unique_ptr<Pipeline::PipelineContext> m_pipeline_context;
 
    std::unique_ptr<Workers::WorkerContext> m_worker_context;
 
    std::unique_ptr<ImageProcessing::WorkingImageContext> m_working_image_context;
 
    std::string m_original_image_path;
 
    std::optional<std::vector<Operations::OperationDescriptor>> m_pending_work;
 
    std::shared_ptr<std::promise<bool>> m_active_promise;
 
    std::atomic<bool> m_is_idle{true};
 
    std::unique_ptr<Managers::ISourceManager> m_source_manager;
 
    std::thread m_worker_thread;
 
 
    // ========================================================================
    // Idle State Synchronization
    // ========================================================================
 
    std::mutex m_idle_mutex;
 
    std::condition_variable m_idle_cv;
};
 
} // namespace Managers
 
} // namespace CaptureMoment::Core