raw_settings.h

Go to the documentation of this file.

 
#pragma once
#include <string>
#include <array>
#include <magic_enum/magic_enum.hpp>
namespace CaptureMoment::Core::ImageConfig {
 
namespace Raw {
// ═══════════════════════════════════════════════════════════════════════════════
// ENUMERATIONS FOR RAW SETTINGS
// ═══════════════════════════════════════════════════════════════════════════════
enum class HighlightMode : std::uint8_t {
    clip = 0,       
    unclip = 1,     
    blend = 2,      
    rebuild = 3     
};
 
enum class DemosaicAlgorithm : std::uint8_t {
    linear,     
    vng,        
    ppg,        
    ahd,        
    dcb,        
    ahd_mod,    
    afd,        
    vcd,        
    mixed,      
    lmmse,      
    amaze,      
    dht,        
    aahd,       
    none        
};
 
enum class RawColorSpace : std::uint8_t {
    raw,            
    srgb,           
    srgb_linear,    
    adobe,          
    wide,           
    prophoto,       
    prophoto_linear,
    xyz,            
    aces,           
    dci_p3,         
    rec2020         
};
 
enum class CameraMatrixMode : std::uint8_t {
    never = 0,      
    dng_only = 1,   
    always = 3      
};
 
enum class FbddNoiseRd : std::uint8_t {
    off = 0,    
    light = 1,  
    full = 2    
};
 
enum class Orientation : std::int8_t {
    ignored = -1,       
    normal = 0,         
    flip_horizontal = 1, 
    rotate_180 = 2,      
    flip_vertical = 3,   
    flip_h_rotate_90 = 4,  
    rotate_90_cw = 5,     
    flip_h_rotate_270 = 6, 
    rotate_270_cw = 7,    
    flip_v_rotate_90 = 8   
};
 
enum class WhiteBalanceMode : std::uint8_t {
    none = 0,       
    camera = 1,     
    auto_wb = 2,    
    grey_box = 3,   
    user_mul = 4    
};
 
// ═══════════════════════════════════════════════════════════════════════════════
// RAW SETTINGS STRUCTURE
// ═══════════════════════════════════════════════════════════════════════════════
struct RawSettings {
    // ═════════════════════════════════════════════════════════════════════════
    // DEMOSAIC SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
private:
    DemosaicAlgorithm m_demosaic{DemosaicAlgorithm::amaze};
 
    bool m_half_size{false};
 
public:
    [[nodiscard]] constexpr DemosaicAlgorithm get_demosaic() const noexcept { return m_demosaic; }
 
    constexpr void set_demosaic(DemosaicAlgorithm algorithm) noexcept { m_demosaic = algorithm; }
 
    [[nodiscard]] std::string get_demosaic_string() const noexcept {
        switch (m_demosaic) {
            case DemosaicAlgorithm::linear:  return "linear";
            case DemosaicAlgorithm::vng:     return "VNG";
            case DemosaicAlgorithm::ppg:     return "PPG";
            case DemosaicAlgorithm::ahd:     return "AHD";
            case DemosaicAlgorithm::dcb:     return "DCB";
            case DemosaicAlgorithm::ahd_mod: return "AHD-Mod";
            case DemosaicAlgorithm::afd:     return "AFD";
            case DemosaicAlgorithm::vcd:     return "VCD";
            case DemosaicAlgorithm::mixed:   return "Mixed";
            case DemosaicAlgorithm::lmmse:   return "LMMSE";
            case DemosaicAlgorithm::amaze:   return "AMaZE";
            case DemosaicAlgorithm::dht:     return "DHT";
            case DemosaicAlgorithm::aahd:    return "AAHD";
            case DemosaicAlgorithm::none:    return "none";
            default:                         return "AHD";
        }
    }
 
    [[nodiscard]] constexpr bool get_half_size() const noexcept { return m_half_size; }
 
    constexpr void set_half_size(bool half_size) noexcept { m_half_size = half_size; }
    // ═════════════════════════════════════════════════════════════════════════
    // COLOR SPACE SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
 
private:
    RawColorSpace m_color_space{RawColorSpace::prophoto_linear};
 
public:
    [[nodiscard]] constexpr RawColorSpace get_color_space() const noexcept { return m_color_space; }
 
    constexpr void set_color_space(RawColorSpace color_space) noexcept { m_color_space = color_space; }
 
    [[nodiscard]] std::string get_color_space_string() const noexcept {
        switch (m_color_space) {
            case RawColorSpace::raw:             return "raw";
            case RawColorSpace::srgb:            return "sRGB";
            case RawColorSpace::srgb_linear:     return "sRGB-linear";
            case RawColorSpace::adobe:           return "Adobe";
            case RawColorSpace::wide:            return "Wide";
            case RawColorSpace::prophoto:        return "ProPhoto";
            case RawColorSpace::prophoto_linear: return "ProPhoto-linear";
            case RawColorSpace::xyz:             return "XYZ";
            case RawColorSpace::aces:            return "ACES";
            case RawColorSpace::dci_p3:          return "DCI-P3";
            case RawColorSpace::rec2020:         return "Rec2020";
            default:                             return "ProPhoto-linear";
        }
    }
    // ═════════════════════════════════════════════════════════════════════════
    // HIGHLIGHT RECOVERY SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
 
private:
    HighlightMode m_highlight_mode{HighlightMode::blend};
 
    bool m_balance_clamped{true};
 
public:
    [[nodiscard]] constexpr HighlightMode get_highlight_mode() const noexcept { return m_highlight_mode; }
 
    constexpr void set_highlight_mode(HighlightMode mode) noexcept { m_highlight_mode = mode; }
 
    [[nodiscard]] constexpr int get_highlight_mode_value() const noexcept { 
        return static_cast<int>(m_highlight_mode); 
    }
 
    [[nodiscard]] constexpr bool get_balance_clamped() const noexcept { return m_balance_clamped; }
 
    constexpr void set_balance_clamped(bool balance) noexcept { m_balance_clamped = balance; }
    // ═════════════════════════════════════════════════════════════════════════
    // WHITE BALANCE SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
 
private:
    bool m_use_camera_wb{true};
    bool m_use_auto_wb{false};
    std::array<int, 4> m_grey_box{0, 0, 0, 0};           
    std::array<float, 4> m_user_mul{1.0f, 1.0f, 1.0f, 1.0f}; 
 
public:
 
    [[nodiscard]] constexpr bool get_use_camera_wb() const noexcept { return m_use_camera_wb; }
 
    constexpr void set_use_camera_wb(bool use_camera) noexcept { m_use_camera_wb = use_camera; }
 
    [[nodiscard]] constexpr bool get_use_auto_wb() const noexcept { return m_use_auto_wb; }
 
    constexpr void set_use_auto_wb(bool use_auto) noexcept { m_use_auto_wb = use_auto; }
 
    [[nodiscard]] constexpr WhiteBalanceMode get_white_balance_mode() const noexcept {
        if (m_use_camera_wb) {
            return WhiteBalanceMode::camera;
        }
        if (m_use_auto_wb) {
            return WhiteBalanceMode::auto_wb;
        }
        // Check if grey_box is valid (non-zero size)
        if (m_grey_box[2] > 0 && m_grey_box[3] > 0) {
            return WhiteBalanceMode::grey_box;
        }
        return WhiteBalanceMode::user_mul;
    }
 
    constexpr void set_white_balance_mode(WhiteBalanceMode mode) noexcept {
        switch (mode) {
            case WhiteBalanceMode::none:
                m_use_camera_wb = false;
                m_use_auto_wb = false;
                break;
            case WhiteBalanceMode::camera:
                m_use_camera_wb = true;
                m_use_auto_wb = false;
                break;
            case WhiteBalanceMode::auto_wb:
                m_use_camera_wb = false;
                m_use_auto_wb = true;
                break;
            case WhiteBalanceMode::grey_box:
                m_use_camera_wb = false;
                m_use_auto_wb = false;
                break;
            case WhiteBalanceMode::user_mul:
                m_use_camera_wb = false;
                m_use_auto_wb = false;
                m_grey_box = {0, 0, 0, 0};  // Disable grey_box to use user_mul
                break;
        }
    }
    [[nodiscard]] constexpr const std::array<int, 4>& get_grey_box() const noexcept { return m_grey_box; }
 
    constexpr void set_grey_box(int x, int y, int width, int height) noexcept {
        m_grey_box = {x, y, width, height};
        // Disable other WB modes to use grey_box
        m_use_camera_wb = false;
        m_use_auto_wb = false;
    }
 
    [[nodiscard]] constexpr const std::array<float, 4>& get_user_mul() const noexcept { return m_user_mul; }
 
    constexpr void set_user_mul(float r, float g, float b, float g2) noexcept {
        m_user_mul = {r, g, b, g2};
        // Disable other WB modes to use user_mul
        m_use_camera_wb = false;
        m_use_auto_wb = false;
        m_grey_box = {0, 0, 0, 0};
    }
    // ═════════════════════════════════════════════════════════════════════════
    // COLOR MATRIX SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
 
private:
    CameraMatrixMode m_camera_matrix{CameraMatrixMode::always};
 
public:
    [[nodiscard]] constexpr CameraMatrixMode get_camera_matrix() const noexcept { return m_camera_matrix; }
 
     constexpr void set_camera_matrix(CameraMatrixMode mode) noexcept { m_camera_matrix = mode; }
 
    [[nodiscard]] constexpr int get_camera_matrix_value() const noexcept { 
        return static_cast<int>(m_camera_matrix); 
    }
    // ═════════════════════════════════════════════════════════════════════════
    // EXPOSURE SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
private:
    float m_exposure{1.0f};             
    bool m_auto_bright{false};           
    bool m_apply_scene_linear_scale{false};
    float m_camera_to_scene_linear_scale{2.2222222222222223f}; 
 
public:
    [[nodiscard]] constexpr float get_exposure() const noexcept { return m_exposure; }
 
    constexpr void set_exposure(float exposure) noexcept { m_exposure = exposure; }
 
    [[nodiscard]] constexpr bool get_auto_bright() const noexcept { return m_auto_bright; }
 
    constexpr void set_auto_bright(bool auto_bright) noexcept { m_auto_bright = auto_bright; }
 
    [[nodiscard]] constexpr bool get_apply_scene_linear_scale() const noexcept { return m_apply_scene_linear_scale; }
 
    constexpr void set_apply_scene_linear_scale(bool apply) noexcept { m_apply_scene_linear_scale = apply; }
 
    [[nodiscard]] constexpr float get_camera_to_scene_linear_scale() const noexcept { 
        return m_camera_to_scene_linear_scale; 
    }
 
    constexpr void set_camera_to_scene_linear_scale(float scale) noexcept { 
        m_camera_to_scene_linear_scale = scale; 
    }
    // ═════════════════════════════════════════════════════════════════════════
    // BLACK/WHITE POINT SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
 
private:
    int m_user_black{-1};    
    int m_user_sat{0};       
    float m_adjust_maximum_thr{0.0f}; 
 
public:
    [[nodiscard]] constexpr int get_user_black() const noexcept { return m_user_black; }
 
    constexpr void set_user_black(int black) noexcept { m_user_black = black; }
 
    [[nodiscard]] constexpr int get_user_sat() const noexcept { return m_user_sat; }
 
    constexpr void set_user_sat(int sat) noexcept { m_user_sat = sat; }
 
    [[nodiscard]] constexpr float get_adjust_maximum_thr() const noexcept { return m_adjust_maximum_thr; }
 
    constexpr void set_adjust_maximum_thr(float thr) noexcept { m_adjust_maximum_thr = thr; }
    // ═════════════════════════════════════════════════════════════════════════
    // NOISE REDUCTION SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
 
private:
    FbddNoiseRd m_fbdd_noiserd{FbddNoiseRd::light};
    float m_threshold{0.0f};    
 
public:
    [[nodiscard]] constexpr FbddNoiseRd get_fbdd_noiserd() const noexcept { return m_fbdd_noiserd; }
 
    constexpr void set_fbdd_noiserd(FbddNoiseRd noiserd) noexcept { m_fbdd_noiserd = noiserd; }
 
    [[nodiscard]] constexpr int get_fbdd_noiserd_value() const noexcept { 
        return static_cast<int>(m_fbdd_noiserd); 
    }
 
    [[nodiscard]] constexpr float get_threshold() const noexcept { return m_threshold; }
 
    constexpr void set_threshold(float threshold) noexcept { m_threshold = threshold; }
    // ═════════════════════════════════════════════════════════════════════════
    // CHROMATIC ABERRATION CORRECTION
    // ═════════════════════════════════════════════════════════════════════════
private:
    std::array<float, 2> m_aber{1.0f, 1.0f}; 
 
public:
 
    [[nodiscard]] constexpr const std::array<float, 2>& get_aber() const noexcept { return m_aber; }
 
    constexpr void set_aber(float red, float blue) noexcept { m_aber = {red, blue}; }
    // ═════════════════════════════════════════════════════════════════════════
    // ORIENTATION SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
 
private:
    Orientation m_user_flip{Orientation::ignored};
 
public:
    [[nodiscard]] constexpr Orientation get_user_flip() const noexcept { return m_user_flip; }
 
    constexpr void set_user_flip(Orientation flip) noexcept { m_user_flip = flip; }
 
    [[nodiscard]] constexpr int get_user_flip_value() const noexcept { 
        return static_cast<int>(m_user_flip); 
    }
    // ═════════════════════════════════════════════════════════════════════════
    // CROP SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
 
private:
    std::array<int, 4> m_crop_box{0, 0, 0, 0}; 
 
public:
    [[nodiscard]] constexpr const std::array<int, 4>& get_crop_box() const noexcept { return m_crop_box; }
 
    constexpr void set_crop_box(int x, int y, int width, int height) noexcept {
        m_crop_box = {x, y, width, height};
    }
    // ═════════════════════════════════════════════════════════════════════════
    // MEMORY AND LOADING SETTINGS
    // ═════════════════════════════════════════════════════════════════════════
 
private:
    int m_max_raw_memory_mb{4096}; 
    bool m_force_load{true};     
 
public:
 
    [[nodiscard]] constexpr int get_max_raw_memory_mb() const noexcept { return m_max_raw_memory_mb; }
 
    constexpr void set_max_raw_memory_mb(int max_mb) noexcept { m_max_raw_memory_mb = max_mb; }
 
    [[nodiscard]] constexpr bool get_force_load() const noexcept { return m_force_load; }
 
    constexpr void set_force_load(bool force) noexcept { m_force_load = force; }
    // ═════════════════════════════════════════════════════════════════════════
    // PRESET FACTORY METHODS
    // ═════════════════════════════════════════════════════════════════════════
 
    [[nodiscard]] static constexpr RawSettings fast_settings() noexcept {
        RawSettings settings;
        settings.m_demosaic = DemosaicAlgorithm::linear;
        settings.m_color_space = RawColorSpace::srgb_linear;
        settings.m_highlight_mode = HighlightMode::clip;
        settings.m_balance_clamped = false;
        settings.m_half_size = true;
        settings.m_fbdd_noiserd = FbddNoiseRd::off;
        settings.m_force_load = false;
        settings.m_camera_matrix = CameraMatrixMode::dng_only;
        settings.m_use_camera_wb = true;
        settings.m_use_auto_wb = false;
        return settings;
    }
 
    [[nodiscard]] static constexpr RawSettings quality_settings() noexcept {
        RawSettings settings;
        settings.m_demosaic = DemosaicAlgorithm::amaze;
        settings.m_color_space = RawColorSpace::prophoto_linear;
        settings.m_highlight_mode = HighlightMode::rebuild;
        settings.m_balance_clamped = true;
        settings.m_half_size = false;
        settings.m_fbdd_noiserd = FbddNoiseRd::light;
        settings.m_force_load = true;
        settings.m_camera_matrix = CameraMatrixMode::always;
        settings.m_use_camera_wb = true;
        settings.m_use_auto_wb = false;
        return settings;
    }
 
    [[nodiscard]] static constexpr RawSettings performance_settings() noexcept {
        RawSettings settings;
        settings.m_demosaic = DemosaicAlgorithm::ahd;
        settings.m_color_space = RawColorSpace::prophoto_linear;
        settings.m_highlight_mode = HighlightMode::blend;
        settings.m_balance_clamped = true;
        settings.m_half_size = false;
        settings.m_fbdd_noiserd = FbddNoiseRd::light;
        settings.m_force_load = true;
        settings.m_camera_matrix = CameraMatrixMode::always;
        settings.m_use_camera_wb = true;
        settings.m_use_auto_wb = false;
        return settings;
    }
    // ═════════════════════════════════════════════════════════════════════════
    // UTILITY METHODS
    // ═════════════════════════════════════════════════════════════════════════
 
    void reset_to_defaults() noexcept {
        *this = RawSettings{};
    }
 
    [[nodiscard]] constexpr bool is_quality_configuration() const noexcept {
        return m_demosaic == DemosaicAlgorithm::amaze &&
               m_color_space == RawColorSpace::prophoto_linear &&
               m_highlight_mode >= HighlightMode::blend &&
               m_balance_clamped &&
               m_camera_matrix == CameraMatrixMode::always;
    }
 
    [[nodiscard]] constexpr bool is_fast_configuration() const noexcept {
        return m_half_size &&
               m_demosaic == DemosaicAlgorithm::linear;
    }
 
    [[nodiscard]] constexpr bool is_performance_configuration() const noexcept {
        return m_demosaic == DemosaicAlgorithm::ahd &&
               m_color_space == RawColorSpace::prophoto_linear &&
               m_highlight_mode == HighlightMode::blend &&
               m_balance_clamped &&
               !m_half_size;
    }
};
} // namespace Raw
} // namespace CaptureMoment::Core::ImageConfig