Develop a mask layer's film on its own settings
A layer offered the film's sliders and they moved nothing: its copy of the node was never given the stock, so it stayed inactive. Film now works in a layer the way the other adjustments do, as offsets to the photograph's settings, but blended as settings rather than as results, since a film is a rendering and cross-fading two developments is not what a region on a pushed film looks like. - dr-film bakes no slider. Exposure is a gain in the shader; push interpolates the stock's measured processes, one curve row each; the print is split at the paper's log exposure, so print exposure is an addition between two lookups and exact at any setting. The enlarger stays balanced at the photograph's exposure. - film_sim reads all four settings as uniforms, format one-hot over a grain count per format, so every uniform is linear in what it does. - Operation::blends_settings lets the composer average each overlapping layer's uniforms with the global ones by mask weight, the global setting taking whatever weight the layers leave, and run the fragment once. Three layers at full weight give the mean of their settings. - The stock picker is hidden on a layer. Only the photograph's exposure re-solves the print balance; push, print exposure and format need no rebake at all now.
This commit is contained in:
+443
-112
@@ -21,14 +21,16 @@
|
||||
//! curves and dyes, the viewing illuminant, the adaptation — all of it takes
|
||||
//! three numbers in and gives three numbers out. So it bakes into one small
|
||||
//! 3D lookup, and the per-pixel cost is a matrix multiply, three curve taps
|
||||
//! and one texture fetch.
|
||||
//! and one texture fetch. A print is two: the film's lookup ends at the
|
||||
//! paper's log exposure, where the enlarger's exposure is an addition, and
|
||||
//! the paper's curve and lookup take it from there — see [`Paper`].
|
||||
//!
|
||||
//! Splitting 2 from 3 rather than baking a single LUT over exposure is
|
||||
//! deliberate and measured: the curve carries all of the sharp shape and the
|
||||
//! dye mixing is smooth, so putting the curve in the 3D LUT would force it
|
||||
//! three times larger for the same error.
|
||||
|
||||
use crate::profile::Profile;
|
||||
use crate::profile::{Profile, CURVE_SAMPLES};
|
||||
use crate::spectrum::{illuminant, Spectrum, Viewing};
|
||||
use crate::tables::{SPECTRUM, SRGB_BASIS};
|
||||
|
||||
@@ -47,7 +49,19 @@ pub const MID_GREY: f32 = 0.184;
|
||||
/// that on: the error is already under what the output can represent.
|
||||
pub const LUT_SIZE: usize = 32;
|
||||
|
||||
/// What to develop, and how.
|
||||
/// TRACES: FR-DEV-3f
|
||||
/// The most development times a stock may measure: one curve row, and one
|
||||
/// push station, each. Every stock shipped measures five; the ceiling is what
|
||||
/// the shader's fixed uniform block can hold.
|
||||
pub const MAX_CURVE_ROWS: usize = 8;
|
||||
|
||||
/// What to develop: the materials, and where the enlarger is balanced.
|
||||
///
|
||||
/// **Not how far, and not how bright.** Push, print exposure and camera
|
||||
/// exposure are [`Settings`], evaluated per pixel against these tables, so
|
||||
/// that a mask layer can hold its own and a pixel under it can take the
|
||||
/// weighted average of everyone's (FR-DEV-3f). What is left here is what a
|
||||
/// photograph has one of.
|
||||
pub struct Recipe<'a> {
|
||||
/// The stock the picture was taken on.
|
||||
pub film: &'a Profile,
|
||||
@@ -55,17 +69,15 @@ pub struct Recipe<'a> {
|
||||
/// what a reversal stock wants and what makes a negative come out orange
|
||||
/// and inverted — that being what a negative actually looks like.
|
||||
pub print: Option<&'a Profile>,
|
||||
/// Camera exposure, in stops.
|
||||
pub exposure_ev: f32,
|
||||
/// Enlarger exposure, in stops. Ignored without a `print`.
|
||||
pub print_exposure_ev: f32,
|
||||
/// TRACES: FR-DEV-3f
|
||||
/// Development, in stops of push. Positive develops longer.
|
||||
/// The camera exposure the enlarger is balanced at, in stops. Ignored
|
||||
/// without a `print`.
|
||||
///
|
||||
/// Ignored by a stock measured at one process, of which there are many —
|
||||
/// see [`crate::profile::Profile::curves_at_push`], which returns the one
|
||||
/// measured curve rather than inventing a pushed one.
|
||||
pub push_stops: f32,
|
||||
/// The *photograph's* exposure, never a region's. An enlarger has one
|
||||
/// filtration for the whole print: a negative exposed a stop brighter in
|
||||
/// one corner prints a stop darker there, and that difference is the
|
||||
/// picture — balancing it away per pixel would erase every local exposure
|
||||
/// change a layer made.
|
||||
pub exposure_ev: f32,
|
||||
}
|
||||
|
||||
impl<'a> Recipe<'a> {
|
||||
@@ -76,12 +88,27 @@ impl<'a> Recipe<'a> {
|
||||
film,
|
||||
print,
|
||||
exposure_ev: 0.0,
|
||||
print_exposure_ev: 0.0,
|
||||
push_stops: 0.0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// TRACES: FR-DEV-3f
|
||||
/// What a pixel is developed with, against a [`Baked`] stock.
|
||||
///
|
||||
/// The shader's uniforms, as the CPU sees them: every field is linear in what
|
||||
/// the tables are indexed by, which is what lets the composer blend several
|
||||
/// layers' settings into one before the fragment runs.
|
||||
#[derive(Debug, Clone, Copy, Default, PartialEq)]
|
||||
pub struct Settings {
|
||||
/// Camera exposure, in stops: a gain on the scene.
|
||||
pub exposure_ev: f32,
|
||||
/// Development, in stops of push. Positive develops longer. Nothing for a
|
||||
/// stock measured at one process, of which there are many.
|
||||
pub push_stops: f32,
|
||||
/// Enlarger exposure, in stops. Nothing without a print.
|
||||
pub print_exposure_ev: f32,
|
||||
}
|
||||
|
||||
/// A recipe reduced to three tables.
|
||||
///
|
||||
/// Plain `f32` with a documented layout, and no notion of a texture: what to
|
||||
@@ -89,16 +116,31 @@ impl<'a> Recipe<'a> {
|
||||
/// the whole model be tested on the CPU.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Baked {
|
||||
/// Linear sRGB to the three layers' log₁₀ exposure, before the log — row
|
||||
/// `l`, column `c` is layer `l`'s response to sRGB channel `c`.
|
||||
/// Linear sRGB to the three layers' exposure, before the log — row `l`,
|
||||
/// column `c` is layer `l`'s response to sRGB channel `c`. At unit gain:
|
||||
/// [`Settings::exposure_ev`] is applied per pixel.
|
||||
pub exposure_matrix: [[f32; 3]; 3],
|
||||
/// The characteristic curves, `CURVE_SAMPLES` samples per layer, uniform
|
||||
/// over `[curve_log_min, curve_log_max]`.
|
||||
/// The characteristic curves: `curve_rows` rows of `CURVE_SAMPLES`
|
||||
/// samples, row after row, each uniform over
|
||||
/// `[curve_log_min, curve_log_max]`.
|
||||
///
|
||||
/// Row `r` is the stock as measured at its `r`th development time, which
|
||||
/// is push [`Self::push_stations`]`[r]`. The rows are the measurements
|
||||
/// themselves rather than a resampling: between two, density is linear in
|
||||
/// push (development is interpolated in log time, and push is log time),
|
||||
/// so interpolating the rows by push reproduces
|
||||
/// [`Profile::curves_at_push`] exactly. A stock measured at one process
|
||||
/// has one row.
|
||||
pub curves: Vec<[f32; 3]>,
|
||||
pub curve_rows: usize,
|
||||
/// The push each row was developed to, ascending, one per row.
|
||||
pub push_stations: Vec<f32>,
|
||||
pub curve_log_min: f32,
|
||||
pub curve_log_max: f32,
|
||||
/// Density to linear sRGB, `LUT_SIZE³` entries uniform over
|
||||
/// `[0, density_max]` on each axis.
|
||||
/// Film density to what comes next, `LUT_SIZE³` entries uniform over
|
||||
/// `[0, density_max]` on each axis: linear sRGB when the film is viewed
|
||||
/// directly, and the paper's log₁₀ exposure through it, per layer, when it
|
||||
/// is printed.
|
||||
///
|
||||
/// **The red axis varies fastest**, then green, then blue — that is,
|
||||
/// `lut[(b * size + g) * size + r]`. Stated because it is not the order
|
||||
@@ -108,60 +150,142 @@ pub struct Baked {
|
||||
/// picture with red and blue transposed, which looks like a plausible
|
||||
/// photograph of the wrong colour.
|
||||
pub lut: Vec<[f32; 3]>,
|
||||
/// The paper, when there is one. See [`Paper`].
|
||||
pub paper: Option<Paper>,
|
||||
/// The deepest density any row develops to, so one lookup covers every
|
||||
/// push.
|
||||
pub density_max: f32,
|
||||
pub lut_size: usize,
|
||||
}
|
||||
|
||||
/// TRACES: FR-DEV-3f
|
||||
/// The print half of a baked stock: enlarger to paper to viewing.
|
||||
///
|
||||
/// Split from the film's lookup at the paper's log exposure, for the reason
|
||||
/// the film is split from its own curve. The enlarger's exposure is a shift
|
||||
/// *in that log exposure*, the same stops on all three layers, so a print
|
||||
/// exposure is an addition between the two lookups — exact at any value and
|
||||
/// free per pixel. Baking it into one lookup instead needs a slice per
|
||||
/// setting, and interpolating between slices misses by several code values,
|
||||
/// because the paper's curve is the sharpest thing in the print.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Paper {
|
||||
/// The enlarger's filtration, per layer, in log₁₀ exposure: what makes a
|
||||
/// mid-grey scene print neutral at the photograph's exposure. See
|
||||
/// [`Recipe::exposure_ev`].
|
||||
pub balance: [f32; 3],
|
||||
/// The paper's characteristic curves, `CURVE_SAMPLES` samples uniform
|
||||
/// over `[log_min, log_max]`.
|
||||
pub curves: Vec<[f32; 3]>,
|
||||
pub log_min: f32,
|
||||
pub log_max: f32,
|
||||
/// Paper density to linear sRGB, laid out as [`Baked::lut`] is, uniform
|
||||
/// over `[0, density_max]`.
|
||||
pub lut: Vec<[f32; 3]>,
|
||||
pub density_max: f32,
|
||||
}
|
||||
|
||||
/// Where `push` falls among the rows: the lower row and the fraction toward
|
||||
/// the next. Clamped at both ends, as `curves_at_push` clamps to the first and
|
||||
/// last measured process.
|
||||
fn push_row(stations: &[f32], push: f32) -> (usize, f32) {
|
||||
if stations.len() < 2 {
|
||||
return (0, 0.0);
|
||||
}
|
||||
let last = stations.len() - 1;
|
||||
let hi = stations
|
||||
.iter()
|
||||
.position(|p| *p >= push)
|
||||
.unwrap_or(last)
|
||||
.max(1);
|
||||
let lo = hi - 1;
|
||||
let f = (push - stations[lo]) / (stations[hi] - stations[lo]).max(1e-6);
|
||||
(lo, f.clamp(0.0, 1.0))
|
||||
}
|
||||
|
||||
impl Baked {
|
||||
/// Look a colour up the way the shader will, for tests and for previews.
|
||||
/// Look a colour up the way the shader will, at the stock's own settings.
|
||||
pub fn apply(&self, rgb: [f32; 3]) -> [f32; 3] {
|
||||
self.apply_at(rgb, &Settings::default())
|
||||
}
|
||||
|
||||
/// Look a colour up the way the shader will, for tests and for previews.
|
||||
pub fn apply_at(&self, rgb: [f32; 3], settings: &Settings) -> [f32; 3] {
|
||||
let gain = 2f32.powf(settings.exposure_ev);
|
||||
let mut log_exposure = [0.0f32; 3];
|
||||
for (l, slot) in log_exposure.iter_mut().enumerate() {
|
||||
let m = self.exposure_matrix[l];
|
||||
let e = m[0] * rgb[0] + m[1] * rgb[1] + m[2] * rgb[2];
|
||||
let e = gain * (m[0] * rgb[0] + m[1] * rgb[1] + m[2] * rgb[2]);
|
||||
*slot = (e.max(0.0) + 1e-10).log10();
|
||||
}
|
||||
self.sample_lut(self.sample_curves(log_exposure))
|
||||
let density = self.sample_curves(log_exposure, settings.push_stops);
|
||||
let through = sample_cube(&self.lut, self.lut_size, density, self.density_max);
|
||||
let Some(paper) = &self.paper else {
|
||||
return through;
|
||||
};
|
||||
let shift = settings.print_exposure_ev * 2f32.log10();
|
||||
let paper_log = [0, 1, 2].map(|l| through[l] + paper.balance[l] + shift);
|
||||
let paper_density = sample_curve(&paper.curves, paper.log_min, paper.log_max, paper_log);
|
||||
sample_cube(&paper.lut, self.lut_size, paper_density, paper.density_max)
|
||||
}
|
||||
|
||||
fn sample_curves(&self, log_exposure: [f32; 3]) -> [f32; 3] {
|
||||
let last = self.curves.len() - 1;
|
||||
let span = self.curve_log_max - self.curve_log_min;
|
||||
let mut out = [0.0f32; 3];
|
||||
for (c, slot) in out.iter_mut().enumerate() {
|
||||
let t = ((log_exposure[c] - self.curve_log_min) / span).clamp(0.0, 1.0) * last as f32;
|
||||
let i = (t.floor() as usize).min(last - 1);
|
||||
let f = t - i as f32;
|
||||
*slot = self.curves[i][c] * (1.0 - f) + self.curves[i + 1][c] * f;
|
||||
fn sample_curves(&self, log_exposure: [f32; 3], push_stops: f32) -> [f32; 3] {
|
||||
let (row, g) = push_row(&self.push_stations, push_stops);
|
||||
let lo = self.sample_curve_row(log_exposure, row);
|
||||
if self.curve_rows < 2 {
|
||||
return lo;
|
||||
}
|
||||
out
|
||||
let hi = self.sample_curve_row(log_exposure, row + 1);
|
||||
[0, 1, 2].map(|c| lo[c] * (1.0 - g) + hi[c] * g)
|
||||
}
|
||||
|
||||
fn sample_lut(&self, density: [f32; 3]) -> [f32; 3] {
|
||||
let n = self.lut_size;
|
||||
let mut base = [0usize; 3];
|
||||
let mut frac = [0f32; 3];
|
||||
for c in 0..3 {
|
||||
let t = (density[c] / self.density_max).clamp(0.0, 1.0) * (n - 1) as f32;
|
||||
base[c] = (t.floor() as usize).min(n - 2);
|
||||
frac[c] = t - base[c] as f32;
|
||||
}
|
||||
let mut out = [0.0f32; 3];
|
||||
for dx in 0..2 {
|
||||
for dy in 0..2 {
|
||||
for dz in 0..2 {
|
||||
let w = if dx == 0 { 1.0 - frac[0] } else { frac[0] }
|
||||
* if dy == 0 { 1.0 - frac[1] } else { frac[1] }
|
||||
* if dz == 0 { 1.0 - frac[2] } else { frac[2] };
|
||||
let e = self.lut[((base[2] + dz) * n + base[1] + dy) * n + base[0] + dx];
|
||||
for c in 0..3 {
|
||||
out[c] += w * e[c];
|
||||
}
|
||||
fn sample_curve_row(&self, log_exposure: [f32; 3], row: usize) -> [f32; 3] {
|
||||
let samples = self.curves.len() / self.curve_rows;
|
||||
let curve = &self.curves[row * samples..(row + 1) * samples];
|
||||
sample_curve(curve, self.curve_log_min, self.curve_log_max, log_exposure)
|
||||
}
|
||||
}
|
||||
|
||||
/// Three curves sampled uniformly over `[log_min, log_max]`, read at a log
|
||||
/// exposure per layer. Clamped at both ends, as the shader's is.
|
||||
fn sample_curve(curve: &[[f32; 3]], log_min: f32, log_max: f32, at: [f32; 3]) -> [f32; 3] {
|
||||
let last = curve.len() - 1;
|
||||
let span = log_max - log_min;
|
||||
let mut out = [0.0f32; 3];
|
||||
for (c, slot) in out.iter_mut().enumerate() {
|
||||
let t = ((at[c] - log_min) / span).clamp(0.0, 1.0) * last as f32;
|
||||
let i = (t.floor() as usize).min(last - 1);
|
||||
let f = t - i as f32;
|
||||
*slot = curve[i][c] * (1.0 - f) + curve[i + 1][c] * f;
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// A cube of `n³` triples over `[0, max]` per axis, red fastest, read
|
||||
/// trilinearly.
|
||||
fn sample_cube(lut: &[[f32; 3]], n: usize, density: [f32; 3], max: f32) -> [f32; 3] {
|
||||
let mut base = [0usize; 3];
|
||||
let mut frac = [0f32; 3];
|
||||
for c in 0..3 {
|
||||
let t = (density[c] / max).clamp(0.0, 1.0) * (n - 1) as f32;
|
||||
base[c] = (t.floor() as usize).min(n - 2);
|
||||
frac[c] = t - base[c] as f32;
|
||||
}
|
||||
let mut out = [0.0f32; 3];
|
||||
for dx in 0..2 {
|
||||
for dy in 0..2 {
|
||||
for dz in 0..2 {
|
||||
let w = if dx == 0 { 1.0 - frac[0] } else { frac[0] }
|
||||
* if dy == 0 { 1.0 - frac[1] } else { frac[1] }
|
||||
* if dz == 0 { 1.0 - frac[2] } else { frac[2] };
|
||||
let e = lut[((base[2] + dz) * n + base[1] + dy) * n + base[0] + dx];
|
||||
for c in 0..3 {
|
||||
out[c] += w * e[c];
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Linear sRGB to the three layers' exposure, mid-grey normalised.
|
||||
@@ -204,12 +328,7 @@ pub fn exposure_matrix(film: &Profile) -> [[f32; 3]; 3] {
|
||||
/// goes: the mask is a fixed density, so balancing mid-grey to neutral cancels
|
||||
/// it — which is why a printed negative looks like a photograph while a scanned
|
||||
/// one looks orange.
|
||||
fn print_balance(
|
||||
film: &Profile,
|
||||
paper: &Profile,
|
||||
exposure_ev: f32,
|
||||
print_exposure_ev: f32,
|
||||
) -> [f32; 3] {
|
||||
pub fn print_balance(film: &Profile, paper: &Profile, exposure_ev: f32) -> [f32; 3] {
|
||||
let matrix = exposure_matrix(film);
|
||||
let scene = MID_GREY * 2f32.powf(exposure_ev);
|
||||
let mut log_exposure = [0.0f32; 3];
|
||||
@@ -227,7 +346,7 @@ fn print_balance(
|
||||
|
||||
let mut offsets = [0.0f32; 3];
|
||||
for (l, slot) in offsets.iter_mut().enumerate() {
|
||||
*slot = target - (mid_raw[l] + 1e-10).log10() + print_exposure_ev * 2f32.log10();
|
||||
*slot = target - (mid_raw[l] + 1e-10).log10();
|
||||
}
|
||||
offsets
|
||||
}
|
||||
@@ -257,77 +376,117 @@ fn paper_exposure(film: &Profile, paper: &Profile, density: [f32; 3]) -> [f32; 3
|
||||
/// Bake a recipe into the tables a shader runs.
|
||||
pub fn bake(recipe: &Recipe) -> Baked {
|
||||
let film = recipe.film;
|
||||
let mut matrix = exposure_matrix(film);
|
||||
// Camera exposure rides in the matrix rather than in the shader: it is a
|
||||
// scalar on a linear quantity, and folding it in here costs nothing and
|
||||
// keeps the per-pixel work identical whether or not it has been moved.
|
||||
let gain = 2f32.powf(recipe.exposure_ev);
|
||||
for row in &mut matrix {
|
||||
for v in row.iter_mut() {
|
||||
*v *= gain;
|
||||
}
|
||||
}
|
||||
// At unit gain. Camera exposure is a scalar on a linear quantity, so the
|
||||
// shader applies it for the price of one multiply — and has to, since a
|
||||
// layer may hold its own.
|
||||
let matrix = exposure_matrix(film);
|
||||
|
||||
// TRACES: FR-DEV-3f
|
||||
// Developed to the requested push before anything else reads the curves:
|
||||
// the density ceiling, the print balance and the grain all depend on how
|
||||
// far this film was taken, and a push that only reached one of them would
|
||||
// be a contrast change wearing a push's name.
|
||||
let curves = film.curves_at_push(recipe.push_stops);
|
||||
let density_max = curves
|
||||
.iter()
|
||||
.flat_map(|row| row.iter())
|
||||
.fold(0.0f32, |a, &b| a.max(b))
|
||||
.max(1e-3);
|
||||
|
||||
let viewing = match recipe.print {
|
||||
Some(paper) => Viewing::new(&paper.viewing_illuminant),
|
||||
None => Viewing::new(&film.viewing_illuminant),
|
||||
// Every measured process, not the one the slider is at: the shader
|
||||
// interpolates between rows per pixel, so a layer can push a region.
|
||||
// Resampled to one length because the rows share a texture.
|
||||
let measured = film.development_curves.len() >= 2
|
||||
&& film.development_times.len() == film.development_curves.len();
|
||||
let (curves, push_stations): (Vec<[f32; 3]>, Vec<f32>) = if measured {
|
||||
let rows = film.development_curves.len().min(MAX_CURVE_ROWS);
|
||||
(
|
||||
film.development_curves[..rows]
|
||||
.iter()
|
||||
.flat_map(|c| resample(c))
|
||||
.collect(),
|
||||
film.development_times[..rows]
|
||||
.iter()
|
||||
.map(|t| 2.0 * (t / film.development_normal).log2())
|
||||
.collect(),
|
||||
)
|
||||
} else {
|
||||
(resample(&film.density_curves), vec![0.0])
|
||||
};
|
||||
let balance = recipe
|
||||
.print
|
||||
.map(|paper| print_balance(film, paper, recipe.exposure_ev, recipe.print_exposure_ev));
|
||||
let curve_rows = push_stations.len();
|
||||
// The ceiling of the deepest row, so one lookup covers every push.
|
||||
let density_max = ceiling(&curves);
|
||||
|
||||
let n = LUT_SIZE;
|
||||
let mut lut = Vec::with_capacity(n * n * n);
|
||||
// Blue outermost and red innermost, so the red axis varies fastest. See
|
||||
// `Baked::lut`: this is the layout a 3D texture upload wants, and getting
|
||||
// it backwards transposes red and blue in the finished picture.
|
||||
for b in 0..n {
|
||||
for g in 0..n {
|
||||
for r in 0..n {
|
||||
let density = [
|
||||
density_max * r as f32 / (n - 1) as f32,
|
||||
density_max * g as f32 / (n - 1) as f32,
|
||||
density_max * b as f32 / (n - 1) as f32,
|
||||
];
|
||||
lut.push(match recipe.print.zip(balance) {
|
||||
Some((paper, offsets)) => {
|
||||
let raw = paper_exposure(film, paper, density);
|
||||
let mut log_exposure = [0.0f32; 3];
|
||||
for (l, slot) in log_exposure.iter_mut().enumerate() {
|
||||
*slot = (raw[l] + 1e-10).log10() + offsets[l];
|
||||
}
|
||||
let paper_density = paper.density_at(log_exposure);
|
||||
viewing.to_srgb(&paper.transmittance(paper_density))
|
||||
}
|
||||
None => viewing.to_srgb(&film.transmittance(density)),
|
||||
});
|
||||
let cube = |max: f32, f: &dyn Fn([f32; 3]) -> [f32; 3]| {
|
||||
let mut out = Vec::with_capacity(n * n * n);
|
||||
for b in 0..n {
|
||||
for g in 0..n {
|
||||
for r in 0..n {
|
||||
let step = max / (n - 1) as f32;
|
||||
out.push(f([r as f32 * step, g as f32 * step, b as f32 * step]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
};
|
||||
|
||||
let (lut, paper) = match recipe.print {
|
||||
None => {
|
||||
let viewing = Viewing::new(&film.viewing_illuminant);
|
||||
(
|
||||
cube(density_max, &|d| viewing.to_srgb(&film.transmittance(d))),
|
||||
None,
|
||||
)
|
||||
}
|
||||
Some(paper) => {
|
||||
let viewing = Viewing::new(&paper.viewing_illuminant);
|
||||
let curves = resample(&paper.density_curves);
|
||||
let paper_max = ceiling(&curves);
|
||||
let lut = cube(density_max, &|d| {
|
||||
paper_exposure(film, paper, d).map(|raw| (raw + 1e-10).log10())
|
||||
});
|
||||
let paper = Paper {
|
||||
balance: print_balance(film, paper, recipe.exposure_ev),
|
||||
log_min: paper.log_exposure_min,
|
||||
log_max: paper.log_exposure_max,
|
||||
lut: cube(paper_max, &|d| viewing.to_srgb(&paper.transmittance(d))),
|
||||
density_max: paper_max,
|
||||
curves,
|
||||
};
|
||||
(lut, Some(paper))
|
||||
}
|
||||
};
|
||||
|
||||
Baked {
|
||||
exposure_matrix: matrix,
|
||||
curves,
|
||||
curve_rows,
|
||||
push_stations,
|
||||
curve_log_min: film.log_exposure_min,
|
||||
curve_log_max: film.log_exposure_max,
|
||||
lut,
|
||||
paper,
|
||||
density_max,
|
||||
lut_size: n,
|
||||
}
|
||||
}
|
||||
|
||||
/// A curve at `CURVE_SAMPLES`, uniform over the same domain it came in on.
|
||||
fn resample(curve: &[[f32; 3]]) -> Vec<[f32; 3]> {
|
||||
if curve.len() == CURVE_SAMPLES {
|
||||
return curve.to_vec();
|
||||
}
|
||||
(0..CURVE_SAMPLES)
|
||||
.map(|i| {
|
||||
let at = i as f32 / (CURVE_SAMPLES - 1) as f32;
|
||||
sample_curve(curve, 0.0, 1.0, [at; 3])
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The deepest density in a set of curves, floored so a lookup over it has
|
||||
/// a width.
|
||||
fn ceiling(curves: &[[f32; 3]]) -> f32 {
|
||||
curves
|
||||
.iter()
|
||||
.flat_map(|row| row.iter())
|
||||
.fold(0.0f32, |a, &b| a.max(b))
|
||||
.max(1e-3)
|
||||
}
|
||||
|
||||
fn mean(s: &Spectrum) -> f32 {
|
||||
s.iter().sum::<f32>() / SPECTRUM as f32
|
||||
}
|
||||
@@ -467,6 +626,10 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn exposure_moves_the_print_the_way_it_moves_a_photograph() {
|
||||
// The photograph's exposure: the enlarger balanced at it, and the
|
||||
// scene brighter by it. Mid-grey stays where the balance puts it —
|
||||
// that is what the balance is for — so what a stop more does to a
|
||||
// print is lift everything either side of it along the paper's curve.
|
||||
let film = portra();
|
||||
let paper = endura();
|
||||
let brighter = bake(&Recipe {
|
||||
@@ -474,7 +637,155 @@ mod tests {
|
||||
..Recipe::new(&film, Some(&paper))
|
||||
});
|
||||
let base = bake(&Recipe::new(&film, Some(&paper)));
|
||||
assert!(brighter.apply([MID_GREY; 3])[1] > base.apply([MID_GREY; 3])[1]);
|
||||
let one_stop = Settings {
|
||||
exposure_ev: 1.0,
|
||||
..Settings::default()
|
||||
};
|
||||
for v in [0.02f32, 0.6] {
|
||||
assert!(
|
||||
brighter.apply_at([v; 3], &one_stop)[1] > base.apply([v; 3])[1],
|
||||
"{v} did not print brighter a stop up"
|
||||
);
|
||||
}
|
||||
let (a, b) = (
|
||||
brighter.apply_at([MID_GREY; 3], &one_stop)[1],
|
||||
base.apply([MID_GREY; 3])[1],
|
||||
);
|
||||
assert!(
|
||||
(a - b).abs() < 1.0 / 255.0,
|
||||
"the balance let mid-grey move: {a} vs {b}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_region_exposed_brighter_prints_brighter_than_the_enlarger_expects() {
|
||||
// TRACES: FR-DEV-3f
|
||||
// A layer's exposure is the scene's, not the enlarger's: the balance
|
||||
// stays where the photograph put it, so the region prints lighter by
|
||||
// more than the whole photograph would, which is what dodging at the
|
||||
// camera is.
|
||||
let film = portra();
|
||||
let paper = endura();
|
||||
let base = bake(&Recipe::new(&film, Some(&paper)));
|
||||
let rebalanced = bake(&Recipe {
|
||||
exposure_ev: 1.0,
|
||||
..Recipe::new(&film, Some(&paper))
|
||||
});
|
||||
let one_stop = Settings {
|
||||
exposure_ev: 1.0,
|
||||
..Settings::default()
|
||||
};
|
||||
let local = base.apply_at([MID_GREY; 3], &one_stop)[1];
|
||||
let global = rebalanced.apply_at([MID_GREY; 3], &one_stop)[1];
|
||||
assert!(local > base.apply([MID_GREY; 3])[1], "not brighter at all");
|
||||
assert!(
|
||||
local > global,
|
||||
"a region was rebalanced as though it were the whole print: {local} vs {global}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn more_light_through_the_enlarger_darkens_the_print() {
|
||||
// TRACES: FR-DEV-3f
|
||||
// Paper is negative-working. Opening the enlarger a stop is burning
|
||||
// in, and a slider that brightened would be the wrong way round for
|
||||
// anyone who has printed.
|
||||
let film = portra();
|
||||
let paper = endura();
|
||||
let baked = bake(&Recipe::new(&film, Some(&paper)));
|
||||
let at = |stops: f32| {
|
||||
baked.apply_at(
|
||||
[MID_GREY; 3],
|
||||
&Settings {
|
||||
print_exposure_ev: stops,
|
||||
..Settings::default()
|
||||
},
|
||||
)[1]
|
||||
};
|
||||
assert!(at(1.0) < at(0.0) && at(0.0) < at(-1.0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_push_on_a_row_is_the_measured_curve() {
|
||||
// TRACES: FR-DEV-3f
|
||||
// The rows are the measured processes, so at a row the table must be
|
||||
// that curve exactly, and between rows — density being linear in push
|
||||
// there — it must be `curves_at_push` to rounding.
|
||||
let film = profile(include_str!("../profiles/kodak_doublex.yaml"));
|
||||
let baked = bake(&Recipe::new(&film, None));
|
||||
assert_eq!(
|
||||
baked.curve_rows, 5,
|
||||
"Double-X measures five development times"
|
||||
);
|
||||
|
||||
let span = film.log_exposure_max - film.log_exposure_min;
|
||||
let mut worst = 0.0f32;
|
||||
let stations = baked.push_stations.clone();
|
||||
let mut pushes: Vec<(f32, bool)> = stations.iter().map(|p| (*p, true)).collect();
|
||||
for k in 0..=16 {
|
||||
pushes.push((-1.0 + 4.0 * k as f32 / 16.0, false));
|
||||
}
|
||||
for (push, on_row) in pushes {
|
||||
let exact = film.curves_at_push(push);
|
||||
for i in (0..exact.len()).step_by(7) {
|
||||
let log = film.log_exposure_min + span * i as f32 / (exact.len() - 1) as f32;
|
||||
let got = baked.sample_curves([log; 3], push);
|
||||
for c in 0..3 {
|
||||
let err = (got[c] - exact[i][c]).abs();
|
||||
if on_row {
|
||||
assert!(err < 1e-4, "push {push} is a row but misses it by {err}");
|
||||
}
|
||||
worst = worst.max(err);
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(worst < 1e-3, "between rows the density is off by {worst}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_print_exposure_is_exact_at_any_setting() {
|
||||
// TRACES: FR-DEV-3f
|
||||
// The enlarger's exposure is added between the two lookups rather than
|
||||
// baked into either, so no setting is nearer the tables than another.
|
||||
// Compared against the chain evaluated spectrally, end to end, at
|
||||
// settings chosen off every half and whole stop.
|
||||
let film = portra();
|
||||
let paper = endura();
|
||||
let baked = bake(&Recipe::new(&film, Some(&paper)));
|
||||
let offsets = print_balance(&film, &paper, 0.0);
|
||||
let viewing = Viewing::new(&paper.viewing_illuminant);
|
||||
|
||||
let mut worst = 0.0f32;
|
||||
for stops in [-2.3f32, -0.6, 0.0, 0.35, 1.7] {
|
||||
for i in 0..14 {
|
||||
let v = 0.004 * 2f32.powf(i as f32 * 0.6);
|
||||
let rgb = [v, v * 0.8, v * 1.1];
|
||||
let mut log_exposure = [0.0f32; 3];
|
||||
for (l, slot) in log_exposure.iter_mut().enumerate() {
|
||||
let m = baked.exposure_matrix[l];
|
||||
*slot =
|
||||
((m[0] * rgb[0] + m[1] * rgb[1] + m[2] * rgb[2]).max(0.0) + 1e-10).log10();
|
||||
}
|
||||
let raw = paper_exposure(&film, &paper, film.density_at(log_exposure));
|
||||
let paper_log =
|
||||
[0, 1, 2].map(|l| (raw[l] + 1e-10).log10() + offsets[l] + stops * 2f32.log10());
|
||||
let exact = viewing.to_srgb(&paper.transmittance(paper.density_at(paper_log)));
|
||||
let approx = baked.apply_at(
|
||||
rgb,
|
||||
&Settings {
|
||||
print_exposure_ev: stops,
|
||||
..Settings::default()
|
||||
},
|
||||
);
|
||||
for c in 0..3 {
|
||||
worst = worst.max((exact[c] - approx[c]).abs());
|
||||
}
|
||||
}
|
||||
}
|
||||
assert!(
|
||||
worst < 1.0 / 255.0,
|
||||
"the print misses the spectral chain by {worst}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -550,5 +861,25 @@ mod tests {
|
||||
let baked = bake(&Recipe::new(&film, None));
|
||||
assert_eq!(baked.lut.len(), LUT_SIZE * LUT_SIZE * LUT_SIZE);
|
||||
assert_eq!(baked.curves.len(), CURVE_SAMPLES);
|
||||
assert_eq!(baked.curve_rows, 1);
|
||||
assert!(baked.paper.is_none());
|
||||
|
||||
// A print has a second lookup and a curve of its own; a development
|
||||
// series a row per push. Neither is inferred from the other.
|
||||
let negative = portra();
|
||||
let paper = endura();
|
||||
let printed = bake(&Recipe::new(&negative, Some(&paper)));
|
||||
let print = printed
|
||||
.paper
|
||||
.as_ref()
|
||||
.expect("a printed negative has a paper");
|
||||
assert_eq!(print.lut.len(), LUT_SIZE.pow(3));
|
||||
assert_eq!(print.curves.len(), CURVE_SAMPLES);
|
||||
|
||||
let pushable = profile(include_str!("../profiles/kodak_doublex.yaml"));
|
||||
let rows = bake(&Recipe::new(&pushable, None));
|
||||
assert_eq!(rows.curve_rows, pushable.development_times.len());
|
||||
assert_eq!(rows.push_stations.len(), rows.curve_rows);
|
||||
assert_eq!(rows.curves.len(), rows.curve_rows * CURVE_SAMPLES);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user