Move convert_space fns to N channel

Remove `convert_space_alpha`

Author: Beinsezii

src/lib.rs

@@ -761,8 +761,8 @@ macro_rules! op_chunk {
 
 macro_rules! op_inter {
     ($func:ident, $data:expr) => {
-        $data.chunks_exact_mut(3).for_each(|pixel| {
-            let pixel: &mut [T; 3] = pixel.try_into().unwrap();
+        $data.chunks_exact_mut(N).for_each(|pixel| {
+            let pixel: &mut [T; N] = pixel.try_into().unwrap();
             $func(pixel);
         })
     };
@@ -821,23 +821,32 @@ macro_rules! graph {
 
 /// Runs conversion functions to convert `pixel` from one `Space` to another
 /// in the least possible moves.
-pub fn convert_space<T: DType>(from: Space, to: Space, pixel: &mut [T; 3]) {
+pub fn convert_space<T: DType, const N: usize>(from: Space, to: Space, pixel: &mut [T; N])
+where
+    Channels<N>: ValidChannels,
+{
     graph!(convert_space, pixel, from, to, op_single);
 }
 
 /// Runs conversion functions to convert `pixel` from one `Space` to another
 /// in the least possible moves.
 ///
 /// Caches conversion graph for faster iteration.
-pub fn convert_space_chunked<T: DType>(from: Space, to: Space, pixels: &mut [[T; 3]]) {
+pub fn convert_space_chunked<T: DType, const N: usize>(from: Space, to: Space, pixels: &mut [[T; N]])
+where
+    Channels<N>: ValidChannels,
+{
     graph!(convert_space_chunked, pixels, from, to, op_chunk);
 }
 
 /// Runs conversion functions to convert `pixel` from one `Space` to another
 /// in the least possible moves.
 ///
 /// Caches conversion graph for faster iteration and ignores remainder values in slice.
-pub fn convert_space_sliced<T: DType>(from: Space, to: Space, pixels: &mut [T]) {
+pub fn convert_space_sliced<T: DType, const N: usize>(from: Space, to: Space, pixels: &mut [T])
+where
+    Channels<N>: ValidChannels,
+{
     graph!(convert_space_sliced, pixels, from, to, op_inter);
 }
 
@@ -885,15 +894,10 @@ pub extern "C" fn convert_space_ffi(from: *const c_char, to: *const c_char, pixe
             core::slice::from_raw_parts_mut(pixels, len)
         }
     };
-    convert_space_sliced(from, to, pixels);
+    convert_space_sliced::<_, 3>(from, to, pixels);
     0
 }
 
-/// Same as `convert_space`, ignores the 4th value in `pixel`.
-pub fn convert_space_alpha(from: Space, to: Space, pixel: &mut [f32; 4]) {
-    unsafe { convert_space(from, to, pixel.get_unchecked_mut(0..3).try_into().unwrap_unchecked()) }
-}
-
 // ### Convert Space ### }}}
 
 // ### Str2Col ### {{{

src/tests.rs

@@ -369,8 +369,25 @@ fn alpha_untouch() {
         lch_to_lab,
     ] {
         f(&mut pixel);
-        assert_eq!(pixel[3].to_bits(), 4.0_f64.to_bits());
+        assert_eq!(pixel[3].to_bits(), 4.0_f64.to_bits(), "{:?}", f);
     }
+    convert_space(Space::SRGB, Space::CIELCH, &mut pixel);
+    assert_eq!(pixel[3].to_bits(), 4.0_f64.to_bits());
+    let mut chunks = [pixel, pixel, pixel];
+    convert_space_chunked(Space::CIELCH, Space::SRGB, &mut chunks);
+    chunks
+        .iter()
+        .for_each(|c| assert_eq!(c[3].to_bits(), 4.0_f64.to_bits(), "alpha_untouch_chunked"));
+    let mut slice = [pixel, pixel, pixel].iter().fold(Vec::<f64>::new(), |mut acc, it| {
+        acc.extend_from_slice(it.as_slice());
+        acc
+    });
+    convert_space_sliced::<_, 4>(Space::CIELCH, Space::SRGB, &mut slice);
+    slice
+        .iter()
+        .skip(3)
+        .step_by(4)
+        .for_each(|n| assert_eq!(n.to_bits(), 4.0_f64.to_bits(), "alpha_untouch_sliced"));
 }
 
 #[test]
@@ -379,7 +396,7 @@ fn sliced() {
         acc.extend_from_slice(it);
         acc
     });
-    convert_space_sliced(Space::SRGB, Space::CIELCH, &mut pixel);
+    convert_space_sliced::<_, 3>(Space::SRGB, Space::CIELCH, &mut pixel);
     pix_cmp(
         &pixel
             .chunks_exact(3)
@@ -398,7 +415,7 @@ fn sliced_odd() {
         acc
     });
     pixel.push(1234.5678);
-    convert_space_sliced(Space::SRGB, Space::CIELCH, &mut pixel);
+    convert_space_sliced::<_, 3>(Space::SRGB, Space::CIELCH, &mut pixel);
     pix_cmp(
         &pixel
             .chunks_exact(3)
@@ -415,7 +432,7 @@ fn sliced_odd() {
 fn sliced_smol() {
     let pixels = [1.0, 0.0];
     let mut smol = pixels.clone();
-    convert_space_sliced(Space::SRGB, Space::CIELCH, &mut smol);
+    convert_space_sliced::<_, 3>(Space::SRGB, Space::CIELCH, &mut smol);
     assert_eq!(pixels, smol);
 }