use coeus_core::FloatElement;
use eunomia::convert::IntegerTarget;
const CUBIC_COEFFICIENT: f64 = -0.75;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ResizeMode {
Nearest,
Bilinear,
Bicubic,
Area,
}
fn cubic(x: f64) -> f64 {
let x = x.abs();
if x <= 1.0 {
(CUBIC_COEFFICIENT + 2.0) * x.powi(3) - (CUBIC_COEFFICIENT + 3.0) * x.powi(2) + 1.0
} else if x < 2.0 {
CUBIC_COEFFICIENT * x.powi(3) - 5.0 * CUBIC_COEFFICIENT * x.powi(2)
+ 8.0 * CUBIC_COEFFICIENT * x
- 4.0 * CUBIC_COEFFICIENT
} else {
0.0
}
}
#[derive(Default)]
pub(super) struct TapTable {
index: Vec<usize>,
weight: Vec<f64>,
}
impl TapTable {
pub(super) fn fill(
&mut self,
out_index: usize,
in_len: usize,
out_len: usize,
mode: ResizeMode,
scale: f64,
) {
self.index.clear();
self.weight.clear();
let half_pixel = (f64::from_count(out_index) + 0.5) * scale;
match mode {
ResizeMode::Nearest => {
let source =
usize::from_truncated(f64::from_count(out_index) * scale).min(in_len - 1);
self.index.push(source);
self.weight.push(1.0);
}
ResizeMode::Bilinear => {
let source = (half_pixel - 0.5).max(0.0);
let lower = source.floor();
let lower_index = usize::from_truncated(lower);
let upper_weight = source - lower;
self.index.push(lower_index);
self.weight.push(1.0 - upper_weight);
self.index.push((lower_index + 1).min(in_len - 1));
self.weight.push(upper_weight);
}
ResizeMode::Bicubic => {
let source = half_pixel - 0.5;
let lower = source.floor();
let fraction = source - lower;
let lower_index = isize::from_truncated(lower);
let last_index =
isize::try_from(in_len).expect("invariant: an axis length fits isize") - 1;
for tap in 0..4_usize {
let offset = isize::try_from(tap).expect("invariant: four taps fit isize");
let index = (lower_index - 1 + offset).clamp(0, last_index);
self.index.push(
usize::try_from(index).expect("invariant: a clamped index is non-negative"),
);
self.weight
.push(cubic(fraction + 1.0 - f64::from_count(tap)));
}
}
ResizeMode::Area => {
let start = out_index * in_len / out_len;
let end = ((out_index + 1) * in_len).div_ceil(out_len);
let weight = 1.0 / f64::from_count(end - start);
for index in start..end {
self.index.push(index);
self.weight.push(weight);
}
}
}
}
pub(super) fn iter(&self) -> impl Iterator<Item = (usize, f64)> + '_ {
self.index.iter().copied().zip(self.weight.iter().copied())
}
}