use thiserror::Error;
#[derive(Debug, Error, PartialEq)]
pub enum VignettingError {
#[error("Invalid vignetting config: {0}")]
InvalidConfig(String),
#[error("Invalid image: {0}")]
InvalidImage(String),
#[error("Image is empty (zero width or height)")]
EmptyImage,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum VignettingModel {
PowerLaw { power: f32 },
Cosine4,
Polynomial { k1: f32, k2: f32, k3: f32 },
Gaussian { sigma: f32 },
}
impl VignettingModel {
pub fn factor(&self, r: f32) -> f32 {
match self {
Self::PowerLaw { power } => {
let r_clamped = r.clamp(0.0, 1.0);
(1.0 - r_clamped.powi(2)).powf(*power).max(0.0)
}
Self::Cosine4 => {
let angle = r * std::f32::consts::FRAC_PI_4;
angle.cos().powi(4)
}
Self::Polynomial { k1, k2, k3 } => {
let r2 = r * r;
let r4 = r2 * r2;
let r6 = r4 * r2;
(1.0 + k1 * r2 + k2 * r4 + k3 * r6).clamp(0.0, 1.0)
}
Self::Gaussian { sigma } => {
let s2 = sigma * sigma;
(-(r * r) / (2.0 * s2)).exp()
}
}
}
pub fn validate(&self) -> Result<(), VignettingError> {
match self {
Self::PowerLaw { power } => {
if *power <= 0.0 {
return Err(VignettingError::InvalidConfig(format!(
"PowerLaw: power must be > 0, got {}",
power
)));
}
}
Self::Cosine4 => {}
Self::Polynomial { k1, k2, k3 } => {
if !k1.is_finite() || !k2.is_finite() || !k3.is_finite() {
return Err(VignettingError::InvalidConfig(format!(
"Polynomial: k1={k1}, k2={k2}, k3={k3} must all be finite"
)));
}
}
Self::Gaussian { sigma } => {
if *sigma <= 0.0 {
return Err(VignettingError::InvalidConfig(format!(
"Gaussian: sigma must be > 0, got {}",
sigma
)));
}
}
}
Ok(())
}
}
#[derive(Debug, Clone)]
pub struct VignettingConfig {
pub model: VignettingModel,
pub strength: f32,
pub aspect_correction: bool,
pub center_x: f32,
pub center_y: f32,
pub tint_r: f32,
pub tint_g: f32,
pub tint_b: f32,
}
impl Default for VignettingConfig {
fn default() -> Self {
Self {
model: VignettingModel::PowerLaw { power: 2.0 },
strength: 0.5,
aspect_correction: true,
center_x: 0.0,
center_y: 0.0,
tint_r: 0.0,
tint_g: 0.0,
tint_b: 0.0,
}
}
}
impl VignettingConfig {
pub fn validate(&self) -> Result<(), VignettingError> {
if !(0.0..=1.0).contains(&self.strength) {
return Err(VignettingError::InvalidConfig(format!(
"strength must be in [0, 1], got {}",
self.strength
)));
}
if !(-0.5..=0.5).contains(&self.center_x) {
return Err(VignettingError::InvalidConfig(format!(
"center_x must be in [-0.5, 0.5], got {}",
self.center_x
)));
}
if !(-0.5..=0.5).contains(&self.center_y) {
return Err(VignettingError::InvalidConfig(format!(
"center_y must be in [-0.5, 0.5], got {}",
self.center_y
)));
}
self.model.validate()
}
pub fn cinematic() -> Self {
Self {
model: VignettingModel::PowerLaw { power: 3.0 },
strength: 0.7,
aspect_correction: true,
center_x: 0.0,
center_y: 0.0,
tint_r: 0.1,
tint_g: 0.05,
tint_b: 0.0,
}
}
pub fn subtle() -> Self {
Self {
model: VignettingModel::Cosine4,
strength: 0.3,
aspect_correction: true,
center_x: 0.0,
center_y: 0.0,
tint_r: 0.0,
tint_g: 0.0,
tint_b: 0.0,
}
}
pub fn hard_edge() -> Self {
Self {
model: VignettingModel::Gaussian { sigma: 0.5 },
strength: 0.8,
aspect_correction: true,
center_x: 0.0,
center_y: 0.0,
tint_r: 0.0,
tint_g: 0.0,
tint_b: 0.0,
}
}
}
pub fn pixel_radius(
px: usize,
py: usize,
width: usize,
height: usize,
center_x: f32,
center_y: f32,
aspect_correction: bool,
) -> f32 {
let mut nx = (px as f32 + 0.5) / width as f32 - 0.5 - center_x;
let ny = (py as f32 + 0.5) / height as f32 - 0.5 - center_y;
if aspect_correction {
nx *= width as f32 / height as f32;
}
(nx * nx + ny * ny).sqrt() * 2.0
}
fn validate_rgb(image: &[f32], width: usize, height: usize) -> Result<(), VignettingError> {
if width == 0 || height == 0 {
return Err(VignettingError::EmptyImage);
}
let expected = width * height * 3;
if image.len() != expected {
return Err(VignettingError::InvalidImage(format!(
"expected {expected} values for {width}×{height} RGB, got {}",
image.len()
)));
}
Ok(())
}
fn validate_rgba(image: &[f32], width: usize, height: usize) -> Result<(), VignettingError> {
if width == 0 || height == 0 {
return Err(VignettingError::EmptyImage);
}
let expected = width * height * 4;
if image.len() != expected {
return Err(VignettingError::InvalidImage(format!(
"expected {expected} values for {width}×{height} RGBA, got {}",
image.len()
)));
}
Ok(())
}
#[inline]
fn has_tint(config: &VignettingConfig) -> bool {
config.tint_r > 0.0 || config.tint_g > 0.0 || config.tint_b > 0.0
}
#[inline]
fn effective_factor(model: &VignettingModel, r: f32, strength: f32) -> f32 {
let v = model.factor(r);
1.0 - strength * (1.0 - v)
}
pub fn apply_vignetting(
image: &[f32],
width: usize,
height: usize,
config: &VignettingConfig,
) -> Result<Vec<f32>, VignettingError> {
validate_rgb(image, width, height)?;
config.validate()?;
let use_tint = has_tint(config);
let mut output = Vec::with_capacity(image.len());
for py in 0..height {
for px in 0..width {
let r = pixel_radius(
px,
py,
width,
height,
config.center_x,
config.center_y,
config.aspect_correction,
);
let ev = effective_factor(&config.model, r, config.strength);
let dark = 1.0 - ev;
let base = (py * width + px) * 3;
let (ir, ig, ib) = (image[base], image[base + 1], image[base + 2]);
let (or_, og, ob) = if use_tint {
(
(ir * ev + config.tint_r * dark).clamp(0.0, 1.0),
(ig * ev + config.tint_g * dark).clamp(0.0, 1.0),
(ib * ev + config.tint_b * dark).clamp(0.0, 1.0),
)
} else {
(
(ir * ev).clamp(0.0, 1.0),
(ig * ev).clamp(0.0, 1.0),
(ib * ev).clamp(0.0, 1.0),
)
};
output.push(or_);
output.push(og);
output.push(ob);
}
}
Ok(output)
}
pub fn apply_vignetting_rgba(
image: &[f32],
width: usize,
height: usize,
config: &VignettingConfig,
) -> Result<Vec<f32>, VignettingError> {
validate_rgba(image, width, height)?;
config.validate()?;
let use_tint = has_tint(config);
let mut output = Vec::with_capacity(image.len());
for py in 0..height {
for px in 0..width {
let r = pixel_radius(
px,
py,
width,
height,
config.center_x,
config.center_y,
config.aspect_correction,
);
let ev = effective_factor(&config.model, r, config.strength);
let dark = 1.0 - ev;
let base = (py * width + px) * 4;
let (ir, ig, ib, ia) = (
image[base],
image[base + 1],
image[base + 2],
image[base + 3],
);
let (or_, og, ob) = if use_tint {
(
(ir * ev + config.tint_r * dark).clamp(0.0, 1.0),
(ig * ev + config.tint_g * dark).clamp(0.0, 1.0),
(ib * ev + config.tint_b * dark).clamp(0.0, 1.0),
)
} else {
(
(ir * ev).clamp(0.0, 1.0),
(ig * ev).clamp(0.0, 1.0),
(ib * ev).clamp(0.0, 1.0),
)
};
output.push(or_);
output.push(og);
output.push(ob);
output.push(ia); }
}
Ok(output)
}
pub fn generate_vignetting_mask(
width: usize,
height: usize,
config: &VignettingConfig,
) -> Result<Vec<f32>, VignettingError> {
if width == 0 || height == 0 {
return Err(VignettingError::EmptyImage);
}
config.validate()?;
let mut mask = Vec::with_capacity(width * height);
for py in 0..height {
for px in 0..width {
let r = pixel_radius(
px,
py,
width,
height,
config.center_x,
config.center_y,
config.aspect_correction,
);
let ev = effective_factor(&config.model, r, config.strength);
mask.push(ev);
}
}
Ok(mask)
}
pub fn animated_vignetting_strength(
frame_idx: usize,
total_frames: usize,
base_strength: f32,
pulse_amplitude: f32,
) -> f32 {
let phase = if total_frames == 0 {
0.0
} else {
std::f32::consts::TAU * frame_idx as f32 / total_frames as f32
};
(base_strength + pulse_amplitude * phase.sin()).clamp(0.0, 1.0)
}
pub fn apply_vignetting_sequence(
frames: &[Vec<f32>],
width: usize,
height: usize,
config: &VignettingConfig,
strength_per_frame: &[f32],
) -> Result<Vec<Vec<f32>>, VignettingError> {
if frames.len() != strength_per_frame.len() {
return Err(VignettingError::InvalidConfig(format!(
"frames.len() ({}) != strength_per_frame.len() ({})",
frames.len(),
strength_per_frame.len()
)));
}
let mut results = Vec::with_capacity(frames.len());
for (frame, &strength) in frames.iter().zip(strength_per_frame.iter()) {
let mut frame_config = config.clone();
frame_config.strength = strength.clamp(0.0, 1.0);
results.push(apply_vignetting(frame, width, height, &frame_config)?);
}
Ok(results)
}
#[derive(Debug, Clone)]
pub struct VignettingStats {
pub mean_factor_at_center: f32,
pub mean_factor_at_corner: f32,
pub mean_factor_at_edge: f32,
pub effective_dark_area: f32,
pub mean_image_change: f32,
}
pub fn compute_vignetting_stats(
original: &[f32],
vignetted: &[f32],
width: usize,
height: usize,
config: &VignettingConfig,
) -> Result<VignettingStats, VignettingError> {
validate_rgb(original, width, height)?;
validate_rgb(vignetted, width, height)?;
config.validate()?;
let factor_at_center = effective_factor(&config.model, 0.0, config.strength);
let factor_at_corner = effective_factor(&config.model, 1.0, config.strength);
let factor_at_edge = effective_factor(&config.model, 0.5, config.strength);
let total_pixels = width * height;
let mut dark_count = 0usize;
for py in 0..height {
for px in 0..width {
let r = pixel_radius(
px,
py,
width,
height,
config.center_x,
config.center_y,
config.aspect_correction,
);
let ev = effective_factor(&config.model, r, config.strength);
if ev < 0.5 {
dark_count += 1;
}
}
}
let n_values = original.len();
let mut sum_change = 0.0f64;
for (o, v) in original.iter().zip(vignetted.iter()) {
let change = (*v - *o).abs() as f64;
let denom = o.abs() as f64 + 1e-8;
sum_change += change / denom;
}
let mean_image_change = (sum_change / n_values as f64) as f32;
Ok(VignettingStats {
mean_factor_at_center: factor_at_center,
mean_factor_at_corner: factor_at_corner,
mean_factor_at_edge: factor_at_edge,
effective_dark_area: dark_count as f32 / total_pixels as f32,
mean_image_change,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_power_law_center() {
let m = VignettingModel::PowerLaw { power: 2.0 };
assert!(
(m.factor(0.0) - 1.0).abs() < 1e-6,
"PowerLaw center should be 1.0"
);
}
#[test]
fn test_power_law_edge() {
let m = VignettingModel::PowerLaw { power: 2.0 };
assert!(
(m.factor(1.0) - 0.0).abs() < 1e-6,
"PowerLaw at r=1 should be 0.0"
);
}
#[test]
fn test_cosine4_center() {
let m = VignettingModel::Cosine4;
assert!(
(m.factor(0.0) - 1.0).abs() < 1e-6,
"Cosine4 center should be 1.0"
);
}
#[test]
fn test_cosine4_corner() {
let m = VignettingModel::Cosine4;
let v = m.factor(1.0);
assert!(
(v - 0.25).abs() < 1e-5,
"Cosine4 at r=1 should be ~0.25, got {v}"
);
}
#[test]
fn test_gaussian_center() {
let m = VignettingModel::Gaussian { sigma: 0.5 };
assert!(
(m.factor(0.0) - 1.0).abs() < 1e-6,
"Gaussian center should be 1.0"
);
}
#[test]
fn test_gaussian_falloff() {
let m = VignettingModel::Gaussian { sigma: 0.5 };
assert!(m.factor(0.5) < m.factor(0.0));
assert!(m.factor(1.0) < m.factor(0.5));
}
#[test]
fn test_polynomial_center() {
let m = VignettingModel::Polynomial {
k1: -0.3,
k2: -0.1,
k3: 0.0,
};
assert!(
(m.factor(0.0) - 1.0).abs() < 1e-6,
"Polynomial center should be 1.0"
);
}
#[test]
fn test_polynomial_negative_darkens() {
let m = VignettingModel::Polynomial {
k1: -0.5,
k2: -0.3,
k3: 0.0,
};
assert!(
m.factor(1.0) < m.factor(0.0),
"Negative k1/k2 should darken edges"
);
}
#[test]
fn test_power_law_zero_power_invalid() {
let m = VignettingModel::PowerLaw { power: 0.0 };
assert!(m.validate().is_err(), "power=0 should be invalid");
}
#[test]
fn test_power_law_negative_power_invalid() {
let m = VignettingModel::PowerLaw { power: -1.0 };
assert!(m.validate().is_err(), "negative power should be invalid");
}
#[test]
fn test_cosine4_always_valid() {
assert!(VignettingModel::Cosine4.validate().is_ok());
}
#[test]
fn test_gaussian_zero_sigma_invalid() {
let m = VignettingModel::Gaussian { sigma: 0.0 };
assert!(m.validate().is_err(), "sigma=0 should be invalid");
}
#[test]
fn test_polynomial_non_finite_invalid() {
let m = VignettingModel::Polynomial {
k1: f32::INFINITY,
k2: 0.0,
k3: 0.0,
};
assert!(m.validate().is_err(), "infinite k1 should be invalid");
}
#[test]
fn test_pixel_radius_center() {
let r = pixel_radius(50, 50, 101, 101, 0.0, 0.0, false);
assert!(r < 0.02, "center pixel radius should be near 0, got {r}");
}
#[test]
fn test_pixel_radius_corner_square() {
let r = pixel_radius(0, 0, 100, 100, 0.0, 0.0, true);
assert!(
r > 1.3 && r < 1.5,
"corner radius of square should be ~√2, got {r}"
);
}
#[test]
fn test_pixel_radius_without_aspect_correction() {
let r_corrected = pixel_radius(0, 50, 200, 100, 0.0, 0.0, true);
let r_uncorrected = pixel_radius(0, 50, 200, 100, 0.0, 0.0, false);
assert!(
(r_corrected - r_uncorrected).abs() > 0.1,
"aspect correction should change radius"
);
}
#[test]
fn test_default_config_valid() {
let config = VignettingConfig::default();
assert!(config.validate().is_ok(), "default config should be valid");
}
#[test]
fn test_config_strength_above_one_invalid() {
let config = VignettingConfig {
strength: 1.5,
..Default::default()
};
assert!(config.validate().is_err(), "strength > 1 should be invalid");
}
#[test]
fn test_config_center_out_of_range() {
let config = VignettingConfig {
center_x: 0.6,
..Default::default()
};
assert!(
config.validate().is_err(),
"center_x > 0.5 should be invalid"
);
}
#[test]
fn test_cinematic_stronger_than_subtle() {
let cin = VignettingConfig::cinematic();
let sub = VignettingConfig::subtle();
assert!(
cin.strength > sub.strength,
"cinematic ({}) should have higher strength than subtle ({})",
cin.strength,
sub.strength
);
}
#[test]
fn test_all_presets_valid() {
assert!(VignettingConfig::cinematic().validate().is_ok());
assert!(VignettingConfig::subtle().validate().is_ok());
assert!(VignettingConfig::hard_edge().validate().is_ok());
}
#[test]
fn test_apply_vignetting_empty_image_error() {
let config = VignettingConfig::default();
let result = apply_vignetting(&[], 0, 0, &config);
assert!(matches!(result, Err(VignettingError::EmptyImage)));
}
#[test]
fn test_apply_vignetting_wrong_size_error() {
let config = VignettingConfig::default();
let result = apply_vignetting(&[0.5; 5], 4, 4, &config);
assert!(matches!(result, Err(VignettingError::InvalidImage(_))));
}
#[test]
fn test_apply_vignetting_strength_zero_unchanged() {
let config = VignettingConfig {
strength: 0.0,
..Default::default()
};
let w = 8;
let h = 8;
let image: Vec<f32> = (0..w * h * 3)
.map(|i| i as f32 / (w * h * 3) as f32)
.collect();
let out = apply_vignetting(&image, w, h, &config).expect("apply failed");
for (orig, vig) in image.iter().zip(out.iter()) {
assert!(
(*orig - *vig).abs() < 1e-6,
"strength=0 should leave image unchanged, diff = {}",
(*orig - *vig).abs()
);
}
}
#[test]
fn test_apply_vignetting_center_brighter_than_corner() {
let config = VignettingConfig::default(); let w = 64;
let h = 64;
let image = vec![1.0_f32; w * h * 3];
let out = apply_vignetting(&image, w, h, &config).expect("apply failed");
let center_idx = (h / 2 * w + w / 2) * 3;
let center_val = out[center_idx];
let corner_val = out[0];
assert!(
center_val > corner_val,
"center ({center_val}) should be brighter than corner ({corner_val})"
);
}
#[test]
fn test_apply_vignetting_center_is_max() {
let config = VignettingConfig::default();
let w = 32;
let h = 32;
let image = vec![1.0_f32; w * h * 3];
let out = apply_vignetting(&image, w, h, &config).expect("apply failed");
let center_idx = (h / 2 * w + w / 2) * 3;
let center_val = out[center_idx];
for i in (0..out.len()).step_by(3) {
assert!(
out[i] <= center_val + 1e-5,
"center should be the brightest pixel, found pixel {i} with value {}",
out[i]
);
}
}
#[test]
fn test_apply_vignetting_output_clamped() {
let config = VignettingConfig::default();
let w = 4;
let h = 4;
let image = vec![1.0_f32; w * h * 3];
let out = apply_vignetting(&image, w, h, &config).expect("apply failed");
for v in &out {
assert!(
*v >= 0.0 && *v <= 1.0,
"output should be clamped to [0,1], got {v}"
);
}
}
#[test]
fn test_apply_vignetting_tint_blends() {
let config = VignettingConfig::cinematic(); let w = 8;
let h = 8;
let image = vec![0.5_f32; w * h * 3];
let out = apply_vignetting(&image, w, h, &config).expect("apply failed");
let corner_r = out[0];
assert!(
corner_r > 0.0,
"corner with warm tint should not be pure black, got {corner_r}"
);
let center_idx = (h / 2 * w + w / 2) * 3;
let center_r = out[center_idx];
assert!(
center_r > 0.4,
"center should remain relatively bright, got {center_r}"
);
}
#[test]
fn test_apply_vignetting_rgba_alpha_unchanged() {
let config = VignettingConfig::default();
let w = 4;
let h = 4;
let mut image = vec![0.8_f32; w * h * 4];
for i in (3..image.len()).step_by(4) {
image[i] = 0.75;
}
let out = apply_vignetting_rgba(&image, w, h, &config).expect("apply_rgba failed");
for i in (3..out.len()).step_by(4) {
assert!(
(out[i] - 0.75).abs() < 1e-6,
"alpha should be unchanged, got {}",
out[i]
);
}
}
#[test]
fn test_apply_vignetting_rgba_wrong_size_error() {
let config = VignettingConfig::default();
let result = apply_vignetting_rgba(&[0.5; 5], 4, 4, &config);
assert!(matches!(result, Err(VignettingError::InvalidImage(_))));
}
#[test]
fn test_generate_vignetting_mask_correct_size() {
let config = VignettingConfig::default();
let w = 16;
let h = 12;
let mask = generate_vignetting_mask(w, h, &config).expect("mask failed");
assert_eq!(mask.len(), w * h, "mask should have w*h elements");
}
#[test]
fn test_generate_vignetting_mask_center_near_one() {
let config = VignettingConfig::default(); let w = 65;
let h = 65;
let mask = generate_vignetting_mask(w, h, &config).expect("mask failed");
let center_idx = h / 2 * w + w / 2;
let center_val = mask[center_idx];
assert!(
center_val > 0.95,
"center of mask should be near 1.0, got {center_val}"
);
}
#[test]
fn test_generate_vignetting_mask_corner_darker_than_center() {
let config = VignettingConfig::default();
let w = 32;
let h = 32;
let mask = generate_vignetting_mask(w, h, &config).expect("mask failed");
let center_idx = h / 2 * w + w / 2;
let corner_val = mask[0]; let center_val = mask[center_idx];
assert!(
corner_val < center_val,
"corner ({corner_val}) should be darker than center ({center_val})"
);
}
#[test]
fn test_generate_vignetting_mask_empty_error() {
let config = VignettingConfig::default();
let result = generate_vignetting_mask(0, 10, &config);
assert!(matches!(result, Err(VignettingError::EmptyImage)));
}
#[test]
fn test_animated_strength_in_range() {
for frame in 0..60 {
let s = animated_vignetting_strength(frame, 60, 0.5, 0.4);
assert!(
(0.0..=1.0).contains(&s),
"animated strength must be in [0,1], got {s} at frame {frame}"
);
}
}
#[test]
fn test_animated_strength_zero_frames_no_panic() {
let s = animated_vignetting_strength(0, 0, 0.5, 0.3);
assert!((0.0..=1.0).contains(&s));
}
#[test]
fn test_animated_strength_oscillates() {
let base = 0.5;
let amp = 0.3;
let total = 100;
let strengths: Vec<f32> = (0..total)
.map(|f| animated_vignetting_strength(f, total, base, amp))
.collect();
let min_s = strengths.iter().cloned().fold(f32::INFINITY, f32::min);
let max_s = strengths.iter().cloned().fold(f32::NEG_INFINITY, f32::max);
assert!(min_s < base, "should have frames below base strength");
assert!(max_s > base, "should have frames above base strength");
}
#[test]
fn test_apply_vignetting_sequence_length_mismatch_error() {
let config = VignettingConfig::default();
let w = 4;
let h = 4;
let frame = vec![0.5_f32; w * h * 3];
let frames = vec![frame.clone(), frame.clone()];
let strengths = vec![0.5_f32]; let result = apply_vignetting_sequence(&frames, w, h, &config, &strengths);
assert!(matches!(result, Err(VignettingError::InvalidConfig(_))));
}
#[test]
fn test_apply_vignetting_sequence_correct_output_count() {
let config = VignettingConfig::default();
let w = 4;
let h = 4;
let frame = vec![0.8_f32; w * h * 3];
let frames = vec![frame.clone(), frame.clone(), frame.clone()];
let strengths = vec![0.3_f32, 0.5, 0.7];
let out =
apply_vignetting_sequence(&frames, w, h, &config, &strengths).expect("sequence failed");
assert_eq!(out.len(), 3, "should produce 3 output frames");
}
#[test]
fn test_apply_vignetting_sequence_zero_strength_frame_unchanged() {
let config = VignettingConfig::default();
let w = 4;
let h = 4;
let image = vec![0.7_f32; w * h * 3];
let frames = vec![image.clone()];
let strengths = vec![0.0_f32];
let out =
apply_vignetting_sequence(&frames, w, h, &config, &strengths).expect("sequence failed");
for (a, b) in image.iter().zip(out[0].iter()) {
assert!(
(*a - *b).abs() < 1e-6,
"strength=0 frame should be unchanged"
);
}
}
#[test]
fn test_compute_vignetting_stats_center_near_one() {
let config = VignettingConfig::default(); let w = 32;
let h = 32;
let image = vec![1.0_f32; w * h * 3];
let vignetted = apply_vignetting(&image, w, h, &config).expect("apply failed");
let stats =
compute_vignetting_stats(&image, &vignetted, w, h, &config).expect("stats failed");
assert!(
stats.mean_factor_at_center > 0.95,
"center factor should be near 1.0, got {}",
stats.mean_factor_at_center
);
}
#[test]
fn test_compute_vignetting_stats_corner_darker() {
let config = VignettingConfig::default();
let w = 8;
let h = 8;
let image = vec![1.0_f32; w * h * 3];
let vignetted = apply_vignetting(&image, w, h, &config).expect("apply failed");
let stats =
compute_vignetting_stats(&image, &vignetted, w, h, &config).expect("stats failed");
assert!(
stats.mean_factor_at_corner < stats.mean_factor_at_center,
"corner factor should be darker than center"
);
}
#[test]
fn test_compute_vignetting_stats_no_change_when_strength_zero() {
let config = VignettingConfig {
strength: 0.0,
..Default::default()
};
let w = 8;
let h = 8;
let image = vec![0.6_f32; w * h * 3];
let vignetted = apply_vignetting(&image, w, h, &config).expect("apply failed");
let stats =
compute_vignetting_stats(&image, &vignetted, w, h, &config).expect("stats failed");
assert!(
stats.mean_image_change < 1e-5,
"no change expected with strength=0, got {}",
stats.mean_image_change
);
}
#[test]
fn test_compute_vignetting_stats_size_mismatch_error() {
let config = VignettingConfig::default();
let result = compute_vignetting_stats(&[0.5; 12], &[0.5; 15], 2, 2, &config);
assert!(matches!(result, Err(VignettingError::InvalidImage(_))));
}
}