Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-color

Source of release 0.8.1

0.8.1 / src / temperature.lucb

## Correlated color temperature and tint: a white point named the way photo editors
## name it, in kelvin along the Planckian locus and a tint off it (green negative,
## magenta positive), and back. Robertson's method on his table of isotemperature
## lines in CIE 1960 uv, with the DNG SDK's tint scale (−3000 per uv unit), so a
## temperature and tint mean the same white as in Adobe's raw converters and in
## luce-raw. Temperatures run from 1667 K to 50000 K.
from luce_std import math
import xyz

## Robertson's table: per row, the reciprocal temperature (mireds), u, v and the
## isotemperature line's 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]

## uv distance off the locus per unit of tint (the DNG SDK's scale).
let tint_scale: f64 = -3000.0

## The white of `kelvin` (clamped to 1667–50000) and `tint`.
pub func white(kelvin: f64, tint: f64 = 0.0) -> xyz.Chromaticity:
    let r = 1.0e6 / math.clamp(kelvin, 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 du = (1.0 / length1) * f + (1.0 / length2) * (1.0 - f)
            var dv = (robertson[row + 3] / length1) * f + (robertson[row + 7] / length2) * (1.0 - f)
            let length3 = math.sqrt(du * du + dv * dv)
            du /= length3
            dv /= length3
            u += du * offset
            v += dv * offset
            return xyz.Chromaticity(1.5 * u / (u - 4.0 * v + 2.0), v / (u - 4.0 * v + 2.0))
    return xyz.d50

## The temperature (kelvin) and tint of the white `point`.
pub func of(point: xyz.Chromaticity) -> (f64, f64):
    let denominator = 1.5 - point.x + 6.0 * point.y
    let u = 2.0 * point.x / denominator
    let v = 3.0 * point.y / 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 kelvin = 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 (kelvin, (uu * du + vv * dv) * tint_scale)
        last_dt = dt
        last_du = du
        last_dv = dv
    return (5000.0, 0.0)

test "D65 is about 6504 K, a little magenta of the locus (tint +10), and D50 about 5003 K":
    let (d65_kelvin, d65_tint) = of(xyz.d65)
    assert(math.abs(d65_kelvin - 6504.0) < 3.0 and math.abs(d65_tint - 9.8) < 1.0)
    let (d50_kelvin, _) = of(xyz.d50)
    assert(math.abs(d50_kelvin - 5003.0) < 3.0)

test "a white and its temperature round-trip":
    for kelvin in [2000.0, 3200.0, 5500.0, 6500.0, 9000.0, 20000.0]:
        for tint in [-40.0, 0.0, 25.0]:
            let (back_kelvin, back_tint) = of(white(kelvin, tint))
            assert(math.abs(back_kelvin - kelvin) < 0.01 * kelvin and math.abs(back_tint - tint) < 0.5)