working_image_data.h

Go to the documentation of this file.

 
#pragma once
 
#include "common/image_region.h"
#include "common/error_handling/core_error.h"
#include "common/types/image_types.h"
 
#include <memory>
#include <expected>
#include <cstddef>
 
namespace CaptureMoment::Core {
 
namespace ImageProcessing {
 
class WorkingImageData {
 
public:
 
    explicit WorkingImageData(std::unique_ptr<Common::ImageRegion> source);
 
    virtual ~WorkingImageData() = default;
 
    // Non-copyable by default (expensive), but movable
    WorkingImageData(const WorkingImageData&) = delete;
    WorkingImageData& operator=(const WorkingImageData&) = delete;
    WorkingImageData(WorkingImageData&&) noexcept = default;
    WorkingImageData& operator=(WorkingImageData&&) noexcept = default;
 
    [[nodiscard]] std::expected<void, ErrorHandling::CoreError>
    initializeData(Common::ImageRegion&& source_image);
 
    [[nodiscard]] std::span<const float> getOriginalDataSpan() const noexcept {
        return std::span<const float>(m_original_data);
    }
 
    [[nodiscard]] std::span<const float> getWorkingDataSpan() const noexcept {
        return std::span<const float>(m_data);
    }
 
    [[nodiscard]] std::span<float> getWorkingDataSpan() noexcept {
        return std::span<float>(m_data);
 
    }
 
    [[nodiscard]] Common::ImageDim getWidth() const noexcept { return m_width; }
 
    [[nodiscard]] Common::ImageDim getHeight() const noexcept { return m_height; }
 
    [[nodiscard]] Common::ImageChan getChannels() const noexcept { return m_channels; }
 
    [[nodiscard]] bool isValid() const noexcept { return m_valid; }
 
    void restoreOriginalData();
 
private:
    std::vector<float> m_data;
 
    std::vector<float> m_original_data;
 
    Common::ImageSize m_data_size{0};
 
    Common::ImageDim m_width{0};
 
    Common::ImageDim m_height{0};
 
    Common::ImageChan m_channels{0};
 
    bool m_valid{false};
 
};
 
} // namespace ImageProcessing
 
} // namespace CaptureMoment::Core