use image::{DynamicImage, ImageBuffer, Rgba};
use rayon::prelude::*;
use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize)]
pub enum FocusMode {
Auto,
Center,
}
impl FocusMode {
pub fn as_str(&self) -> &'static str {
match self {
FocusMode::Auto => "auto",
FocusMode::Center => "center",
}
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize)]
pub enum QuantMode {
Standard,
MsSsim,
Csf,
}
impl QuantMode {
pub fn as_str(&self) -> &'static str {
match self {
QuantMode::Standard => "standard",
QuantMode::MsSsim => "msssim",
QuantMode::Csf => "csf",
}
}
}
#[derive(Clone, Debug)]
pub struct PerceptualOptions {
pub denoise_strength: u8,
pub focus_mode: FocusMode,
pub quality_ceil: u8,
pub quant_mode: QuantMode,
pub budget_kb: Option<u32>,
pub platform: Option<String>,
}
impl Default for PerceptualOptions {
fn default() -> Self {
Self {
denoise_strength: 25,
focus_mode: FocusMode::Auto,
quality_ceil: 95,
quant_mode: QuantMode::Standard,
budget_kb: None,
platform: None,
}
}
}
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct PerceptualMetrics {
pub ssim_vs_source: f64,
pub psnr_vs_source: f64,
pub final_quality: u8,
pub denoise_applied: bool,
pub denoise_ms: u64,
pub downscale_ms: u64,
pub sharpen_ms: u64,
pub encode_ms: u64,
}
#[inline]
fn luma_f32(r: u8, g: u8, b: u8) -> f32 {
0.299 * r as f32 + 0.587 * g as f32 + 0.114 * b as f32
}
pub fn bilateral_denoise(
img: &ImageBuffer<Rgba<u8>, Vec<u8>>,
strength: u8,
) -> ImageBuffer<Rgba<u8>, Vec<u8>> {
if strength == 0 {
return img.clone();
}
let (w, h) = img.dimensions();
if w < 5 || h < 5 {
return img.clone();
}
const RADIUS: i32 = 2;
let sigma_s = 1.7f32;
let sigma_r = 4.0 + strength.min(100) as f32 * 0.35;
let two_sr2 = 2.0 * sigma_r * sigma_r;
let mut spatial = [[0f32; 5]; 5];
for (dy, row) in spatial.iter_mut().enumerate() {
for (dx, v) in row.iter_mut().enumerate() {
let fy = dy as f32 - RADIUS as f32;
let fx = dx as f32 - RADIUS as f32;
*v = (-(fx * fx + fy * fy) / (2.0 * sigma_s * sigma_s)).exp();
}
}
let src = img.as_raw();
let row_stride = (w * 4) as usize;
let mut out = vec![0u8; src.len()];
out.par_chunks_mut(row_stride)
.enumerate()
.for_each(|(row_y, row)| {
let y = row_y as i32;
for x in 0..w as i32 {
let ci = (row_y * row_stride) + (x as usize) * 4;
let cl = luma_f32(src[ci], src[ci + 1], src[ci + 2]);
let (mut acc_r, mut acc_g, mut acc_b, mut acc_w) = (0f32, 0f32, 0f32, 0f32);
for dy in -RADIUS..=RADIUS {
let yy = (y + dy).clamp(0, h as i32 - 1) as usize;
for dx in -RADIUS..=RADIUS {
let xx = (x + dx).clamp(0, w as i32 - 1) as usize;
let ni = yy * row_stride + xx * 4;
let nl = luma_f32(src[ni], src[ni + 1], src[ni + 2]);
let dl = nl - cl;
let wgt = spatial[(dy + RADIUS) as usize][(dx + RADIUS) as usize]
* (-(dl * dl) / two_sr2).exp();
acc_r += src[ni] as f32 * wgt;
acc_g += src[ni + 1] as f32 * wgt;
acc_b += src[ni + 2] as f32 * wgt;
acc_w += wgt;
}
}
let o = (x as usize) * 4;
if acc_w > 0.0 {
row[o] = (acc_r / acc_w).round().clamp(0.0, 255.0) as u8;
row[o + 1] = (acc_g / acc_w).round().clamp(0.0, 255.0) as u8;
row[o + 2] = (acc_b / acc_w).round().clamp(0.0, 255.0) as u8;
} else {
row[o] = src[ci];
row[o + 1] = src[ci + 1];
row[o + 2] = src[ci + 2];
}
row[o + 3] = src[ci + 3];
}
});
ImageBuffer::from_raw(w, h, out).expect("bilateral output buffer size mismatch")
}
const SAL_SIZE: usize = 64;
fn fft1d(re: &mut [f64], im: &mut [f64], inverse: bool) {
let n = re.len();
debug_assert!(n.is_power_of_two() && im.len() == n);
let mut j = 0usize;
for i in 1..n {
let mut bit = n >> 1;
while j & bit != 0 {
j ^= bit;
bit >>= 1;
}
j |= bit;
if i < j {
re.swap(i, j);
im.swap(i, j);
}
}
let sign = if inverse { 1.0 } else { -1.0 };
let mut len = 2usize;
while len <= n {
let ang = sign * 2.0 * std::f64::consts::PI / len as f64;
let (wr, wi) = (ang.cos(), ang.sin());
let mut i = 0usize;
while i < n {
let (mut cur_r, mut cur_i) = (1.0f64, 0.0f64);
for k in 0..len / 2 {
let (ur, ui) = (re[i + k], im[i + k]);
let (vr0, vi0) = (re[i + k + len / 2], im[i + k + len / 2]);
let vr = vr0 * cur_r - vi0 * cur_i;
let vi = vr0 * cur_i + vi0 * cur_r;
re[i + k] = ur + vr;
im[i + k] = ui + vi;
re[i + k + len / 2] = ur - vr;
im[i + k + len / 2] = ui - vi;
let nr = cur_r * wr - cur_i * wi;
cur_i = cur_r * wi + cur_i * wr;
cur_r = nr;
}
i += len;
}
len <<= 1;
}
if inverse {
let inv_n = 1.0 / n as f64;
for v in re.iter_mut() {
*v *= inv_n;
}
for v in im.iter_mut() {
*v *= inv_n;
}
}
}
fn fft2d(re: &mut [f64], im: &mut [f64], n: usize, inverse: bool) {
for y in 0..n {
fft1d(
&mut re[y * n..(y + 1) * n],
&mut im[y * n..(y + 1) * n],
inverse,
);
}
let mut col_r = vec![0f64; n];
let mut col_i = vec![0f64; n];
for x in 0..n {
for y in 0..n {
col_r[y] = re[y * n + x];
col_i[y] = im[y * n + x];
}
fft1d(&mut col_r, &mut col_i, inverse);
for y in 0..n {
re[y * n + x] = col_r[y];
im[y * n + x] = col_i[y];
}
}
}
pub fn saliency_mask(img: &ImageBuffer<Rgba<u8>, Vec<u8>>) -> Vec<f32> {
let (w, h) = img.dimensions();
let n = SAL_SIZE;
let mut small = vec![0f64; n * n];
let src = img.as_raw();
let row_stride = (w * 4) as usize;
for sy in 0..n {
let y0 = sy as u32 * h / n as u32;
let y1 = ((sy as u32 + 1) * h / n as u32).max(y0 + 1).min(h);
for sx in 0..n {
let x0 = sx as u32 * w / n as u32;
let x1 = ((sx as u32 + 1) * w / n as u32).max(x0 + 1).min(w);
let mut acc = 0f64;
let mut cnt = 0f64;
for y in y0..y1 {
let base = y as usize * row_stride;
for x in x0..x1 {
let i = base + x as usize * 4;
acc += luma_f32(src[i], src[i + 1], src[i + 2]) as f64;
cnt += 1.0;
}
}
small[sy * n + sx] = if cnt > 0.0 { acc / cnt } else { 0.0 };
}
}
let mut re = small.clone();
let mut im = vec![0f64; n * n];
fft2d(&mut re, &mut im, n, false);
let mut log_amp = vec![0f64; n * n];
let mut phase = vec![0f64; n * n];
for i in 0..n * n {
let amp = (re[i] * re[i] + im[i] * im[i]).sqrt();
log_amp[i] = (amp + 1e-8).ln();
phase[i] = im[i].atan2(re[i]);
}
let mut smooth = vec![0f64; n * n];
for y in 0..n {
for x in 0..n {
let mut acc = 0f64;
let mut cnt = 0f64;
for dy in -1i32..=1 {
for dx in -1i32..=1 {
let yy = (y as i32 + dy).clamp(0, n as i32 - 1) as usize;
let xx = (x as i32 + dx).clamp(0, n as i32 - 1) as usize;
acc += log_amp[yy * n + xx];
cnt += 1.0;
}
}
smooth[y * n + x] = acc / cnt;
}
}
for i in 0..n * n {
let residual = log_amp[i] - smooth[i];
let amp = residual.exp();
re[i] = amp * phase[i].cos();
im[i] = amp * phase[i].sin();
}
fft2d(&mut re, &mut im, n, true);
let mut sal = vec![0f32; n * n];
for i in 0..n * n {
sal[i] = (re[i] * re[i] + im[i] * im[i]) as f32;
}
let sal = gaussian_smooth_small(&sal, n, 2.5);
let max_v = sal.iter().cloned().fold(f32::MIN, f32::max);
let min_v = sal.iter().cloned().fold(f32::MAX, f32::min);
let range = (max_v - min_v).max(1e-9);
let norm: Vec<f32> = sal.iter().map(|v| (v - min_v) / range).collect();
upscale_bilinear(&norm, n, n, w as usize, h as usize)
}
fn gaussian_smooth_small(data: &[f32], n: usize, sigma: f32) -> Vec<f32> {
let ksize = ((sigma * 6.0) as usize).max(3) | 1;
let half = (ksize / 2) as i32;
let mut kernel = vec![0f32; ksize];
let two_s2 = 2.0 * sigma * sigma;
let mut sum = 0f32;
for (i, v) in kernel.iter_mut().enumerate() {
let d = i as f32 - half as f32;
*v = (-d * d / two_s2).exp();
sum += *v;
}
for v in kernel.iter_mut() {
*v /= sum;
}
let mut tmp = vec![0f32; n * n];
for y in 0..n {
for x in 0..n {
let mut acc = 0f32;
for (k, &kw) in kernel.iter().enumerate() {
let xx = (x as i32 + k as i32 - half).clamp(0, n as i32 - 1) as usize;
acc += data[y * n + xx] * kw;
}
tmp[y * n + x] = acc;
}
}
let mut out = vec![0f32; n * n];
for y in 0..n {
for x in 0..n {
let mut acc = 0f32;
for (k, &kw) in kernel.iter().enumerate() {
let yy = (y as i32 + k as i32 - half).clamp(0, n as i32 - 1) as usize;
acc += tmp[yy * n + x] * kw;
}
out[y * n + x] = acc;
}
}
out
}
fn upscale_bilinear(src: &[f32], sw: usize, sh: usize, dw: usize, dh: usize) -> Vec<f32> {
let mut out = vec![0f32; dw * dh];
let sx_ratio = sw as f32 / dw as f32;
let sy_ratio = sh as f32 / dh as f32;
for y in 0..dh {
let fy = (y as f32 + 0.5) * sy_ratio - 0.5;
let y0 = fy.floor().clamp(0.0, sh as f32 - 1.0) as usize;
let y1 = (y0 + 1).min(sh - 1);
let ty = (fy - y0 as f32).clamp(0.0, 1.0);
for x in 0..dw {
let fx = (x as f32 + 0.5) * sx_ratio - 0.5;
let x0 = fx.floor().clamp(0.0, sw as f32 - 1.0) as usize;
let x1 = (x0 + 1).min(sw - 1);
let tx = (fx - x0 as f32).clamp(0.0, 1.0);
let top = src[y0 * sw + x0] * (1.0 - tx) + src[y0 * sw + x1] * tx;
let bot = src[y1 * sw + x0] * (1.0 - tx) + src[y1 * sw + x1] * tx;
out[y * dw + x] = top * (1.0 - ty) + bot * ty;
}
}
out
}
pub fn center_mask(w: u32, h: u32) -> Vec<f32> {
let (wf, hf) = (w as f32, h as f32);
let (cx, cy) = (wf / 2.0, hf / 2.0);
let sigma = 0.45 * wf.min(hf);
let two_s2 = 2.0 * sigma * sigma;
let mut out = vec![0f32; (w * h) as usize];
for y in 0..h {
let dy = y as f32 - cy;
for x in 0..w {
let dx = x as f32 - cx;
out[(y * w + x) as usize] = (-(dx * dx + dy * dy) / two_s2).exp();
}
}
out
}
pub fn masked_usm_sharpen(
image: &DynamicImage,
mask: &[f32],
radius: f32,
amount: f32,
threshold: u8,
) -> DynamicImage {
let rgba = image.to_rgba8();
let (width, height) = rgba.dimensions();
debug_assert_eq!(mask.len(), (width * height) as usize);
let blurred = crate::gaussian_blur(&rgba, radius);
let is_portrait = crate::estimate_skin_ratio(image) > 0.3;
let mut output = ImageBuffer::new(width, height);
for y in 0..height {
for x in 0..width {
let orig = rgba.get_pixel(x, y);
let blur = blurred.get_pixel(x, y);
let m = mask[(y * width + x) as usize].clamp(0.0, 1.0);
let skin_score = crate::is_skin_color(orig[0], orig[1], orig[2]);
let skin_factor = if is_portrait && skin_score > 0.3 {
1.0 - skin_score * 0.8
} else {
1.0
};
let effective = amount * m * skin_factor;
let mut out_px = Rgba([0u8; 4]);
for c in 0..3 {
let diff = orig[c] as i16 - blur[c] as i16;
if diff.abs() > threshold as i16 && effective > 0.01 {
let sharpened = orig[c] as i32 + (effective * diff as f32) as i32;
out_px[c] = sharpened.clamp(0, 255) as u8;
} else {
out_px[c] = orig[c];
}
}
out_px[3] = orig[3];
output.put_pixel(x, y, out_px);
}
}
DynamicImage::ImageRgba8(output)
}
const STD_LUMA_BASE: [u16; 64] = [
16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19, 26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69, 56,
14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56, 68, 109, 103, 77, 24, 35, 55, 64, 81, 104, 113,
92, 49, 64, 78, 87, 103, 121, 120, 101, 72, 92, 95, 98, 112, 100, 103, 99,
];
const STD_CHROMA_BASE: [u16; 64] = [
17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66, 99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99, 99,
47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
];
pub fn csf_quant_tables(quality: u8) -> ([u16; 64], [u16; 64]) {
let csf = |f: f64| -> f64 {
if f < 1e-6 {
1.0
} else {
2.6 * (0.0192 + 0.114 * f) * (-(0.114 * f).powf(1.1)).exp()
}
};
const FS: f64 = 32.0; let freq = |u: usize, v: usize| -> f64 {
let fu = u as f64 * FS / 16.0;
let fv = v as f64 * FS / 16.0;
(fu * fu + fv * fv).sqrt()
};
let mut csf_peak = 0f64;
for i in 0..80 {
csf_peak = csf_peak.max(csf(i as f64 * 0.5));
}
let q = quality.clamp(1, 100) as u32;
let scale = if q < 50 { 5000 / q } else { 200 - q * 2 };
let std_table = |base: &[u16; 64]| -> [u16; 64] {
let mut out = [0u16; 64];
for (o, &b) in out.iter_mut().zip(base.iter()) {
let v = (b as f64 * scale as f64 + 50.0) / 100.0;
*o = (v.round() as u16).clamp(1, 255);
}
out
};
let std_luma = std_table(&STD_LUMA_BASE);
let std_chroma = std_table(&STD_CHROMA_BASE);
let mut luma_sens = [0f64; 64];
let mut chroma_sens = [0f64; 64];
let mut luma_sum = 0f64;
let mut chroma_sum = 0f64;
for v in 0..8 {
for u in 0..8 {
let i = v * 8 + u;
let f = freq(u, v);
let s = csf(f) / csf_peak;
luma_sens[i] = s.clamp(0.05, 1.0);
chroma_sens[i] = s.powf(1.35).clamp(0.05, 1.0);
if i != 0 {
luma_sum += luma_sens[i];
chroma_sum += chroma_sens[i];
}
}
}
let luma_mean = luma_sum / 63.0;
let chroma_mean = chroma_sum / 63.0;
let build = |std: &[u16; 64], sens: &[f64; 64], mean: f64| -> [u16; 64] {
let mut out = [0u16; 64];
for v in 0..8 {
for u in 0..8 {
let i = v * 8 + u;
if i == 0 {
out[i] = std[0];
continue;
}
let m = (sens[i] / mean).clamp(0.3, 3.0);
let val = std[i] as f64 / m;
out[i] = (val.round() as u16).clamp(1, 255);
}
}
out
};
(
build(&std_luma, &luma_sens, luma_mean),
build(&std_chroma, &chroma_sens, chroma_mean),
)
}
pub fn to_gray(img: &DynamicImage) -> (Vec<u8>, usize, usize) {
let g = img.to_luma8();
let (w, h) = g.dimensions();
(g.into_raw(), w as usize, h as usize)
}
pub fn ssim_gray(a: &[u8], b: &[u8], w: usize, h: usize) -> f64 {
if a.len() != w * h || b.len() != w * h || w < 8 || h < 8 {
return 0.0;
}
const C1: f64 = 6.5025; const C2: f64 = 58.5225; const WIN: usize = 8;
let mut total = 0f64;
let mut count = 0usize;
let mut by = 0;
while by + WIN <= h {
let mut bx = 0;
while bx + WIN <= w {
let (mut sa, mut sb, mut saa, mut sbb, mut sab) = (0f64, 0f64, 0f64, 0f64, 0f64);
for y in by..by + WIN {
for x in bx..bx + WIN {
let va = a[y * w + x] as f64;
let vb = b[y * w + x] as f64;
sa += va;
sb += vb;
saa += va * va;
sbb += vb * vb;
sab += va * vb;
}
}
let np = (WIN * WIN) as f64;
let mu_a = sa / np;
let mu_b = sb / np;
let var_a = saa / np - mu_a * mu_a;
let var_b = sbb / np - mu_b * mu_b;
let cov = sab / np - mu_a * mu_b;
let ssim = ((2.0 * mu_a * mu_b + C1) * (2.0 * cov + C2))
/ ((mu_a * mu_a + mu_b * mu_b + C1) * (var_a + var_b + C2));
total += ssim;
count += 1;
bx += WIN;
}
by += WIN;
}
if count == 0 {
0.0
} else {
total / count as f64
}
}
pub fn psnr_gray(a: &[u8], b: &[u8]) -> f64 {
if a.len() != b.len() || a.is_empty() {
return 0.0;
}
let mse: f64 = a
.iter()
.zip(b.iter())
.map(|(&x, &y)| {
let d = x as f64 - y as f64;
d * d
})
.sum::<f64>()
/ a.len() as f64;
if mse <= 1e-12 {
return 99.0;
}
10.0 * (255.0f64 * 255.0 / mse).log10()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn fft_roundtrip() {
let n = 8;
let mut re: Vec<f64> = (0..n).map(|i| i as f64).collect();
let mut im = vec![0f64; n];
let orig = re.clone();
fft1d(&mut re, &mut im, false);
fft1d(&mut re, &mut im, true);
for i in 0..n {
assert!((re[i] - orig[i]).abs() < 1e-9);
}
}
#[test]
fn ssim_identical_is_one() {
let w = 16;
let h = 16;
let a: Vec<u8> = (0..w * h).map(|i| (i % 251) as u8).collect();
let s = ssim_gray(&a, &a, w, h);
assert!((s - 1.0).abs() < 1e-9);
}
#[test]
fn psnr_identical_is_high() {
let a = vec![128u8; 64];
assert!(psnr_gray(&a, &a) > 90.0);
}
#[test]
fn bilateral_keeps_dims() {
let img = ImageBuffer::from_fn(32, 24, |x, y| {
Rgba([(x * 8) as u8, (y * 10) as u8, 100, 255])
});
let out = bilateral_denoise(&img, 25);
assert_eq!(out.dimensions(), (32, 24));
}
#[test]
fn saliency_mask_full_size() {
let img = ImageBuffer::from_fn(100, 80, |x, _| {
if x > 40 && x < 60 {
Rgba([255, 255, 255, 255])
} else {
Rgba([10, 10, 10, 255])
}
});
let m = saliency_mask(&img);
assert_eq!(m.len(), 100 * 80);
assert!(m.iter().all(|v| (0.0..=1.0).contains(v)));
}
}