use kallo_spectral::Spectrum;
use crate::model::{PrintModel, inverse3, table, tables};
use crate::scan::solve3;
use crate::spectral::{GRID_LEN, GRID_START_NM, GRID_STEP_NM};
#[derive(Debug, Clone, Copy)]
struct Band {
peak_nm: f64,
width_nm: f64,
}
const DYE_BANDS: [Band; 3] = [
Band {
peak_nm: 650.0,
width_nm: 55.0,
},
Band {
peak_nm: 550.0,
width_nm: 50.0,
},
Band {
peak_nm: 450.0,
width_nm: 55.0,
},
];
const FILTER_BANDS: [Band; 3] = [
Band {
peak_nm: 450.0,
width_nm: 55.0,
},
Band {
peak_nm: 550.0,
width_nm: 50.0,
},
Band {
peak_nm: 650.0,
width_nm: 55.0,
},
];
const PAPER_BANDS: [Band; 3] = [
Band {
peak_nm: 650.0,
width_nm: 45.0,
},
Band {
peak_nm: 550.0,
width_nm: 40.0,
},
Band {
peak_nm: 450.0,
width_nm: 45.0,
},
];
#[derive(Debug, Clone, Copy)]
pub struct Masking {
pub strength: [f64; 3],
pub reference_density: f64,
}
impl Default for Masking {
fn default() -> Self {
Self {
strength: [1.0, 0.0, 0.0],
reference_density: 2.0,
}
}
}
impl Masking {
#[must_use]
pub fn surviving(&self, density_cmy: [f64; 3]) -> f64 {
let reference = self.reference_density.max(1e-9);
let removed: f64 = density_cmy
.iter()
.zip(&self.strength)
.map(|(density, strength)| strength * (density / reference).clamp(0.0, 1.0))
.sum();
(1.0 - removed).clamp(0.0, 1.0)
}
}
#[derive(Debug, Clone)]
pub struct PrintContext {
grid: Spectrum,
dye: [Spectrum; 3],
paper: [Spectrum; 3],
reference: [f64; 3],
reference_density: [f64; 3],
filters: [f64; 3],
filter_bands: [Spectrum; 3],
illuminant: Spectrum,
base_density: Option<Spectrum>,
masking: Option<Masking>,
}
impl PrintContext {
#[must_use]
pub fn new(reference_density: [f64; 3]) -> Self {
let grid = Spectrum::uniform(GRID_START_NM, GRID_STEP_NM, GRID_LEN)
.expect("the internal grid is a valid constant");
let dye: [Spectrum; 3] = DYE_BANDS.map(|band| gaussian(&grid, band));
let paper: [Spectrum; 3] = PAPER_BANDS.map(|band| normalised(gaussian(&grid, band)));
let filter_bands: [Spectrum; 3] = FILTER_BANDS.map(|band| gaussian(&grid, band));
let illuminant = Spectrum::filled(grid.clone(), 1.0);
let mut context = Self {
grid,
dye,
paper,
reference: [1.0; 3],
reference_density,
filters: [0.0; 3],
filter_bands,
illuminant,
base_density: None,
masking: None,
};
let neutral_level =
(reference_density[0] + reference_density[1] + reference_density[2]) / 3.0;
context.reference = context.balanced([neutral_level; 3]);
context
}
#[must_use]
pub fn with_dyes(mut self, dye: [Spectrum; 3]) -> Self {
self.dye = dye.map(|spectrum| spectrum.resampled(&self.grid));
self.reference = self.balanced(self.reference_density);
self
}
#[must_use]
pub fn balance_gain(&self, neutral_density: f64) -> [f64; 3] {
let response = self.response([neutral_density; 3]);
let target = (response[0] * response[1] * response[2]).cbrt();
std::array::from_fn(|layer| target / response[layer].max(1e-12))
}
#[must_use]
pub fn with_enlarger(
mut self,
pack: crate::filters::FilterPack,
glass: Option<crate::filters::HeatGlass>,
) -> Self {
if pack.is_empty() && glass.is_none() {
return self;
}
let lamp = crate::filters::lamp(3200.0);
let pack_transmission = pack.transmittance();
let glass_transmission = glass.map(|heat| heat.transmittance(2.0));
let mut transmission = [0.0_f64; GRID_LEN];
for (index, value) in transmission.iter_mut().enumerate() {
let heat = glass_transmission.map_or(1.0, |values| values[index]);
*value = lamp[index] * pack_transmission[index] * heat;
}
let peak = transmission
.iter()
.copied()
.fold(0.0_f64, f64::max)
.max(1e-12);
for (value, sample) in self.illuminant.values_mut().iter_mut().zip(transmission) {
*value = sample / peak;
}
self.filters = [0.0, 0.0, 0.0];
self
}
#[must_use]
pub fn with_filters(mut self, filters: [f64; 3]) -> Self {
self.filters = filters;
self.reference = self.balanced(self.reference_density);
self
}
#[must_use]
pub fn solve_filters(&self, density: f64) -> [f64; 3] {
let spread = |candidate: Self| {
let response = candidate.response([density; 3]);
let target = (response[0] * response[1] * response[2]).cbrt();
let gains: [f64; 3] = std::array::from_fn(|i| target / response[i].max(1e-12));
gains.iter().copied().fold(f64::NEG_INFINITY, f64::max)
- gains.iter().copied().fold(f64::INFINITY, f64::min)
};
let mut best = (f64::INFINITY, [0.0; 3]);
let mut step = 10.0_f64;
let mut centre = [0.0_f64; 3];
for _ in 0..4 {
for yellow in 0..=20 {
for magenta in 0..=20 {
let candidate = [
centre[0] + (f64::from(yellow) - 10.0) * step,
centre[1] + (f64::from(magenta) - 10.0) * step,
0.0,
]
.map(|value| value.max(0.0));
let value = spread(self.clone().with_filters(candidate));
if value < best.0 {
best = (value, candidate);
}
}
}
centre = best.1;
step /= 5.0;
}
best.1
}
#[must_use]
pub fn measured(reference_density: [f64; 3]) -> Self {
Self::measured_with(
reference_density,
&crate::measured::FILM_DYES,
&crate::measured::FILM_MASK,
&crate::measured::PAPER_LAYERS,
)
}
#[must_use]
pub fn measured_with(
reference_density: [f64; 3],
film_dyes: &[[f64; crate::spectral::GRID_LEN]; 3],
film_mask: &[f64; crate::spectral::GRID_LEN],
paper_layers: &[[f64; crate::spectral::GRID_LEN]; 3],
) -> Self {
Self::new(reference_density)
.with_spectra(
film_dyes.map(|table| crate::measured::spectrum(&table)),
paper_layers.map(|table| crate::measured::spectrum(&table)),
)
.with_base_density(crate::measured::spectrum(film_mask))
.with_masking(Masking::default())
}
#[must_use]
pub fn with_base_density(mut self, base: Spectrum) -> Self {
let base = base.resampled(&self.grid);
self.base_density = Some(base);
self.reference = self.balanced(self.reference_density);
self
}
#[must_use]
pub fn with_masking(mut self, masking: Masking) -> Self {
self.masking = Some(masking);
self.reference = self.balanced(self.reference_density);
self
}
#[must_use]
pub fn with_spectra(mut self, dye: [Spectrum; 3], paper: [Spectrum; 3]) -> Self {
self.dye = dye.map(|spectrum| spectrum.resampled(&self.grid));
self.paper = paper.map(|spectrum| spectrum.resampled(&self.grid));
self.reference = self.balanced(self.reference_density);
self
}
#[must_use]
pub fn grid(&self) -> &Spectrum {
&self.grid
}
#[must_use]
pub fn expose(&self, density_cmy: [f64; 3]) -> [f64; 3] {
let response = self.balanced(density_cmy);
std::array::from_fn(|layer| {
let ratio = response[layer] / self.reference[layer].max(1e-12);
ratio.max(1e-10).log10()
})
}
fn balanced(&self, density_cmy: [f64; 3]) -> [f64; 3] {
let response = self.response(density_cmy);
let mean = (density_cmy[0] + density_cmy[1] + density_cmy[2]) / 3.0;
let neutral = self.response([mean; 3]);
let target = (neutral[0] * neutral[1] * neutral[2]).cbrt();
std::array::from_fn(|layer| {
let scale = target / neutral[layer].max(1e-12);
response[layer] * scale
})
}
fn analytical_matrix(&self) -> [[f64; 3]; 3] {
let probes = [650.0, 550.0, 450.0];
let mut matrix = [[0.0_f64; 3]; 3];
for (row, wavelength) in probes.iter().enumerate() {
for (column, dye) in self.dye.iter().enumerate() {
matrix[row][column] = dye.interpolate(*wavelength);
}
}
matrix
}
fn analytical(&self, status: [f64; 3]) -> [f64; 3] {
solve3(self.analytical_matrix(), status)
.map(|values| values.map(|value| value.max(0.0)))
.unwrap_or(status)
}
#[must_use]
pub fn model(&self) -> Option<PrintModel> {
let inverse = inverse3(self.analytical_matrix());
Some(PrintModel {
analytical: inverse.unwrap_or([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]),
clamped: inverse.is_some(),
dye: tables(&self.dye)?,
paper: tables(&self.paper)?,
illuminant: table(&self.illuminant)?,
mask: match &self.base_density {
Some(base) => table(base)?,
None => [0.0; GRID_LEN],
},
masking: self.masking.map_or([0.0; 3], |masking| masking.strength),
masking_reference: self
.masking
.map_or(1.0, |masking| masking.reference_density),
filters: self.filters,
filter_bands: tables(&self.filter_bands)?,
reference: self.reference,
})
}
fn response(&self, status_density: [f64; 3]) -> [f64; 3] {
let density_cmy = self.analytical(status_density);
let step = self.grid.step_nm();
let mut response = [0.0_f64; 3];
for wavelength_index in 0..self.grid.len() {
let mask = match (&self.base_density, &self.masking) {
(Some(base), Some(masking)) => {
base.values()[wavelength_index] * masking.surviving(density_cmy)
}
(Some(base), None) => base.values()[wavelength_index],
(None, _) => 0.0,
};
let mut density: f64 = mask;
density += density_cmy
.iter()
.zip(&self.dye)
.map(|(value, dye)| value * dye.values()[wavelength_index])
.sum::<f64>();
let mut filter = 0.0;
for (cc, band) in self.filters.iter().zip(&self.filter_bands) {
filter += cc * band.values()[wavelength_index] / 100.0;
}
let light = self.illuminant.values()[wavelength_index];
let transmitted = (-(density + filter) * std::f64::consts::LOG2_10).exp2() * light;
for (value, paper) in response.iter_mut().zip(&self.paper) {
*value += paper.values()[wavelength_index] * transmitted;
}
}
for value in &mut response {
*value *= step;
}
response
}
}
fn gaussian(grid: &Spectrum, band: Band) -> Spectrum {
let mut spectrum = Spectrum::filled(grid.clone(), 0.0);
for (index, value) in spectrum.values_mut().iter_mut().enumerate() {
let wavelength = grid.start_nm() + grid.step_nm() * index as f64;
let z = (wavelength - band.peak_nm) / band.width_nm;
*value = (-0.5 * z * z).exp();
}
spectrum
}
fn normalised(mut spectrum: Spectrum) -> Spectrum {
let area: f64 = spectrum.values().iter().sum::<f64>() * spectrum.step_nm();
if area > 0.0 {
for value in spectrum.values_mut() {
*value /= area;
}
}
spectrum
}
#[test]
fn without_masking_the_base_density_is_constant() {
let masking = Masking::default();
assert!((masking.surviving([0.0; 3]) - 1.0).abs() < 1e-12);
assert!((masking.surviving([2.0, 0.0, 0.0]) - 0.0).abs() < 1e-12);
assert!((masking.surviving([1.0, 0.0, 0.0]) - 0.5).abs() < 1e-12);
}
#[test]
fn only_the_layer_that_owns_the_mask_destroys_it() {
let masking = Masking::default();
assert!((masking.surviving([0.0, 2.0, 0.0]) - 1.0).abs() < 1e-12);
assert!((masking.surviving([0.0, 0.0, 2.0]) - 1.0).abs() < 1e-12);
}
#[test]
fn the_mask_gives_blue_back_as_cyan_forms() {
let grid = Spectrum::uniform(380.0, 5.0, 71).unwrap();
let mut base = Spectrum::filled(grid.clone(), 0.0);
for (index, value) in base.values_mut().iter_mut().enumerate() {
let wavelength = grid.start_nm() + grid.step_nm() * index as f64;
*value = 0.6 * (-0.5 * ((wavelength - 450.0) / 25.0).powi(2)).exp();
}
let context = PrintContext::new([1.0; 3]).with_base_density(base);
let masked = context.clone().with_masking(Masking::default());
let plain_gain = context.expose([2.0, 0.0, 0.0])[2] - context.expose([0.0; 3])[2];
let masked_gain = masked.expose([2.0, 0.0, 0.0])[2] - masked.expose([0.0; 3])[2];
assert!(
masked_gain > plain_gain,
"the mask must give blue back: {masked_gain} vs {plain_gain}"
);
}
#[cfg(test)]
mod tests {
use super::*;
fn reference_density() -> [f64; 3] {
[1.2, 1.1, 1.0]
}
#[test]
fn another_films_dyes_print_another_colour() {
let density = [0.9, 0.9, 0.9];
let vision = PrintContext::measured_with(
reference_density(),
&crate::measured::FILM_DYES,
&crate::measured::FILM_MASK,
&crate::measured::PAPER_LAYERS,
)
.expose(density);
let mut swapped = crate::measured::FILM_DYES;
swapped.swap(0, 2);
let other = PrintContext::measured_with(
reference_density(),
&swapped,
&crate::measured::FILM_MASK,
&crate::measured::PAPER_LAYERS,
)
.expose(density);
let shift = (0..3)
.map(|channel| (other[channel] - vision[channel]).abs())
.fold(0.0_f64, f64::max);
assert!(
shift > 0.05,
"swapping the dyes should move the print: {vision:?} vs {other:?}"
);
}
#[test]
fn the_neutral_reference_lands_at_zero() {
let context = PrintContext::new(reference_density());
let level =
(reference_density()[0] + reference_density()[1] + reference_density()[2]) / 3.0;
for log_e in context.expose([level; 3]) {
assert!(log_e.abs() < 1e-9, "{log_e}");
}
}
#[test]
fn the_reference_negative_is_near_zero() {
let context = PrintContext::new(reference_density());
for log_e in context.expose(reference_density()) {
assert!(log_e.abs() < 0.15, "{log_e}");
}
}
#[test]
fn more_density_means_less_light_on_every_layer() {
let context = PrintContext::new(reference_density());
let base = context.expose(reference_density());
let denser = context.expose([1.6, 1.1, 1.0]);
assert!(denser[0] < base[0], "{denser:?}");
}
#[test]
fn measured_spectra_replace_the_placeholders() {
let context = PrintContext::new(reference_density());
let baseline = context.expose([1.0, 0.5, 0.2]);
let grid = context.grid().clone();
let narrow: [Spectrum; 3] = [450.0, 550.0, 650.0].map(|peak| {
let mut spectrum = Spectrum::filled(grid.clone(), 0.0);
for (index, value) in spectrum.values_mut().iter_mut().enumerate() {
let wavelength = grid.start_nm() + grid.step_nm() * index as f64;
*value = (-0.5 * ((wavelength - peak) / 12.0).powi(2)).exp();
}
spectrum
});
let replaced = PrintContext::new(reference_density()).with_spectra(narrow.clone(), narrow);
let moved = replaced.expose([1.0, 0.5, 0.2]);
let difference: f64 = baseline
.iter()
.zip(&moved)
.map(|(a, b)| (a - b).abs())
.sum();
assert!(difference > 1e-3, "replacing the spectra changed nothing");
}
#[test]
fn neutral_densities_stay_neutral() {
let context = PrintContext::new(reference_density());
for step in 0..=12 {
let density = 0.2 + 0.15 * f64::from(step);
let log_e = context.expose([density; 3]);
let spread = log_e.iter().copied().fold(f64::NEG_INFINITY, f64::max)
- log_e.iter().copied().fold(f64::INFINITY, f64::min);
assert!(
spread < 1e-9,
"grey {density} drifts by {spread}: {log_e:?}"
);
}
}
#[test]
fn dyes_leak_into_neighbouring_layers() {
let context = PrintContext::new(reference_density());
let base = context.expose(reference_density());
let cyan = context.expose([1.7, 1.1, 1.0]);
let red_drop = base[0] - cyan[0];
let green_drop = base[1] - cyan[1];
assert!(
red_drop > green_drop,
"red {red_drop} vs green {green_drop}"
);
assert!(green_drop.abs() > 1e-4, "no crosstalk: {green_drop}");
}
}