Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

LR-PROF-CAMERACOLOR: the camera-look guard blends in smoothly instead of switching (#820)

PiMinusMax385348b25851
diff --git a/crates/engine/src/camera_preview.rs b/crates/engine/src/camera_preview.rs
index b12e968ad..d47c135a5 100644
--- a/crates/engine/src/camera_preview.rs
+++ b/crates/engine/src/camera_preview.rs
@@ -833,9 +833,21 @@ fn to_prophoto() -> Mat3 {
PROPHOTO.from_xyz().mul(&bradford(D65, D50)).mul(&REC2020.to_xyz())
}
-/// [`HueSat::apply`] restores the luminance only if the table kept at least this share of it; a colour the
-/// table darkens more (only near-black noise, whose channels go negative) keeps its colour.
+/// [`HueSat::apply`] restores the luminance in full only if the table kept at least this share of it. A colour
+/// the table darkens to [`NO_LUMINANCE_KEPT`] or less (only near-black noise, whose channels go negative) keeps
+/// its colour; in between the two are blended, so noisy shadows show no step.
const MIN_LUMINANCE_KEPT: f32 = 0.25;
+const NO_LUMINANCE_KEPT: f32 = 0.15;
+
+/// How much of the table's colour a pixel gets when the table kept `share` of its luminance: 0 up to
+/// [`NO_LUMINANCE_KEPT`], 1 from [`MIN_LUMINANCE_KEPT`], a smoothstep between.
+fn restore_weight(share: f32) -> f32 {
+ if !share.is_finite() {
+ return 0.0;
+ }
+ let t = ((share - NO_LUMINANCE_KEPT) / (MIN_LUMINANCE_KEPT - NO_LUMINANCE_KEPT)).clamp(0.0, 1.0);
+ t * t * (3.0 - 2.0 * t)
+}
/// A fitted [`CameraLook::hue_sat`] table, ready to apply to linear Rec.2020 pixels. It changes
/// hue and saturation only: luminance is restored, the camera tone curve owns it.
@@ -858,7 +870,17 @@ impl<'a> HueSat<'a> {
let (before, after) = (luminance_2020(rgb), luminance_2020(out));
// restoring the luminance divides by the table's: near black, where noise makes some channels
// negative, the table can bring it close to 0, and the gain would turn the pixel white (#820)
- if before > 0.0 && after > MIN_LUMINANCE_KEPT * before && out.iter().all(|v| v.is_finite()) { out.map(|v| v * before / after) } else { rgb }
+ if before <= 0.0 || after <= 0.0 || !out.iter().all(|v| v.is_finite()) {
+ return rgb;
+ }
+ let w = restore_weight(after / before);
+ if w >= 1.0 {
+ return out.map(|v| v * before / after);
+ }
+ if w <= 0.0 {
+ return rgb;
+ }
+ std::array::from_fn(|i| rgb[i] + (out[i] * before / after - rgb[i]) * w)
}
}
@@ -1470,6 +1492,36 @@ mod tests {
assert!(worst < 20.0, "a near-black pixel came out {worst}× its largest channel");
}
+ #[test]
+ fn hue_sat_restore_weight_blends_smoothly_between_the_thresholds() {
+ assert_eq!(restore_weight(0.0), 0.0);
+ assert_eq!(restore_weight(NO_LUMINANCE_KEPT), 0.0);
+ assert_eq!(restore_weight(MIN_LUMINANCE_KEPT), 1.0);
+ assert_eq!(restore_weight(1.0), 1.0);
+ assert_eq!(restore_weight(f32::NAN), 0.0);
+ // monotonic and without a step: neighbouring shares 0.001 apart differ by little
+ let mut last = 0.0f32;
+ for i in 0..=400 {
+ let w = restore_weight(i as f32 * 0.001);
+ assert!(w >= last && w - last < 0.02, "step at {}: {last} → {w}", i as f32 * 0.001);
+ last = w;
+ }
+ }
+
+ #[test]
+ fn hue_sat_keeps_colours_the_table_leaves_bright_exactly_as_before() {
+ // the blend only touches colours whose luminance the table cut below MIN_LUMINANCE_KEPT
+ let table = HsvTable { hue_divisions: 4, sat_divisions: 2, val_divisions: 1, data: vec![[10.0, 1.5, 1.0]; 8], srgb_value: false };
+ let hue_sat = HueSat::new(&table).unwrap();
+ let mul = |m: &[[f32; 3]; 3], v: [f32; 3]| -> [f32; 3] { std::array::from_fn(|i| m[i][0] * v[0] + m[i][1] * v[1] + m[i][2] * v[2]) };
+ for rgb in [[0.4, 0.2, 0.1], [0.05, 0.3, 0.2], [0.18, 0.18, 0.18], [0.6, 0.1, 0.5]] {
+ let out = mul(&hue_sat.from, table.apply(mul(&hue_sat.to, rgb)));
+ let (before, after) = (luminance_2020(rgb), luminance_2020(out));
+ assert!(after >= MIN_LUMINANCE_KEPT * before);
+ assert_eq!(hue_sat.apply(rgb), out.map(|v| v * before / after));
+ }
+ }
+
fn raw_of(format: RawFormat, make: &str, model: &str, color: lightcraft_raw::ColorData) -> RawImage {
let area = lightcraft_raw::Rect::new(0, 0, 2, 2);
RawImage {