1use kallo_spectral::Spectrum;
28
29use crate::model::{PrintModel, inverse3, table, tables};
30use crate::scan::solve3;
31
32use crate::spectral::{GRID_LEN, GRID_START_NM, GRID_STEP_NM};
33
34#[derive(Debug, Clone, Copy)]
36struct Band {
37 peak_nm: f64,
38 width_nm: f64,
39}
40
41const DYE_BANDS: [Band; 3] = [
44 Band {
45 peak_nm: 650.0,
46 width_nm: 55.0,
47 },
48 Band {
49 peak_nm: 550.0,
50 width_nm: 50.0,
51 },
52 Band {
53 peak_nm: 450.0,
54 width_nm: 55.0,
55 },
56];
57
58const FILTER_BANDS: [Band; 3] = [
61 Band {
62 peak_nm: 450.0,
63 width_nm: 55.0,
64 },
65 Band {
66 peak_nm: 550.0,
67 width_nm: 50.0,
68 },
69 Band {
70 peak_nm: 650.0,
71 width_nm: 55.0,
72 },
73];
74
75const PAPER_BANDS: [Band; 3] = [
77 Band {
78 peak_nm: 650.0,
79 width_nm: 45.0,
80 },
81 Band {
82 peak_nm: 550.0,
83 width_nm: 40.0,
84 },
85 Band {
86 peak_nm: 450.0,
87 width_nm: 45.0,
88 },
89];
90
91#[derive(Debug, Clone, Copy)]
106pub struct Masking {
107 pub strength: [f64; 3],
109 pub reference_density: f64,
111}
112
113impl Default for Masking {
114 fn default() -> Self {
115 Self {
116 strength: [1.0, 0.0, 0.0],
117 reference_density: 2.0,
118 }
119 }
120}
121
122impl Masking {
123 #[must_use]
125 pub fn surviving(&self, density_cmy: [f64; 3]) -> f64 {
126 let reference = self.reference_density.max(1e-9);
127 let removed: f64 = density_cmy
128 .iter()
129 .zip(&self.strength)
130 .map(|(density, strength)| strength * (density / reference).clamp(0.0, 1.0))
131 .sum();
132 (1.0 - removed).clamp(0.0, 1.0)
133 }
134}
135
136#[derive(Debug, Clone)]
138pub struct PrintContext {
139 grid: Spectrum,
140 dye: [Spectrum; 3],
141 paper: [Spectrum; 3],
142 reference: [f64; 3],
143 reference_density: [f64; 3],
146 filters: [f64; 3],
149 filter_bands: [Spectrum; 3],
152 illuminant: Spectrum,
154 base_density: Option<Spectrum>,
157 masking: Option<Masking>,
159}
160
161impl PrintContext {
162 #[must_use]
172 pub fn new(reference_density: [f64; 3]) -> Self {
173 let grid = Spectrum::uniform(GRID_START_NM, GRID_STEP_NM, GRID_LEN)
174 .expect("the internal grid is a valid constant");
175
176 let dye: [Spectrum; 3] = DYE_BANDS.map(|band| gaussian(&grid, band));
177 let paper: [Spectrum; 3] = PAPER_BANDS.map(|band| normalised(gaussian(&grid, band)));
179 let filter_bands: [Spectrum; 3] = FILTER_BANDS.map(|band| gaussian(&grid, band));
181 let illuminant = Spectrum::filled(grid.clone(), 1.0);
182
183 let mut context = Self {
184 grid,
185 dye,
186 paper,
187 reference: [1.0; 3],
188 reference_density,
189 filters: [0.0; 3],
190 filter_bands,
191 illuminant,
192 base_density: None,
193 masking: None,
194 };
195 let neutral_level =
199 (reference_density[0] + reference_density[1] + reference_density[2]) / 3.0;
200 context.reference = context.balanced([neutral_level; 3]);
201 context
202 }
203
204 #[must_use]
206 pub fn with_dyes(mut self, dye: [Spectrum; 3]) -> Self {
207 self.dye = dye.map(|spectrum| spectrum.resampled(&self.grid));
208 self.reference = self.balanced(self.reference_density);
209 self
210 }
211
212 #[must_use]
217 pub fn balance_gain(&self, neutral_density: f64) -> [f64; 3] {
218 let response = self.response([neutral_density; 3]);
219 let target = (response[0] * response[1] * response[2]).cbrt();
220 std::array::from_fn(|layer| target / response[layer].max(1e-12))
221 }
222
223 #[must_use]
239 pub fn with_enlarger(
240 mut self,
241 pack: crate::filters::FilterPack,
242 glass: Option<crate::filters::HeatGlass>,
243 ) -> Self {
244 if pack.is_empty() && glass.is_none() {
245 return self;
246 }
247 let lamp = crate::filters::lamp(3200.0);
248 let pack_transmission = pack.transmittance();
249 let glass_transmission = glass.map(|heat| heat.transmittance(2.0));
250 let mut transmission = [0.0_f64; GRID_LEN];
251 for (index, value) in transmission.iter_mut().enumerate() {
252 let heat = glass_transmission.map_or(1.0, |values| values[index]);
253 *value = lamp[index] * pack_transmission[index] * heat;
254 }
255 let peak = transmission
256 .iter()
257 .copied()
258 .fold(0.0_f64, f64::max)
259 .max(1e-12);
260 for (value, sample) in self.illuminant.values_mut().iter_mut().zip(transmission) {
261 *value = sample / peak;
262 }
263 self.filters = [0.0, 0.0, 0.0];
266 self
267 }
268
269 #[must_use]
271 pub fn with_filters(mut self, filters: [f64; 3]) -> Self {
272 self.filters = filters;
273 self.reference = self.balanced(self.reference_density);
274 self
275 }
276
277 #[must_use]
284 pub fn solve_filters(&self, density: f64) -> [f64; 3] {
285 let spread = |candidate: Self| {
286 let response = candidate.response([density; 3]);
287 let target = (response[0] * response[1] * response[2]).cbrt();
288 let gains: [f64; 3] = std::array::from_fn(|i| target / response[i].max(1e-12));
289 gains.iter().copied().fold(f64::NEG_INFINITY, f64::max)
290 - gains.iter().copied().fold(f64::INFINITY, f64::min)
291 };
292
293 let mut best = (f64::INFINITY, [0.0; 3]);
294 let mut step = 10.0_f64;
295 let mut centre = [0.0_f64; 3];
296 for _ in 0..4 {
297 for yellow in 0..=20 {
298 for magenta in 0..=20 {
299 let candidate = [
300 centre[0] + (f64::from(yellow) - 10.0) * step,
301 centre[1] + (f64::from(magenta) - 10.0) * step,
302 0.0,
303 ]
304 .map(|value| value.max(0.0));
305 let value = spread(self.clone().with_filters(candidate));
306 if value < best.0 {
307 best = (value, candidate);
308 }
309 }
310 }
311 centre = best.1;
312 step /= 5.0;
313 }
314 best.1
315 }
316
317 #[must_use]
328 pub fn measured(reference_density: [f64; 3]) -> Self {
329 Self::measured_with(
330 reference_density,
331 &crate::measured::FILM_DYES,
332 &crate::measured::FILM_MASK,
333 &crate::measured::PAPER_LAYERS,
334 )
335 }
336
337 #[must_use]
344 pub fn measured_with(
345 reference_density: [f64; 3],
346 film_dyes: &[[f64; crate::spectral::GRID_LEN]; 3],
347 film_mask: &[f64; crate::spectral::GRID_LEN],
348 paper_layers: &[[f64; crate::spectral::GRID_LEN]; 3],
349 ) -> Self {
350 Self::new(reference_density)
351 .with_spectra(
352 film_dyes.map(|table| crate::measured::spectrum(&table)),
353 paper_layers.map(|table| crate::measured::spectrum(&table)),
354 )
355 .with_base_density(crate::measured::spectrum(film_mask))
356 .with_masking(Masking::default())
357 }
358
359 #[must_use]
366 pub fn with_base_density(mut self, base: Spectrum) -> Self {
367 let base = base.resampled(&self.grid);
368 self.base_density = Some(base);
369 self.reference = self.balanced(self.reference_density);
370 self
371 }
372
373 #[must_use]
378 pub fn with_masking(mut self, masking: Masking) -> Self {
379 self.masking = Some(masking);
380 self.reference = self.balanced(self.reference_density);
381 self
382 }
383
384 #[must_use]
390 pub fn with_spectra(mut self, dye: [Spectrum; 3], paper: [Spectrum; 3]) -> Self {
391 self.dye = dye.map(|spectrum| spectrum.resampled(&self.grid));
392 self.paper = paper.map(|spectrum| spectrum.resampled(&self.grid));
393 self.reference = self.balanced(self.reference_density);
394 self
395 }
396
397 #[must_use]
399 pub fn grid(&self) -> &Spectrum {
400 &self.grid
401 }
402
403 #[must_use]
405 pub fn expose(&self, density_cmy: [f64; 3]) -> [f64; 3] {
406 let response = self.balanced(density_cmy);
407 std::array::from_fn(|layer| {
408 let ratio = response[layer] / self.reference[layer].max(1e-12);
409 ratio.max(1e-10).log10()
410 })
411 }
412
413 fn balanced(&self, density_cmy: [f64; 3]) -> [f64; 3] {
425 let response = self.response(density_cmy);
426 let mean = (density_cmy[0] + density_cmy[1] + density_cmy[2]) / 3.0;
427 let neutral = self.response([mean; 3]);
428 let target = (neutral[0] * neutral[1] * neutral[2]).cbrt();
429
430 std::array::from_fn(|layer| {
431 let scale = target / neutral[layer].max(1e-12);
432 response[layer] * scale
433 })
434 }
435
436 fn analytical_matrix(&self) -> [[f64; 3]; 3] {
446 let probes = [650.0, 550.0, 450.0];
447 let mut matrix = [[0.0_f64; 3]; 3];
448 for (row, wavelength) in probes.iter().enumerate() {
449 for (column, dye) in self.dye.iter().enumerate() {
450 matrix[row][column] = dye.interpolate(*wavelength);
451 }
452 }
453 matrix
454 }
455
456 fn analytical(&self, status: [f64; 3]) -> [f64; 3] {
457 solve3(self.analytical_matrix(), status)
458 .map(|values| values.map(|value| value.max(0.0)))
459 .unwrap_or(status)
460 }
461
462 #[must_use]
467 pub fn model(&self) -> Option<PrintModel> {
468 let inverse = inverse3(self.analytical_matrix());
469 Some(PrintModel {
473 analytical: inverse.unwrap_or([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]),
474 clamped: inverse.is_some(),
475 dye: tables(&self.dye)?,
476 paper: tables(&self.paper)?,
477 illuminant: table(&self.illuminant)?,
478 mask: match &self.base_density {
479 Some(base) => table(base)?,
480 None => [0.0; GRID_LEN],
481 },
482 masking: self.masking.map_or([0.0; 3], |masking| masking.strength),
483 masking_reference: self
484 .masking
485 .map_or(1.0, |masking| masking.reference_density),
486 filters: self.filters,
487 filter_bands: tables(&self.filter_bands)?,
488 reference: self.reference,
489 })
490 }
491
492 fn response(&self, status_density: [f64; 3]) -> [f64; 3] {
493 let density_cmy = self.analytical(status_density);
494 let step = self.grid.step_nm();
497 let mut response = [0.0_f64; 3];
498 for wavelength_index in 0..self.grid.len() {
499 let mask = match (&self.base_density, &self.masking) {
502 (Some(base), Some(masking)) => {
503 base.values()[wavelength_index] * masking.surviving(density_cmy)
504 }
505 (Some(base), None) => base.values()[wavelength_index],
506 (None, _) => 0.0,
507 };
508 let mut density: f64 = mask;
509 density += density_cmy
510 .iter()
511 .zip(&self.dye)
512 .map(|(value, dye)| value * dye.values()[wavelength_index])
513 .sum::<f64>();
514 let mut filter = 0.0;
517 for (cc, band) in self.filters.iter().zip(&self.filter_bands) {
518 filter += cc * band.values()[wavelength_index] / 100.0;
519 }
520 let light = self.illuminant.values()[wavelength_index];
521 let transmitted = (-(density + filter) * std::f64::consts::LOG2_10).exp2() * light;
522 for (value, paper) in response.iter_mut().zip(&self.paper) {
523 *value += paper.values()[wavelength_index] * transmitted;
524 }
525 }
526 for value in &mut response {
527 *value *= step;
528 }
529 response
530 }
531}
532
533fn gaussian(grid: &Spectrum, band: Band) -> Spectrum {
534 let mut spectrum = Spectrum::filled(grid.clone(), 0.0);
535 for (index, value) in spectrum.values_mut().iter_mut().enumerate() {
536 let wavelength = grid.start_nm() + grid.step_nm() * index as f64;
537 let z = (wavelength - band.peak_nm) / band.width_nm;
538 *value = (-0.5 * z * z).exp();
539 }
540 spectrum
541}
542
543fn normalised(mut spectrum: Spectrum) -> Spectrum {
544 let area: f64 = spectrum.values().iter().sum::<f64>() * spectrum.step_nm();
545 if area > 0.0 {
546 for value in spectrum.values_mut() {
547 *value /= area;
548 }
549 }
550 spectrum
551}
552
553#[test]
556fn without_masking_the_base_density_is_constant() {
557 let masking = Masking::default();
558 assert!((masking.surviving([0.0; 3]) - 1.0).abs() < 1e-12);
559 assert!((masking.surviving([2.0, 0.0, 0.0]) - 0.0).abs() < 1e-12);
560 assert!((masking.surviving([1.0, 0.0, 0.0]) - 0.5).abs() < 1e-12);
561}
562
563#[test]
566fn only_the_layer_that_owns_the_mask_destroys_it() {
567 let masking = Masking::default();
568 assert!((masking.surviving([0.0, 2.0, 0.0]) - 1.0).abs() < 1e-12);
569 assert!((masking.surviving([0.0, 0.0, 2.0]) - 1.0).abs() < 1e-12);
570}
571
572#[test]
575fn the_mask_gives_blue_back_as_cyan_forms() {
576 let grid = Spectrum::uniform(380.0, 5.0, 71).unwrap();
577 let mut base = Spectrum::filled(grid.clone(), 0.0);
579 for (index, value) in base.values_mut().iter_mut().enumerate() {
580 let wavelength = grid.start_nm() + grid.step_nm() * index as f64;
581 *value = 0.6 * (-0.5 * ((wavelength - 450.0) / 25.0).powi(2)).exp();
582 }
583 let context = PrintContext::new([1.0; 3]).with_base_density(base);
584 let masked = context.clone().with_masking(Masking::default());
585 let plain_gain = context.expose([2.0, 0.0, 0.0])[2] - context.expose([0.0; 3])[2];
590 let masked_gain = masked.expose([2.0, 0.0, 0.0])[2] - masked.expose([0.0; 3])[2];
591 assert!(
592 masked_gain > plain_gain,
593 "the mask must give blue back: {masked_gain} vs {plain_gain}"
594 );
595}
596
597#[cfg(test)]
598mod tests {
599 use super::*;
600
601 fn reference_density() -> [f64; 3] {
602 [1.2, 1.1, 1.0]
603 }
604
605 #[test]
610 fn another_films_dyes_print_another_colour() {
611 let density = [0.9, 0.9, 0.9];
612 let vision = PrintContext::measured_with(
613 reference_density(),
614 &crate::measured::FILM_DYES,
615 &crate::measured::FILM_MASK,
616 &crate::measured::PAPER_LAYERS,
617 )
618 .expose(density);
619
620 let mut swapped = crate::measured::FILM_DYES;
621 swapped.swap(0, 2);
622 let other = PrintContext::measured_with(
623 reference_density(),
624 &swapped,
625 &crate::measured::FILM_MASK,
626 &crate::measured::PAPER_LAYERS,
627 )
628 .expose(density);
629
630 let shift = (0..3)
634 .map(|channel| (other[channel] - vision[channel]).abs())
635 .fold(0.0_f64, f64::max);
636 assert!(
637 shift > 0.05,
638 "swapping the dyes should move the print: {vision:?} vs {other:?}"
639 );
640 }
641
642 #[test]
643 fn the_neutral_reference_lands_at_zero() {
644 let context = PrintContext::new(reference_density());
645 let level =
646 (reference_density()[0] + reference_density()[1] + reference_density()[2]) / 3.0;
647 for log_e in context.expose([level; 3]) {
648 assert!(log_e.abs() < 1e-9, "{log_e}");
649 }
650 }
651
652 #[test]
653 fn the_reference_negative_is_near_zero() {
654 let context = PrintContext::new(reference_density());
655 for log_e in context.expose(reference_density()) {
659 assert!(log_e.abs() < 0.15, "{log_e}");
660 }
661 }
662
663 #[test]
664 fn more_density_means_less_light_on_every_layer() {
665 let context = PrintContext::new(reference_density());
666 let base = context.expose(reference_density());
667 let denser = context.expose([1.6, 1.1, 1.0]);
668 assert!(denser[0] < base[0], "{denser:?}");
669 }
670
671 #[test]
672 fn measured_spectra_replace_the_placeholders() {
673 let context = PrintContext::new(reference_density());
674 let baseline = context.expose([1.0, 0.5, 0.2]);
675
676 let grid = context.grid().clone();
679 let narrow: [Spectrum; 3] = [450.0, 550.0, 650.0].map(|peak| {
680 let mut spectrum = Spectrum::filled(grid.clone(), 0.0);
681 for (index, value) in spectrum.values_mut().iter_mut().enumerate() {
682 let wavelength = grid.start_nm() + grid.step_nm() * index as f64;
683 *value = (-0.5 * ((wavelength - peak) / 12.0).powi(2)).exp();
684 }
685 spectrum
686 });
687 let replaced = PrintContext::new(reference_density()).with_spectra(narrow.clone(), narrow);
688 let moved = replaced.expose([1.0, 0.5, 0.2]);
689 let difference: f64 = baseline
690 .iter()
691 .zip(&moved)
692 .map(|(a, b)| (a - b).abs())
693 .sum();
694 assert!(difference > 1e-3, "replacing the spectra changed nothing");
695 }
696
697 #[test]
698 fn neutral_densities_stay_neutral() {
699 let context = PrintContext::new(reference_density());
700 for step in 0..=12 {
702 let density = 0.2 + 0.15 * f64::from(step);
703 let log_e = context.expose([density; 3]);
704 let spread = log_e.iter().copied().fold(f64::NEG_INFINITY, f64::max)
705 - log_e.iter().copied().fold(f64::INFINITY, f64::min);
706 assert!(
707 spread < 1e-9,
708 "grey {density} drifts by {spread}: {log_e:?}"
709 );
710 }
711 }
712
713 #[test]
714 fn dyes_leak_into_neighbouring_layers() {
715 let context = PrintContext::new(reference_density());
716 let base = context.expose(reference_density());
717
718 let cyan = context.expose([1.7, 1.1, 1.0]);
720 let red_drop = base[0] - cyan[0];
721 let green_drop = base[1] - cyan[1];
722 assert!(
723 red_drop > green_drop,
724 "red {red_drop} vs green {green_drop}"
725 );
726
727 assert!(green_drop.abs() > 1e-4, "no crosstalk: {green_drop}");
730 }
731}