use crate::curve::CharacteristicCurve;
use crate::development::DevelopmentParams;
use crate::emulsion::{FilmStock, PaperStock};
use crate::lut::ExposureLut;
use crate::model::SpectralModel;
use crate::print::PrintContext;
use crate::scan::ScanContext;
use crate::spectral::{CameraProfile, SpectralContext};
#[must_use]
pub fn mid_grey_log_e() -> f64 {
0.18_f64.log10()
}
#[derive(Debug, Clone)]
pub struct RenderParams {
pub film: &'static FilmStock,
pub paper: &'static PaperStock,
pub development: DevelopmentParams,
pub exposure_ev: f64,
pub spectral: bool,
pub camera: CameraProfile,
pub lut_size: usize,
pub spectral_print: bool,
pub spectral_scan: bool,
pub interimage: bool,
pub print_exposure_ev: f64,
pub filters: crate::filters::FilterPack,
pub heat_glass: Option<crate::filters::HeatGlass>,
}
impl Default for RenderParams {
fn default() -> Self {
Self {
film: crate::emulsion::film_stock("vision3_500t").expect("built-in stock"),
paper: crate::emulsion::paper_stock("portra_endura").expect("built-in stock"),
development: DevelopmentParams::default(),
exposure_ev: 0.0,
spectral: false,
camera: CameraProfile::default(),
lut_size: 0,
spectral_print: false,
spectral_scan: false,
print_exposure_ev: 0.0,
interimage: false,
filters: crate::filters::FilterPack::none(),
heat_glass: None,
}
}
}
impl RenderParams {
#[must_use]
pub fn prepare(&self) -> PreparedRender {
self.prepare_with(None)
}
#[must_use]
pub fn prepare_with_lut(&self, lut: ExposureLut) -> PreparedRender {
let mut prepared = Self {
spectral: false,
lut_size: 0,
..self.clone()
}
.prepare_with(None);
prepared.lut = Some(lut);
prepared
}
#[must_use]
pub fn prepare_with(&self, atoms: Option<&[kallo_spectral::Spectrum]>) -> PreparedRender {
let monochrome = self.film.process == crate::emulsion::FilmProcess::Monochrome;
let extra = self
.film
.extra_cyan
.map(|emulsion| self.development.apply_to(emulsion.characteristic()));
let cl_layer = self.interimage && self.film.cl_layer.is_some();
let spectral = self.spectral || monochrome || extra.is_some() || cl_layer;
let channels: [CharacteristicCurve; 3] =
std::array::from_fn(|i| self.development.apply_to(self.film.channels[i]));
let paper = self.paper.channel;
let target_density = -self.paper.target_mid_reflectance.log10();
let target_log_e = paper.log_exposure_at(target_density);
let mid = mid_grey_log_e();
let mut density_mid: [f64; 3] = std::array::from_fn(|i| channels[i].density(mid));
if let Some(extra) = extra {
density_mid[0] += extra.density(mid);
}
let filtered = !self.filters.is_empty() || self.heat_glass.is_some();
let print = ((self.spectral_print || filtered) && !monochrome).then(|| {
PrintContext::measured_with(
density_mid,
self.film.dyes,
self.film.mask,
self.paper.layers,
)
.with_enlarger(self.filters, self.heat_glass)
});
let print_shift: [f64; 3] = match &print {
Some(context) => {
let mid_exposure = context.expose(density_mid);
std::array::from_fn(|i| target_log_e - mid_exposure[i])
}
None => {
std::array::from_fn(|i| target_log_e + density_mid[i] + self.film.base_density[i])
}
};
let print_exposure = self.print_exposure_ev * 2.0_f64.log10();
let print_shift: [f64; 3] =
std::array::from_fn(|layer| print_shift[layer] + print_exposure);
PreparedRender {
channels,
base_density: self.film.base_density,
paper,
print_shift,
print,
scan: self
.spectral_scan
.then(|| ScanContext::measured_with(self.paper.dyes)),
extra,
cl_layer,
exposure_shift: self.exposure_ev * 2.0_f64.log10(),
reversal: self.film.process == crate::emulsion::FilmProcess::Reversal,
spectral: spectral
.then(|| {
let context =
SpectralContext::for_stock(self.film).with_camera(self.camera.clone());
match atoms {
Some(atoms) => context.with_atoms(atoms),
None => context,
}
})
.filter(|_| self.lut_size < 2),
lut: (spectral && self.lut_size >= 2 && extra.is_none()).then(|| {
let context =
SpectralContext::for_stock(self.film).with_camera(self.camera.clone());
let context = match atoms {
Some(atoms) => context.with_atoms(atoms),
None => context,
};
ExposureLut::bake(self.lut_size, &context)
}),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ScalarModel {
pub curve: [[f64; 4]; 3],
pub paper: [f64; 4],
pub toe_transition: [f64; 4],
pub shoulder_transition: [f64; 4],
pub base_density: [f64; 3],
pub print_shift: [f64; 3],
pub exposure_shift: f64,
pub reversal: bool,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Exposure {
pub layers: [f64; 3],
pub extra: Option<f64>,
}
#[derive(Debug, Clone)]
pub struct PreparedRender {
pub reversal: bool,
channels: [CharacteristicCurve; 3],
base_density: [f64; 3],
paper: CharacteristicCurve,
print_shift: [f64; 3],
exposure_shift: f64,
spectral: Option<SpectralContext>,
lut: Option<ExposureLut>,
print: Option<PrintContext>,
scan: Option<ScanContext>,
extra: Option<CharacteristicCurve>,
cl_layer: bool,
}
impl PreparedRender {
#[must_use]
pub fn print_shift(&self) -> [f64; 3] {
self.print_shift
}
#[must_use]
pub fn printed_like(mut self, reference: &Self) -> Self {
self.paper = reference.paper;
self.print_shift = reference.print_shift;
self.print = reference.print.clone();
self.scan = reference.scan.clone();
self
}
fn numbers(&self) -> ScalarModel {
ScalarModel {
curve: std::array::from_fn(|layer| {
let curve = &self.channels[layer];
[curve.d_min, curve.d_max, curve.gamma, curve.log_e0]
}),
paper: [
self.paper.d_min,
self.paper.d_max,
self.paper.gamma,
self.paper.log_e0,
],
toe_transition: [
self.channels[0].toe_transition,
self.channels[1].toe_transition,
self.channels[2].toe_transition,
self.paper.toe_transition,
],
shoulder_transition: [
self.channels[0].shoulder_transition,
self.channels[1].shoulder_transition,
self.channels[2].shoulder_transition,
self.paper.shoulder_transition,
],
base_density: self.base_density,
print_shift: self.print_shift,
exposure_shift: self.exposure_shift,
reversal: self.reversal,
}
}
#[must_use]
pub fn scalar_model(&self) -> Option<ScalarModel> {
if self.spectral.is_some()
|| self.lut.is_some()
|| self.print.is_some()
|| self.scan.is_some()
{
return None;
}
Some(self.numbers())
}
#[must_use]
pub fn spectral_model(&self) -> Option<SpectralModel> {
if self.extra.is_some() || self.cl_layer {
return None;
}
if self.lut.is_some() {
return None;
}
let step_nm = self
.spectral
.as_ref()
.map(|context| context.grid().step_nm())
.or_else(|| self.print.as_ref().map(|context| context.grid().step_nm()))
.or_else(|| self.scan.as_ref().map(|context| context.grid().step_nm()))
.unwrap_or(0.0);
let model = SpectralModel {
scalar: self.numbers(),
step_nm,
exposure: match &self.spectral {
Some(context) => Some(context.model()?),
None => None,
},
enlarger: match &self.print {
Some(context) => Some(context.model()?),
None => None,
},
scan: match &self.scan {
Some(context) => Some(context.model()?),
None => None,
},
};
model.is_spectral().then_some(model)
}
#[must_use]
pub fn channels(&self) -> &[CharacteristicCurve; 3] {
&self.channels
}
#[must_use]
pub fn is_spectral(&self) -> bool {
self.spectral.is_some() || self.lut.is_some()
}
#[must_use]
pub fn is_spectral_print(&self) -> bool {
self.print.is_some()
}
#[must_use]
pub fn is_spectral_scan(&self) -> bool {
self.scan.is_some()
}
#[must_use]
pub fn lut(&self) -> Option<&ExposureLut> {
self.lut.as_ref()
}
pub fn expose(&self, linear: [f64; 3]) -> Exposure {
let scalar = || std::array::from_fn(|channel| linear[channel].max(1e-10).log10());
if let Some(lut) = &self.lut {
return Exposure {
layers: lut.sample(linear),
extra: None,
};
}
if let Some(context) = &self.spectral {
return match context.expose_with_extra(linear) {
Some((layers, extra)) => Exposure { layers, extra },
None => Exposure {
layers: scalar(),
extra: None,
},
};
}
Exposure {
layers: scalar(),
extra: None,
}
}
#[must_use]
pub fn log_exposure(&self, linear: [f64; 3]) -> [f64; 3] {
self.expose(linear).layers
}
#[must_use]
pub fn negative_density(&self, log_e: [f64; 3]) -> [f64; 3] {
self.negative_density_with(log_e, None)
}
#[must_use]
pub fn negative_density_with(&self, log_e: [f64; 3], extra: Option<f64>) -> [f64; 3] {
let mut density: [f64; 3] = std::array::from_fn(|channel| {
self.channels[channel].density(log_e[channel] + self.exposure_shift)
});
if let (Some(curve), Some(log_e)) = (self.extra, extra) {
density[0] += curve.density(log_e + self.exposure_shift);
}
density
}
#[must_use]
pub fn positive(&self, density_cmy: [f64; 3]) -> [f64; 3] {
if self.reversal {
return std::array::from_fn(|channel| {
let white = self.channels[channel].d_max;
10.0_f64
.powf(-(density_cmy[channel] + self.base_density[channel] - white))
.clamp(0.0, 1.0)
});
}
let print_exposure = self
.print
.as_ref()
.map(|context| context.expose(density_cmy));
let mut density_print = [0.0; 3];
for channel in 0..3 {
let log_transmittance = match &print_exposure {
Some(values) => values[channel],
None => -(density_cmy[channel] + self.base_density[channel]),
};
density_print[channel] = self
.paper
.density(log_transmittance + self.print_shift[channel]);
}
match &self.scan {
Some(context) => context.scan(density_print),
None => density_print.map(|density| 10.0_f64.powf(-density).clamp(0.0, 1.0)),
}
}
#[must_use]
pub fn render_pixel(&self, linear: [f64; 3]) -> [f64; 3] {
let exposure = self.expose(linear);
self.positive(self.negative_density_with(exposure.layers, exposure.extra))
}
#[must_use]
pub fn has_extra_layer(&self) -> bool {
self.extra.is_some() || self.cl_layer
}
#[must_use]
pub fn has_inhibitor_layer(&self) -> bool {
self.cl_layer
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct Finishing<'a> {
pub emulsion: Option<&'a crate::mtf::EmulsionBlur>,
pub halation: Option<&'a crate::halation::Halation>,
pub grain: Option<&'a crate::grain::GrainField>,
pub couplers: Option<&'a crate::couplers::Couplers>,
pub interimage: Option<&'a crate::interimage::InterImage>,
}
#[inline]
fn each_pixel<T: Send>(data: &mut [T], width: usize, f: impl Fn(usize, usize, &mut T) + Sync) {
#[cfg(feature = "parallel")]
{
use rayon::prelude::*;
data.par_iter_mut()
.enumerate()
.for_each(|(index, slot)| f(index % width, index / width, slot));
}
#[cfg(not(feature = "parallel"))]
{
for (index, slot) in data.iter_mut().enumerate() {
f(index % width, index / width, slot);
}
}
}
#[inline]
fn each_pixel_pair<A: Send, B: Send>(
first: &mut [A],
second: &mut [B],
width: usize,
f: impl Fn(usize, usize, &mut A, &mut B) + Sync,
) {
#[cfg(feature = "parallel")]
{
use rayon::prelude::*;
first
.par_iter_mut()
.zip(second.par_iter_mut())
.enumerate()
.for_each(|(index, (left, right))| f(index % width, index / width, left, right));
}
#[cfg(not(feature = "parallel"))]
{
for (index, (left, right)) in first.iter_mut().zip(second.iter_mut()).enumerate() {
f(index % width, index / width, left, right);
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct Negative {
pub width: usize,
pub height: usize,
pub densities: Vec<[f64; 3]>,
}
impl PreparedRender {
#[must_use]
pub fn develop(
&self,
pixels: &[[f64; 3]],
width: usize,
height: usize,
finishing: &Finishing,
) -> Negative {
let width = width.max(1);
let height = height.max(1);
if finishing.emulsion.is_none()
&& finishing.halation.is_none()
&& finishing.couplers.is_none()
&& finishing.interimage.is_none()
{
let densities: Vec<[f64; 3]> = pixels
.iter()
.enumerate()
.map(|(index, pixel)| {
let exposure = self.expose(*pixel);
let mean = self.negative_density_with(exposure.layers, exposure.extra);
match finishing.grain {
Some(grain) => self.negative_density_with(
std::array::from_fn(|channel| {
exposure.layers[channel]
+ grain.jitter(
index % width,
index / width,
mean[channel],
channel,
)
}),
exposure.extra,
),
None => mean,
}
})
.collect();
return Negative {
width,
height,
densities,
};
}
let mut log_e: Vec<[f64; 3]> = pixels.to_vec();
let mut extra: Option<Vec<f64>> = self.has_extra_layer().then(|| vec![0.0; log_e.len()]);
match extra.as_mut() {
Some(plane) => each_pixel_pair(&mut log_e, plane, width, |_, _, pixel, slot| {
let exposure = self.expose(*pixel);
*pixel = exposure.layers;
*slot = exposure.extra.unwrap_or(f64::NEG_INFINITY);
}),
None => each_pixel(&mut log_e, width, |_, _, pixel| {
*pixel = self.log_exposure(*pixel);
}),
}
if let Some(emulsion) = finishing.emulsion {
emulsion.apply(&mut log_e, width, height);
}
if let Some(halation) = finishing.halation {
halation.apply(&mut log_e, width, height);
}
let mut density: Vec<[f64; 3]> = log_e.clone();
each_pixel(&mut density, width, |x, y, slot| {
let log_e = log_e[y * width + x];
let extra = extra.as_ref().map(|plane| plane[y * width + x]);
let mean = self.negative_density_with(log_e, extra);
*slot = match finishing.grain {
Some(grain) => self.negative_density_with(
std::array::from_fn(|channel| {
log_e[channel] + grain.jitter(x, y, mean[channel], channel)
}),
extra,
),
None => mean,
};
});
if let (Some(stage), Some(plane)) = (finishing.interimage, extra.as_ref()) {
let light: Vec<f64> = plane.iter().map(|value| 10f64.powf(*value)).collect();
stage.apply(&mut density, &light, width, height);
}
if let Some(couplers) = finishing.couplers {
couplers.apply(&mut density, width, height);
}
Negative {
width,
height,
densities: density,
}
}
#[must_use]
pub fn print(&self, negative: &Negative) -> Vec<[f64; 3]> {
negative
.densities
.iter()
.map(|density| self.positive(*density))
.collect()
}
}
pub fn render_pixels_finished(
pixels: &mut [[f64; 3]],
prepared: &PreparedRender,
width: usize,
height: usize,
finishing: &Finishing,
) {
let negative = prepared.develop(pixels, width, height, finishing);
for (pixel, density) in pixels.iter_mut().zip(&negative.densities) {
*pixel = prepared.positive(*density);
}
}
pub fn render_pixels(pixels: &mut [[f64; 3]], prepared: &PreparedRender) {
each_pixel(pixels, 1, |_, _, pixel| {
*pixel = prepared.render_pixel(*pixel);
});
}
pub fn render_pixels_with_grain(
pixels: &mut [[f64; 3]],
prepared: &PreparedRender,
grain: &crate::grain::GrainField,
) {
render_pixels_finished(
pixels,
prepared,
grain.width,
grain.height,
&Finishing {
emulsion: None,
halation: None,
grain: Some(grain),
couplers: None,
interimage: None,
},
);
}
#[cfg(test)]
mod tests {
use super::*;
const STRAIGHT: [f32; 36] = {
let mut table = [0.0_f32; 36];
let mut index = 0;
while index < 36 {
table[index] = 1.0 + 0.02 * (index as f32);
index += 1;
}
table
};
fn four_layer(curve: [f64; 4]) -> &'static FilmStock {
let mut straight = [0.0; crate::spectral::GRID_LEN];
for (index, value) in straight.iter_mut().enumerate() {
*value = 1.0 + 0.01 * index as f64;
}
let layers: &'static [[f64; crate::spectral::GRID_LEN]; 3] =
Box::leak(Box::new([straight, straight, straight]));
let mut stock = *crate::emulsion::film_stock("vision3_500t").expect("built-in stock");
stock.id = "test_four_layer";
stock.layers = layers;
stock.extra_cyan = Some(crate::dye::Emulsion {
curve,
transition: crate::curve::TRANSITION,
sensitivity: &STRAIGHT,
});
Box::leak(Box::new(stock))
}
#[test]
fn print_exposure_darkens_the_print() {
let base = RenderParams::default();
let over = RenderParams {
print_exposure_ev: 1.0,
..RenderParams::default()
};
let grey = [0.18, 0.18, 0.18];
let solved = base.prepare().render_pixel(grey);
let darker = over.prepare().render_pixel(grey);
for channel in 0..3 {
assert!(
darker[channel] < solved[channel],
"channel {channel}: {darker:?} should be darker than {solved:?}"
);
}
assert!(darker[0] < solved[0] * 0.95);
}
#[test]
fn a_colour_pack_engages_the_spectral_print() {
use crate::filters::{FilterPack, HeatGlass};
let plain = RenderParams::default().prepare();
assert!(!plain.is_spectral_print(), "no glass, no spectral print");
let filtered = RenderParams {
filters: FilterPack::new(0.0, 30.0, 0.0),
..RenderParams::default()
}
.prepare();
assert!(filtered.is_spectral_print());
let glass = RenderParams {
heat_glass: Some(HeatGlass::Kg3),
..RenderParams::default()
}
.prepare();
assert!(glass.is_spectral_print());
}
#[test]
fn a_test_strip_keeps_the_first_prints_balance() {
let at = |minutes: f64| {
RenderParams {
development: DevelopmentParams {
time_min: minutes,
..DevelopmentParams::default()
},
..RenderParams::default()
}
.prepare()
};
let first = at(3.0);
let second = at(12.0);
let strip = second.clone().printed_like(&first);
assert_eq!(strip.print_shift(), first.print_shift());
assert_ne!(strip.print_shift(), second.print_shift());
let log_e = [-1.0, -1.0, -1.0];
assert_eq!(
strip.negative_density_with(log_e, None),
second.negative_density_with(log_e, None)
);
assert_ne!(
strip.negative_density_with(log_e, None),
first.negative_density_with(log_e, None)
);
let grey = [0.18, 0.18, 0.18];
assert!(
strip.render_pixel(grey)[0] > first.render_pixel(grey)[0],
"the strip's twelve-minute print should be lighter than its three"
);
}
#[test]
fn a_negative_prints_on_any_paper() {
let first = RenderParams::default();
let second = RenderParams {
paper: crate::emulsion::paper_stock("endura_premier").expect("built-in paper"),
..RenderParams::default()
};
let negative = first.prepare().develop(
&[[0.18, 0.18, 0.18], [0.4, 0.3, 0.2]],
2,
1,
&Finishing::default(),
);
assert_eq!(negative.densities.len(), 2);
let on_first = first.prepare().print(&negative);
let on_second = second.prepare().print(&negative);
assert_ne!(on_first, on_second);
let mut pixels = vec![[0.18, 0.18, 0.18], [0.4, 0.3, 0.2]];
render_pixels_finished(&mut pixels, &first.prepare(), 2, 1, &Finishing::default());
assert_eq!(pixels, on_first);
}
#[test]
fn a_four_layer_frame_renders_through_the_effects_path() {
let prepared = RenderParams {
film: four_layer([0.0, 1.0, 1.0, -0.5]),
..RenderParams::default()
}
.prepare();
assert!(prepared.has_extra_layer());
let mut pixels = vec![
[0.6, 0.3, 0.1],
[0.1, 0.2, 0.4],
[0.05, 0.05, 0.05],
[0.9, 0.9, 0.9],
];
let halation = crate::halation::Halation::typical(6.0);
render_pixels_finished(
&mut pixels,
&prepared,
2,
2,
&Finishing {
emulsion: None,
halation: Some(&halation),
grain: None,
couplers: None,
interimage: None,
},
);
assert!(
pixels
.iter()
.all(|pixel| pixel.iter().all(|value| value.is_finite() && *value >= 0.0))
);
let mut plain = vec![
[0.6, 0.3, 0.1],
[0.1, 0.2, 0.4],
[0.05, 0.05, 0.05],
[0.9, 0.9, 0.9],
];
render_pixels_finished(
&mut plain,
&prepared,
2,
2,
&Finishing {
emulsion: None,
halation: None,
grain: None,
couplers: None,
interimage: None,
},
);
for (halated, plain) in pixels.iter().zip(&plain) {
for (left, right) in halated.iter().zip(plain) {
assert!((left - right).abs() < 0.5, "{halated:?} vs {plain:?}");
}
}
}
#[test]
fn a_four_layer_stock_still_prints_mid_grey_as_mid_grey() {
for curve in [[0.0, 1.0, 1.0, -1.0], [0.0, 2.0, 0.7, -0.2]] {
let prepared = RenderParams {
film: four_layer(curve),
..RenderParams::default()
}
.prepare();
let exposure = prepared.expose([0.18, 0.18, 0.18]);
let printed =
prepared.positive(prepared.negative_density_with(exposure.layers, exposure.extra));
for value in printed {
assert!(
(value - 0.18).abs() < 0.02,
"curve {curve:?} printed {printed:?}"
);
}
}
}
fn inhibitor_stock() -> &'static FilmStock {
static SENSITIVITY: [f64; crate::spectral::GRID_LEN] = [1.0; crate::spectral::GRID_LEN];
let mut stock = *crate::emulsion::film_stock("vision3_500t").expect("built-in stock");
stock.id = "test_inhibitor_layer";
stock.cl_layer = Some(crate::dye::InhibitorLayer {
sensitivity: &SENSITIVITY,
});
Box::leak(Box::new(stock))
}
#[test]
fn the_inhibitor_layer_shows_only_where_the_frame_has_structure() {
let off = RenderParams {
film: inhibitor_stock(),
..RenderParams::default()
}
.prepare();
let on = RenderParams {
film: inhibitor_stock(),
interimage: true,
..RenderParams::default()
}
.prepare();
assert!(!off.has_inhibitor_layer());
assert!(on.has_inhibitor_layer());
assert!(on.spectral_model().is_none());
assert!(off.scalar_model().is_some());
let stage = crate::interimage::InterImage::typical(6.0);
let finishing = |interimage| Finishing {
emulsion: None,
halation: None,
grain: None,
couplers: None,
interimage,
};
let mut pixels = Vec::new();
for index in 0..64 {
pixels.push(if index < 32 {
[0.9, 0.2, 0.1]
} else {
[0.1, 0.2, 0.9]
});
}
let mut with = pixels.clone();
let mut without = pixels;
render_pixels_finished(&mut with, &on, 64, 1, &finishing(Some(&stage)));
render_pixels_finished(&mut without, &on, 64, 1, &finishing(None));
let warm = on
.expose([0.9, 0.2, 0.1])
.extra
.expect("the layer is in the render");
let cool = on
.expose([0.1, 0.2, 0.9])
.extra
.expect("the layer is in the render");
let (bright, shadow) = if warm > cool { (31, 32) } else { (32, 31) };
assert!(
with[shadow][0] < without[shadow][0],
"the shadow did not lose cyan: {:?} vs {:?}",
with[shadow],
without[shadow]
);
assert!(
with[bright][0] > without[bright][0],
"the bright side did not gain: {:?} vs {:?}",
with[bright],
without[bright]
);
for (left, right) in with.iter().zip(&without) {
assert!((left[1] - right[1]).abs() < 1e-12);
assert!((left[2] - right[2]).abs() < 1e-12);
}
}
#[test]
fn a_stock_without_a_fourth_layer_is_still_the_three_layer_model() {
for stock in crate::emulsion::FILM_STOCKS {
let prepared = RenderParams {
film: stock,
..RenderParams::default()
}
.prepare();
assert!(!prepared.has_extra_layer(), "{}", stock.id);
let pixel = [0.4, 0.3, 0.2];
let exposure = prepared.expose(pixel);
assert_eq!(exposure.extra, None, "{}", stock.id);
let expected: [f64; 3] = std::array::from_fn(|channel| {
prepared.channels()[channel].density(exposure.layers[channel])
});
assert_eq!(
prepared.negative_density(exposure.layers),
expected,
"{}",
stock.id
);
assert!(
prepared.scalar_model().is_some() || prepared.spectral_model().is_some(),
"{}",
stock.id
);
}
}
#[test]
fn a_second_emulsion_adds_density_on_the_cyan_dye() {
let curve = [0.05, 1.2, 0.7, -1.0];
let prepared = RenderParams {
film: four_layer(curve),
..RenderParams::default()
}
.prepare();
assert!(prepared.has_extra_layer());
assert!(prepared.is_spectral());
assert!(prepared.scalar_model().is_none());
assert!(prepared.spectral_model().is_none());
let exposure = prepared.expose([0.4, 0.3, 0.2]);
let extra = exposure.extra.expect("the stock has a second emulsion");
let added = crate::curve::density_from(
curve[0],
curve[1],
curve[2],
curve[3],
crate::curve::TRANSITION,
crate::curve::TRANSITION,
extra,
);
let without = prepared.negative_density_with(exposure.layers, None);
let with = prepared.negative_density_with(exposure.layers, Some(extra));
assert!(
(with[0] - without[0] - added).abs() < 1e-12,
"cyan: {} + {added} vs {}",
without[0],
with[0]
);
assert_eq!([with[1], with[2]], [without[1], without[2]]);
}
#[test]
fn the_fourth_layer_is_anchored_on_the_blue_layer() {
let prepared = RenderParams {
film: four_layer([0.0, 1.0, 1.0, 0.0]),
..RenderParams::default()
}
.prepare();
for pixel in [[0.18, 0.18, 0.18], [0.9, 0.1, 0.05], [0.05, 0.2, 0.8]] {
let exposure = prepared.expose(pixel);
let extra = exposure.extra.expect("the stock has a second emulsion");
let blue = exposure.layers[2];
assert!(
(extra - blue).abs() < 1e-6,
"{pixel:?}: fourth layer {extra} vs blue layer {blue}"
);
}
}
fn chain(development: DevelopmentParams) -> PreparedRender {
RenderParams {
development,
..RenderParams::default()
}
.prepare()
}
#[test]
fn print_balance_lands_mid_grey_on_target() {
let prepared = chain(DevelopmentParams::default());
let out = prepared.render_pixel([0.18, 0.18, 0.18]);
for channel in out {
assert!(
(channel - 0.18).abs() < 0.005,
"mid grey printed at {channel}"
);
}
}
#[test]
fn a_reversal_film_is_not_printed() {
let stock = crate::emulsion::film_stock("provia_100f").expect("the reversal stock");
let prepared = RenderParams {
film: stock,
..RenderParams::default()
}
.prepare();
assert!(prepared.reversal);
let density = [1.0, 1.5, 2.0];
let out = prepared.positive(density);
for channel in 0..3 {
let white = prepared.channels()[channel].d_max;
let expected =
10.0_f64.powf(-(density[channel] + prepared.base_density[channel] - white));
assert!(
(out[channel] - expected).abs() < 1e-12,
"channel {channel}: {} against {expected}",
out[channel]
);
}
let black = prepared.render_pixel([0.0; 3]);
let clear = prepared.render_pixel([4.0; 3]);
for channel in 0..3 {
assert!(black[channel] < 0.01, "unexposed at {}", black[channel]);
assert!(clear[channel] > 0.9, "fully exposed at {}", clear[channel]);
}
}
fn local_contrast(prepared: &PreparedRender) -> f64 {
let mid = 0.18;
let low = prepared.render_pixel([mid / 2.0; 3])[1].max(1e-6);
let high = prepared.render_pixel([mid * 2.0; 3])[1].max(1e-6);
(high / low).log10() / 4.0_f64.log10()
}
fn luma(rgb: [f64; 3]) -> f64 {
0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]
}
#[test]
fn every_stock_prints_mid_grey_as_mid_grey() {
for film in crate::emulsion::FILM_STOCKS {
let prepared = RenderParams {
film,
..RenderParams::default()
}
.prepare();
if prepared.reversal {
continue;
}
let out = prepared.render_pixel([0.18; 3]);
assert!(
(luma(out) - 0.18).abs() < 0.01,
"{} printed mid grey at {:.4}",
film.id,
luma(out)
);
let high = out.iter().copied().fold(f64::MIN, f64::max);
let low = out.iter().copied().fold(f64::MAX, f64::min);
assert!(
high - low < 0.01,
"{} printed mid grey {:.4} off neutral",
film.id,
high - low
);
}
for paper in crate::emulsion::PAPER_STOCKS {
let prepared = RenderParams {
paper,
..RenderParams::default()
}
.prepare();
let out = prepared.render_pixel([0.18; 3]);
assert!(
(luma(out) - 0.18).abs() < 0.02,
"{} printed mid grey at {:.4}",
paper.id,
luma(out)
);
}
}
#[test]
fn every_stock_keeps_a_ramp_monotone() {
let steps = [0.0, 0.02, 0.05, 0.1, 0.18, 0.35, 0.6, 0.8, 1.0];
for film in crate::emulsion::FILM_STOCKS {
let prepared = RenderParams {
film,
..RenderParams::default()
}
.prepare();
let mut previous = f64::MIN;
for step in steps {
let value = luma(prepared.render_pixel([step; 3]));
assert!(
value >= previous - 1e-9,
"{} inverts the ramp at {step}: {value:.4} under {previous:.4}",
film.id
);
previous = value;
}
}
}
fn spread(prepared: &PreparedRender) -> f64 {
let steps = [0.0, 0.02, 0.05, 0.1, 0.18, 0.35, 0.6, 0.8, 1.0];
let values: Vec<f64> = steps
.iter()
.map(|step| luma(prepared.render_pixel([*step; 3])))
.collect();
let mean = values.iter().sum::<f64>() / values.len() as f64;
(values.iter().map(|v| (v - mean).powi(2)).sum::<f64>() / values.len() as f64).sqrt()
}
#[test]
fn every_stock_gains_contrast_with_development() {
for film in crate::emulsion::FILM_STOCKS {
let at = |time_min: f64| {
spread(
&RenderParams {
film,
development: DevelopmentParams {
time_min,
..DevelopmentParams::default()
},
..RenderParams::default()
}
.prepare(),
)
};
let pulled = at(4.0);
let normal = at(8.0);
let pushed = at(16.0);
assert!(
pulled < normal && normal < pushed,
"{}: spread {pulled:.3} / {normal:.3} / {pushed:.3} at 4 / 8 / 16 min",
film.id
);
}
}
#[test]
fn over_development_raises_contrast() {
let normal = local_contrast(&chain(DevelopmentParams::default()));
let pushed = local_contrast(&chain(DevelopmentParams {
time_min: 12.0,
..DevelopmentParams::default()
}));
assert!(pushed > normal, "normal {normal}, pushed {pushed}");
}
#[test]
fn under_development_lowers_contrast() {
let normal = local_contrast(&chain(DevelopmentParams::default()));
let pulled = local_contrast(&chain(DevelopmentParams {
time_min: 3.0,
..DevelopmentParams::default()
}));
assert!(pulled < normal, "normal {normal}, pulled {pulled}");
}
#[test]
fn a_silver_film_does_not_print_spectrally() {
let prepared = RenderParams {
film: crate::emulsion::film_stock("kodak_trix400").expect("the silver stock"),
spectral: true,
spectral_print: true,
..RenderParams::default()
}
.prepare();
assert!(!prepared.is_spectral_print());
let out = prepared.render_pixel([0.18, 0.18, 0.18]);
assert!(out.iter().all(|channel| channel.is_finite()));
assert!(out[1] > 0.02 && out[1] < 0.6, "mid grey at {}", out[1]);
}
#[test]
fn spectral_path_keeps_mid_grey_on_target() {
let prepared = RenderParams {
spectral: true,
..RenderParams::default()
}
.prepare();
assert!(prepared.is_spectral());
let out = prepared.render_pixel([0.18, 0.18, 0.18]);
for channel in out {
assert!(
(channel - 0.18).abs() < 0.01,
"mid grey printed at {channel}"
);
}
}
#[test]
fn spectral_scan_produces_neutral_grey() {
let prepared = RenderParams {
spectral_print: true,
spectral_scan: true,
..RenderParams::default()
}
.prepare();
assert!(prepared.is_spectral_scan());
let out = prepared.render_pixel([0.18, 0.18, 0.18]);
let spread = out.iter().copied().fold(f64::NEG_INFINITY, f64::max)
- out.iter().copied().fold(f64::INFINITY, f64::min);
assert!(spread < 0.02, "grey drifts by {spread}: {out:?}");
assert!(out[1] > 0.02 && out[1] < 0.6, "mid grey at {}", out[1]);
}
#[test]
fn spectral_scan_is_monotonic_and_bounded() {
let prepared = RenderParams {
spectral_print: true,
spectral_scan: true,
..RenderParams::default()
}
.prepare();
let mut previous = -1.0;
for i in -80..80 {
let x = 2.0_f64.powf(f64::from(i) / 10.0) * 0.18;
let y = prepared.render_pixel([x; 3])[1];
assert!((0.0..=1.0).contains(&y));
assert!(y >= previous - 1e-9, "non-monotonic at {x}");
previous = y;
}
}
#[test]
fn spectral_print_keeps_mid_grey_on_target() {
let prepared = RenderParams {
spectral_print: true,
..RenderParams::default()
}
.prepare();
assert!(prepared.is_spectral_print());
let out = prepared.render_pixel([0.18, 0.18, 0.18]);
for channel in out {
assert!(
(channel - 0.18).abs() < 0.01,
"mid grey printed at {channel}"
);
}
}
#[test]
fn spectral_print_couples_the_layers() {
let scalar = RenderParams::default().prepare();
let spectral = RenderParams {
spectral_print: true,
..RenderParams::default()
}
.prepare();
let sample = [0.08, 0.42, 0.45];
let a = scalar.render_pixel(sample);
let b = spectral.render_pixel(sample);
let difference: f64 = a.iter().zip(&b).map(|(x, y)| (x - y).abs()).sum();
assert!(difference > 1e-4, "no coupling visible: {difference}");
}
#[test]
fn spectral_print_is_monotonic_and_bounded() {
let prepared = RenderParams {
spectral_print: true,
..RenderParams::default()
}
.prepare();
let mut previous = -1.0;
for i in -80..80 {
let x = 2.0_f64.powf(f64::from(i) / 10.0) * 0.18;
let y = prepared.render_pixel([x; 3])[1];
assert!((0.0..=1.0).contains(&y));
assert!(y >= previous - 1e-9, "non-monotonic at {x}");
previous = y;
}
}
#[test]
fn the_baked_table_matches_the_live_path() {
let live = RenderParams {
spectral: true,
..RenderParams::default()
}
.prepare();
let baked = RenderParams {
spectral: true,
lut_size: 33,
..RenderParams::default()
}
.prepare();
assert!(baked.lut().is_some());
assert!(live.lut().is_none());
let mut worst = 0.0_f64;
for r in 0..6 {
for g in 0..6 {
for b in 0..6 {
let rgb = [
0.02 + 0.16 * f64::from(r),
0.02 + 0.16 * f64::from(g),
0.02 + 0.16 * f64::from(b),
];
let a = live.render_pixel(rgb);
let c = baked.render_pixel(rgb);
for channel in 0..3 {
worst = worst.max((a[channel] - c[channel]).abs());
}
}
}
}
assert!(worst < 0.05, "baked path differs by {worst}");
}
#[test]
fn spectral_path_changes_colour_separation() {
let scalar = RenderParams::default().prepare();
let spectral = RenderParams {
spectral: true,
..RenderParams::default()
}
.prepare();
let sample = [0.75, 0.12, 0.08];
let a = scalar.render_pixel(sample);
let b = spectral.render_pixel(sample);
let difference: f64 = a.iter().zip(&b).map(|(x, y)| (x - y).abs()).sum();
assert!(
difference > 1e-4,
"spectral path changed nothing: {difference}"
);
}
#[test]
fn spectral_output_is_monotonic_and_bounded() {
let prepared = RenderParams {
spectral: true,
..RenderParams::default()
}
.prepare();
let mut previous = -1.0;
for i in -80..80 {
let x = 2.0_f64.powf(f64::from(i) / 10.0) * 0.18;
let y = prepared.render_pixel([x; 3])[1];
assert!((0.0..=1.0).contains(&y));
assert!(y >= previous - 1e-9, "non-monotonic at {x}");
previous = y;
}
}
#[test]
fn output_is_monotonic_and_bounded() {
let prepared = chain(DevelopmentParams::default());
let mut previous = -1.0;
for i in -80..80 {
let x = 2.0_f64.powf(f64::from(i) / 10.0) * 0.18;
let y = prepared.render_pixel([x; 3])[1];
assert!((0.0..=1.0).contains(&y));
assert!(y >= previous - 1e-9, "non-monotonic at {x}");
previous = y;
}
}
#[test]
fn grain_peaks_inside_the_straight_line() {
const SIDE: usize = 64;
let mut grain = crate::grain::GrainField::new(SIDE, SIDE, 36.0, 11);
grain.pixel_area_um2 = 36.0;
let spread = |ev: f64| {
let prepared = RenderParams {
exposure_ev: ev,
..RenderParams::default()
}
.prepare();
let mut pixels = vec![[0.18; 3]; SIDE * SIDE];
render_pixels_with_grain(&mut pixels, &prepared, &grain);
let mean = pixels.iter().map(|p| p[0]).sum::<f64>() / pixels.len() as f64;
(pixels.iter().map(|p| (p[0] - mean).powi(2)).sum::<f64>() / pixels.len() as f64).sqrt()
};
let dark = spread(-8.0);
let mid = spread(0.0);
let peak = spread(2.0);
let bright = spread(8.0);
assert!(
peak > 5.0 * dark && peak > 5.0 * bright,
"peak {peak} dark {dark} bright {bright}"
);
assert!(
peak > spread(-2.0) && peak > spread(6.0),
"the peak is not in the middle: -2 {}, +2 {peak}, +6 {}",
spread(-2.0),
spread(6.0)
);
assert!(mid > 0.5 * peak, "mid {mid} against peak {peak}");
}
#[test]
fn probe() {
for (name, params) in [
(
"spectral",
RenderParams {
spectral: true,
..RenderParams::default()
},
),
(
"print",
RenderParams {
spectral_print: true,
..RenderParams::default()
},
),
(
"scan",
RenderParams {
spectral_print: true,
spectral_scan: true,
..RenderParams::default()
},
),
] {
let prepared = params.prepare();
let model = prepared.spectral_model().expect(name);
println!("== {name}");
if let Some(e) = &model.exposure {
println!(" reconstruct = {:?}", e.reconstruct);
println!(" reference = {:?}", e.reference);
println!(
" basis max = {:?}",
[
e.basis[0].iter().fold(f64::MIN, |a, &b| a.max(b)),
e.basis[1].iter().fold(f64::MIN, |a, &b| a.max(b)),
e.basis[2].iter().fold(f64::MIN, |a, &b| a.max(b)),
]
);
println!(
" film max = {:?}",
[
e.film[0].iter().fold(f64::MIN, |a, &b| a.max(b)),
e.film[1].iter().fold(f64::MIN, |a, &b| a.max(b)),
e.film[2].iter().fold(f64::MIN, |a, &b| a.max(b)),
]
);
}
if let Some(p) = &model.enlarger {
println!(" analytical = {:?}", p.analytical);
println!(
" clamped={} reference={:?} masking={:?} ref={}",
p.clamped, p.reference, p.masking, p.masking_reference
);
println!(
" paper max = {:?}",
[0, 1, 2].map(|c| p.paper[c].iter().fold(f64::MIN, |a, &b| a.max(b)))
);
}
if let Some(s) = &model.scan {
println!(
" scan clamped={} white_xyz={:?} white_rgb={:?}",
s.clamped, s.white_xyz, s.white_rgb
);
println!(
" neutral[0]={:?} neutral[32]={:?}",
s.neutral[0], s.neutral[32]
);
}
}
}
}
#[cfg(test)]
mod enlarger_tests {
use super::*;
use crate::filters::{FilterPack, HeatGlass};
fn print_with(pack: FilterPack, glass: Option<HeatGlass>) -> [f64; 3] {
RenderParams {
spectral_print: true,
filters: pack,
heat_glass: glass,
..RenderParams::default()
}
.prepare()
.render_pixel([0.45, 0.28, 0.14])
}
#[test]
fn a_pack_changes_the_print() {
let clear = print_with(FilterPack::none(), None);
let heavy = print_with(FilterPack::new(0.0, 200.0, 0.0), None);
let moved = (0..3)
.map(|i| (clear[i] - heavy[i]).abs())
.fold(0.0, f64::max);
assert!(moved > 0.01, "200 CC of magenta moved the print by {moved}");
}
#[test]
fn magenta_moves_the_green_exposure_one_way() {
let green_exposure = |cc: f64| {
let prepared = RenderParams {
spectral_print: true,
filters: FilterPack::new(0.0, cc, 0.0),
..RenderParams::default()
}
.prepare();
prepared.print_shift()[1]
};
let mut previous: Option<f64> = None;
for step in 1..=12 {
let cc = 5.0 * f64::from(step);
let shift = green_exposure(cc);
if let Some(before) = previous {
assert!(
shift > before + 1e-9,
"at {cc} CC the green layer's exposure went {before} -> {shift}"
);
}
previous = Some(shift);
}
let step = green_exposure(10.0) - green_exposure(5.0);
assert!(
(0.005..0.08).contains(&step),
"5 CC moved the green exposure by {step}"
);
}
}