Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-raw

Source of release 0.8.2

0.8.2 / src / raw / color.lucb

#==============================================================================================
#
#   raw/color - Camera color: matrices, white balance and temperature/tint
#
#   DESCRIPTION:
#       A Development is what the pixel stages need: the white balance multipliers
#       for camera values and the matrix from white-balanced camera values to linear
#       sRGB. For DNG it follows the DNG specification: the two calibrated color
#       matrices interpolated in inverse temperature for the white, the forward
#       matrix when present, into XYZ D50 and by Bradford to sRGB's D65. Tabled
#       cameras use one D65 matrix as the Adobe converter and dcraw do. Temperature
#       and tint are Robertson's isotemperature lines, as Adobe's DNG SDK uses them.
#
#==============================================================================================

## sRGB's primaries in XYZ under D65 (columns red, green, blue).
let xyz_from_srgb: f64[9] = [0.412453, 0.357580, 0.180423, 0.212671, 0.715160, 0.072169, 0.019334, 0.119193, 0.950227]
## The Bradford cone response matrix.
let bradford: f64[9] = [0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296]
## D50 as DNG's profile connection space states it, and D65, as xy.
let d50_xy: f64[2] = [0.3457, 0.3585]
let d65_xy: f64[2] = [0.3127, 0.3290]
## Robertson's isotemperature lines: reciprocal megakelvin, u, v and slope.
let robertson: f64[124] = [
    0.0, 0.18006, 0.26352, -0.24341, 10.0, 0.18066, 0.26589, -0.25479, 20.0, 0.18133, 0.26846, -0.26876,
    30.0, 0.18208, 0.27119, -0.28539, 40.0, 0.18293, 0.27407, -0.30470, 50.0, 0.18388, 0.27709, -0.32675,
    60.0, 0.18494, 0.28021, -0.35156, 70.0, 0.18611, 0.28342, -0.37915, 80.0, 0.18740, 0.28668, -0.40955,
    90.0, 0.18880, 0.28997, -0.44278, 100.0, 0.19032, 0.29326, -0.47888, 125.0, 0.19462, 0.30141, -0.58204,
    150.0, 0.19962, 0.30921, -0.70471, 175.0, 0.20525, 0.31647, -0.84901, 200.0, 0.21142, 0.32312, -1.0182,
    225.0, 0.21807, 0.32909, -1.2168, 250.0, 0.22511, 0.33439, -1.4512, 275.0, 0.23247, 0.33904, -1.7298,
    300.0, 0.24010, 0.34308, -2.0637, 325.0, 0.24702, 0.34655, -2.4681, 350.0, 0.25591, 0.34951, -2.9641,
    375.0, 0.26400, 0.35200, -3.5814, 400.0, 0.27218, 0.35407, -4.3633, 425.0, 0.28039, 0.35577, -5.3762,
    450.0, 0.28863, 0.35714, -6.7262, 475.0, 0.29685, 0.35823, -8.5955, 500.0, 0.30505, 0.35907, -11.324,
    525.0, 0.31320, 0.35968, -15.628, 550.0, 0.32129, 0.36011, -23.325, 575.0, 0.32931, 0.36038, -40.770,
    600.0, 0.33724, 0.36051, -116.45]
let tint_scale: f64 = -3000.0

func multiply(a: f64[9], b: f64[9]) -> f64[9]:
    var out: f64[9]
    for i: usize in 0..<3:
        for j: usize in 0..<3:
            out[i * 3 + j] = a[i * 3] * b[j] + a[i * 3 + 1] * b[3 + j] + a[i * 3 + 2] * b[6 + j]
    return out

func apply(m: f64[9], v: f64[3]) -> f64[3]:
    return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]]

func diagonal(v: f64[3]) -> f64[9]:
    return [v[0], 0.0, 0.0, 0.0, v[1], 0.0, 0.0, 0.0, v[2]]

func blend(a: f64[9], b: f64[9], g: f64) -> f64[9]:
    var out: f64[9]
    for i: usize in 0..<9:
        out[i] = a[i] * g + b[i] * (1.0 - g)
    return out

func invert(m: f64[9]) -> f64[9]!:
    let a = m[4] * m[8] - m[5] * m[7]
    let b = m[5] * m[6] - m[3] * m[8]
    let c = m[3] * m[7] - m[4] * m[6]
    let det = m[0] * a + m[1] * b + m[2] * c
    if math.abs(det) < 1e-12 or not math.is_finite(det):
        error(corrupt, "raw color matrix is singular")
    let r = 1.0 / det
    return [a * r, (m[2] * m[7] - m[1] * m[8]) * r, (m[1] * m[5] - m[2] * m[4]) * r,
            b * r, (m[0] * m[8] - m[2] * m[6]) * r, (m[2] * m[3] - m[0] * m[5]) * r,
            c * r, (m[1] * m[6] - m[0] * m[7]) * r, (m[0] * m[4] - m[1] * m[3]) * r]

func xy_to_xyz(xy: f64[2]) -> f64[3]:
    let y = xy[1] if xy[1] > 1e-6 else 1e-6
    return [xy[0] / y, 1.0, (1.0 - xy[0] - xy[1]) / y]

func xyz_to_xy(v: f64[3]) -> f64[2]:
    let total = v[0] + v[1] + v[2]
    if total <= 0.0 or not math.is_finite(total):
        return d50_xy
    return [v[0] / total, v[1] / total]

## The Bradford adaptation from white `from_xy` to white `to_xy`.
func adaptation(from_xy: f64[2], to_xy: f64[2]) -> f64[9]!:
    let a = apply(bradford, xy_to_xyz(from_xy))
    let b = apply(bradford, xy_to_xyz(to_xy))
    let scale = diagonal([b[0] / a[0], b[1] / a[1], b[2] / a[2]])
    return multiply(try invert(bradford), multiply(scale, bradford))

## Linear sRGB from XYZ relative to D50, scaled so D50 maps to (1, 1, 1).
func srgb_from_d50() -> f64[9]!:
    var m = multiply(try invert(xyz_from_srgb), try adaptation(d50_xy, d65_xy))
    let white = apply(m, xy_to_xyz(d50_xy))
    for i: usize in 0..<9:
        m[i] /= white[i // 3]
    return m

## Temperature (kelvin) and tint of a white given as xy.
func temperature_of(xy: f64[2]) -> (f64, f64):
    let denominator = 1.5 - xy[0] + 6.0 * xy[1]
    let u = 2.0 * xy[0] / denominator
    let v = 3.0 * xy[1] / denominator
    var last_dt = 0.0
    var last_du = 0.0
    var last_dv = 0.0
    for index: usize in 1..=30:
        let row = index * 4
        var du = 1.0
        var dv = robertson[row + 3]
        var length = math.sqrt(1.0 + dv * dv)
        du /= length
        dv /= length
        var uu = u - robertson[row + 1]
        var vv = v - robertson[row + 2]
        var dt = -uu * dv + vv * du
        if dt <= 0.0 or index == 30:
            if dt > 0.0:
                dt = 0.0
            dt = -dt
            let f = 0.0 if index == 1 else dt / (last_dt + dt)
            let temperature = 1.0e6 / (robertson[row - 4] * f + robertson[row] * (1.0 - f))
            uu = u - (robertson[row - 3] * f + robertson[row + 1] * (1.0 - f))
            vv = v - (robertson[row - 2] * f + robertson[row + 2] * (1.0 - f))
            du = du * (1.0 - f) + last_du * f
            dv = dv * (1.0 - f) + last_dv * f
            length = math.sqrt(du * du + dv * dv)
            du /= length
            dv /= length
            return (temperature, (uu * du + vv * dv) * tint_scale)
        last_dt = dt
        last_du = du
        last_dv = dv
    return (5000.0, 0.0)

## The white xy of a temperature (kelvin) and tint.
func white_of(temperature: f64, tint: f64) -> f64[2]:
    let r = 1.0e6 / math.clamp(temperature, 1667.0, 50000.0)
    let offset = tint / tint_scale
    for index: usize in 0..<30:
        let row = index * 4
        if r < robertson[row + 4] or index == 29:
            let f = (robertson[row + 4] - r) / (robertson[row + 4] - robertson[row])
            var u = robertson[row + 1] * f + robertson[row + 5] * (1.0 - f)
            var v = robertson[row + 2] * f + robertson[row + 6] * (1.0 - f)
            let length1 = math.sqrt(1.0 + robertson[row + 3] * robertson[row + 3])
            let length2 = math.sqrt(1.0 + robertson[row + 7] * robertson[row + 7])
            var uu = (1.0 / length1) * f + (1.0 / length2) * (1.0 - f)
            var vv = (robertson[row + 3] / length1) * f + (robertson[row + 7] / length2) * (1.0 - f)
            let length3 = math.sqrt(uu * uu + vv * vv)
            uu /= length3
            vv /= length3
            u += uu * offset
            v += vv * offset
            return [1.5 * u / (u - 4.0 * v + 2.0), v / (u - 4.0 * v + 2.0)]
    return d50_xy