// Port of jxl-color/src/ciexyz.rs.
///|
let mat_bradford : FixedArray[Float] = [
0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296,
]
///|
let mat_bradford_inv : FixedArray[Float] = [
0.9869929, -0.1470543, 0.1599627, 0.4323053, 0.5183603, 0.0492912, -0.0085287,
0.0400428, 0.9684867,
]
///|
/// Types that represent an illuminant (white point) as xy-chromaticity.
pub(open) trait AsIlluminant {
fn as_illuminant(Self) -> FixedArray[Float]
}
///|
/// Types that represent RGB primaries as xy-chromaticity (`[[x, y]; 3]`).
pub(open) trait AsPrimaries {
fn as_primaries(Self) -> FixedArray[FixedArray[Float]]
}
///|
pub impl AsIlluminant for FixedArray[Float] with fn as_illuminant(self) {
self
}
///|
pub impl AsIlluminant for WhitePoint with fn as_illuminant(self) {
match self {
D65 => illuminant_d65
Custom(xy) => xy.as_float()
E => illuminant_e
Dci => illuminant_dci
}
}
///|
pub impl AsPrimaries for FixedArray[FixedArray[Float]] with fn as_primaries(
self,
) {
self
}
///|
pub impl AsPrimaries for Primaries with fn as_primaries(self) {
match self {
Srgb => primaries_srgb
Custom(red~, green~, blue~) =>
[red.as_float(), green.as_float(), blue.as_float()]
Bt2100 => primaries_bt2100
P3 => primaries_p3
}
}
///|
pub fn matmul3(
a : FixedArray[Float],
b : FixedArray[Float],
) -> FixedArray[Float] {
let bcol0 : FixedArray[Float] = [b[0], b[3], b[6]]
let bcol1 : FixedArray[Float] = [b[1], b[4], b[7]]
let bcol2 : FixedArray[Float] = [b[2], b[5], b[8]]
[
a[0] * bcol0[0] + a[1] * bcol0[1] + a[2] * bcol0[2],
a[0] * bcol1[0] + a[1] * bcol1[1] + a[2] * bcol1[2],
a[0] * bcol2[0] + a[1] * bcol2[1] + a[2] * bcol2[2],
a[3] * bcol0[0] + a[4] * bcol0[1] + a[5] * bcol0[2],
a[3] * bcol1[0] + a[4] * bcol1[1] + a[5] * bcol1[2],
a[3] * bcol2[0] + a[4] * bcol2[1] + a[5] * bcol2[2],
a[6] * bcol0[0] + a[7] * bcol0[1] + a[8] * bcol0[2],
a[6] * bcol1[0] + a[7] * bcol1[1] + a[8] * bcol1[2],
a[6] * bcol2[0] + a[7] * bcol2[1] + a[8] * bcol2[2],
]
}
///|
pub fn matmul3vec(
a : FixedArray[Float],
b : FixedArray[Float],
) -> FixedArray[Float] {
[
a[0] * b[0] + a[1] * b[1] + a[2] * b[2],
a[3] * b[0] + a[4] * b[1] + a[5] * b[2],
a[6] * b[0] + a[7] * b[1] + a[8] * b[2],
]
}
///|
pub fn matinv(mat : FixedArray[Float]) -> FixedArray[Float] {
let det = mat[0] * (mat[4] * mat[8] - mat[5] * mat[7]) +
mat[1] * (mat[5] * mat[6] - mat[3] * mat[8]) +
mat[2] * (mat[3] * mat[7] - mat[4] * mat[6])
[
(mat[4] * mat[8] - mat[5] * mat[7]) / det,
(mat[7] * mat[2] - mat[8] * mat[1]) / det,
(mat[1] * mat[5] - mat[2] * mat[4]) / det,
(mat[5] * mat[6] - mat[3] * mat[8]) / det,
(mat[8] * mat[0] - mat[6] * mat[2]) / det,
(mat[2] * mat[3] - mat[0] * mat[5]) / det,
(mat[3] * mat[7] - mat[4] * mat[6]) / det,
(mat[6] * mat[1] - mat[7] * mat[0]) / det,
(mat[0] * mat[4] - mat[1] * mat[3]) / det,
]
}
///|
pub fn[I : AsIlluminant] illuminant_to_xyz(illuminant : I) -> FixedArray[Float] {
let xy = illuminant.as_illuminant()
let x = xy[0]
let y = xy[1]
[x / y, 1.0, ((1.0 : Float) - x) / y - 1.0]
}
///|
pub fn[F : AsIlluminant, T : AsIlluminant] adapt_mat(
from_illuminant : F,
to_illuminant : T,
) -> FixedArray[Float] {
let from_w = illuminant_to_xyz(from_illuminant)
let to_w = illuminant_to_xyz(to_illuminant)
if from_w[0] == to_w[0] && from_w[1] == to_w[1] && from_w[2] == to_w[2] {
return [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0]
}
let from_lms = matmul3vec(mat_bradford, from_w)
let to_lms = matmul3vec(mat_bradford, to_w)
let mul : FixedArray[Float] = [
to_lms[0] / from_lms[0],
to_lms[1] / from_lms[1],
to_lms[2] / from_lms[2],
]
let multiplied = FixedArray::makei(9, idx => mat_bradford[idx] * mul[idx / 3])
matmul3(mat_bradford_inv, multiplied)
}
///|
fn primaries_matrix(p : FixedArray[FixedArray[Float]]) -> FixedArray[Float] {
[
p[0][0],
p[1][0],
p[2][0],
p[0][1],
p[1][1],
p[2][1],
(1.0 : Float) - p[0][0] - p[0][1],
(1.0 : Float) - p[1][0] - p[1][1],
(1.0 : Float) - p[2][0] - p[2][1],
]
}
///|
pub fn[P : AsPrimaries, W : AsIlluminant] primaries_to_xyz_mat(
primaries : P,
wp : W,
) -> FixedArray[Float] {
let primaries = primaries_matrix(primaries.as_primaries())
let primaries_inv = matinv(primaries)
let w_xyz = illuminant_to_xyz(wp)
let mul = matmul3vec(primaries_inv, w_xyz)
for idx in 0..<9 {
primaries[idx] = primaries[idx] * mul[idx % 3]
}
primaries
}
///|
pub fn[P : AsPrimaries, W : AsIlluminant] xyz_to_primaries_mat(
primaries : P,
wp : W,
) -> FixedArray[Float] {
let primaries = primaries_matrix(primaries.as_primaries())
let primaries_inv = matinv(primaries)
let w_xyz = illuminant_to_xyz(wp)
let mul = matmul3vec(primaries_inv, w_xyz)
for idx in 0..<9 {
primaries_inv[idx] = primaries_inv[idx] / mul[idx / 3]
}
primaries_inv
}