dymokomi/luce-raw
Source of release 0.8.0
0.8.0 / 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