atmos/os_lib/css/

color_space.rs

//! CIE Lab/LCH と広色域 RGB の sRGB 変換（純粋モジュール）。
//!
//! CSS Color Module Level 4 の以下を担当する。
//!
//! - `lab(L a b)` / `lch(L C H)` … CIE Lab（**白色点 D50**）
//! - `color(display-p3 …)` / `a98-rgb` / `prophoto-rgb` / `rec2020`
//! - `color(xyz …)` / `xyz-d65` / `xyz-d50`
//!
//! いずれもハードウェアにもグローバル状態にも依存しない数値変換だけなので、
//! QEMU 抜きでホスト側から検証できる。
//!
//! # 白色点が 2 種類あることに注意
//!
//! CSS の `lab()`/`lch()` と `xyz-d50`/`prophoto-rgb` は **D50**、
//! sRGB・display-p3・rec2020・a98-rgb・`xyz`/`xyz-d65` は **D65** を使う。
//! D50 の値をそのまま D65 の行列へ入れると色がずれるので、
//! 途中で **Bradford 色順応**（`d50_to_d65`）を必ず挟む。
//! 仕様の参照実装（csswg-drafts の `conversions.js`）と同じ順序にしてある。
//!
//! # 色域外の扱い
//!
//! display-p3 等は sRGB より広いので、変換結果が 0-1 を外れることがある
//! （例: 純粋な P3 の緑）。厳密な gamut mapping は行わず素直にクランプする。
//! これは既存の `oklab()`/`oklch()` 実装と同じ割り切りで、
//! 「色は出るが最も近い sRGB へ丸められる」挙動になる。

extern crate alloc;

/// sRGB のガンマ符号化（線形 0-1 → 表示値 0-1）。
///
/// 負値は色域外なので 0 側へクランプしてから符号化する。
pub fn linear_to_srgb(c: f32) -> f32 {
    let c = c.clamp(0.0, 1.0);
    if c <= 0.003_130_8 {
        c * 12.92
    } else {
        1.055 * libm::powf(c, 1.0 / 2.4) - 0.055
    }
}

/// sRGB のガンマ復号（表示値 0-1 → 線形 0-1）。
pub fn srgb_to_linear(c: f32) -> f32 {
    let c = c.clamp(0.0, 1.0);
    if c <= 0.040_45 {
        c / 12.92
    } else {
        libm::powf((c + 0.055) / 1.055, 2.4)
    }
}

/// CIE Lab（D50）→ XYZ（D50）。
///
/// `L` は 0-100、`a`/`b` はおおむね -125〜125。
pub fn lab_to_xyz_d50(l: f32, a: f32, b: f32) -> (f32, f32, f32) {
    // CIE 標準の定数。κ = 24389/27、ε = 216/24389。
    const KAPPA: f32 = 24389.0 / 27.0;
    const EPSILON: f32 = 216.0 / 24389.0;
    // D50 の白色点（CSS 仕様が採用する値）。
    const WHITE_D50: [f32; 3] = [0.964_2, 1.0, 0.824_9];

    let fy = (l + 16.0) / 116.0;
    let fx = a / 500.0 + fy;
    let fz = fy - b / 200.0;

    let cube = |t: f32| t * t * t;
    let x = if cube(fx) > EPSILON {
        cube(fx)
    } else {
        (116.0 * fx - 16.0) / KAPPA
    };
    let y = if l > KAPPA * EPSILON {
        cube((l + 16.0) / 116.0)
    } else {
        l / KAPPA
    };
    let z = if cube(fz) > EPSILON {
        cube(fz)
    } else {
        (116.0 * fz - 16.0) / KAPPA
    };

    (x * WHITE_D50[0], y * WHITE_D50[1], z * WHITE_D50[2])
}

/// Bradford 色順応で XYZ の白色点を D50 から D65 へ移す。
///
/// これを飛ばすと `lab()` の色が全体に黄色寄りにずれる。
pub fn d50_to_d65(x: f32, y: f32, z: f32) -> (f32, f32, f32) {
    (
        0.955_473_4 * x - 0.023_098_1 * y + 0.063_259_3 * z,
        -0.028_369_7 * x + 1.009_943_9 * y + 0.021_041_0 * z,
        0.012_314_2 * x - 0.020_483_0 * y + 1.330_889_0 * z,
    )
}

/// XYZ（D65）→ 線形 sRGB。
pub fn xyz_d65_to_linear_srgb(x: f32, y: f32, z: f32) -> (f32, f32, f32) {
    (
        3.240_97 * x - 1.537_383 * y - 0.498_610_8 * z,
        -0.969_243_6 * x + 1.875_967_5 * y + 0.041_555_1 * z,
        0.055_630_8 * x - 0.203_976_9 * y + 1.056_971_5 * z,
    )
}

/// `color()` が受け付ける色空間。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ColorSpace {
    /// ガンマ符号化済み sRGB。
    Srgb,
    /// 線形 sRGB。
    SrgbLinear,
    /// Display P3（sRGB と同じ伝達関数、より広い原色）。
    DisplayP3,
    /// Adobe RGB (1998)。伝達関数は単純な γ=563/256。
    A98Rgb,
    /// ProPhoto RGB（**D50**）。
    ProPhotoRgb,
    /// ITU-R BT.2020。
    Rec2020,
    /// CIE XYZ（D65）。`xyz` は `xyz-d65` の別名。
    XyzD65,
    /// CIE XYZ（D50）。
    XyzD50,
}

/// 色空間名を解決する。未知の名前は `None`。
pub fn parse_color_space(name: &str) -> Option<ColorSpace> {
    match name.trim() {
        "srgb" => Some(ColorSpace::Srgb),
        "srgb-linear" => Some(ColorSpace::SrgbLinear),
        "display-p3" => Some(ColorSpace::DisplayP3),
        "a98-rgb" => Some(ColorSpace::A98Rgb),
        "prophoto-rgb" => Some(ColorSpace::ProPhotoRgb),
        "rec2020" => Some(ColorSpace::Rec2020),
        // `xyz` は仕様上 `xyz-d65` の別名。
        "xyz" | "xyz-d65" => Some(ColorSpace::XyzD65),
        "xyz-d50" => Some(ColorSpace::XyzD50),
        _ => None,
    }
}

/// `color(<space> c1 c2 c3)` の 3 成分を **線形 sRGB** へ変換する。
///
/// 返り値は 0-1 にクランプしていない（色域外は呼び出し側でクランプする）。
pub fn components_to_linear_srgb(space: ColorSpace, c1: f32, c2: f32, c3: f32) -> (f32, f32, f32) {
    match space {
        ColorSpace::Srgb => (srgb_to_linear(c1), srgb_to_linear(c2), srgb_to_linear(c3)),
        ColorSpace::SrgbLinear => (c1, c2, c3),
        ColorSpace::DisplayP3 => {
            // 伝達関数は sRGB と同一。原色だけが違う。
            let (r, g, b) = (srgb_to_linear(c1), srgb_to_linear(c2), srgb_to_linear(c3));
            // P3(linear) → XYZ(D65) → linear sRGB を 1 つに畳んだ行列。
            (
                1.224_940_2 * r - 0.224_940_18 * g,
                -0.042_056_95 * r + 1.042_056_9 * g,
                -0.019_637_39 * r - 0.078_636_04 * g + 1.098_273_4 * b,
            )
        }
        ColorSpace::A98Rgb => {
            // Adobe RGB の伝達関数は γ=563/256（≒2.199）の単純べき乗。
            let dec = |v: f32| -> f32 {
                let s = if v < 0.0 { -1.0 } else { 1.0 };
                s * libm::powf(libm::fabsf(v), 563.0 / 256.0)
            };
            let (r, g, b) = (dec(c1), dec(c2), dec(c3));
            (
                1.398_240_9 * r - 0.398_240_9 * g,
                0.999_999_9 * g,
                -0.043_306_2 * g + 1.043_306_2 * b,
            )
        }
        ColorSpace::ProPhotoRgb => {
            // ProPhoto は D50 基準。伝達関数は γ=1.8、線形部の閾値は 16/512。
            let dec = |v: f32| -> f32 {
                let s = if v < 0.0 { -1.0 } else { 1.0 };
                let a = libm::fabsf(v);
                if a <= 16.0 / 512.0 {
                    v / 16.0
                } else {
                    s * libm::powf(a, 1.8)
                }
            };
            let (r, g, b) = (dec(c1), dec(c2), dec(c3));
            // ProPhoto(linear) → XYZ(D50)
            let x = 0.797_675_3 * r + 0.135_192_2 * g + 0.031_353_6 * b;
            let y = 0.288_040_4 * r + 0.711_874_2 * g + 0.000_085_4 * b;
            let z = 0.825_210_5 * b;
            // D50 → D65 → linear sRGB
            let (x, y, z) = d50_to_d65(x, y, z);
            xyz_d65_to_linear_srgb(x, y, z)
        }
        ColorSpace::Rec2020 => {
            // BT.2020 の伝達関数（α, β は仕様の定数）。
            const A: f32 = 1.098_729_0;
            const B: f32 = 0.018_053_97;
            let dec = |v: f32| -> f32 {
                let s = if v < 0.0 { -1.0 } else { 1.0 };
                let a = libm::fabsf(v);
                if a < B * 4.5 {
                    v / 4.5
                } else {
                    s * libm::powf((a + A - 1.0) / A, 1.0 / 0.45)
                }
            };
            let (r, g, b) = (dec(c1), dec(c2), dec(c3));
            (
                1.660_496_1 * r - 0.587_656_1 * g - 0.072_840_0 * b,
                -0.124_547_4 * r + 1.132_895_9 * g - 0.008_348_5 * b,
                -0.018_154_1 * r - 0.100_597_0 * g + 1.118_751_1 * b,
            )
        }
        ColorSpace::XyzD65 => xyz_d65_to_linear_srgb(c1, c2, c3),
        ColorSpace::XyzD50 => {
            let (x, y, z) = d50_to_d65(c1, c2, c3);
            xyz_d65_to_linear_srgb(x, y, z)
        }
    }
}

/// `lab(L a b)` を **線形 sRGB** へ変換する。
pub fn lab_to_linear_srgb(l: f32, a: f32, b: f32) -> (f32, f32, f32) {
    let (x, y, z) = lab_to_xyz_d50(l, a, b);
    let (x, y, z) = d50_to_d65(x, y, z);
    xyz_d65_to_linear_srgb(x, y, z)
}

/// `lch(L C H)` の極座標を `lab()` の直交座標へ直す。
///
/// `h` は度。負や 360 以上でも `libm` の三角関数がそのまま扱えるが、
/// 実装の意図を明示するため呼び出し側で正規化してから渡すのが望ましい。
pub fn lch_to_lab(l: f32, c: f32, h_deg: f32) -> (f32, f32, f32) {
    let rad = h_deg * core::f32::consts::PI / 180.0;
    (l, c * libm::cosf(rad), c * libm::sinf(rad))
}

/// 線形 sRGB の 3 成分を 0-255 の ARGB 各チャンネルへ符号化する。
///
/// 丸めは四捨五入。単純な切り捨てだと行列係数の丸め誤差で
/// 255 になるべき白が 254 へ落ちる（`oklab()` 実装で実際に起きた）。
pub fn linear_srgb_to_rgb8(r: f32, g: f32, b: f32) -> (u32, u32, u32) {
    let enc = |c: f32| -> u32 {
        libm::roundf((linear_to_srgb(c) * 255.0).clamp(0.0, 255.0)) as u32
    };
    (enc(r), enc(g), enc(b))
}