Add saturation, value, brightness and color blind views

src/analysis/mod.rs

@@ -1,5 +1,24 @@
 //! Analysis always uses source pixels, never the scaled preview.
 use std::collections::HashMap;
+pub mod vision;
+pub const LEVEL_BINS: usize = 20;
+
+#[derive(Default)]
+pub struct Distribution {
+    pub pixels: [u64; LEVEL_BINS],
+    pub colors: [u64; LEVEL_BINS],
+    pub pixel_sum: f64,
+    pub color_sum: f64,
+}
+impl Distribution {
+    fn add(&mut self, value: f64, count: u64) {
+        let bin = ((value.clamp(0.0, 1.0) * LEVEL_BINS as f64) as usize).min(LEVEL_BINS - 1);
+        self.pixels[bin] += count;
+        self.colors[bin] += 1;
+        self.pixel_sum += value * count as f64;
+        self.color_sum += value;
+    }
+}
 
 use crate::capture::Frame;
 
@@ -42,9 +61,14 @@ impl Region {
 pub struct Swatch {
     pub rgb: [u8; 3],
     pub count: u64,
+    pub opaque_count: u64,
 }
 
 pub struct Analysis {
+    pub saturation: Distribution,
+    pub brightness: Distribution,
+    pub luminance: Distribution,
+    pub vision: vision::Report,
     pub palette: Vec<Swatch>,
     pub pixels: u64,
     pub neutral_pixels: u64,
@@ -56,6 +80,10 @@ pub struct Analysis {
 impl Default for Analysis {
     fn default() -> Self {
         Self {
+            saturation: Distribution::default(),
+            brightness: Distribution::default(),
+            luminance: Distribution::default(),
+            vision: vision::Report::default(),
             palette: Vec::new(),
             pixels: 0,
             neutral_pixels: 0,
@@ -86,17 +114,22 @@ pub fn hsv(rgb: [u8; 3]) -> [f32; 3] {
 }
 
 pub fn analyze(rgba: &[u8]) -> Analysis {
-    let mut counts = HashMap::<[u8; 3], u64>::new();
+    let mut counts = HashMap::<[u8; 3], (u64, u64)>::new();
     for pixel in rgba.as_chunks::<4>().0 {
         // Ignore fully transparent pixels; count other captured RGB values exactly.
         if pixel[3] != 0 {
-            *counts.entry([pixel[0], pixel[1], pixel[2]]).or_default() += 1;
+            let entry = counts.entry([pixel[0], pixel[1], pixel[2]]).or_default();
+            entry.0 += 1;
+            entry.1 += u64::from(pixel[3] == 255);
         }
     }
     let mut result = Analysis::default();
-    for (rgb, count) in counts {
+    for (rgb, (count, opaque_count)) in counts {
         result.pixels += count;
-        let [h, s, _] = hsv(rgb);
+        let [h, s, v] = hsv(rgb);
+        result.saturation.add(s as f64, count);
+        result.brightness.add(v as f64, count);
+        result.luminance.add(vision::luminance(rgb), count);
         if s < NEUTRAL_SATURATION {
             result.neutral_pixels += count;
             result.neutral_colors += 1;
@@ -105,11 +138,16 @@ pub fn analyze(rgba: &[u8]) -> Analysis {
             result.hue_pixels[bin] += count;
             result.hue_colors[bin] += 1;
         }
-        result.palette.push(Swatch { rgb, count });
+        result.palette.push(Swatch {
+            rgb,
+            count,
+            opaque_count,
+        });
     }
     result
         .palette
         .sort_unstable_by(|a, b| b.count.cmp(&a.count).then(a.rgb.cmp(&b.rgb)));
+    result.vision = vision::check(&result.palette);
     result
 }
 
@@ -145,6 +183,29 @@ mod tests {
         );
     }
 
+    #[test]
+    fn saturation_value_and_luminance_include_endpoints_with_both_weights() {
+        let a = analyze(&[
+            0, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 255, 255, 0, 0, 255, 128, 128, 128, 255,
+            0, 255, 0, 0,
+        ]);
+        for d in [&a.saturation, &a.brightness, &a.luminance] {
+            assert_eq!(d.pixels.iter().sum::<u64>(), 5);
+            assert_eq!(d.colors.iter().sum::<u64>(), 4);
+        }
+        assert_eq!(a.saturation.pixels[0], 3);
+        assert_eq!(a.saturation.pixels[19], 2);
+        assert_eq!(a.saturation.colors[19], 1);
+        assert_eq!(a.brightness.pixels[0], 1);
+        assert_eq!(a.brightness.pixels[19], 3);
+        assert_eq!(a.luminance.pixels[19], 1);
+        assert!((a.saturation.pixel_sum / 5.0 - 0.4).abs() < 1e-9);
+        assert!((a.saturation.color_sum / 4.0 - 0.25).abs() < 1e-9);
+        let empty = analyze(&[]);
+        assert_eq!(empty.brightness.pixel_sum, 0.0);
+        assert_eq!(empty.vision.colors_checked, 0);
+    }
+
     #[test]
     fn crop_uses_source_coordinates_and_clamps() {
         let frame = Frame {

src/analysis/vision.rs

@@ -0,0 +1,296 @@
+//! Machado, Oliveira & Fernandes (2009), severity 1.0 matrices in linear RGB.
+//! https://www.inf.ufrgs.br/~oliveira/pubs_files/CVD_Simulation/CVD_Simulation.html
+//! Model also used by Chromium: https://developer.chrome.com/docs/chromium/cvd
+//! Matrix coefficients cross-checked against QGIS's published implementation:
+//! https://api.qgis.org/api/qgsprevieweffect_8cpp_source.html
+//! Pair warnings are our own heuristic, not a WCAG test or clinical prediction.
+use super::Swatch;
+use std::{collections::HashMap, sync::OnceLock};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum Vision {
+    #[default]
+    Original,
+    Protanopia,
+    Deuteranopia,
+    Tritanopia,
+    Grayscale,
+}
+
+impl Vision {
+    pub const CHECKS: [Self; 4] = [
+        Self::Protanopia,
+        Self::Deuteranopia,
+        Self::Tritanopia,
+        Self::Grayscale,
+    ];
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Original => "Original",
+            Self::Protanopia => "Protanopia (red-cone loss)",
+            Self::Deuteranopia => "Deuteranopia (green-cone loss)",
+            Self::Tritanopia => "Tritanopia (blue-cone loss)",
+            Self::Grayscale => "Grayscale (no color cues)",
+        }
+    }
+
+    fn linear(self, rgb: [f64; 3]) -> [f64; 3] {
+        let matrix = match self {
+            Self::Original => return rgb,
+            Self::Grayscale => return [luminance_linear(rgb); 3],
+            Self::Protanopia => [
+                [0.152286, 1.052583, -0.204868],
+                [0.114503, 0.786281, 0.099216],
+                [-0.003882, -0.048116, 1.051998],
+            ],
+            Self::Deuteranopia => [
+                [0.367322, 0.860646, -0.227968],
+                [0.280085, 0.672501, 0.047413],
+                [-0.011820, 0.042940, 0.968881],
+            ],
+            Self::Tritanopia => [
+                [1.255528, -0.076749, -0.178779],
+                [-0.078411, 0.930809, 0.147602],
+                [0.004733, 0.691367, 0.303900],
+            ],
+        };
+        matrix.map(|row| {
+            row.iter()
+                .zip(rgb)
+                .map(|(a, b)| a * b)
+                .sum::<f64>()
+                .clamp(0.0, 1.0)
+        })
+    }
+
+    pub fn simulate(self, rgb: [u8; 3]) -> [u8; 3] {
+        if self == Self::Original {
+            return rgb;
+        }
+        self.linear(linear_rgb(rgb)).map(encode)
+    }
+}
+
+fn decode(value: u8) -> f64 {
+    let value = value as f64 / 255.0;
+    if value <= 0.04045 {
+        value / 12.92
+    } else {
+        ((value + 0.055) / 1.055).powf(2.4)
+    }
+}
+
+fn encode(value: f64) -> u8 {
+    let value = value.clamp(0.0, 1.0);
+    let value = if value <= 0.0031308 {
+        value * 12.92
+    } else {
+        1.055 * value.powf(1.0 / 2.4) - 0.055
+    };
+    (value * 255.0).round() as u8
+}
+
+pub fn linear_rgb(rgb: [u8; 3]) -> [f64; 3] {
+    static LINEAR: OnceLock<[f64; 256]> = OnceLock::new();
+    let table = LINEAR.get_or_init(|| std::array::from_fn(|i| decode(i as u8)));
+    rgb.map(|v| table[v as usize])
+}
+
+fn luminance_linear([r, g, b]: [f64; 3]) -> f64 {
+    0.2126 * r + 0.7152 * g + 0.0722 * b
+}
+pub fn luminance(rgb: [u8; 3]) -> f64 {
+    luminance_linear(linear_rgb(rgb))
+}
+
+// OKLab reference transform: https://bottosson.github.io/posts/oklab/
+fn oklab([r, g, b]: [f64; 3]) -> [f64; 3] {
+    let l = (0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b).cbrt();
+    let m = (0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b).cbrt();
+    let s = (0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b).cbrt();
+    [
+        0.2104542553 * l + 0.7936177850 * m - 0.0040720468 * s,
+        1.9779984951 * l - 2.4285922050 * m + 0.4505937099 * s,
+        0.0259040371 * l + 0.7827717662 * m - 0.8086757660 * s,
+    ]
+}
+
+fn distance(a: [f64; 3], b: [f64; 3]) -> f64 {
+    a.iter()
+        .zip(b)
+        .map(|(a, b)| (a - b).powi(2))
+        .sum::<f64>()
+        .sqrt()
+}
+
+pub fn simulate_rgba(rgba: &[u8], mode: Vision) -> Vec<u8> {
+    let mut output = rgba.to_vec();
+    if mode == Vision::Original {
+        return output;
+    }
+    let mut cache = HashMap::new();
+    for pixel in output.as_chunks_mut::<4>().0 {
+        if pixel[3] == 0 {
+            continue;
+        }
+        let rgb = [pixel[0], pixel[1], pixel[2]];
+        pixel[..3].copy_from_slice(cache.entry(rgb).or_insert_with(|| mode.simulate(rgb)));
+    }
+    output
+}
+
+pub const MAX_COLORS: usize = 64;
+#[derive(Debug)]
+pub struct PairWarning {
+    pub a: [u8; 3],
+    pub b: [u8; 3],
+    pub before: f64,
+    pub after: f64,
+}
+
+pub struct Scenario {
+    pub mode: Vision,
+    pub pairs: Vec<PairWarning>,
+}
+
+#[derive(Default)]
+pub struct Report {
+    pub scenarios: Vec<Scenario>,
+    pub colors_checked: usize,
+    pub opaque_colors: usize,
+    pub pixels_checked: u64,
+    pub opaque_pixels: u64,
+}
+
+pub fn check(palette: &[Swatch]) -> Report {
+    // Only opaque colors: imported alpha pixels have an unknown backdrop.
+    let mut colors: Vec<_> = palette.iter().filter(|s| s.opaque_count > 0).collect();
+    colors.sort_unstable_by(|a, b| b.opaque_count.cmp(&a.opaque_count).then(a.rgb.cmp(&b.rgb)));
+    let opaque_colors = colors.len();
+    let opaque_pixels = colors.iter().map(|s| s.opaque_count).sum();
+    colors.truncate(MAX_COLORS);
+    let mut report = Report {
+        colors_checked: colors.len(),
+        opaque_colors,
+        pixels_checked: colors.iter().map(|s| s.opaque_count).sum(),
+        opaque_pixels,
+        scenarios: Vec::new(),
+    };
+    let originals: Vec<_> = colors.iter().map(|s| oklab(linear_rgb(s.rgb))).collect();
+    for mode in Vision::CHECKS {
+        let simulated: Vec<_> = colors
+            .iter()
+            .map(|s| oklab(mode.linear(linear_rgb(s.rgb))))
+            .collect();
+        let mut pairs = Vec::new();
+        for a in 0..colors.len() {
+            for b in a + 1..colors.len() {
+                let before = distance(originals[a], originals[b]);
+                let after = distance(simulated[a], simulated[b]);
+                // Deliberately exclude pairs already similar in the original.
+                // These are tunable screening thresholds, not visibility limits.
+                if before >= 0.08 && after <= 0.04 && after <= before * 0.5 {
+                    pairs.push(PairWarning {
+                        a: colors[a].rgb,
+                        b: colors[b].rgb,
+                        before,
+                        after,
+                    });
+                }
+            }
+        }
+        pairs.sort_by(|a, b| {
+            a.after
+                .total_cmp(&b.after)
+                .then(a.a.cmp(&b.a))
+                .then(a.b.cmp(&b.b))
+        });
+        report.scenarios.push(Scenario { mode, pairs });
+    }
+    report
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn gamma_roundtrip_luminance_and_neutrals() {
+        for c in 0..=255 {
+            assert_eq!(encode(decode(c)), c);
+            for mode in Vision::CHECKS {
+                assert_eq!(mode.simulate([c; 3]), [c; 3]);
+            }
+        }
+        assert_eq!(luminance([0; 3]), 0.0);
+        assert!((luminance([255; 3]) - 1.0).abs() < 1e-9);
+        assert!((luminance([128; 3]) - 0.2158605).abs() < 1e-6);
+        assert!(luminance([0, 255, 0]) > luminance([255, 0, 0]));
+    }
+    #[test]
+    fn known_primary_simulations_use_linear_light() {
+        // Independently calculated from severity-1 matrix columns + sRGB OETF.
+        assert_eq!(Vision::Protanopia.simulate([255, 0, 0]), [109, 95, 0]);
+        assert_eq!(Vision::Deuteranopia.simulate([255, 0, 0]), [163, 144, 0]);
+        assert_eq!(Vision::Tritanopia.simulate([0, 0, 255]), [0, 107, 150]);
+        assert_eq!(Vision::Grayscale.simulate([255, 0, 0]), [127; 3]);
+    }
+    #[test]
+    fn preserves_alpha_and_original_pixels() {
+        let pixels = [255, 0, 0, 128, 4, 5, 6, 0];
+        assert_eq!(simulate_rgba(&pixels, Vision::Original), pixels);
+        let simulated = simulate_rgba(&pixels, Vision::Deuteranopia);
+        assert_eq!(simulated[3], 128);
+        assert_eq!(&simulated[4..], &pixels[4..]);
+    }
+    #[test]
+    fn warns_for_merging_colors_but_not_existing_gray_similarity() {
+        // Red and this green have nearly equal luminance but different hues.
+        let analysis = super::super::analyze(&[255, 0, 0, 255, 0, 148, 0, 255]);
+        let report = check(&analysis.palette);
+        assert_eq!(report.scenarios.last().unwrap().pairs.len(), 1);
+        let gray = super::super::analyze(&[
+            128, 128, 128, 255, 129, 129, 129, 255, 0, 0, 0, 255, 255, 255, 255, 255,
+        ]);
+        assert!(
+            check(&gray.palette)
+                .scenarios
+                .iter()
+                .all(|s| s.pairs.is_empty())
+        );
+    }
+    #[test]
+    fn catches_red_green_confusion_under_deuteranopia() {
+        let a = super::super::analyze(&[255, 0, 0, 255, 0, 173, 0, 255]);
+        let report = check(&a.palette);
+        let deutan = report
+            .scenarios
+            .iter()
+            .find(|s| s.mode == Vision::Deuteranopia)
+            .unwrap();
+        assert_eq!(deutan.pairs.len(), 1);
+        assert!(deutan.pairs[0].before > deutan.pairs[0].after * 2.0);
+    }
+
+    #[test]
+    fn coverage_is_bounded_and_alpha_is_not_a_pass() {
+        let palette: Vec<_> = (0..100)
+            .map(|i| Swatch {
+                rgb: [i, 0, 0],
+                count: 1,
+                opaque_count: 1,
+            })
+            .collect();
+        let report = check(&palette);
+        assert_eq!(
+            (
+                report.colors_checked,
+                report.opaque_colors,
+                report.pixels_checked,
+                report.opaque_pixels
+            ),
+            (64, 100, 64, 100)
+        );
+        let transparent = super::super::analyze(&[255, 0, 0, 128, 0, 148, 0, 0]);
+        assert_eq!(check(&transparent.palette).colors_checked, 0);
+    }
+}