cmm: add color-management module

src/cmm/cmm_transform.rs

@@ -0,0 +1,258 @@
+use {
+    crate::{
+        cmm::{cmm_primaries::Primaries, cmm_transfer_function::TransferFunction},
+        theme::Color,
+        utils::{debug_fn::debug_fn, ordered_float::F64},
+    },
+    std::{
+        fmt::{Debug, Formatter},
+        hash::{Hash, Hasher},
+        marker::PhantomData,
+        ops::{Mul, MulAssign},
+    },
+};
+
+pub struct ColorMatrix<To = Local, From = Local>(pub [[F64; 4]; 3], PhantomData<(To, From)>);
+
+#[derive(Copy, Clone)]
+pub struct Local;
+#[derive(Copy, Clone)]
+pub struct Xyz;
+#[derive(Copy, Clone)]
+pub struct Bradford;
+
+impl<T, U> Copy for ColorMatrix<T, U> {}
+
+impl<T, U> Clone for ColorMatrix<T, U> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T, U> PartialEq<Self> for ColorMatrix<T, U> {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+
+impl<T, U> Eq for ColorMatrix<T, U> {}
+
+impl<T, U> Hash for ColorMatrix<T, U> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.hash(state);
+    }
+}
+
+impl<T, U> Debug for ColorMatrix<T, U> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("ColorMatrix")
+            .field(&format_matrix(&self.0))
+            .finish()
+    }
+}
+
+fn format_matrix<'a>(m: &'a [[F64; 4]; 3]) -> impl Debug + use<'a> {
+    debug_fn(move |f| {
+        let iter = m
+            .iter()
+            .copied()
+            .chain(Some([F64(0.0), F64(0.0), F64(0.0), F64(1.0)]))
+            .enumerate();
+        if f.alternate() {
+            for (idx, row) in iter {
+                if idx > 0 {
+                    f.write_str("\n")?;
+                }
+                write!(
+                    f,
+                    "{:7.4} {:7.4} {:7.4} {:7.4}",
+                    row[0], row[1], row[2], row[3]
+                )?;
+            }
+        } else {
+            f.write_str("[")?;
+            for (idx, row) in iter {
+                if idx > 0 {
+                    f.write_str(", ")?;
+                }
+                write!(
+                    f,
+                    "[{:.4}, {:.4}, {:.4}, {:.4}]",
+                    row[0], row[1], row[2], row[3]
+                )?;
+            }
+            f.write_str("]")?;
+        }
+        Ok(())
+    })
+}
+
+impl<T, U, V> Mul<ColorMatrix<U, T>> for ColorMatrix<V, U> {
+    type Output = ColorMatrix<V, T>;
+
+    fn mul(self, rhs: ColorMatrix<U, T>) -> Self::Output {
+        let a = &self.0;
+        let b = &rhs.0;
+        macro_rules! mul {
+            ($ar:expr, $bc:expr) => {
+                a[$ar][0] * b[0][$bc] + a[$ar][1] * b[1][$bc] + a[$ar][2] * b[2][$bc]
+            };
+        }
+        let m = [
+            [mul!(0, 0), mul!(0, 1), mul!(0, 2), mul!(0, 3) + a[0][3]],
+            [mul!(1, 0), mul!(1, 1), mul!(1, 2), mul!(1, 3) + a[1][3]],
+            [mul!(2, 0), mul!(2, 1), mul!(2, 2), mul!(2, 3) + a[2][3]],
+        ];
+        ColorMatrix(m, PhantomData)
+    }
+}
+
+impl<U, V> MulAssign<ColorMatrix<U, U>> for ColorMatrix<V, U> {
+    fn mul_assign(&mut self, rhs: ColorMatrix<U, U>) {
+        *self = *self * rhs;
+    }
+}
+
+impl<T, U> Mul<[f64; 3]> for ColorMatrix<T, U> {
+    type Output = [f64; 3];
+
+    fn mul(self, rhs: [f64; 3]) -> Self::Output {
+        let a = &self.0;
+        macro_rules! mul {
+            ($ar:expr) => {
+                a[$ar][0].0 * rhs[0] + a[$ar][1].0 * rhs[1] + a[$ar][2].0 * rhs[2]
+            };
+        }
+        [mul!(0), mul!(1), mul!(2)]
+    }
+}
+
+impl<T, U> Mul<Color> for ColorMatrix<T, U> {
+    type Output = Color;
+
+    fn mul(self, rhs: Color) -> Self::Output {
+        let mut rgba = rhs.to_array(TransferFunction::Linear);
+        let a = rgba[3];
+        if a < 1.0 && a > 0.0 {
+            for c in &mut rgba[..3] {
+                *c /= a;
+            }
+        }
+        let [r, g, b] = self * [rgba[0] as f64, rgba[1] as f64, rgba[2] as f64];
+        let mut color = Color::new(TransferFunction::Linear, r as f32, g as f32, b as f32);
+        if a < 1.0 {
+            color = color * a;
+        }
+        color
+    }
+}
+
+impl<T, U> ColorMatrix<T, U> {
+    pub const fn new(m: [[f64; 4]; 3]) -> Self {
+        let m = [
+            [F64(m[0][0]), F64(m[0][1]), F64(m[0][2]), F64(m[0][3])],
+            [F64(m[1][0]), F64(m[1][1]), F64(m[1][2]), F64(m[1][3])],
+            [F64(m[2][0]), F64(m[2][1]), F64(m[2][2]), F64(m[2][3])],
+        ];
+        Self(m, PhantomData)
+    }
+
+    #[expect(dead_code)]
+    pub const fn to_f32(&self) -> [[f32; 4]; 4] {
+        let m = &self.0;
+        macro_rules! map {
+            ($r:expr, $c:expr) => {
+                m[$r][$c].0 as f32
+            };
+        }
+        [
+            [map!(0, 0), map!(0, 1), map!(0, 2), map!(0, 3)],
+            [map!(1, 0), map!(1, 1), map!(1, 2), map!(1, 3)],
+            [map!(2, 0), map!(2, 1), map!(2, 2), map!(2, 3)],
+            [0.0, 0.0, 0.0, 1.0],
+        ]
+    }
+}
+
+impl ColorMatrix<Bradford, Xyz> {
+    const BFD: Self = Self::new([
+        [0.8951, 0.2664, -0.1614, 0.0],
+        [-0.7502, 1.7135, 0.0367, 0.0],
+        [0.0389, -0.0685, 1.0296, 0.0],
+    ]);
+}
+
+impl ColorMatrix<Xyz, Bradford> {
+    const BFD_INV: Self = Self::new([
+        [0.9870, -0.1471, 0.1600, 0.0],
+        [0.4323, 0.5184, 0.0493, 0.0],
+        [-0.0085, 0.04, 0.9685, 0.0],
+    ]);
+}
+
+#[expect(non_snake_case)]
+pub fn bradford_adjustment(w_from: (F64, F64), w_to: (F64, F64)) -> ColorMatrix<Xyz, Xyz> {
+    let (F64(x_from), F64(y_from)) = w_from;
+    let (F64(x_to), F64(y_to)) = w_to;
+    let X_from = x_from / y_from;
+    let Z_from = (1.0 - x_from - y_from) / y_from;
+    let X_to = x_to / y_to;
+    let Z_to = (1.0 - x_to - y_to) / y_to;
+    let [R_from, G_from, B_from] = ColorMatrix::BFD * [X_from, 1.0, Z_from];
+    let [R_to, G_to, B_to] = ColorMatrix::BFD * [X_to, 1.0, Z_to];
+    let adj = ColorMatrix::new([
+        [R_to / R_from, 0.0, 0.0, 0.0],
+        [0.0, G_to / G_from, 0.0, 0.0],
+        [0.0, 0.0, B_to / B_from, 0.0],
+    ]);
+    ColorMatrix::BFD_INV * adj * ColorMatrix::BFD
+}
+
+impl Primaries {
+    #[expect(non_snake_case)]
+    pub const fn matrices(&self) -> (ColorMatrix<Xyz, Local>, ColorMatrix<Local, Xyz>) {
+        let (F64(xw), F64(yw)) = self.wp;
+        let Xw = xw / yw;
+        let Zw = (1.0 - xw - yw) / yw;
+        let (F64(xr), F64(yr)) = self.r;
+        let (F64(xg), F64(yg)) = self.g;
+        let (F64(xb), F64(yb)) = self.b;
+        let zr = 1.0 - xr - yr;
+        let zg = 1.0 - xg - yg;
+        let zb = 1.0 - xb - yb;
+        let srx = yg * zb - zg * yb;
+        let sry = zg * xb - xg * zb;
+        let srz = xg * yb - yg * xb;
+        let sgx = zr * yb - yr * zb;
+        let sgz = yr * xb - xr * yb;
+        let sgy = xr * zb - zr * xb;
+        let sbx = yr * zg - zr * yg;
+        let sby = zr * xg - xr * zg;
+        let sbz = xr * yg - yr * xg;
+        let det = srz + sgz + sbz;
+        let sr = srx * Xw + sry + srz * Zw;
+        let sg = sgx * Xw + sgy + sgz * Zw;
+        let sb = sbx * Xw + sby + sbz * Zw;
+        let det_inv = 1.0 / det;
+        let sr_inv = 1.0 / sr;
+        let sg_inv = 1.0 / sg;
+        let sb_inv = 1.0 / sb;
+        let srp = sr * det_inv;
+        let sgp = sg * det_inv;
+        let sbp = sb * det_inv;
+        let XYZ_from_local = [
+            [srp * xr, sgp * xg, sbp * xb, 0.0],
+            [srp * yr, sgp * yg, sbp * yb, 0.0],
+            [srp * zr, sgp * zg, sbp * zb, 0.0],
+        ];
+        let local_from_XYZ = [
+            [srx * sr_inv, sry * sr_inv, srz * sr_inv, 0.0],
+            [sgx * sg_inv, sgy * sg_inv, sgz * sg_inv, 0.0],
+            [sbx * sb_inv, sby * sb_inv, sbz * sb_inv, 0.0],
+        ];
+        (
+            ColorMatrix::new(XYZ_from_local),
+            ColorMatrix::new(local_from_XYZ),
+        )
+    }
+}