5a24289898fd
tests.rs
use lightcraft_develop::{DevelopSettings, controls};
use lightcraft_raster::Rgb32f;
use crate::{RenderRequest, SourceInfo, render};
fn mean_luma(img: &lightcraft_raster::Rgba8) -> f32 {
img.data.iter().map(|p| 0.2126 * p[0] as f32 + 0.7152 * p[1] as f32 + 0.0722 * p[2] as f32).sum::<f32>() / img.len() as f32
}
fn scene() -> Rgb32f {
lightcraft_scenes::demo_library()[0].render(240, 160)
}
#[test]
fn default_render_is_sane() {
let r = render(&scene(), &SourceInfo::default(), &DevelopSettings::default(), &RenderRequest::fit(240, 240));
assert_eq!((r.image.width, r.image.height), (240, 160));
let m = mean_luma(&r.image);
assert!((40.0..220.0).contains(&m), "{m}");
assert!(r.histogram.total > 0);
}
#[test]
fn grey_ramp_stays_neutral() {
let src = Rgb32f::from_fn(64, 8, |x, _| [0.002 * 1.12f32.powi(x as i32); 3]);
let r = render(&src, &SourceInfo::default(), &DevelopSettings::default(), &RenderRequest::fit(64, 8));
for p in &r.image.data {
assert!((p[0] as i32 - p[1] as i32).abs() <= 1 && (p[1] as i32 - p[2] as i32).abs() <= 1, "{p:?}");
}
}
#[test]
fn every_slider_changes_or_keeps_output_without_panicking() {
let src = scene();
let base = render(&src, &SourceInfo::default(), &DevelopSettings::default(), &RenderRequest::fit(96, 96)).image;
for c in controls::CONTROLS {
for v in [c.min, c.max] {
let mut s = DevelopSettings::default();
controls::set(&mut s, c.id, v);
let r = render(&src, &SourceInfo::default(), &s, &RenderRequest::fit(96, 96));
assert!(r.image.width > 0, "{}", c.id);
let _ = &base;
}
}
}
#[test]
fn exposure_is_monotone() {
let src = scene();
let mut prev = -1.0;
for ev in [-3.0, -1.5, 0.0, 1.0, 2.5] {
let mut s = DevelopSettings::default();
s.light.exposure = ev;
let m = mean_luma(&render(&src, &SourceInfo::default(), &s, &RenderRequest::fit(96, 96)).image);
assert!(m > prev, "{ev}: {m} <= {prev}");
prev = m;
}
}
#[test]
fn directional_sliders() {
let src = scene();
let at = |id: &str, v: f64| {
let mut s = DevelopSettings::default();
controls::set(&mut s, id, v);
mean_luma(&render(&src, &SourceInfo::default(), &s, &RenderRequest::fit(96, 96)).image)
};
let base = at("light.exposure", 0.0);
assert!(at("light.shadows", 100.0) > base);
assert!(at("light.highlights", -100.0) < base);
assert!(at("light.whites", 100.0) > base);
assert!(at("light.blacks", -100.0) < base);
assert!(at("vignette.amount", -100.0) < base);
assert!(at("vignette.amount", 100.0) > base);
assert!(at("effects.dehaze", -100.0) != base);
}
/// Dehaze crushed dark regions next to bright ones to black: the dark channel is a blur, not a
/// patch minimum, so near the boundary it credited the dark pixels with the bright side's veil and
/// the subtraction went past zero (#2504). The veil credited to a pixel is now bounded by its own
/// minimum channel, so a uniform dark region renders uniformly under dehaze.
#[test]
fn dehaze_does_not_crush_dark_regions_next_to_bright_ones() {
// a dark field against a bright hazy sky; the blur bleeds the sky's dark channel ~10 px into
// the field, which is where the blotches formed
let src = Rgb32f::from_fn(240, 160, |x, _| if x < 120 { [0.02, 0.03, 0.012] } else { [0.45, 0.5, 0.55] });
let mut s = DevelopSettings::default();
s.effects.dehaze = 80.0;
let r = render(&src, &SourceInfo::default(), &s, &RenderRequest::fit(240, 160)).image;
for ch in 0..3 {
let mut v: Vec<u8> = Vec::with_capacity(160 * 100);
for y in 0..160 {
for x in 0..100 {
v.push(r.get(x, y)[ch]);
}
}
v.sort_unstable();
let mid = v[v.len() / 2] as i32;
// a field rendered all black would pass the comparison below vacuously
assert!(mid > 2, "the dark field itself is crushed in ch {ch}: level {mid}");
for y in 0..160 {
for x in 0..120 {
let p = r.get(x, y)[ch] as i32;
assert!(p >= mid - 2, "crushed at {x},{y} ch {ch}: {p} vs field level {mid}");
}
}
}
}
#[test]
fn resolution_independence_of_local_contrast() {
// Clarity at two preview sizes should give similar results after downscaling.
let src = lightcraft_scenes::demo_library()[3].render(480, 320);
let mut s = DevelopSettings::default();
s.effects.clarity = 80.0;
s.light.shadows = 60.0;
let small = render(&src, &SourceInfo::default(), &s, &RenderRequest::fit(120, 120)).image;
let big = render(&src, &SourceInfo::default(), &s, &RenderRequest::fit(480, 480)).image;
let bl = big.to_linear();
let down = lightcraft_raster::resample::resize(&bl, small.width, small.height, lightcraft_raster::resample::Filter::Box).to_srgb8();
let err: f32 = small.data.iter().zip(&down.data).map(|(a, b)| (a[1] as f32 - b[1] as f32).abs()).sum::<f32>() / small.len() as f32;
assert!(err < 9.0, "mean abs error {err}");
}
#[test]
fn crop_and_straighten_output_size() {
let mut s = DevelopSettings::default();
s.crop.geometry = lightcraft_geom::crop_fit_angle(240.0, 160.0, 8.0, Some(1.0));
let r = render(&scene(), &SourceInfo::default(), &s, &RenderRequest::fit(200, 200));
assert_eq!((r.image.width, r.image.height), (200, 200));
}
#[test]
fn mask_brightens_only_inside() {
use lightcraft_develop::{Mask, MaskComponent, MaskOp, MaskShape};
use lightcraft_geom::Point;
let src = Rgb32f::filled(100, 100, [0.1, 0.1, 0.1]);
let mut s = DevelopSettings::default();
s.masks.push(Mask {
components: vec![MaskComponent {
name: None,
op: MaskOp::Add,
invert: false,
shape: MaskShape::Radial { center: Point::new(0.5, 0.5), rx: 0.2, ry: 0.2, angle: 0.0, feather: 10.0, invert: false },
}],
adjust: lightcraft_develop::LocalAdjustments { exposure: 2.0, ..Default::default() },
..Default::default()
});
let r = render(&src, &SourceInfo::default(), &s, &RenderRequest::fit(100, 100)).image;
assert!(r.get(50, 50)[0] > r.get(5, 5)[0] + 40);
}
#[test]
#[ignore]
fn perf_report() {
let src = lightcraft_scenes::demo_library()[0].render(3000, 2000);
let mut s = DevelopSettings::default();
s.light.shadows = 40.0;
s.effects.clarity = 20.0;
s.effects.dehaze = 10.0;
s.color.vibrance = 20.0;
let t = std::time::Instant::now();
let n = 5;
for _ in 0..n {
let _ = render(&src, &SourceInfo::default(), &s, &RenderRequest::fit(2560, 1440));
}
eprintln!("render 2160x1440 from 6 MP: {:.1} ms", t.elapsed().as_secs_f64() * 1000.0 / n as f64);
}
#[test]
fn unedited_rendered_source_is_passthrough() {
// An sRGB ramp decoded to linear Rec.2020 must render back to the same 8-bit values, white
// included (issue #1945: neutral 255, 254 and 253 came back one level darker).
let src8 = lightcraft_raster::Rgba8::from_fn(256, 4, |x, y| [x as u8, (x as u8).wrapping_add(y as u8 * 40), 255 - x as u8, 255]);
let m = lightcraft_color::SRGB.to_space(&lightcraft_color::REC2020);
let src = src8.to_linear().map(|c| m.apply_f32(c));
let r = render(&src, &SourceInfo::default(), &DevelopSettings::default(), &RenderRequest::fit(256, 4)).image;
let mut worst = 0i32;
for (a, b) in src8.data.iter().zip(&r.data) {
for c in 0..3 {
worst = worst.max((a[c] as i32 - b[c] as i32).abs());
}
}
assert_eq!(worst, 0, "max error {worst}");
}
#[test]
fn unedited_neutral_near_whites_are_passthrough() {
// Issue #1945: neutral 255, 254 and 253 rendered one level darker (the display tone map's
// shoulder ran at neutral settings), so a white background never exported as 255.
let vals = [255u8, 254, 253, 252, 250, 240, 200, 128, 0];
let src8 = lightcraft_raster::Rgba8::from_fn(vals.len(), 1, |x, _| {
let v = vals[x];
[v, v, v, 255]
});
let m = lightcraft_color::SRGB.to_space(&lightcraft_color::REC2020);
let src = src8.to_linear().map(|c| m.apply_f32(c));
let r = render(&src, &SourceInfo::default(), &DevelopSettings::default(), &RenderRequest::fit(vals.len(), 1)).image;
let got: Vec<[u8; 3]> = r.data.iter().map(|p| [p[0], p[1], p[2]]).collect();
let want: Vec<[u8; 3]> = vals.iter().map(|&v| [v, v, v]).collect();
assert_eq!(got, want);
}
fn typical_edits() -> DevelopSettings {
let mut s = DevelopSettings::default();
s.light.exposure = 0.4;
s.light.highlights = -40.0;
s.light.shadows = 30.0;
s.effects.clarity = 15.0;
s.effects.texture = 10.0;
s.effects.dehaze = 12.0;
s.detail.nr_luminance = 30.0;
s.detail.nr_color = 25.0;
s.detail.sharpen_amount = 40.0;
s
}
fn max_diff(a: &lightcraft_raster::Rgba8, b: &lightcraft_raster::Rgba8) -> i32 {
assert_eq!((a.width, a.height), (b.width, b.height));
a.data.iter().zip(&b.data).map(|(p, q)| (0..3).map(|c| (p[c] as i32 - q[c] as i32).abs()).max().unwrap_or(0)).max().unwrap_or(0)
}
#[test]
fn stage_cache_matches_uncached_render_through_a_slider_session() {
use crate::{Quality, StageCache, render_cached};
use std::sync::Arc;
let src = Arc::new(scene());
let info = SourceInfo { raw: true, ..Default::default() };
let cache = StageCache::default();
let full = RenderRequest::fit(200, 200);
let draft = RenderRequest { quality: Quality::Draft, ..RenderRequest::fit(120, 120) };
let mut s = typical_edits();
// every kind of edit: tone, exposure, spatial amounts, NR, WB, crop, colour — at two sizes
let steps: Vec<Box<dyn Fn(&mut DevelopSettings)>> = vec![
Box::new(|s| s.light.contrast = 20.0),
Box::new(|s| s.light.exposure = -0.7),
Box::new(|s| s.light.highlights = -80.0),
Box::new(|s| s.effects.clarity = -30.0),
Box::new(|s| s.effects.dehaze = 0.0),
Box::new(|s| s.effects.dehaze = 25.0),
Box::new(|s| s.detail.nr_luminance = 60.0),
Box::new(|s| {
s.wb.mode = lightcraft_develop::WbMode::Custom;
s.wb.temp = 4000.0;
}),
Box::new(|s| s.crop.geometry.rect = lightcraft_geom::Rect::new(0.1, 0.1, 0.9, 0.8)),
Box::new(|s| s.color.saturation = 30.0),
// optics and geometry (merged after the stage cache): defringe lives in the cached linear stage
Box::new(|s| s.optics.defringe_purple_amount = 10.0),
Box::new(|s| s.optics.distortion = 30.0),
Box::new(|s| s.optics.remove_ca = true),
Box::new(|s| s.geometry.vertical = 20.0),
];
for (i, step) in steps.iter().enumerate() {
step(&mut s);
for req in [&full, &draft] {
let a = render_cached(&src, &info, &s, req, &cache).image;
let b = render(&src, &info, &s, req).image;
if req.quality == Quality::Draft && i == 6 {
// a draft while noise reduction changes keeps the wide planes of the image before it
let d = max_diff(&a, &b);
assert!(d <= 3, "step {i} draft: {d}");
} else {
assert_eq!(a, b, "step {i} {:?}", req.quality);
}
}
}
assert_eq!(cache.len(), 2);
// both sizes' sampled + linear images at least (12 bytes per pixel each), nothing after clear()
let b = cache.bytes();
assert!(b >= 2 * 12 * (200 * 133 + 120 * 80), "{b}");
cache.clear();
assert_eq!(cache.bytes(), 0);
// a different source buffer never hits another source's entries
let other = Arc::new(Rgb32f::filled(src.width, src.height, [0.3, 0.3, 0.3]));
assert_eq!(render_cached(&other, &info, &s, &full, &cache).image, render(&other, &info, &s, &full).image);
}
#[test]
fn drafts_keep_wide_planes_across_a_noise_reduction_change_and_full_renders_do_not() {
use crate::{Quality, StageCache, render_cached};
use std::sync::Arc;
let src = Arc::new(scene());
let info = SourceInfo { raw: true, ..Default::default() };
let cache = StageCache::default();
let draft = RenderRequest { quality: Quality::Draft, ..RenderRequest::fit(160, 160) };
let full = RenderRequest { quality: Quality::Full, ..draft };
let mut s = typical_edits();
s.effects.clarity = 60.0;
s.detail.sharpen_amount = 80.0;
render_cached(&src, &info, &s, &draft, &cache);
let clarity_plane = |c: &StageCache| c.entries.lock().unwrap().first().and_then(|e| e.planes.clarity.clone()).unwrap().1;
let sharpen_plane = |c: &StageCache| c.entries.lock().unwrap().first().and_then(|e| e.planes.sharpen.clone()).unwrap().1;
let first = clarity_plane(&cache);
let first_sharpen = sharpen_plane(&cache);
s.detail.nr_luminance = 50.0;
render_cached(&src, &info, &s, &draft, &cache);
assert!(Arc::ptr_eq(&first, &clarity_plane(&cache)), "a draft redid the clarity plane for a noise-reduction change");
assert!(!Arc::ptr_eq(&first_sharpen, &sharpen_plane(&cache)), "a draft reused the old sharpening plane after noise reduction changed");
for v in [10.0, 45.0, 80.0] {
s.detail.nr_luminance = v;
s.detail.nr_color = v / 2.0;
let a = render_cached(&src, &info, &s, &draft, &cache).image;
let d = max_diff(&a, &render(&src, &info, &s, &draft).image);
// close to the exact draft (a few levels at edges, where clarity is strong)
assert!(d <= 8, "nr {v}: {d}");
// a full-quality render after the drafts is exact (it never takes the stand-in planes)
assert_eq!(render_cached(&src, &info, &s, &full, &cache).image, render(&src, &info, &s, &full).image, "nr {v}");
}
}
#[test]
fn exposure_after_spatial_filters_equals_exposing_the_source() {
// The pipeline filters the image before exposure and applies exposure per pixel; filters on
// log luminance are shift-equivariant, so this must equal scaling the source.
let src = scene();
let info = SourceInfo { raw: true, ..Default::default() };
let mut s = typical_edits();
s.light.exposure = 1.3;
let a = render(&src, &info, &s, &RenderRequest::fit(200, 200)).image;
let g = 2f32.powf(1.3);
let scaled = src.map(|c| c.map(|v| v * g));
s.light.exposure = 0.0;
let b = render(&scaled, &info, &s, &RenderRequest::fit(200, 200)).image;
let d = max_diff(&a, &b);
assert!(d <= 2, "max difference {d}");
}
#[test]
fn color_range_sampling_respects_disabled_sections() {
use crate::{MaskView, Overlay, color_range_sample};
let src = Rgb32f::from_fn(32, 24, |_, _| [0.15, 0.25, 0.08]);
let info = SourceInfo::default();
let req = RenderRequest::fit(32, 24);
let point = lightcraft_geom::Point::new(0.5, 0.5);
let plain = color_range_sample(&src, &info, &DevelopSettings::default(), &req, point).unwrap();
for section in ["light", "color"] {
let mut s = DevelopSettings::default();
if section == "light" {
s.light.exposure = 3.0;
} else {
s.wb.mode = lightcraft_develop::WbMode::Custom;
s.wb.temp = 12000.0;
s.wb.tint = 100.0;
}
assert_ne!(color_range_sample(&src, &info, &s, &req, point).unwrap(), plain, "enabled {section}");
s.set_section_enabled(section, false);
let sample = color_range_sample(&src, &info, &s, &req, point).unwrap();
assert_eq!(sample, plain, "disabled {section} must not change the picked colour");
s.masks.push(lightcraft_develop::Mask {
id: 1,
components: vec![lightcraft_develop::MaskComponent {
name: None,
op: lightcraft_develop::MaskOp::Add,
invert: false,
shape: lightcraft_develop::MaskShape::ColorRange { samples: vec![sample], refine: 0.0 },
}],
..Default::default()
});
let overlay = RenderRequest { overlay: Overlay::Mask { id: 1, view: MaskView::WhiteOnBlack, color: [255, 0, 0], opacity: 100 }, ..req };
let img = render(&src, &info, &s, &overlay).image;
assert_eq!(img.data[12 * 32 + 16], [255; 4], "the sampled colour is selected with {section} off");
}
}
#[test]
fn color_range_sampling_uses_the_requested_hdr_rendition() {
use crate::{OutputDepth, color_range_sample};
let src = Rgb32f::from_fn(32, 24, |_, _| [0.15, 0.25, 0.08]);
let info = SourceInfo::default();
let point = lightcraft_geom::Point::new(0.5, 0.5);
let mut s = DevelopSettings::default();
s.hdr.enabled = true;
s.hdr.sdr_brightness = 100.0;
let req = RenderRequest::fit(32, 24);
let expected = color_range_sample(&src, &info, &s.sdr_rendition(), &req, point).unwrap();
assert_eq!(color_range_sample(&src, &info, &s, &req, point).unwrap(), expected, "SDR preview brightness affects the picked colour");
let hdr = RenderRequest { depth: OutputDepth::F32Hdr, ..req };
let plain = color_range_sample(&src, &info, &DevelopSettings::default(), &hdr, point).unwrap();
assert_eq!(color_range_sample(&src, &info, &s, &hdr, point).unwrap(), plain, "HDR does not use the SDR offset");
assert_ne!(plain, expected);
}
/// A section whose eye is off renders as if it were at its defaults (issue #316): Light, Color
/// and Detail, which the pipeline doesn't switch off where it applies them.
#[test]
fn sections_switched_off_render_as_defaults() {
let src = Rgb32f::from_fn(32, 24, |x, y| [0.05 + x as f32 / 40.0, 0.1 + y as f32 / 30.0, 0.3]);
let info = SourceInfo::default();
let req = RenderRequest::fit(32, 24);
let plain = render(&src, &info, &DevelopSettings::default(), &req).image;
let mut s = DevelopSettings::default();
s.light.exposure = 1.5;
s.light.contrast = 40.0;
s.color.saturation = -60.0;
s.color.vibrance = 30.0;
s.detail.sharpen_amount = 120.0;
let edited = render(&src, &info, &s, &req).image;
assert_ne!(edited.data, plain.data);
for section in ["light", "color", "detail"] {
s.set_section_enabled(section, false);
}
assert_eq!(render(&src, &info, &s, &req).image.data, plain.data, "every edited section off = the unedited photo");
// one section back on brings back only its own adjustments
s.set_section_enabled("light", true);
let mut light_only = DevelopSettings::default();
light_only.light.exposure = 1.5;
light_only.light.contrast = 40.0;
assert_eq!(render(&src, &info, &s, &req).image.data, render(&src, &info, &light_only, &req).image.data);
assert!(matches!(DevelopSettings::default().effective(), std::borrow::Cow::Borrowed(_)), "nothing is copied when every section is on");
}
#[test]
fn calibration_shifts_colours_but_keeps_greys() {
let info = SourceInfo { raw: true, ..Default::default() };
let req = RenderRequest::fit(64, 8);
// a grey ramp is untouched by the primaries
let grey = Rgb32f::from_fn(64, 8, |x, _| [0.002 * 1.12f32.powi(x as i32); 3]);
let mut s = DevelopSettings::default();
s.calibration.red_hue = 80.0;
s.calibration.green_sat = -60.0;
let a = render(&grey, &info, &DevelopSettings::default(), &req).image;
let b = render(&grey, &info, &s, &req).image;
assert!(max_diff(&a, &b) <= 1);
// a red patch rotates towards yellow (green rises relative to blue)
let red = Rgb32f::filled(16, 16, [0.3, 0.04, 0.03]);
let r0 = render(&red, &info, &DevelopSettings::default(), &RenderRequest::fit(16, 16)).image.data[0];
let r1 = render(&red, &info, &s, &RenderRequest::fit(16, 16)).image.data[0];
assert!(r1[1] as i32 - r1[2] as i32 > r0[1] as i32 - r0[2] as i32 + 5, "{r0:?} -> {r1:?}");
// shadows tint: magenta (+) lowers green in a dark grey
let dark = Rgb32f::filled(16, 16, [0.01, 0.01, 0.01]);
s = DevelopSettings::default();
s.calibration.shadows_tint = 100.0;
let d = render(&dark, &info, &s, &RenderRequest::fit(16, 16)).image.data[0];
assert!(d[1] + 3 < d[0], "{d:?}");
// the section toggle disables it
s.set_section_enabled("calibration", false);
let off = render(&dark, &info, &s, &RenderRequest::fit(16, 16)).image.data[0];
assert!(off[1].abs_diff(off[0]) <= 1, "{off:?}");
}
#[test]
fn refine_saturation_tames_a_contrast_curve() {
let info = SourceInfo { raw: true, ..Default::default() };
let src = Rgb32f::filled(16, 16, [0.12, 0.05, 0.03]);
let req = RenderRequest::fit(16, 16);
let sat = |p: [u8; 4]| p[0] as i32 - p[2] as i32;
let mut s = DevelopSettings::default();
let flat = render(&src, &info, &s, &req).image.data[0];
s.curve.master = vec![
lightcraft_geom::Point::new(0.0, 0.0),
lightcraft_geom::Point::new(0.3, 0.15),
lightcraft_geom::Point::new(0.7, 0.85),
lightcraft_geom::Point::new(1.0, 1.0),
];
let full = render(&src, &info, &s, &req).image.data[0];
s.curve.refine_saturation = 0.0;
let refined = render(&src, &info, &s, &req).image.data[0];
assert!(sat(full) > sat(refined), "{flat:?} {full:?} {refined:?}");
// the curve's tone change stays
let y = |p: [u8; 4]| 0.2126 * p[0] as f32 + 0.7152 * p[1] as f32 + 0.0722 * p[2] as f32;
assert!((y(full) - y(refined)).abs() < 2.0);
}
#[test]
fn soft_proof_maps_into_the_proof_gamut_and_flags_what_does_not_fit() {
use crate::{OutputSpace, Proof};
let src = scene();
let mut s = DevelopSettings::default();
s.color.saturation = 100.0;
s.color.vibrance = 100.0;
let info = SourceInfo { raw: true, ..Default::default() };
let req = |space, proof| RenderRequest { space, proof, ..RenderRequest::fit(120, 120) };
let red = |img: &lightcraft_raster::Rgba8| img.data.iter().filter(|p| p[..3] == [255, 0, 0]).count();
let blue = |img: &lightcraft_raster::Rgba8| img.data.iter().filter(|p| p[2] == 255 && p[0] == 0 && p[1] < 80).count();
// proofing sRGB on an sRGB render changes nothing but the warning
let plain = render(&src, &info, &s, &req(OutputSpace::Srgb, None)).image;
let same = render(&src, &info, &s, &req(OutputSpace::Srgb, Some(Proof { space: OutputSpace::Srgb, ..Default::default() }))).image;
assert_eq!(plain, same);
let warned = render(
&src,
&info,
&s,
&req(OutputSpace::Srgb, Some(Proof { space: OutputSpace::Srgb, dest_warning: true, display_warning: false, profile: 0 })),
)
.image;
let n = red(&warned);
assert!(n > 0 && n < warned.len(), "{n}");
// …and nothing is flagged on an unsaturated edit of a neutral ramp
let grey = Rgb32f::from_fn(64, 8, |x, _| [0.002 * 1.12f32.powi(x as i32); 3]);
let g = render(
&grey,
&info,
&DevelopSettings::default(),
&RenderRequest {
proof: Some(Proof { space: OutputSpace::Srgb, dest_warning: true, display_warning: true, profile: 0 }),
..RenderRequest::fit(64, 8)
},
);
assert_eq!(red(&g.image) + blue(&g.image), 0);
// a wide-gamut render proofed for sRGB loses the colours sRGB can't hold
let wide = render(&src, &info, &s, &req(OutputSpace::DisplayP3, None)).image;
let proofed = render(&src, &info, &s, &req(OutputSpace::DisplayP3, Some(Proof { space: OutputSpace::Srgb, ..Default::default() }))).image;
assert_ne!(wide, proofed);
// proofing a wider space than the display: what the display can't show is flagged blue
let pro = render(
&src,
&info,
&s,
&req(OutputSpace::Srgb, Some(Proof { space: OutputSpace::ProPhoto, dest_warning: true, display_warning: true, profile: 0 })),
)
.image;
assert!(blue(&pro) > 0);
assert!(red(&pro) < n, "ProPhoto holds more than sRGB");
}
/// A preview for a monitor with a display profile renders into the display's primaries: for a
/// display that *is* a standard space, exactly what an 8-bit render into that space gives.
#[test]
fn display_space_renders_like_the_matching_output_space() {
use crate::{DisplaySpace, OutputSpace, Proof};
let src = scene();
let mut s = DevelopSettings::default();
s.color.saturation = 100.0;
s.color.vibrance = 100.0;
let info = SourceInfo { raw: true, ..Default::default() };
let req = |space, display, proof| RenderRequest { space, display, proof, ..RenderRequest::fit(120, 120) };
for space in [OutputSpace::Srgb, OutputSpace::DisplayP3] {
let d = DisplaySpace::of(space, 7).unwrap();
let want = render(&src, &info, &s, &req(space, None, None)).image;
let got = render(&src, &info, &s, &req(OutputSpace::Srgb, Some(d), None)).image;
assert!(max_diff(&got, &want) <= 1, "{space:?}: {}", max_diff(&got, &want));
}
// a wide display shows the saturated colours sRGB clips
let srgb = render(&src, &info, &s, &req(OutputSpace::Srgb, None, None)).image;
let p3 = render(&src, &info, &s, &req(OutputSpace::Srgb, Some(DisplaySpace::of(OutputSpace::DisplayP3, 1).unwrap()), None)).image;
assert!(max_diff(&srgb, &p3) > 4);
// soft proofing on a display: the display gamut warning is about *this* display
let blue = |img: &lightcraft_raster::Rgba8| img.data.iter().filter(|p| p[2] == 255 && p[0] == 0 && p[1] < 80).count();
let pro = Some(Proof { space: OutputSpace::ProPhoto, dest_warning: false, display_warning: true, profile: 0 });
let on_srgb = blue(&render(&src, &info, &s, &req(OutputSpace::Srgb, Some(DisplaySpace::of(OutputSpace::Srgb, 2).unwrap()), pro)).image);
let on_wide = blue(&render(&src, &info, &s, &req(OutputSpace::Srgb, Some(DisplaySpace::of(OutputSpace::Rec2020, 3).unwrap()), pro)).image);
assert!(on_srgb > 0 && on_wide < on_srgb, "{on_srgb} {on_wide}");
let plain = blue(&render(&src, &info, &s, &req(OutputSpace::Srgb, None, pro)).image);
assert_eq!(plain, on_srgb, "an sRGB display warns like no display profile");
}
/// Proofing against an output-device table: the table's colours are what the render shows, and its
/// gamut distances drive the destination warning.
#[test]
fn soft_proof_through_a_device_table() {
use crate::{OutputSpace, Proof, ProofLut, register_proof_profile};
let n = 5;
// a "paper" that dims everything to 80 % and calls every non-grey colour out of gamut
let data: Vec<[f32; 4]> = (0..n * n * n)
.map(|i| {
let c = [i / (n * n), (i / n) % n, i % n].map(|k| lightcraft_color::transfer::srgb_to_linear(k as f32 / (n - 1) as f32));
let grey = c[0] == c[1] && c[1] == c[2];
[c[0] * 0.8, c[1] * 0.8, c[2] * 0.8, if grey { 0.0 } else { 1.0 }]
})
.collect();
assert!(ProofLut::new(n, data[1..].to_vec()).is_none());
assert!(ProofLut::new(n, vec![[f32::NAN; 4]; n * n * n]).is_none());
let id = register_proof_profile(0xfeed, ProofLut::new(n, data).unwrap());
let info = SourceInfo { raw: true, ..Default::default() };
let white = Rgb32f::from_fn(16, 4, |_, _| [100.0; 3]);
let req = |proof| RenderRequest { space: OutputSpace::Srgb, proof, ..RenderRequest::fit(16, 4) };
let plain = render(&white, &info, &DevelopSettings::default(), &req(None)).image;
let pr = Proof { profile: id, dest_warning: true, ..Default::default() };
let paper = render(&white, &info, &DevelopSettings::default(), &req(Some(pr))).image;
assert!(plain.data[0][0] > 250 && paper.data[0][0] < 240 && paper.data[0][0] > 200, "{:?} {:?}", plain.data[0], paper.data[0]);
// an unknown id falls back to the space proof (sRGB on sRGB: no change)
let none = render(&white, &info, &DevelopSettings::default(), &req(Some(Proof { profile: 12345, ..Default::default() }))).image;
assert_eq!(none, plain);
// saturated colours are flagged
let src = scene();
let mut s = DevelopSettings::default();
s.color.saturation = 100.0;
let warned = render(&src, &info, &s, &req(Some(pr))).image;
assert!(warned.data.iter().any(|p| p[..3] == [255, 0, 0]));
}
#[test]
fn display_space_rejects_degenerate_matrices() {
use crate::DisplaySpace;
assert!(DisplaySpace::new(lightcraft_color::Mat3([[1.0, 1.0, 0.0], [1.0, 1.0, 0.0], [0.0, 0.0, 1.0]]), 1).is_none());
assert!(DisplaySpace::new(lightcraft_color::Mat3([[f64::NAN, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]), 1).is_none());
assert!(DisplaySpace::new(lightcraft_color::Mat3::IDENTITY, 1).is_some());
}
#[test]
fn tint_negative_is_green_and_positive_is_magenta() {
use lightcraft_develop::WbMode;
let src = Rgb32f::filled(16, 16, [0.18; 3]);
// Rendered images, uncalibrated RAW and calibrated RAW with a nonzero As Shot tint.
for info in [
SourceInfo::default(),
SourceInfo { raw: true, relative_wb: true, ..Default::default() },
SourceInfo { raw: true, as_shot_temp: 4200.0, as_shot_tint: 15.0, ..Default::default() },
// camera-space white balance: the same sign through the camera's own colour model
SourceInfo { raw: true, as_shot_temp: 4200.0, as_shot_tint: 15.0, camera_color: Some(camera_color(4200.0, 15.0)), ..Default::default() },
] {
let mut s = DevelopSettings::default();
let neutral = render(&src, &info, &s, &RenderRequest::fit(16, 16)).image.get(8, 8);
assert!((neutral[0] as i16 - neutral[1] as i16).abs() <= 1);
assert!((neutral[2] as i16 - neutral[1] as i16).abs() <= 1);
s.wb.mode = WbMode::Custom;
s.wb.temp = info.as_shot_temp;
for delta in [-50.0, 50.0] {
s.wb.tint = info.as_shot_tint + delta;
let p = render(&src, &info, &s, &RenderRequest::fit(16, 16)).image.get(8, 8);
let magenta = (p[0] as f64 + p[2] as f64) / 2.0 - p[1] as f64;
assert!(magenta * delta > 100.0, "delta {delta} must follow the green/magenta track, got {p:?}");
}
}
}
/// Settings written on the relative scale (6500 K / 0 = as shot, no `WbScale`) for a raw whose camera matrices now
/// give it a Kelvin scale render exactly as they did: the same white-balance matrix, and the same pixels, as the
/// relative render; the Kelvin / tint they convert to renders the same again (issue #730, the class of bug of #510).
#[test]
fn legacy_relative_white_balance_renders_as_before_on_a_kelvin_raw() {
use crate::local::{effective_wb, legacy_to_kelvin, wb_matrix_for};
use lightcraft_develop::{WbMode, WbScale};
let old_info = SourceInfo { raw: true, relative_wb: true, as_shot_temp: 6500.0, as_shot_tint: 0.0, ..Default::default() };
let src = Rgb32f::filled(16, 16, [0.3, 0.18, 0.09]);
// (as-shot whites the ILCE-7M3 table of issue #730 reads, and the relative slider's whole reach: −100..+100 is
// 2000..13550 K around 6500 K; a white bluer than 50000 K after the composition has no Kelvin and clamps, so
// the blue end is paired with as-shot whites up to 7000 K only)
for (as_t, as_tint) in [(4986.0, -2.4), (2707.0, -4.0), (9338.0, 8.9), (6500.0, 0.0), (3157.0, 40.0), (7000.0, -20.0)] {
let new_info =
SourceInfo { raw: true, relative_wb: false, legacy_relative_wb: true, as_shot_temp: as_t, as_shot_tint: as_tint, ..Default::default() };
let blue_end = as_t <= 7000.0;
for (temp, tint) in [(6500.0, 0.0), (5800.0, 3.0), (7682.0, 10.0), (4000.0, -30.0), (2000.0, 150.0), (12000.0, 55.0), (13550.0, -150.0)] {
if temp > 10000.0 && !blue_end {
continue;
}
let mut s = DevelopSettings::default();
(s.wb.mode, s.wb.temp, s.wb.tint) = (WbMode::Custom, temp, tint);
assert_eq!(s.wb.scale, WbScale::Legacy);
let old = wb_matrix_for(&old_info, &s);
let new = wb_matrix_for(&new_info, &s);
let near = |a: Option<[[f32; 3]; 3]>, b: Option<[[f32; 3]; 3]>, tol: f32| match (a, b) {
(None, None) => true,
(Some(a), Some(b)) => a.iter().flatten().zip(b.iter().flatten()).all(|(x, y)| (x - y).abs() <= tol * (1.0 + x.abs())),
_ => false,
};
// the same matrix to f32 precision: the white is composed, not read back through Kelvin / tint
assert!(near(old, new, 2e-6), "as shot {as_t}/{as_tint}, {temp}/{tint}: {old:?} vs {new:?}");
// the converted Kelvin values, once written, render the same again to the precision of the Kelvin /
// tint parametrisation (whose seam at 4000 K costs up to 0.01 %)
let (kt, ktint) = legacy_to_kelvin(temp, tint, (as_t, as_tint));
assert_eq!(effective_wb(&new_info, &s), (kt, ktint));
let mut k = s.clone();
(k.wb.temp, k.wb.tint, k.wb.scale) = (kt, ktint, WbScale::Kelvin);
assert!(near(old, wb_matrix_for(&new_info, &k), 3e-4), "as shot {as_t}/{as_tint}, {temp}/{tint} → {kt}/{ktint}");
// and the rendered pixels agree
let a = render(&src, &old_info, &s, &RenderRequest::fit(16, 16)).image;
let b = render(&src, &new_info, &s, &RenderRequest::fit(16, 16)).image;
let c = render(&src, &new_info, &k, &RenderRequest::fit(16, 16)).image;
for (x, (y, z)) in a.data.iter().zip(b.data.iter().zip(&c.data)) {
assert_eq!(x, y, "as shot {as_t}/{as_tint}, {temp}/{tint}");
assert!(x.iter().zip(z).all(|(p, q)| p.abs_diff(*q) <= 1), "{x:?} {z:?}");
}
}
// as shot on the relative scale is as shot on the Kelvin scale, exactly
assert_eq!(legacy_to_kelvin(6500.0, 0.0, (as_t, as_tint)), (as_t, as_tint));
}
// a preset stored on the relative scale keeps its old look, not the preset's Kelvin value
let new_info = SourceInfo { raw: true, legacy_relative_wb: true, as_shot_temp: 4986.0, as_shot_tint: -2.4, ..Default::default() };
let mut s = DevelopSettings::default();
(s.wb.mode, s.wb.temp, s.wb.tint) = (WbMode::Cloudy, 6500.0 * 6500.0 / 5500.0, 10.0);
assert_eq!(effective_wb(&new_info, &s), legacy_to_kelvin(s.wb.temp, s.wb.tint, (4986.0, -2.4)));
s.wb.scale = WbScale::Kelvin;
assert_eq!(effective_wb(&new_info, &s), WbMode::Cloudy.preset().unwrap());
// a raw whose file carries the matrices (DNG) never had a relative scale: its old values are Kelvin
let dng = SourceInfo { raw: true, as_shot_temp: 5100.0, as_shot_tint: 4.0, ..Default::default() };
s.wb.scale = WbScale::Legacy;
(s.wb.mode, s.wb.temp, s.wb.tint) = (WbMode::Custom, 3200.0, 10.0);
assert_eq!(effective_wb(&dng, &s), (3200.0, 10.0));
// hostile numbers come back unchanged
assert!(legacy_to_kelvin(f64::NAN, 0.0, (5000.0, 0.0)).0.is_nan());
assert_eq!(legacy_to_kelvin(5000.0, f64::INFINITY, (5000.0, 0.0)).1, f64::INFINITY);
assert_eq!(legacy_to_kelvin(5000.0, 0.0, (f64::NAN, 0.0)), (5000.0, 0.0));
assert_eq!(legacy_to_kelvin(6500.0, 0.0, (f64::NAN, 0.0)), (6500.0, 0.0));
assert_eq!(crate::local::legacy_white(f64::NAN, 0.0, (5000.0, 0.0)), None);
let hostile = SourceInfo { raw: true, legacy_relative_wb: true, as_shot_temp: f64::NAN, as_shot_tint: 0.0, ..Default::default() };
let _ = render(&Rgb32f::filled(4, 4, [0.2; 3]), &hostile, &s, &RenderRequest::fit(4, 4));
}
/// Before an edit, the settings' white balance is brought onto the source's scale: Kelvin raws mark it (converting
/// relative values once, into a Custom value with the same look), everything else clears it.
#[test]
fn normalize_wb_marks_kelvin_raws_and_converts_relative_values_once() {
use crate::local::{legacy_to_kelvin, normalize_wb};
use lightcraft_develop::{WbMode, WbScale};
let kelvin = SourceInfo { raw: true, legacy_relative_wb: true, as_shot_temp: 4986.0, as_shot_tint: -2.4, ..Default::default() };
// as shot: marked, values untouched
let mut s = DevelopSettings::default();
normalize_wb(&mut s, &kelvin);
assert_eq!((s.wb.mode, s.wb.temp, s.wb.tint, s.wb.scale), (WbMode::AsShot, 6500.0, 0.0, WbScale::Kelvin));
// a relative custom value: converted, Custom, marked; a second pass changes nothing
let mut s = DevelopSettings::default();
(s.wb.mode, s.wb.temp, s.wb.tint) = (WbMode::Cloudy, 7682.0, 10.0);
normalize_wb(&mut s, &kelvin);
let (t, tint) = legacy_to_kelvin(7682.0, 10.0, (4986.0, -2.4));
assert_eq!((s.wb.mode, s.wb.temp, s.wb.tint, s.wb.scale), (WbMode::Custom, t, tint, WbScale::Kelvin));
let again = s.clone();
normalize_wb(&mut s, &kelvin);
assert_eq!(s, again);
// a DNG's old values are Kelvin already: marked, untouched
let dng = SourceInfo { raw: true, as_shot_temp: 5100.0, as_shot_tint: 4.0, ..Default::default() };
let mut s = DevelopSettings::default();
(s.wb.mode, s.wb.temp, s.wb.tint) = (WbMode::Custom, 3200.0, 10.0);
normalize_wb(&mut s, &dng);
assert_eq!((s.wb.mode, s.wb.temp, s.wb.tint, s.wb.scale), (WbMode::Custom, 3200.0, 10.0, WbScale::Kelvin));
// a rendered photo and a raw without matrices: the scale is cleared
for info in [SourceInfo::default(), SourceInfo { raw: true, relative_wb: true, ..Default::default() }] {
let mut s = DevelopSettings::default();
(s.wb.mode, s.wb.temp, s.wb.scale) = (WbMode::Custom, 5800.0, WbScale::Kelvin);
normalize_wb(&mut s, &info);
assert_eq!((s.wb.mode, s.wb.temp, s.wb.scale), (WbMode::Custom, 5800.0, WbScale::Legacy));
}
}
/// A dual-illuminant (A / D65) camera colour model, its pixels developed for `temp` / `tint`.
fn camera_color(temp: f64, tint: f64) -> std::sync::Arc<crate::CameraColor> {
use lightcraft_color::Mat3;
let tags = lightcraft_raw::ColorData {
illuminant: [17, 21],
color_matrix: [
Some(Mat3([[0.9, 0.2, -0.15], [-0.3, 1.25, 0.08], [0.02, -0.12, 0.85]])),
Some(Mat3([[0.7, 0.3, -0.1], [-0.35, 1.3, 0.1], [0.05, -0.2, 1.0]])),
],
..Default::default()
};
std::sync::Arc::new(crate::CameraColor { tags, developed_for: lightcraft_color::cct::temp_tint_to_xy(temp, tint) })
}
/// Camera-space white balance: a raw source with its colour model is re-developed for the chosen
/// white, so a grey card lit by that white renders neutral. Without the model, or with a relative
/// white balance, the developed pixels are adapted (Bradford, neutral luminance kept).
#[test]
fn custom_white_balance_redevelops_in_camera_space() {
use crate::local::wb_matrix_for;
use lightcraft_color::cct::temp_tint_to_xy;
use lightcraft_develop::WbMode;
let cc = camera_color(5500.0, 0.0);
let info = SourceInfo { raw: true, as_shot_temp: 5500.0, as_shot_tint: 0.0, camera_color: Some(cc.clone()), ..Default::default() };
let mut s = DevelopSettings::default();
(s.wb.mode, s.wb.temp, s.wb.tint) = (WbMode::Custom, 3200.0, 10.0);
// a grey card lit by 3200 K / +10, as the camera records it, developed for the as-shot white
let a = lightcraft_raw::color::camera_transform_of(&cc.tags, cc.developed_for);
let n = lightcraft_raw::color::camera_neutral(&cc.tags, temp_tint_to_xy(3200.0, 10.0));
let card = a.matrix.apply(std::array::from_fn(|i| n[i] * a.wb[i] as f64)).map(|v| v as f32);
let apply = |m: [[f32; 3]; 3], c: [f32; 3]| -> [f32; 3] { std::array::from_fn(|r| m[r][0] * c[0] + m[r][1] * c[1] + m[r][2] * c[2]) };
let m = wb_matrix_for(&info, &s).unwrap();
let out = apply(m, card);
assert!(out.iter().all(|v| (v / out[1] - 1.0).abs() < 1e-4), "{card:?} -> {out:?}");
// the adaptation path for sources without a colour model, and for relative white balance
let luma = |c: [f32; 3]| lightcraft_color::luminance_2020(c);
for other in [SourceInfo { camera_color: None, ..info.clone() }, SourceInfo { relative_wb: true, ..info.clone() }] {
let b = wb_matrix_for(&other, &s).unwrap();
assert_ne!(b, m);
assert!((luma(apply(b, [1.0; 3])) - 1.0).abs() < 1e-4);
}
// the white-balance picker / auto white balance invert the same model: the card names its white
let picked = crate::auto::auto_wb(&Rgb32f::filled(4, 4, card), &info);
assert_eq!(picked, (3200.0, 10.0));
// the as-shot white needs nothing
s.wb.mode = WbMode::AsShot;
assert!(wb_matrix_for(&info, &s).is_none());
}
/// Every stored process number renders with a process this build knows: settings saved before
/// process versions existed exactly as V1, and a number from a newer LightCraft exactly as the
/// latest process here (`docs/process-versions.md`). Raw (base tone curve), camera-tone and
/// rendered sources, plain and edited, 8-bit and 16-bit.
#[test]
fn stored_process_numbers_render_with_a_known_process() {
use lightcraft_develop::{Process, ProcessVersion};
let src = scene();
let curve = crate::tone::CameraTone::new(std::array::from_fn(|i| {
let x = 0.004 * 1.18f32.powi(i as i32);
[x, 1.0 - (-2.0 * x).exp()]
}))
.unwrap();
let infos = [
SourceInfo::default(),
SourceInfo { raw: true, as_shot_temp: 5200.0, as_shot_tint: 4.0, ..Default::default() },
SourceInfo { raw: true, relative_wb: true, camera_tone: Some(curve), ..Default::default() },
];
let mut edited = DevelopSettings::for_raw(5200.0, 4.0);
for (id, v) in [("light.exposure", 0.4), ("light.contrast", 30.0), ("light.highlights", -60.0), ("light.whites", 15.0), ("light.blacks", -20.0)] {
controls::set(&mut edited, id, v);
}
let legacy = |s: &DevelopSettings| {
let mut v = s.to_json();
v.as_object_mut().unwrap().remove("process");
DevelopSettings::from_json(&v).unwrap()
};
let with = |s: &DevelopSettings, p: ProcessVersion| DevelopSettings { process: p, ..s.clone() };
let deep = RenderRequest { depth: crate::OutputDepth::U16, ..RenderRequest::fit(96, 96) };
for info in &infos {
for s in [DevelopSettings::default(), edited.clone()] {
for req in [RenderRequest::fit(96, 96), deep] {
let out = |s: &DevelopSettings| {
let r = render(&src, info, s, &req);
(r.image.data, r.deep)
};
let v1 = out(&with(&s, ProcessVersion::V1));
assert_eq!(legacy(&s).process, ProcessVersion::V1);
assert!(out(&legacy(&s)) == v1, "saved before process versions: rendered as V1");
let latest = out(&with(&s, Process::LATEST.version()));
assert!(out(&with(&s, ProcessVersion(Process::LATEST.version().0 + 7))) == latest, "newer than this build: as the latest");
}
}
}
}
/// A crop a hair wide (or of no size, as a command or a sidecar can set) shown to fit made the
/// tone, clarity and dehaze stages blur with sigmas of millions of pixels (infinite for no size):
/// the box width's square overflowed (a panic in debug builds, a radius of billions of pixels and
/// a hung render in release ones). The blur is held to twice the picture's size: the render is
/// quick and its pixels are numbers.
#[test]
fn sliver_crops_render_quickly_with_wide_stages_on() {
let src = scene();
for (rect, angle) in [([0.0, 0.0, 1e-9, 1.0], 45.0), ([0.5, 0.5, 0.5, 0.5], 0.0), ([0.0, 0.0, 1e-5, 1.0], -30.0)] {
let mut s = DevelopSettings::default();
s.crop.geometry.rect = lightcraft_geom::Rect::new(rect[0], rect[1], rect[2], rect[3]);
s.crop.geometry.angle = angle;
s.effects.clarity = 80.0;
s.effects.dehaze = 50.0;
s.effects.texture = 40.0;
s.light.highlights = -60.0;
s.light.shadows = 60.0;
let t = std::time::Instant::now();
let r = render(&src, &SourceInfo::default(), &s, &RenderRequest::fit(280, 180));
assert!(t.elapsed().as_secs_f64() < 20.0, "{rect:?}: {:?}", t.elapsed());
assert!(r.image.width >= 1 && r.image.height >= 1, "{rect:?}");
}
}
// Given a cached render with one process, a change to a process with another colour filter (Update
// to Current Process, undo) renders like a fresh render, not the cached denoised image
#[test]
fn a_process_change_does_not_reuse_the_other_colour_filter() {
use crate::{StageCache, render_cached};
use lightcraft_develop::Process;
use std::sync::Arc;
let src = Arc::new(colour_noise_scene(128, 96, 128));
let info = SourceInfo::default();
let req = RenderRequest::fit(128, 96);
let cache = StageCache::default();
let mut old = DevelopSettings::default();
old.detail.nr_color = 25.0;
old.detail.nr_color_smoothness = 0.0;
old.process = Process::V2.version();
let current = DevelopSettings { process: Process::LATEST.version(), ..old.clone() };
let first = render_cached(&src, &info, &old, &req, &cache).image;
let fresh = render(&src, &info, ¤t, &req).image;
assert!(max_diff(&first, &fresh) > 0, "the two colour filters differ on this scene");
assert_eq!(render_cached(&src, &info, ¤t, &req, &cache).image, fresh, "process update");
assert_eq!(render_cached(&src, &info, &old, &req, &cache).image, first, "undo");
}
/// Flat grey with chroma noise: `quiet` columns on the left with little noise, the rest with much.
pub(crate) fn colour_noise_scene(w: usize, h: usize, quiet: usize) -> Rgb32f {
let mut seed = 0x2545_f491_4f6c_dd1d_u64;
let mut noise = move || {
seed ^= seed << 13;
seed ^= seed >> 7;
seed ^= seed << 17;
((seed >> 11) as f32 / (1u64 << 53) as f32 - 0.5) * 2.0
};
let mut img = Rgb32f::new(w, h);
for (i, p) in img.data.iter_mut().enumerate() {
let sigma = if i % w < quiet { 0.001 } else { 0.015 };
let y = 0.04f32;
let (r, b) = (y + noise() * sigma, y + noise() * sigma);
*p = [r, (y - 0.2627 * r - 0.0593 * b) / 0.6780, b];
}
img
}
/// A crop of no width used to give grain NaN coordinates (and NaN pixels); the render stays finite.
#[test]
fn zero_width_crop_with_grain_renders_finite_pixels() {
let mut s = DevelopSettings::default();
s.grain.amount = 60.0;
s.crop.geometry.rect = lightcraft_geom::Rect::new(0.5, 0.1, 0.5, 0.9);
let mut req = RenderRequest::fit(240, 240);
req.depth = crate::OutputDepth::F32Linear;
let r = render(&scene(), &SourceInfo::default(), &s, &req);
if let Some(d) = r.deep
&& let crate::DeepSamples::F32(v) = d.samples
{
assert!(v.iter().all(|x| x.is_finite()), "non-finite sample in a zero-width crop with grain");
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.