halide_color_space.h

Go to the documentation of this file.

 
#pragma once
 
#include <Halide.h>
 
namespace CaptureMoment::Core::Pipeline {
 
namespace ColorSpace {
 
inline Halide::Func rgbToOklab(const Halide::Func& input, const Halide::Var& x, const Halide::Var& y, const Halide::Var& c)
{
    Halide::Func oklab_func("rgb_to_oklab");
 
    // 1. Read linear RGB (assumes input is already linear, if sRGB, add gamma removal here)
    Halide::Expr r { input(x, y, 0) };
    Halide::Expr g { input(x, y, 1) };
    Halide::Expr b { input(x, y, 2) };
 
    // 2. Linear RGB to LMS (Cone responses)
    Halide::Expr l { 0.4122214708f * r + 0.5363325363f * g + 0.0514459929f * b };
    Halide::Expr m { 0.2119034982f * r + 0.6806995451f * g + 0.1073969566f * b };
    Halide::Expr s { 0.0883024619f * r + 0.2817188376f * g + 0.6299787005f * b };
 
    // 3. Cube root of LMS (Sign-aware to prevent NaN on negative values)
    // Halide::select is evaluated per-pixel at compile time to generate branching-less SIMD code.
    Halide::Expr l_ { select(l >= 0.0f, pow(l, 1.0f / 3.0f), -pow(-l, 1.0f / 3.0f)) };
    Halide::Expr m_ { select(m >= 0.0f, pow(m, 1.0f / 3.0f), -pow(-m, 1.0f / 3.0f)) };
    Halide::Expr s_ { select(s >= 0.0f, pow(s, 1.0f / 3.0f), -pow(-s, 1.0f / 3.0f)) };
 
    // 4. LMS' to Oklab using M2 matrix
    Halide::Expr L { 0.2104542553f * l_ + 0.7936177850f * m_ - 0.0040720468f * s_ };
    Halide::Expr a { 1.9779984951f * l_ - 2.4285922050f * m_ + 0.4505937099f * s_ };
    Halide::Expr b_val { 0.0259040371f * l_ + 0.7827717662f * m_ - 0.8086757660f * s_ };
 
    // 5. Define the output, preserving Alpha on channel 3
    oklab_func(x, y, c) = select(
        c == 0, L,
        c == 1, a,
        c == 2, b_val,
        input(x, y, c) // c == 3 (Alpha)
    );
 
    return oklab_func;
}
 
inline Halide::Func oklabToRgb(const Halide::Func& input, const Halide::Var& x, const Halide::Var& y, const Halide::Var& c)
{
 
    Halide::Func rgb_func("oklab_to_rgb");
 
    // 1. Read Oklab
    Halide::Expr L { input(x, y, 0) };
    Halide::Expr a { input(x, y, 1) };
    Halide::Expr b_val { input(x, y, 2) };
 
    // 2. Oklab to LMS' (Inverse M2 matrix)
    Halide::Expr l_ { L + 0.3963377774f * a + 0.2158037573f * b_val };
    Halide::Expr m_ { L - 0.1055613458f * a - 0.0638541728f * b_val };
    Halide::Expr s_ { L - 0.0894841775f * a - 1.2914855480f * b_val };
 
    // 3. Cube LMS' (Inverse perceptual non-linearity)
    // No need for select() here, multiplying a negative number by itself stays safe.
    Halide::Expr l { l_ * l_ * l_ };
    Halide::Expr m { m_ * m_ * m_ };
    Halide::Expr s { s_ * s_ * s_ };
 
    // 4. LMS to Linear RGB (Inverse M1 matrix)
    Halide::Expr r { +4.0767416621f * l - 3.3077115913f * m + 0.2309699292f * s };
    Halide::Expr g { -1.2684380046f * l + 2.6097574011f * m - 0.3413193965f * s };
    Halide::Expr b_out { -0.0041960863f * l - 0.7034186147f * m + 1.7076147010f * s };
 
    // 5. Define the output, preserving Alpha
    rgb_func(x, y, c) = select(
        c == 0, r,
        c == 1, g,
        c == 2, b_out,
        input(x, y, c) // c == 3 (Alpha)
    );
 
    return rgb_func;
}
 
} // namespace ColorSpace
 
} // namespace CaptureMoment::Core::Pipeline