π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
[rust] Collapse the elementwise image-op layer
laurenspriemfaeebe4408c9
diff --git a/rust/crates/ml/src/cv/arith.rs b/rust/crates/ml/src/cv/arith.rsdeleted file mode 100644index 6ca0058e98..0000000000--- a/rust/crates/ml/src/cv/arith.rs+++ /dev/null@@ -1,144 +0,0 @@-use rayon::prelude::*;--use crate::cv::OpResult;-use crate::cv::image::ImageF32;--const PARALLEL_MIN_ELEMS: usize = 200_000;--fn fill<T: Send + Sync + Copy>(- out: &mut [f32],- src: &[T],- chunk: usize,- f: impl Fn(&mut [f32], &[T]) + Send + Sync,-) {- if out.len() >= PARALLEL_MIN_ELEMS {- out.par_chunks_mut(chunk)- .zip(src.par_chunks(chunk))- .for_each(|(o, s)| f(o, s));- } else {- f(out, src);- }-}--fn chunk_len(channels: i32) -> usize {- 65536 * channels as usize-}--fn same_geometry(a: &ImageF32, b: &ImageF32, op: &str) -> OpResult<()> {- if !a.same_geometry(b) {- return Err(format!("{op}: operands have different geometry"));- }- Ok(())-}--fn map1(a: &ImageF32, f: impl Fn(f32) -> f32 + Send + Sync) -> OpResult<ImageF32> {- let mut data = vec![0.0f32; a.data.len()];- fill(&mut data, &a.data, chunk_len(a.channels), |o, s| {- for (o, &v) in o.iter_mut().zip(s.iter()) {- *o = f(v);- }- });- ImageF32::new(a.width, a.height, a.channels, data)-}--fn map2(- a: &ImageF32,- b: &ImageF32,- op: &str,- f: impl Fn(f32, f32) -> f32 + Send + Sync,-) -> OpResult<ImageF32> {- same_geometry(a, b, op)?;- let mut data = vec![0.0f32; a.data.len()];- let chunk = chunk_len(a.channels);- if data.len() >= PARALLEL_MIN_ELEMS {- data.par_chunks_mut(chunk)- .zip(a.data.par_chunks(chunk))- .zip(b.data.par_chunks(chunk))- .for_each(|((o, x), y)| {- for ((o, &x), &y) in o.iter_mut().zip(x.iter()).zip(y.iter()) {- *o = f(x, y);- }- });- } else {- for ((o, &x), &y) in data.iter_mut().zip(a.data.iter()).zip(b.data.iter()) {- *o = f(x, y);- }- }- ImageF32::new(a.width, a.height, a.channels, data)-}--fn map_scalar(- a: &ImageF32,- scalar: [f64; 4],- f: impl Fn(f32, f64) -> f32 + Send + Sync,-) -> OpResult<ImageF32> {- let cn = a.channels as usize;- if cn > 4 {- return Err("scalar operations support at most 4 channels".to_string());- }- let mut data = vec![0.0f32; a.data.len()];- fill(&mut data, &a.data, chunk_len(a.channels), |o, s| {- for (i, (o, &v)) in o.iter_mut().zip(s.iter()).enumerate() {- *o = f(v, scalar[i % cn]);- }- });- ImageF32::new(a.width, a.height, a.channels, data)-}--pub(crate) fn multiply_f32(a: &ImageF32, b: &ImageF32) -> OpResult<ImageF32> {- map2(a, b, "multiply_f32", |x, y| x * y)-}--pub(crate) fn multiply_f32_scalar(a: &ImageF32, scalar: [f64; 4]) -> OpResult<ImageF32> {- map_scalar(a, scalar, |v, s| (v as f64 * s) as f32)-}--pub(crate) fn add_f32_scalar(a: &ImageF32, scalar: f64) -> OpResult<ImageF32> {- map_scalar(a, [scalar, 0.0, 0.0, 0.0], |v, s| v + s as f32)-}--pub(crate) fn subtract_f32_scalar(a: &ImageF32, scalar: f64) -> OpResult<ImageF32> {- map_scalar(a, [scalar, 0.0, 0.0, 0.0], |v, s| v - s as f32)-}--pub(crate) fn subtract_f32(a: &ImageF32, b: &ImageF32) -> OpResult<ImageF32> {- map2(a, b, "subtract_f32", |x, y| x - y)-}--pub(crate) fn add_weighted_f32(- a: &ImageF32,- alpha: f64,- b: &ImageF32,- beta: f64,- gamma: f64,-) -> OpResult<ImageF32> {- map2(a, b, "add_weighted_f32", |x, y| {- (x as f64 * alpha + y as f64 * beta + gamma) as f32- })-}--pub(crate) fn min_f32_scalar(a: &ImageF32, scalar: f64) -> OpResult<ImageF32> {- map_scalar(a, [scalar, 0.0, 0.0, 0.0], |v, s| {- let s = s as f32;- if v < s { v } else { s }- })-}--pub(crate) fn max_f32_scalar(a: &ImageF32, scalar: f64) -> OpResult<ImageF32> {- map_scalar(a, [scalar, 0.0, 0.0, 0.0], |v, s| {- let s = s as f32;- if v > s { v } else { s }- })-}--pub(crate) fn log_f32(a: &ImageF32) -> OpResult<ImageF32> {- map1(a, f32::ln)-}--pub(crate) fn exp_f32(a: &ImageF32) -> OpResult<ImageF32> {- map1(a, f32::exp)-}--pub(crate) fn magnitude_f32(x: &ImageF32, y: &ImageF32) -> OpResult<ImageF32> {- map2(x, y, "magnitude_f32", |a, b| (a * a + b * b).sqrt())-}diff --git a/rust/crates/ml/src/cv/convert.rs b/rust/crates/ml/src/cv/convert.rsdeleted file mode 100644index 38d38a6521..0000000000--- a/rust/crates/ml/src/cv/convert.rs+++ /dev/null@@ -1,23 +0,0 @@-use super::saturate_u8_f32;-use crate::cv::OpResult;-use crate::cv::image::{ImageF32, ImageU8};--pub(crate) fn u8_to_f32(src: &ImageU8) -> OpResult<ImageF32> {- let mut data = vec![0.0f32; src.data.len()];- super::pointwise(&mut data, 1, &src.data, 1, |o, s| {- for (o, &v) in o.iter_mut().zip(s) {- *o = v as f32;- }- });- ImageF32::new(src.width, src.height, src.channels, data)-}--pub(crate) fn f32_to_u8(src: &ImageF32) -> OpResult<ImageU8> {- let mut data = vec![0u8; src.data.len()];- super::pointwise(&mut data, 1, &src.data, 1, |o, s| {- for (o, &v) in o.iter_mut().zip(s) {- *o = saturate_u8_f32(v);- }- });- ImageU8::new(src.width, src.height, src.channels, data)-}diff --git a/rust/crates/ml/src/cv/image.rs b/rust/crates/ml/src/cv/image.rsindex bd09fdfa22..690206b912 100644--- a/rust/crates/ml/src/cv/image.rs+++ b/rust/crates/ml/src/cv/image.rs@@ -1,4 +1,9 @@-use super::OpResult;+use rayon::prelude::*;++use super::{OpResult, saturate_u8_f32};++/// Elementwise work below this many samples is not worth splitting across threads.+const PARALLEL_MIN_ELEMS: usize = 200_000;#[derive(Clone, Debug, PartialEq, Eq)]pub(crate) struct ImageU8 {@@ -64,6 +69,39 @@ impl ImageU8 {pub(crate) fn same_geometry(&self, other: &ImageU8) -> bool {self.width == other.width && self.height == other.height && self.channels == other.channels}++ pub(crate) fn to_f32(&self) -> ImageF32 {+ ImageF32 {+ width: self.width,+ height: self.height,+ channels: self.channels,+ data: map_vec(&self.data, |v| v as f32),+ }+ }+}++/// Elementwise map, parallel once the buffer is large enough to pay for it.+fn map_vec<T: Copy + Sync, U: Send>(src: &[T], f: impl Fn(T) -> U + Send + Sync) -> Vec<U> {+ if src.len() >= PARALLEL_MIN_ELEMS {+ src.par_iter().map(|&v| f(v)).collect()+ } else {+ src.iter().map(|&v| f(v)).collect()+ }+}++fn zip_vec<T: Copy + Sync, U: Send>(+ a: &[T],+ b: &[T],+ f: impl Fn(T, T) -> U + Send + Sync,+) -> Vec<U> {+ if a.len() >= PARALLEL_MIN_ELEMS {+ a.par_iter()+ .zip(b.par_iter())+ .map(|(&x, &y)| f(x, y))+ .collect()+ } else {+ a.iter().zip(b.iter()).map(|(&x, &y)| f(x, y)).collect()+ }}impl ImageF32 {@@ -99,6 +137,76 @@ impl ImageF32 {pub(crate) fn same_geometry(&self, other: &ImageF32) -> bool {self.width == other.width && self.height == other.height && self.channels == other.channels}++ fn like(&self, data: Vec<f32>) -> ImageF32 {+ ImageF32 {+ width: self.width,+ height: self.height,+ channels: self.channels,+ data,+ }+ }++ fn require_same(&self, other: &ImageF32) -> OpResult<()> {+ if self.same_geometry(other) {+ return Ok(());+ }+ Err(format!(+ "elementwise op on {}x{}x{} and {}x{}x{}",+ self.width, self.height, self.channels, other.width, other.height, other.channels+ ))+ }++ pub(crate) fn map(&self, f: impl Fn(f32) -> f32 + Send + Sync) -> ImageF32 {+ self.like(map_vec(&self.data, f))+ }++ pub(crate) fn map_mut(&mut self, f: impl Fn(f32) -> f32 + Send + Sync) {+ if self.data.len() >= PARALLEL_MIN_ELEMS {+ self.data.par_iter_mut().for_each(|v| *v = f(*v));+ } else {+ self.data.iter_mut().for_each(|v| *v = f(*v));+ }+ }++ /// Fused map-and-quantise: skips the intermediate float image.+ pub(crate) fn map_to_u8(&self, f: impl Fn(f32) -> f32 + Send + Sync) -> ImageU8 {+ ImageU8 {+ width: self.width,+ height: self.height,+ channels: self.channels,+ data: map_vec(&self.data, |v| saturate_u8_f32(f(v))),+ }+ }++ pub(crate) fn zip_map(+ &self,+ other: &ImageF32,+ f: impl Fn(f32, f32) -> f32 + Send + Sync,+ ) -> OpResult<ImageF32> {+ self.require_same(other)?;+ Ok(self.like(zip_vec(&self.data, &other.data, f)))+ }++ pub(crate) fn zip_mut(+ &mut self,+ other: &ImageF32,+ f: impl Fn(&mut f32, f32) + Send + Sync,+ ) -> OpResult<()> {+ self.require_same(other)?;+ if self.data.len() >= PARALLEL_MIN_ELEMS {+ self.data+ .par_iter_mut()+ .zip(other.data.par_iter())+ .for_each(|(a, &b)| f(a, b));+ } else {+ self.data+ .iter_mut()+ .zip(other.data.iter())+ .for_each(|(a, &b)| f(a, b));+ }+ Ok(())+ }}#[derive(Clone, Copy, Debug)]diff --git a/rust/crates/ml/src/cv/masking.rs b/rust/crates/ml/src/cv/masking.rsindex e1adb777f9..3d254efb76 100644--- a/rust/crates/ml/src/cv/masking.rs+++ b/rust/crates/ml/src/cv/masking.rs@@ -1,5 +1,5 @@use crate::cv::OpResult;-use crate::cv::image::{ImageF32, ImageU8};+use crate::cv::image::ImageU8;pub(crate) fn threshold_binary_u8(src: &ImageU8, thresh: f64, maxval: f64) -> OpResult<ImageU8> {let ithresh = thresh.floor() as i64;@@ -15,20 +15,6 @@ pub(crate) fn threshold_binary_u8(src: &ImageU8, thresh: f64, maxval: f64) -> Op)}-pub(crate) fn threshold_binary_f32(src: &ImageF32, thresh: f64, maxval: f64) -> OpResult<ImageF32> {- let t = thresh as f32;- let m = maxval as f32;- ImageF32::new(- src.width,- src.height,- src.channels,- src.data- .iter()- .map(|&v| if v > t { m } else { 0.0 })- .collect(),- )-}-pub(crate) fn in_range_u8(src: &ImageU8, lower: f64, upper: f64) -> OpResult<ImageU8> {if src.channels != 1 {return Err("in_range_u8: expected a single-channel image".to_string());diff --git a/rust/crates/ml/src/cv/mod.rs b/rust/crates/ml/src/cv/mod.rsindex df417bd909..e8236998d2 100644--- a/rust/crates/ml/src/cv/mod.rs+++ b/rust/crates/ml/src/cv/mod.rs@@ -1,9 +1,7 @@-mod arith;mod bilateral;mod canny;mod channels;mod contours;-mod convert;mod draw;mod filter;pub(crate) mod image;@@ -22,25 +20,19 @@ use self::image::{Image, ImageRef};pub(crate) type OpResult<T> = Result<T, String>;-pub(crate) use arith::{- add_f32_scalar, add_weighted_f32, exp_f32, log_f32, magnitude_f32, max_f32_scalar,- min_f32_scalar, multiply_f32, multiply_f32_scalar, subtract_f32, subtract_f32_scalar,-};pub(crate) use bilateral::bilateral_filter_u8;pub(crate) use canny::canny;pub(crate) use channels::{bgr_to_gray, gray_to_bgr, merge_u8, split_u8};pub(crate) use contours::find_contours;-pub(crate) use convert::{f32_to_u8, u8_to_f32};pub(crate) use draw::fill_poly;pub(crate) use filter::{box_filter_f32, gaussian_blur_u8};pub(crate) use lab::{bgr_to_lab, lab_to_bgr};pub(crate) use masking::{- bitwise_and_u8, copy_to_masked, count_non_zero, in_range_u8, threshold_binary_f32,- threshold_binary_u8,+ bitwise_and_u8, copy_to_masked, count_non_zero, in_range_u8, threshold_binary_u8,};pub(crate) use morph::{morphology_close, morphology_erode, morphology_open};pub(crate) use stats::{- hist_256_f32, hist_256_u8, mean_f32, mean_u8c3_masked, min_max_loc_f32, percentile_f32, sum_f32,+ hist_256_f32, hist_256_u8, mean_f32, mean_u8c3_masked, min_max_loc_f32, percentile_f32,};pub(crate) use structuring::ellipse_kernel;pub(crate) use transform::rotate_u8;diff --git a/rust/crates/ml/src/cv/stats.rs b/rust/crates/ml/src/cv/stats.rsindex d88b7348d7..9cd47a50dc 100644--- a/rust/crates/ml/src/cv/stats.rs+++ b/rust/crates/ml/src/cv/stats.rs@@ -10,10 +10,6 @@ fn sum_channel0(src: &ImageF32) -> f64 {}}-pub(crate) fn sum_f32(src: &ImageF32) -> OpResult<f64> {- Ok(sum_channel0(src))-}-pub(crate) fn mean_f32(src: &ImageF32) -> OpResult<f64> {Ok(sum_channel0(src) / src.pixels() as f64)}diff --git a/rust/crates/ml/src/scan/color.rs b/rust/crates/ml/src/scan/color.rsindex ed16fd58b4..cbd7338beb 100644--- a/rust/crates/ml/src/scan/color.rs+++ b/rust/crates/ml/src/scan/color.rs@@ -31,8 +31,13 @@ pub(crate) fn auto_color_mode(img: &ImageU8, mask: &Mask, quad: &Quad) -> OpResulet chroma = chroma(a, b)?;- let color_mask_f = cv::threshold_binary_f32(&chroma, CHROMA_THRESHOLD, 255.0)?;- let color_mask = cv::f32_to_u8(&color_mask_f)?;+ let color_mask = chroma.map_to_u8(|v| {+ if v > CHROMA_THRESHOLD as f32 {+ 255.0+ } else {+ 0.0+ }+ });let luminance_mask = cv::in_range_u8(luminance, LUMINANCE_MIN, LUMINANCE_MAX)?;@@ -53,12 +58,19 @@ pub(crate) fn auto_color_mode(img: &ImageU8, mask: &Mask, quad: &Quad) -> OpResu})}+/// Distance from the neutral axis in Lab's biased 0..255 encoding.fn chroma(a: &ImageU8, b: &ImageU8) -> OpResult<ImageF32> {- let a_float = cv::u8_to_f32(a)?;- let b_float = cv::u8_to_f32(b)?;- let a_shifted = cv::subtract_f32_scalar(&a_float, 128.0)?;- let b_shifted = cv::subtract_f32_scalar(&b_float, 128.0)?;- cv::magnitude_f32(&a_shifted, &b_shifted)+ let data = a+ .data+ .iter()+ .zip(b.data.iter())+ .map(|(&a, &b)| {+ let a = a as f32 - 128.0;+ let b = b as f32 - 128.0;+ (a * a + b * b).sqrt()+ })+ .collect();+ ImageF32::new(a.width, a.height, 1, data)}fn erode_border(mask: &ImageU8, quad: &Quad) -> OpResult<ImageU8> {@@ -121,18 +133,16 @@ pub(crate) fn apply_gray_world_to_document(img: &ImageU8, doc_mask: &ImageU8) ->let mean_r = if mean[2] < eps { eps } else { mean[2] };let mean_gray = (mean_b + mean_g + mean_r) / 3.0;- let scales = [- mean_gray / mean_b,- mean_gray / mean_g,- mean_gray / mean_r,- 0.0,- ];-- let img_f = cv::u8_to_f32(img)?;- let scaled_f = cv::multiply_f32_scalar(&img_f, scales)?;- let scaled8 = cv::f32_to_u8(&scaled_f)?;-- cv::copy_to_masked(&scaled8, img, doc_mask)+ let scales = [mean_gray / mean_b, mean_gray / mean_g, mean_gray / mean_r];++ let mut scaled = img.clone();+ for pixel in scaled.data.chunks_exact_mut(3) {+ for (channel, scale) in pixel.iter_mut().zip(scales) {+ *channel = cv::saturate_u8_f32((*channel as f64 * scale) as f32);+ }+ }++ cv::copy_to_masked(&scaled, img, doc_mask)}pub(crate) fn quad_to_image(quad: &Quad, mask: &Mask, image_size: (i32, i32)) -> Quad {diff --git a/rust/crates/ml/src/scan/detection.rs b/rust/crates/ml/src/scan/detection.rsindex e1ea0e16a7..d09fd5a139 100644--- a/rust/crates/ml/src/scan/detection.rs+++ b/rust/crates/ml/src/scan/detection.rs@@ -52,7 +52,7 @@ fn find_quad_from_orientation_with_adaptive_threshold(let probmap_smooth = cv::gaussian_blur_u8(prob_image, 3)?;let kernel = cv::ellipse_kernel(5)?;- let prob_float = cv::u8_to_f32(prob_image)?;+ let prob_float = prob_image.to_f32();let mut best_quad: Option<Vec<Point>> = None;let mut best_score = 0.0f64;diff --git a/rust/crates/ml/src/scan/postprocess.rs b/rust/crates/ml/src/scan/postprocess.rsindex faa85d9649..9287a627f5 100644--- a/rust/crates/ml/src/scan/postprocess.rs+++ b/rust/crates/ml/src/scan/postprocess.rs@@ -11,6 +11,13 @@ pub(crate) fn enhance_captured_image(img: &ImageU8, color_mode: ColorMode) -> Op}}+/// The min-then-max scalar pair the enhancement chains used to end with,+/// including its NaN behaviour (NaN clamps to 255, not to 0).+fn clamp_255(v: f32) -> f32 {+ let v = if v < 255.0 { v } else { 255.0 };+ if v > 0.0 { v } else { 0.0 }+}+const SHADOW_MAP_LONG_EDGE: f64 = 256.0;const SHADOW_KERNEL_FRAC: f64 = 1.0 / 16.0;const SHADOW_MAX_GAIN: f32 = 2.8;@@ -31,7 +38,7 @@ fn remove_shadows(channel: &ImageU8) -> OpResult<ImageU8> {let kernel = cv::ellipse_kernel(k)?;let closed = cv::morphology_close(&small, &kernel)?;- let closed_f = cv::u8_to_f32(&closed)?;+ let closed_f = closed.to_f32();let map_small = cv::box_filter_f32(&cv::box_filter_f32(&closed_f, k, k)?, k, k)?;let paper = cv::percentile_f32(&map_small, SHADOW_PAPER_PERCENTILE)?;@@ -69,8 +76,8 @@ fn multi_scale_retinex_on_l(bgr: &ImageU8) -> OpResult<ImageU8> {let mut lab_channels = cv::split_u8(&lab)?;let l = remove_shadows(&lab_channels[0])?;- let l_float_raw = cv::u8_to_f32(&l)?;- let l_float = cv::add_f32_scalar(&l_float_raw, 1.0)?;+ let l_original_float = l.to_f32();+ let l_float = l_original_float.map(|v| v + 1.0);let scale_factor = 2.0;let small_w = l_float.width as f64 / scale_factor;@@ -78,8 +85,7 @@ fn multi_scale_retinex_on_l(bgr: &ImageU8) -> OpResult<ImageU8> {let (small_cols, small_rows) = size_trunc(small_w, small_h);let l_small = cv::resize_area(ImageRef::F32(&l_float), small_cols, small_rows)?.into_f32()?;-- let log_l_small = cv::log_f32(&l_small)?;+ let log_l_small = l_small.map(f32::ln);let max_dim_small = small_w.max(small_h);let kernel_sizes = [@@ -93,38 +99,31 @@ fn multi_scale_retinex_on_l(bgr: &ImageU8) -> OpResult<ImageU8> {for ks in kernel_sizes {let k = (ks as i32).max(3) | 1;- let blur_log = cv::box_filter_f32(&log_l_small, k, k)?;- let diff = cv::subtract_f32(&log_l_small, &blur_log)?;- retinex_small = cv::add_weighted_f32(&retinex_small, 1.0, &diff, weight, 0.0)?;+ let mut term = cv::box_filter_f32(&log_l_small, k, k)?;+ term.zip_mut(&log_l_small, |blurred, log_l| *blurred = log_l - *blurred)?;+ retinex_small.zip_mut(&term, |acc, detail| {+ *acc = (*acc as f64 + detail as f64 * weight) as f32+ })?;}let (min_val, max_val) = cv::min_max_loc_f32(&retinex_small)?;- let mut retinex_norm_small = cv::subtract_f32_scalar(&retinex_small, min_val)?;-let range = max_val - min_val;- if range > 1e-6 {- retinex_norm_small =- cv::multiply_f32_scalar(&retinex_norm_small, [1.0 / range, 0.0, 0.0, 0.0])?;- }-- let retinex_norm = cv::resize_bicubic(- ImageRef::F32(&retinex_norm_small),- l_float.width,- l_float.height,- )?- .into_f32()?;+ let inv_range = if range > 1e-6 { 1.0 / range } else { 1.0 };+ retinex_small.map_mut(|v| ((v - min_val as f32) as f64 * inv_range) as f32);- let l_original_float = cv::u8_to_f32(&l)?;+ let retinex_norm =+ cv::resize_bicubic(ImageRef::F32(&retinex_small), l_float.width, l_float.height)?+ .into_f32()?;let mean_l = cv::mean_f32(&l_original_float)?;let amplitude = 60.0;-- let corrected_l = cv::multiply_f32_scalar(&retinex_norm, [amplitude, 0.0, 0.0, 0.0])?;- let corrected_l = cv::add_f32_scalar(&corrected_l, mean_l - amplitude / 2.0)?;-let alpha = 0.6;- let corrected_l =- cv::add_weighted_f32(&l_original_float, 1.0 - alpha, &corrected_l, alpha, 0.0)?;+ let bias = (mean_l - amplitude / 2.0) as f32;++ let corrected_l = l_original_float.zip_map(&retinex_norm, |original, detail| {+ let corrected = (detail as f64 * amplitude) as f32 + bias;+ (original as f64 * (1.0 - alpha) + corrected as f64 * alpha) as f32+ })?;let p_low_orig = percentile_l(&l_original_float, 0.001)?;let p_low = percentile_l(&corrected_l, 0.001)?;@@ -134,14 +133,8 @@ fn multi_scale_retinex_on_l(bgr: &ImageU8) -> OpResult<ImageU8> {let target_high = 245.0;let scale = (target_high - target_low) / (p_high - p_low + 1e-6);- let shifted = cv::subtract_f32_scalar(&corrected_l, p_low)?;- let stretched = cv::multiply_f32_scalar(&shifted, [scale, 0.0, 0.0, 0.0])?;- let offset = cv::add_f32_scalar(&stretched, target_low)?;-- let clamped_high = cv::min_f32_scalar(&offset, 255.0)?;- let clamped = cv::max_f32_scalar(&clamped_high, 0.0)?;-- lab_channels[0] = cv::f32_to_u8(&clamped)?;+ lab_channels[0] = corrected_l+ .map_to_u8(|v| clamp_255(((v - p_low as f32) as f64 * scale) as f32 + target_low as f32));let merged = cv::merge_u8(&lab_channels)?;cv::lab_to_bgr(&merged)@@ -174,9 +167,9 @@ fn enhance_grayscale_image(img: &ImageU8) -> OpResult<ImageU8> {let max_dim = gray.width.max(gray.height) as f64;- let img_float_raw = cv::u8_to_f32(&gray)?;- let img_float = cv::add_f32_scalar(&img_float_raw, 1.0)?;- let log_img = cv::log_f32(&img_float)?;+ let gray_f = gray.to_f32();+ let img_float = gray_f.map(|v| v + 1.0);+ let log_img = img_float.map(f32::ln);let kernel_sizes = [max_dim / 6.0, max_dim / 50.0];let weight = 1.0 / kernel_sizes.len() as f64;@@ -184,29 +177,24 @@ fn enhance_grayscale_image(img: &ImageU8) -> OpResult<ImageU8> {for kernel_size in kernel_sizes {let k = (kernel_size as i32).max(3) | 1;- let blur_raw = cv::box_filter_f32(&img_float, k, k)?;- let blur = cv::add_f32_scalar(&blur_raw, 1.0)?;- let log_blur = cv::log_f32(&blur)?;- let diff = cv::subtract_f32(&log_img, &log_blur)?;- retinex = cv::add_weighted_f32(&retinex, 1.0, &diff, weight, 0.0)?;+ let mut term = cv::box_filter_f32(&img_float, k, k)?;+ term.map_mut(|v| (v + 1.0).ln());+ term.zip_mut(&log_img, |log_blur, log_v| *log_blur = log_v - *log_blur)?;+ retinex.zip_mut(&term, |acc, detail| {+ *acc = (*acc as f64 + detail as f64 * weight) as f32+ })?;}- let retinex_exp = cv::exp_f32(&retinex)?;+ retinex.map_mut(f32::exp);- let p_low = cv::percentile_f32(&retinex_exp, 0.004)? as f64;- let p_high = cv::percentile_f32(&retinex_exp, 0.99)? as f64;-- let normalized = cv::subtract_f32_scalar(&retinex_exp, p_low)?;+ let p_low = cv::percentile_f32(&retinex, 0.004)? as f64;+ let p_high = cv::percentile_f32(&retinex, 0.99)? as f64;let scale = if p_high > p_low {255.0 / (p_high - p_low)} else {1.0};- let scaled = cv::multiply_f32_scalar(&normalized, [scale, 0.0, 0.0, 0.0])?;- let clamped_high = cv::min_f32_scalar(&scaled, 255.0)?;- let clamped = cv::max_f32_scalar(&clamped_high, 0.0)?;-- let result8u = cv::f32_to_u8(&clamped)?;+ let result8u = retinex.map_to_u8(|v| clamp_255(((v - p_low as f32) as f64 * scale) as f32));let hist = cv::hist_256_u8(&result8u)?;let mut mode_val = 220usize;@@ -218,23 +206,19 @@ fn enhance_grayscale_image(img: &ImageU8) -> OpResult<ImageU8> {}}+ // A mode pinned at white means the retinex pass blew out the page; fall+ // back to a plain percentile stretch of the original grey.let stretched8u = if mode_val >= 254 {- let gray_f = cv::u8_to_f32(&gray)?;let g_low = cv::percentile_f32(&gray_f, 0.01)? as f64;let g_high = cv::percentile_f32(&gray_f, 0.99)? as f64;-- let shifted = cv::subtract_f32_scalar(&gray_f, g_low)?;- let scaled =- cv::multiply_f32_scalar(&shifted, [255.0 / (g_high - g_low + 1e-6), 0.0, 0.0, 0.0])?;- let min_clamped = cv::min_f32_scalar(&scaled, 255.0)?;- let max_clamped = cv::max_f32_scalar(&min_clamped, 0.0)?;- cv::f32_to_u8(&max_clamped)?+ let scale = 255.0 / (g_high - g_low + 1e-6);+ gray_f.map_to_u8(|v| clamp_255(((v - g_low as f32) as f64 * scale) as f32))} else {- let stretched_f = cv::u8_to_f32(&result8u)?;- let multiplied =- cv::multiply_f32_scalar(&stretched_f, [255.0 / mode_val as f64, 0.0, 0.0, 0.0])?;- let min_clamped = cv::min_f32_scalar(&multiplied, 255.0)?;- cv::f32_to_u8(&min_clamped)?+ let scale = 255.0 / mode_val as f64;+ result8u.to_f32().map_to_u8(|v| {+ let scaled = (v as f64 * scale) as f32;+ if scaled < 255.0 { scaled } else { 255.0 }+ })};let denoised = cv::bilateral_filter_u8(&stretched8u, 9, 20.0, 10.0)?;diff --git a/rust/crates/ml/src/scan/quad_score.rs b/rust/crates/ml/src/scan/quad_score.rsindex 22e085a1e3..7a766cfc82 100644--- a/rust/crates/ml/src/scan/quad_score.rs+++ b/rust/crates/ml/src/scan/quad_score.rs@@ -14,11 +14,14 @@ pub(crate) fn score_quad_against_probmap(min_quad_area_ratio: f64,) -> OpResult<f64> {let mask = make_polygon_mask(probmap.width, probmap.height, quad)?;- let mask_float = cv::u8_to_f32(&mask)?;- let masked = cv::multiply_f32(probmap, &mask_float)?;- let sum_masked = cv::sum_f32(&masked)?;- let sum_mask = cv::sum_f32(&mask_float)?;+ let mut sum_masked = 0.0f64;+ let mut sum_mask = 0.0f64;+ for (&prob, &inside) in probmap.data.iter().zip(mask.data.iter()) {+ let inside = inside as f32;+ sum_masked += (prob * inside) as f64;+ sum_mask += inside as f64;+ }let mean_prob = sum_masked / sum_mask;let area_ratio = sum_mask / (probmap.height * probmap.width) as f64;