#[derive(Debug, Clone, Copy, PartialEq)]
pub struct DevelopmentParams {
pub time_min: f64,
pub temp_c: f64,
pub reference_time_min: f64,
pub reference_temp_c: f64,
pub q10: f64,
pub gamma_inf: f64,
pub gamma_0: f64,
pub tau_min: f64,
pub fog_rate: f64,
pub toe_gain: f64,
pub d_max_gain: f64,
pub speed_gain: f64,
}
impl Default for DevelopmentParams {
fn default() -> Self {
Self {
time_min: 6.5,
temp_c: 20.0,
reference_time_min: 6.5,
reference_temp_c: 20.0,
q10: 1.70,
gamma_inf: 2.20,
gamma_0: 0.18,
tau_min: 39.0,
fog_rate: 0.078,
toe_gain: 0.40,
d_max_gain: 0.91,
speed_gain: 0.44,
}
}
}
impl DevelopmentParams {
#[must_use]
pub fn effective_time_min(&self) -> f64 {
let t = self.time_min.max(0.0);
t * self.q10.powf((self.temp_c - self.reference_temp_c) / 10.0)
}
#[must_use]
pub fn reference_effective_time_min(&self) -> f64 {
self.reference_time_min.max(1e-6)
}
fn contrast_at(&self, effective_time: f64) -> f64 {
self.gamma_inf + (self.gamma_0 - self.gamma_inf) * (-effective_time / self.tau_min).exp()
}
#[must_use]
pub fn gamma_factor(&self) -> f64 {
let reference = self.contrast_at(self.reference_effective_time_min());
if reference.abs() < 1e-9 {
return 1.0;
}
self.contrast_at(self.effective_time_min()) / reference
}
#[must_use]
pub fn fog_delta(&self) -> f64 {
let t = self.effective_time_min().max(0.0).sqrt();
let reference = self.reference_effective_time_min().max(0.0).sqrt();
self.fog_rate * (t - reference)
}
#[must_use]
pub fn toe_delta(&self) -> f64 {
self.toe_gain * (self.effective_time_min() - self.reference_effective_time_min())
}
#[must_use]
pub fn d_max_delta(&self) -> f64 {
let t = self.effective_time_min().max(0.0).sqrt();
let reference = self.reference_effective_time_min().max(0.0).sqrt();
self.d_max_gain * (t - reference)
}
#[must_use]
pub fn speed_delta(&self) -> f64 {
let ratio = self.effective_time_min() / self.reference_effective_time_min();
-self.speed_gain * ratio.max(1e-9).ln()
}
#[must_use]
pub fn apply_to(
&self,
nominal: crate::curve::CharacteristicCurve,
) -> crate::curve::CharacteristicCurve {
crate::curve::CharacteristicCurve {
d_min: (nominal.d_min + self.fog_delta()).max(0.0),
d_max: nominal.d_max + self.d_max_delta(),
gamma: nominal.gamma * self.gamma_factor(),
log_e0: nominal.log_e0 + self.speed_delta(),
toe_transition: (nominal.toe_transition + self.toe_delta()).max(0.05),
shoulder_transition: nominal.shoulder_transition,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::curve::CharacteristicCurve;
#[test]
fn reference_development_is_the_identity() {
let d = DevelopmentParams::default();
assert!((d.gamma_factor() - 1.0).abs() < 1e-12);
assert!(d.fog_delta().abs() < 1e-12);
assert!(d.speed_delta().abs() < 1e-12);
}
#[test]
fn longer_development_builds_contrast_and_fog() {
let base = DevelopmentParams::default();
let long = DevelopmentParams {
time_min: 12.0,
..base
};
assert!(long.gamma_factor() > 1.0);
assert!(long.fog_delta() > 0.0);
assert!(long.speed_delta() < 0.0, "over-development gains speed");
}
#[test]
fn temperature_trades_against_time() {
let base = DevelopmentParams::default();
let warm_short = DevelopmentParams {
time_min: base.reference_time_min / base.q10,
temp_c: 30.0,
..base
};
assert!((warm_short.gamma_factor() - 1.0).abs() < 1e-6);
}
#[test]
fn the_gamma_factor_matches_the_measured_contrast_time_curve() {
let base = DevelopmentParams {
reference_time_min: 6.5,
..DevelopmentParams::default()
};
let at = |time_min: f64| DevelopmentParams { time_min, ..base }.gamma_factor();
assert!((at(12.0) - 1.46).abs() < 0.02, "12 min: {}", at(12.0));
assert!((at(18.0) - 1.89).abs() < 0.02, "18 min: {}", at(18.0));
assert!(at(6.5) - 1.0 < 1e-12);
}
#[test]
fn the_trix400_ladder_is_reproduced() {
const LADDER: [(f64, f64, f64, f64, f64, f64); 4] = [
(6.0, 0.5464, 0.0000, 1.4862, -1.0910, -2.5438),
(8.0, 0.6290, 0.0252, 1.8240, -1.2210, -2.6900),
(10.0, 0.7212, 0.0462, 2.1347, -1.3110, -2.7808),
(12.0, 0.8236, 0.0874, 2.4215, -1.4010, -2.8131),
];
let nominal = CharacteristicCurve::new(0.0, 1.4862, 0.5464, -1.0910).with_corners(3.0, 8.0);
for (minutes, gamma, fog, ceiling, log_e0, speed) in LADDER {
let curve = DevelopmentParams {
time_min: minutes,
reference_time_min: 6.0,
..DevelopmentParams::default()
}
.apply_to(nominal);
assert!(
(curve.gamma - gamma).abs() < 0.03,
"{minutes} min: gamma {:.4} against {gamma:.4}",
curve.gamma
);
assert!(
(curve.d_min - fog).abs() < 0.012,
"{minutes} min: fog {:.4} against {fog:.4}",
curve.d_min
);
assert!(
(curve.d_max - ceiling).abs() < 0.02,
"{minutes} min: ceiling {:.4} against {ceiling:.4}",
curve.d_max
);
assert!(
(curve.log_e0 - log_e0).abs() < 0.01,
"{minutes} min: log_e0 {:.4} against {log_e0:.4}",
curve.log_e0
);
let modelled = curve.log_exposure_at(curve.d_min + 0.10);
assert!(
(modelled - speed).abs() < 0.04,
"{minutes} min: speed point {modelled:.4} against {speed:.4}"
);
}
}
#[test]
fn curve_moves_in_the_documented_direction() {
let nominal = CharacteristicCurve::new(0.2, 2.3, 0.6, -0.75);
let pushed = DevelopmentParams {
time_min: 12.0,
..DevelopmentParams::default()
}
.apply_to(nominal);
assert!(pushed.gamma > nominal.gamma);
assert!(pushed.d_min > nominal.d_min);
assert!(pushed.log_e0 < nominal.log_e0);
}
}