LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M3.7: Canon CR2 decoding + rawinfo/rawrender examples
Brandon Thomas741e93e63202
diff --git a/crates/raw/examples/rawinfo.rs b/crates/raw/examples/rawinfo.rsnew file mode 100644index 000000000..d5cc21b15--- /dev/null+++ b/crates/raw/examples/rawinfo.rs@@ -0,0 +1,133 @@+//! `cargo run --release -p lightcraft-raw --example rawinfo -- [--tree] FILE...`+//!+//! Prints the TIFF structure (with `--tree`), decode result, timings (MP/s) and basic statistics.++use lightcraft_raw::{Method, RawData, decode, embedded_preview, probe};+use lightcraft_tiff::{Ifd, Tiff, Value};+use std::time::Instant;++fn short(v: &Value) -> String {+ let s = match v {+ Value::Ascii(s) => format!("{s:?}"),+ Value::Byte(b) | Value::Undefined(b) => format!("{} bytes {:02x?}", b.len(), &b[..b.len().min(12)]),+ other => {+ let f = other.to_f64_vec();+ format!("{:?}{}", &f[..f.len().min(12)], if f.len() > 12 { format!(" …({})", f.len()) } else { String::new() })+ }+ };+ s.chars().take(160).collect()+}++fn dump(ifd: &Ifd, depth: usize, label: &str) {+ let pad = " ".repeat(depth);+ println!("{pad}{label} @{} ({} entries)", ifd.offset, ifd.entries.len());+ for e in &ifd.entries {+ println!("{pad} {:5} 0x{:04x} {:?}: {}", e.tag, e.tag, e.field_type(), short(&e.value));+ }+ for (i, s) in ifd.sub_ifds.iter().enumerate() {+ dump(s, depth + 1, &format!("SubIFD[{i}]"));+ }+ for (n, c) in [("Exif", &ifd.exif), ("GPS", &ifd.gps), ("Interop", &ifd.interop)] {+ if let Some(c) = c {+ dump(c, depth + 1, n);+ }+ }+}++fn main() {+ let args: Vec<String> = std::env::args().skip(1).collect();+ let tree = args.iter().any(|a| a == "--tree");+ for path in args.iter().filter(|a| !a.starts_with("--")) {+ let bytes = std::fs::read(path).expect("read");+ println!("== {path} ({:.1} MB) format {:?}", bytes.len() as f64 / 1e6, probe(&bytes));+ if tree && let Ok(t) = Tiff::parse(&bytes) {+ for (i, ifd) in t.ifds.iter().enumerate() {+ dump(ifd, 0, &format!("IFD{i}"));+ }+ }+ let t0 = Instant::now();+ match decode(&bytes) {+ Ok(r) => {+ let dt = t0.elapsed().as_secs_f64();+ let mp = (r.width * r.height) as f64 / 1e6;+ let (mn, mx, mean) = match &r.data {+ RawData::U16(v) => {+ let mn = *v.iter().min().unwrap_or(&0) as f64;+ let mx = *v.iter().max().unwrap_or(&0) as f64;+ (mn, mx, v.iter().map(|&x| x as f64).sum::<f64>() / v.len() as f64)+ }+ RawData::F32(v) => (+ v.iter().cloned().fold(f32::MAX, f32::min) as f64,+ v.iter().cloned().fold(f32::MIN, f32::max) as f64,+ v.iter().map(|&x| x as f64).sum::<f64>() / v.len() as f64,+ ),+ };+ println!(+ " {}x{} cpp {} bits {} cfa {:?} black {:.1} white {:?} active {:?} crop {:?} orient {:?}",+ r.width,+ r.height,+ r.cpp,+ r.bits,+ r.cfa.as_ref().map(|c| c.name()),+ r.black.mean(),+ r.white,+ r.active_area,+ r.crop,+ r.orientation+ );+ println!(+ " data min {mn} max {mx} mean {mean:.1}; wb {:?}; opcodes {}/{}/{}",+ r.wb_multipliers,+ r.opcodes.list1.len(),+ r.opcodes.list2.len(),+ r.opcodes.list3.len()+ );+ println!(" decode {:.0} ms ({:.0} MP/s)", dt * 1e3, mp / dt);+ println!(+ " meta: {:?} {:?} lens {:?} iso {:?} f {:?} t {:?} date {:?}",+ r.metadata.make,+ r.metadata.model,+ r.metadata.lens_model,+ r.metadata.iso,+ r.metadata.f_number,+ r.metadata.exposure_display(),+ r.metadata.capture_time.map(|d| d.to_iso())+ );+ let xy = lightcraft_raw::color::as_shot_white_xy(&r);+ let ct = lightcraft_raw::color::camera_transform(&r, xy);+ println!(" as-shot xy ({:.4}, {:.4}) wb {:?} fallback {}", xy.x, xy.y, ct.wb, ct.matrix_is_fallback);+ for m in [Method::Bilinear, Method::Ppg, Method::Ahd] {+ let t1 = Instant::now();+ match r.develop(m) {+ Ok(img) => {+ let dt = t1.elapsed().as_secs_f64();+ let mut s = [0f64; 3];+ for p in &img.data {+ for c in 0..3 {+ s[c] += p[c] as f64;+ }+ }+ let n = img.data.len() as f64;+ println!(+ " develop {m:?}: {}x{} in {:.0} ms ({:.0} MP/s), mean rgb {:.3} {:.3} {:.3}",+ img.width,+ img.height,+ dt * 1e3,+ mp / dt,+ s[0] / n,+ s[1] / n,+ s[2] / n+ );+ }+ Err(e) => println!(" develop {m:?}: {e}"),+ }+ }+ }+ Err(e) => println!(" decode error: {e}"),+ }+ match embedded_preview(&bytes) {+ Some(p) => println!(" preview: {} bytes", p.len()),+ None => println!(" preview: none"),+ }+ }+}diff --git a/crates/raw/examples/rawrender.rs b/crates/raw/examples/rawrender.rsnew file mode 100644index 000000000..abb1fe7c9--- /dev/null+++ b/crates/raw/examples/rawrender.rs@@ -0,0 +1,64 @@+//! `cargo run --release -p lightcraft-raw --example rawrender -- IN OUT.tif [bilinear|ppg|ahd] [max_edge]`+//!+//! Quick visual check: develop → as-shot WB + camera matrix → sRGB, oriented, box-downscaled, 8-bit TIFF.++use lightcraft_color::{REC2020, SRGB, transfer::encode_srgb8};+use lightcraft_raw::{Method, color, decode};+use lightcraft_tiff::{IfdBuilder, ImageData, TiffWriter, Value, tags};++fn main() {+ let a: Vec<String> = std::env::args().skip(1).collect();+ let bytes = std::fs::read(&a[0]).expect("read");+ let method = match a.get(2).map(String::as_str) {+ Some("bilinear") => Method::Bilinear,+ Some("ppg") => Method::Ppg,+ _ => Method::Ahd,+ };+ let max_edge: usize = a.get(3).and_then(|s| s.parse().ok()).unwrap_or(1600);+ let raw = decode(&bytes).expect("decode");+ let mut img = raw.develop(method).expect("develop");+ let xy = color::as_shot_white_xy(&raw);+ let t = color::camera_transform(&raw, xy);+ let wb = t.wb;+ lightcraft_raw::highlight::reconstruct(&mut img, wb, 0.99);+ let to_srgb = REC2020.to_space(&SRGB).mul(&t.matrix);+ let gain = 2f32.powf(t.baseline_exposure as f32);+ let img = img.map(|p| {+ let q = to_srgb.apply_f32([p[0] * wb[0], p[1] * wb[1], p[2] * wb[2]]);+ // simple highlight roll-off so clipped areas are not harsh+ q.map(|v| {+ let v = (v * gain).max(0.0);+ if v < 0.8 { v } else { 0.8 + 0.2 * (1.0 - (-(v - 0.8) / 0.2).exp()) }+ })+ });+ let img = img.oriented(raw.orientation);+ let f = img.width.max(img.height).div_ceil(max_edge).max(1);+ let (w, h) = (img.width / f, img.height / f);+ let mut px = Vec::with_capacity(w * h * 3);+ for y in 0..h {+ for x in 0..w {+ let mut s = [0f32; 3];+ for dy in 0..f {+ for dx in 0..f {+ let p = img.get(x * f + dx, y * f + dy);+ for c in 0..3 {+ s[c] += p[c];+ }+ }+ }+ for c in 0..3 {+ px.push(encode_srgb8(s[c] / (f * f) as f32));+ }+ }+ }+ let mut ifd = IfdBuilder::new();+ ifd.set(tags::IMAGE_WIDTH, Value::Long(vec![w as u32]));+ ifd.set(tags::IMAGE_LENGTH, Value::Long(vec![h as u32]));+ ifd.set(tags::BITS_PER_SAMPLE, Value::Short(vec![8, 8, 8]));+ ifd.set(tags::SAMPLES_PER_PIXEL, Value::Short(vec![3]));+ ifd.set(tags::PHOTOMETRIC, Value::Short(vec![2]));+ ifd.set(tags::COMPRESSION, Value::Short(vec![1]));+ ifd.set_image(ImageData::Strips { rows_per_strip: h as u32, strips: vec![px] });+ std::fs::write(&a[1], TiffWriter::default().write(&[ifd]).unwrap()).expect("write");+ println!("{}x{} wb {:?} xy ({:.4},{:.4}) fallback {}", w, h, wb, xy.x, xy.y, t.matrix_is_fallback);+}diff --git a/crates/raw/src/lib.rs b/crates/raw/src/lib.rsindex cde39418d..da4f4e414 100644--- a/crates/raw/src/lib.rs+++ b/crates/raw/src/lib.rs@@ -113,6 +113,9 @@ pub fn probe(bytes: &[u8]) -> Option<RawFormat> {i.u16(lightcraft_tiff::tags::PHOTOMETRIC) == Some(lightcraft_tiff::tags::photometric::CFA)|| i.u16(lightcraft_tiff::tags::COMPRESSION).is_some_and(|c| c == 34713 || c == 32767 || c == 32769 || c == 32770)});+ if make.starts_with("CANON") && t.ifds.len() >= 4 && t.ifds[3].u16(lightcraft_tiff::tags::COMPRESSION) == Some(6) {+ return Some(RawFormat::Cr2);+ }if make.starts_with("NIKON") {return Some(if has_cfa || t.all_ifds().len() > 1 { RawFormat::Nef } else { RawFormat::Nrw });}diff --git a/crates/raw/src/vendor/cr2.rs b/crates/raw/src/vendor/cr2.rsindex 7452793db..601666d66 100644--- a/crates/raw/src/vendor/cr2.rs+++ b/crates/raw/src/vendor/cr2.rs@@ -1,5 +1,201 @@-use crate::{RawError, RawImage, Result};+//! Canon CR2.+//!+//! Source: Laurent Clévy, "Understanding what is stored in a Canon RAW .CR2 file" (prose sections on the file+//! structure, IFD#3, the `0xc640` slice layout and the maker-note `SensorInfo` table), plus the ExifTool Canon+//! tag-name documentation for maker-note tag meanings. Only the structural description was used.+//!+//! - The raw data is IFD#3's single strip: a lossless-JPEG frame (usually 2 or 4 components).+//! - The decoded sample stream fills vertical slices left to right: `cr2_slice = [n, w, last]` means `n` slices of+//! width `w` then one of width `last`; each slice is filled top to bottom, row by row.+//! - `SensorInfo` (maker note `0x00e0`): sensor width/height and the left/top/right/bottom borders of the image+//! area; the masked columns left of it give the black level.+//! - `ColorBalance` (maker note `0x4001`): as-shot `RGGB` levels at a model-dependent offset; we probe the known+//! offsets and accept the first plausible quadruple.+//! - sRAW / mRAW (YCbCr, subsampled) are not supported yet.-pub(crate) fn decode(_bytes: &[u8]) -> Result<RawImage> {- Err(RawError::Unsupported("cr2: not yet".into()))+use super::{black_from_columns, white_from_data};+use crate::{BlackLevel, Cfa, ColorData, OpcodeLists, RawData, RawError, RawFormat, RawImage, Rect, Result, ljpeg};+use lightcraft_geom::Orientation;+use lightcraft_tiff::image::chunk_bytes;+use lightcraft_tiff::{Ifd, Tiff, makernote, tags as t};++const CR2_SLICE: u16 = 0xc640;+const SRAW_TYPE: u16 = 0xc6c5;+const SENSOR_INFO: u16 = 0x00e0;+const COLOR_BALANCE: u16 = 0x4001;++fn raw_ifd(tiff: &Tiff) -> Option<&Ifd> {+ tiff.ifds.get(3).or_else(|| tiff.ifds.iter().rev().find(|i| i.contains(CR2_SLICE)))+}++/// As-shot WB multipliers (R, G, B; G = 1) from the ColorBalance array.+fn wb_from_color_balance(v: &[u64]) -> Option<[f32; 3]> {+ for off in [63usize, 25, 24, 34, 71, 85, 105, 69, 77] {+ let q = v.get(off..off + 4)?;+ let (r, g1, g2, b) = (q[0] as f32, q[1] as f32, q[2] as f32, q[3] as f32);+ if g1 < 256.0 || g2 < 256.0 || r < 64.0 || b < 64.0 || g1 > 16384.0 || (g1 - g2).abs() > 0.05 * g1 {+ continue;+ }+ let g = (g1 + g2) / 2.0;+ let (mr, mb) = (r / g, b / g);+ if (0.25..6.0).contains(&mr) && (0.25..6.0).contains(&mb) {+ return Some([mr, 1.0, mb]);+ }+ }+ None+}++pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {+ let tiff = Tiff::parse(bytes)?;+ let ifd0 = &tiff.ifds[0];+ let raw = raw_ifd(&tiff).ok_or_else(|| RawError::Corrupt("CR2 without raw IFD".into()))?;+ if raw.u32(SRAW_TYPE).is_some_and(|v| v != 1) {+ return Err(RawError::Unsupported("Canon sRAW/mRAW".into()));+ }+ let off = raw.u64(t::STRIP_OFFSETS).ok_or(RawError::Tiff(lightcraft_tiff::TiffError::MissingTag(t::STRIP_OFFSETS)))?;+ let len = raw.u64(t::STRIP_BYTE_COUNTS).unwrap_or(bytes.len() as u64 - off.min(bytes.len() as u64));+ let chunk = lightcraft_tiff::image::Chunk { index: 0, x: 0, y: 0, width: 0, height: 0, plane: 0, offset: off, len };+ let src = chunk_bytes(bytes, &chunk).ok_or_else(|| RawError::Corrupt("raw strip outside file".into()))?;+ let (fw, fh, nc, prec) = ljpeg::frame_info(src)?;+ let frame = ljpeg::decode(src, (fw * fh * nc).min(crate::MAX_SAMPLES))?;+ let total = frame.data.len();+ let slices = raw.u64s(CR2_SLICE).filter(|s| s.len() == 3 && s[1] > 0 && s[2] > 0);+ let widths: Vec<usize> = match &slices {+ Some(s) => {+ let n = s[0].min(64) as usize;+ let mut v = vec![s[1] as usize; n];+ v.push(s[2] as usize);+ v+ }+ None => vec![fw * nc],+ };+ let width: usize = widths.iter().sum();+ if width == 0 || total % width != 0 {+ return Err(RawError::Corrupt(format!("CR2 slices ({width}) do not divide the frame ({total} samples)")));+ }+ let height = total / width;+ let mut data = vec![0u16; total];+ let mut i = 0;+ let mut x0 = 0;+ for &sw in &widths {+ for y in 0..height {+ data[y * width + x0..y * width + x0 + sw].copy_from_slice(&frame.data[i..i + sw]);+ i += sw;+ }+ x0 += sw;+ }++ // maker note: sensor borders and white balance+ let make = ifd0.string(t::MAKE).unwrap_or_default();+ let mn =+ tiff.exif().and_then(|e| e.get(t::MAKER_NOTE)).and_then(|e| makernote::parse_makernote(bytes, e.offset, e.count() as u64, tiff.order, &make));+ let mut active = Rect::new(0, 0, width, height);+ if let Some(si) = mn.as_ref().and_then(|m| m.ifd.u64s(SENSOR_INFO)).filter(|v| v.len() >= 9) {+ let (l, tp, r, b) = (si[5] as usize, si[6] as usize, si[7] as usize, si[8] as usize);+ if r > l && b > tp && r < width && b < height {+ active = Rect::new(l, tp, r - l + 1, b - tp + 1);+ }+ }+ let wb = mn.as_ref().and_then(|m| m.ifd.u64s(COLOR_BALANCE)).and_then(|v| wb_from_color_balance(&v));+ let cfa = Cfa::bayer("RGGB").expect("static");+ let black = if active.x >= 8 {+ black_from_columns(&data, width, 2..active.x - 2, active.y..active.y + active.height, active)+ } else {+ BlackLevel::uniform(0.0)+ };+ let white = white_from_data(&data, prec as u32);+ let mut metadata = lightcraft_meta::from_tiff(&tiff);+ metadata.width = Some(active.width as u32);+ metadata.height = Some(active.height as u32);+ let img = RawImage {+ format: RawFormat::Cr2,+ width,+ height,+ cpp: 1,+ data: RawData::U16(data),+ cfa: Some(cfa),+ bits: prec as u32,+ black,+ white: vec![white],+ active_area: active,+ crop: Rect::new(0, 0, active.width, active.height),+ orientation: Orientation::from_exif(ifd0.u16(t::ORIENTATION).unwrap_or(1)),+ color: ColorData::default(),+ wb_multipliers: wb,+ linearized: false,+ opcodes: OpcodeLists::default(),+ metadata,+ };+ img.validate()?;+ Ok(img)+}++#[cfg(test)]+pub(crate) mod tests {+ use super::*;+ use lightcraft_tiff::{ByteOrder, IfdBuilder, ImageData, TiffWriter, Value};++ /// Build a synthetic CR2: IFD0..IFD2 placeholders + IFD3 holding a sliced 2-component LJ92 frame.+ pub(crate) fn synthetic_cr2(w: usize, h: usize, slices: Option<[u16; 3]>) -> (Vec<u8>, Vec<u16>) {+ let img: Vec<u16> = (0..w * h).map(|i| 1024 + ((i * 7919) % 12000) as u16).collect();+ let widths: Vec<usize> = match slices {+ Some([n, sw, last]) => {+ let mut v = vec![sw as usize; n as usize];+ v.push(last as usize);+ v+ }+ None => vec![w],+ };+ let mut stream = Vec::with_capacity(w * h);+ let mut x0 = 0;+ for &sw in &widths {+ for y in 0..h {+ stream.extend_from_slice(&img[y * w + x0..y * w + x0 + sw]);+ }+ x0 += sw;+ }+ let enc = crate::ljpeg::encode(&stream, w / 2, h, 2, 14, 1, 0);+ let mut ifd0 = IfdBuilder::new();+ ifd0.set(t::MAKE, Value::Ascii("Canon".into()));+ ifd0.set(t::MODEL, Value::Ascii("Canon EOS Test".into()));+ ifd0.set(t::ORIENTATION, Value::Short(vec![8]));+ // maker note: SensorInfo + ColorBalance, plain IFD with offsets relative to the TIFF header+ let mut exif = IfdBuilder::new();+ exif.set(t::ISO_SPEED, Value::Short(vec![400]));+ ifd0.set_child(t::EXIF_IFD, exif);+ let mut ifd3 = IfdBuilder::new();+ ifd3.set(t::COMPRESSION, Value::Short(vec![6]));+ if let Some(s) = slices {+ ifd3.set(CR2_SLICE, Value::Short(s.to_vec()));+ }+ ifd3.set_image(ImageData::Strips { rows_per_strip: h as u32, strips: vec![enc] });+ // (real files also carry a "CR\x02\0" signature at offset 8; probe recognises the structure without it)+ let bytes = TiffWriter::new(ByteOrder::Little, false)+ .write(&[ifd0, IfdBuilder::new().with(1, Value::Short(vec![0])), IfdBuilder::new().with(1, Value::Short(vec![0])), ifd3])+ .unwrap();+ (bytes, img)+ }++ #[test]+ fn synthetic_roundtrip() {+ for slices in [None, Some([2u16, 24, 16]), Some([1, 40, 24])] {+ let (bytes, img) = synthetic_cr2(64, 10, slices);+ assert_eq!(crate::probe(&bytes), Some(RawFormat::Cr2));+ let r = crate::decode(&bytes).unwrap();+ assert_eq!((r.width, r.height), (64, 10));+ assert_eq!(r.data, RawData::U16(img));+ assert_eq!(r.orientation, Orientation::Rotate270);+ assert_eq!(r.metadata.iso, Some(400));+ assert!(r.develop(crate::Method::Ahd).is_ok());+ }+ }++ #[test]+ fn wb_probe() {+ let mut v = vec![0u64; 120];+ v[63..67].copy_from_slice(&[2000, 1024, 1026, 1500]);+ let wb = wb_from_color_balance(&v).unwrap();+ assert!((wb[0] - 2000.0 / 1025.0).abs() < 1e-4 && (wb[2] - 1500.0 / 1025.0).abs() < 1e-4);+ assert!(wb_from_color_balance(&[0; 10]).is_none());+ }}diff --git a/crates/raw/src/vendor/mod.rs b/crates/raw/src/vendor/mod.rsindex 54cea8b6f..f15e64159 100644--- a/crates/raw/src/vendor/mod.rs+++ b/crates/raw/src/vendor/mod.rs@@ -1,5 +1,84 @@-//! Vendor raw formats (TIFF-based).+//! Vendor raw formats (TIFF-based) and helpers shared by them.pub mod arw;pub mod cr2;pub mod nef;++use crate::{BlackLevel, Rect};+use std::ops::Range;++/// Black level per 2×2 CFA position (anchored at the active area origin) from masked sensor columns `cols` over+/// rows `rows`. Falls back to 0 when the region is empty.+pub(crate) fn black_from_columns(data: &[u16], width: usize, cols: Range<usize>, rows: Range<usize>, active: Rect) -> BlackLevel {+ let height = data.len() / width.max(1);+ let (mut sum, mut n) = ([0f64; 4], [0u64; 4]);+ for y in rows.start..rows.end.min(height) {+ let py = (y as isize - active.y as isize).rem_euclid(2) as usize;+ for x in cols.start..cols.end.min(width) {+ let px = (x as isize - active.x as isize).rem_euclid(2) as usize;+ sum[py * 2 + px] += data[y * width + x] as f64;+ n[py * 2 + px] += 1;+ }+ }+ if n.contains(&0) {+ return BlackLevel::uniform(0.0);+ }+ BlackLevel { repeat_rows: 2, repeat_cols: 2, values: (0..4).map(|i| (sum[i] / n[i] as f64) as f32).collect(), delta_h: vec![], delta_v: vec![] }+}++/// White level estimate: the saturation plateau if a noticeable number of samples sit at the maximum value,+/// otherwise the full `bits` range.+pub(crate) fn white_from_data(data: &[u16], bits: u32) -> f32 {+ let full = ((1u32 << bits.clamp(1, 16)) - 1) as f32;+ let Some(&mx) = data.iter().max() else { return full };+ let band = (mx / 256).max(1);+ let near = mx.saturating_sub(band);+ let below = near.saturating_sub(band);+ let step = (data.len() / 2_000_000).max(1);+ let (mut top, mut under) = (0usize, 0usize);+ for &v in data.iter().step_by(step) {+ if v >= near {+ top += 1;+ } else if v >= below {+ under += 1;+ }+ }+ // a saturation plateau is a spike: many more samples in the top band than in the band just below it+ if mx as f32 > full * 0.5 && top * step >= (data.len() / 20_000).max(16) && top >= 4 * under + 4 {+ // plateau: use its lower edge so everything at saturation maps to ≥ 1.0+ near as f32+ } else {+ full.max(mx as f32)+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn black_columns_by_parity() {+ // 8 wide, masked columns 0..4, active starts at x=4 (even)+ let data: Vec<u16> = (0..8 * 6)+ .map(|i| {+ let (x, y) = (i % 8, i / 8);+ if x < 4 { [100, 101, 102, 103][(y % 2) * 2 + x % 2] } else { 5000 }+ })+ .collect();+ let b = black_from_columns(&data, 8, 0..4, 0..6, Rect::new(4, 0, 4, 6));+ assert_eq!(b.values, vec![100.0, 101.0, 102.0, 103.0]);+ let b = black_from_columns(&data, 8, 0..4, 0..6, Rect::new(3, 1, 4, 5));+ assert_eq!(b.at(0, 0, 0, 1), 103.0);+ assert_eq!(black_from_columns(&data, 8, 0..0, 0..6, Rect::new(0, 0, 8, 6)), BlackLevel::uniform(0.0));+ }++ #[test]+ fn white_plateau() {+ let mut d: Vec<u16> = (0..100_000).map(|i| (i % 10000) as u16).collect();+ assert_eq!(white_from_data(&d, 14), 16383.0);+ d.extend(std::iter::repeat_n(15000u16, 1000));+ let w = white_from_data(&d, 14);+ assert!((14900.0..=15000.0).contains(&w), "{w}");+ assert_eq!(white_from_data(&[], 12), 4095.0);+ }+}