-use slur::{

- color::{u32xN, BlurU32},

- imgref::ImgRefMut,

-};

-use std::{

- ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign},

- simd::Simd,

-};

-

-use crate::Image;

-

-impl<T: AsMut<[u32]> + AsRef<[u32]>> Image<T, 1> {

- /// Blur a image of packed 32 bit integers, `[0xAARRGGBB]`.

- pub fn blur_argb(&mut self, radius: usize) {

- let w = self.width() as usize;

- let h = self.height() as usize;

- slur::simd_blur_argb::<4>(&mut ImgRefMut::new(self.buffer.as_mut(), w, h), radius)

- }

-}

-

-macro_rules! simd {

- ($n:literal) => {

- impl<T: AsMut<[u8]> + AsRef<[u8]>> Image<T, $n> {

- /// Blur a image.

- pub fn blur_in(&mut self, radius: usize) {

- let (w, h) = (self.width() as usize, self.height() as usize);

- let px = self.flatten_mut();

- slur::blur(

- &mut ImgRefMut::new(px, w, h),

- radius,

- |x| slur::color::u32xN(std::simd::Simd::from_array(x.map(|x| x as u32))),

- |x| x.0.to_array().map(|x| x as u8),

- );

- }

- }

- };

-}

-

-simd!(4);

-simd!(2);

-

-impl<T: AsMut<[u8]> + AsRef<[u8]>> Image<T, 3> {

- /// Blur a image.

- /// ```

- /// # use fimg::Image;

- /// let mut i = Image::alloc(300, 300).boxed();

- /// // draw a trongle

- /// i.poly((150., 150.), 3, 100.0, 0.0, [255, 255, 255]);

- /// // give it some blur

- /// i.blur_in(25);

- /// ```

- pub fn blur_in(&mut self, radius: usize) {

- let (w, h) = (self.width() as usize, self.height() as usize);

- let px = self.flatten_mut();

- slur::blur(

- &mut ImgRefMut::new(px, w, h),

- radius,

- |x| Px::from(*x),

- |x| x.into(),

- );

- }

-}

-

-impl<T: AsMut<[u8]> + AsRef<[u8]>> Image<T, 1> {

- /// Blur a image. No copy.

- /// ```

- /// # use fimg::Image;

- /// let mut i = Image::alloc(300, 300);

- /// // draw a lil pentagon

- /// i.poly((150., 150.), 5, 100.0, 0.0, [255]);

- /// // give it some blur

- /// i.blur(25);

- /// # assert_eq!(include_bytes!("../tdata/blurred_pentagon.imgbuf"), i.bytes())

- /// ```

- pub fn blur(&mut self, radius: usize) {

- let (w, h) = (self.width() as usize, self.height() as usize);

- slur::simd_blur::<_, _, _, 8>(

- &mut ImgRefMut::new(self.buffer.as_mut(), w, h),

- radius,

- |x| u32xN(Simd::from_array(x.map(|&x| x as u32))),

- |x| x.0.as_array().map(|x| x as u8),

- |&x| BlurU32(x as u32),

- |x| x.0 as u8,

- );

- }

-}

-

-macro_rules! blur_packing {

- ($n:literal) => {

- impl<T: AsRef<[u8]> + AsMut<[u8]>> Image<T, $n> {

- /// Blur a image. This will allocate a <code>[Image]<[Box]<[[u32]]>, 1></code>.

- /// If you want no copy, but slower if you dont have a simd-able cpu, check out [`Image::blur_in`].

- /// ```

- /// # use fimg::Image;

- /// let mut i = Image::alloc(300, 300);

- /// // draw a sqar

- /// i.poly((150., 150.), 4, 100.0, 0.0, [255]);

- /// // give it some blur

- /// i.blur(25);

- /// ```

- pub fn blur(&mut self, radius: usize) {

- // the bit twiddling lets it simd better

- let mut argb = Image::<Box<[u32]>, 1>::from(self.as_ref());

- argb.blur_argb(radius);

- for (i, n) in crate::convert::unpack_all::<$n>(&argb.buffer).enumerate() {

- *unsafe { self.buffer.as_mut().get_unchecked_mut(i) } = n;

- }

- }

- }

- };

-}

-blur_packing!(2);

-blur_packing!(3);

-blur_packing!(4);

-

-#[repr(transparent)]

-#[derive(Copy, Clone)]

-struct Px<const N: usize>([u32; N]);

-

-impl<const N: usize> Default for Px<N> {

- fn default() -> Self {

- Self([0; N])

- }

-}

-

-impl<const N: usize> From<[u8; N]> for Px<N> {

- fn from(x: [u8; N]) -> Self {

- Self(x.map(|x| x as u32))

- }

-}

-

-impl<const N: usize> From<Px<N>> for [u8; N] {

- fn from(v: Px<N>) -> Self {

- v.0.map(|x| x as u8)

- }

-}

-

-macro_rules! op {

- ($name:ident, $as:ident, $fn:ident, $ass_fn:ident, $meth:ident) => {

- impl<const N: usize> $name<usize> for Px<N> {

- type Output = Px<N>;

-

- fn $fn(self, rhs: usize) -> Self::Output {

- Self(self.0.map(|x| x.$meth(rhs as u32)))

- }

- }

-

- impl<const N: usize> $name for Px<N> {

- type Output = Px<N>;

- fn $fn(self, rhs: Px<N>) -> Self::Output {

- let mut out = [0; N];

- for ((a, b), x) in self.0.iter().zip(rhs.0.iter()).zip(out.iter_mut()) {

- *x = a.$meth(*b);

- }

- Self(out)

- }

- }

-

- impl<const N: usize> $as for Px<N> {

- fn $ass_fn(&mut self, rhs: Self) {

- *self = self.$fn(rhs);

- }

- }

- };

-}

-op!(Mul, MulAssign, mul, mul_assign, wrapping_mul);

-op!(Sub, SubAssign, sub, sub_assign, wrapping_sub);

-op!(Add, AddAssign, add, add_assign, wrapping_add);

-op!(Div, DivAssign, div, div_assign, wrapping_div);