Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

[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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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) -> OpResu
let 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.rs
index 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.rs
index 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.rs
index 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;