Convert str2col into DType and const N

It's getting hectic. I'll want to mildly refactor the tests later.

Author: Beinsezii

src/lib.rs

@@ -928,15 +928,18 @@ fn rm_paren<'a>(s: &'a str) -> &'a str {
 /// ```
 /// use colcon::{str2col, Space};
 ///
-/// assert_eq!(str2col("0.2, 0.5, 0.6"), Some((Space::SRGB, [0.2, 0.5, 0.6])));
-/// assert_eq!(str2col("lch:50;20;120"), Some((Space::CIELCH, [50.0, 20.0, 120.0])));
-/// assert_eq!(str2col("oklab(0.2, 0.6, -0.5)"), Some((Space::OKLAB, [0.2, 0.6, -0.5])));
-/// assert_eq!(str2col("srgb 100% 50% 25%"), Some((Space::SRGB, [1.0, 0.5, 0.25])));
+/// assert_eq!(str2col("0.2, 0.5, 0.6"), Some((Space::SRGB, [0.2f32, 0.5, 0.6])));
+/// assert_eq!(str2col("lch:50;20;120"), Some((Space::CIELCH, [50.0f32, 20.0, 120.0])));
+/// assert_eq!(str2col("oklab(0.2, 0.6, -0.5)"), Some((Space::OKLAB, [0.2f32, 0.6, -0.5])));
+/// assert_eq!(str2col("srgb 100% 50% 25%"), Some((Space::SRGB, [1.0f32, 0.5, 0.25])));
 /// ```
-pub fn str2col(mut s: &str) -> Option<(Space, [f32; 3])> {
+pub fn str2col<T: DType, const N: usize>(mut s: &str) -> Option<(Space, [T; N])>
+where
+    Channels<N>: ValidChannels,
+{
     s = rm_paren(s.trim());
     let mut space = Space::SRGB;
-    let mut result = [f32::NAN; 3];
+    let mut result = [f32::NAN; N];
 
     // Return hex if valid
     if let Ok(irgb) = hex_to_irgb(s) {
@@ -959,19 +962,26 @@ pub fn str2col(mut s: &str) -> Option<(Space, [f32; 3])> {
         .filter(|s| !s.is_empty())
         .enumerate()
     {
-        if n > 2 {
+        if n > 3 {
             return None;
+        } else if n >= result.len() {
+            continue;
         } else if let Ok(value) = split.parse::<f32>() {
             result[n] = value;
         } else if split.ends_with('%') {
-            if let Ok(value) = split[0..(split.len() - 1)].parse::<f32>() {
+            if let Ok(percent) = split[0..(split.len() - 1)].parse::<f32>() {
+                // alpha
+                if n == 3 {
+                    result[n] = percent / 100.0;
+                    continue;
+                }
                 let (q0, q100) = (space.srgb_quant0()[n], space.srgb_quant100()[n]);
                 if q0.is_finite() && q100.is_finite() {
-                    result[n] = value / 100.0 * (q100 - q0) + q0;
+                    result[n] = percent / 100.0 * (q100 - q0) + q0;
                 } else if Space::UCS_POLAR.contains(&space) {
-                    result[n] = value / 100.0 * 360.0
+                    result[n] = percent / 100.0 * 360.0
                 } else if space == Space::HSV {
-                    result[n] = value / 100.0
+                    result[n] = percent / 100.0
                 } else {
                     return None;
                 }
@@ -982,8 +992,8 @@ pub fn str2col(mut s: &str) -> Option<(Space, [f32; 3])> {
             return None;
         }
     }
-    if result.iter().all(|v| v.is_finite()) {
-        Some((space, result))
+    if result.iter().take(3).all(|v| v.is_finite()) {
+        Some((space, result.map(|c| c.to_dt())))
     } else {
         None
     }
@@ -992,7 +1002,10 @@ pub fn str2col(mut s: &str) -> Option<(Space, [f32; 3])> {
 /// Convert a string into a pixel of the requested Space.
 ///
 /// Shorthand for str2col() -> convert_space()
-pub fn str2space(s: &str, to: Space) -> Option<[f32; 3]> {
+pub fn str2space<T: DType, const N: usize>(s: &str, to: Space) -> Option<[T; N]>
+where
+    Channels<N>: ValidChannels,
+{
     str2col(s).map(|(from, mut col)| {
         convert_space(from, to, &mut col);
         col
@@ -1192,11 +1205,11 @@ where
 // ### BACKWARD ### {{{
 
 /// Convert integer (0..255) RGB to floating (0.0..1.0) RGB.
-pub fn irgb_to_srgb<const N: usize>(pixel: [u8; N]) -> [f32; N]
+pub fn irgb_to_srgb<T: DType, const N: usize>(pixel: [u8; N]) -> [T; N]
 where
     Channels<N>: ValidChannels,
 {
-    pixel.map(|c| c as f32 / 255.0)
+    pixel.map(|c| T::ff32(c as f32 / 255.0))
 }
 
 /// Create integer RGB set from hex string.

src/tests.rs

@@ -223,15 +223,15 @@ fn irgb_to_alpha() {
 
 #[test]
 fn irgb_from() {
-    let mut srgb = irgb_to_srgb(IRGB);
+    let mut srgb = irgb_to_srgb::<f32, 3>(IRGB);
     // Round decimal to hundredths
     srgb.iter_mut().for_each(|c| *c = (*c * 100.0).round() / 100.0);
     assert_eq!([0.2, 0.35, 0.95], srgb)
 }
 
 #[test]
 fn irgb_from_alpha() {
-    let mut srgb = irgb_to_srgb(IRGBA);
+    let mut srgb = irgb_to_srgb::<f32, 4>(IRGBA);
     // Round decimal to hundredths
     srgb.iter_mut().for_each(|c| *c = (*c * 100.0).round() / 100.0);
     assert_eq!([0.2, 0.35, 0.95, 0.35], srgb)
@@ -583,100 +583,112 @@ fn space_strings() {
 // ### Str2Col ### {{{
 #[test]
 fn str2col_base() {
-    assert_eq!(str2col("0.2, 0.5, 0.6"), Some((Space::SRGB, [0.2, 0.5, 0.6])))
+    assert_eq!(str2col("0.2, 0.5, 0.6"), Some((Space::SRGB, [0.2f32, 0.5, 0.6])))
 }
 
 #[test]
 fn str2col_base_tight() {
-    assert_eq!(str2col("0.2,0.5,0.6"), Some((Space::SRGB, [0.2, 0.5, 0.6])))
+    assert_eq!(str2col("0.2,0.5,0.6"), Some((Space::SRGB, [0.2f32, 0.5, 0.6])))
 }
 
 #[test]
 fn str2col_base_lop() {
-    assert_eq!(str2col("0.2,0.5, 0.6"), Some((Space::SRGB, [0.2, 0.5, 0.6])))
+    assert_eq!(str2col("0.2,0.5, 0.6"), Some((Space::SRGB, [0.2f32, 0.5, 0.6])))
 }
 
 #[test]
 fn str2col_base_bare() {
-    assert_eq!(str2col("0.2 0.5 0.6"), Some((Space::SRGB, [0.2, 0.5, 0.6])))
+    assert_eq!(str2col("0.2 0.5 0.6"), Some((Space::SRGB, [0.2f32, 0.5, 0.6])))
 }
 
 #[test]
 fn str2col_base_bare_fat() {
-    assert_eq!(str2col("  0.2   0.5     0.6 "), Some((Space::SRGB, [0.2, 0.5, 0.6])))
+    assert_eq!(str2col("  0.2   0.5     0.6 "), Some((Space::SRGB, [0.2f32, 0.5, 0.6])))
 }
 
 #[test]
 fn str2col_base_paren() {
-    assert_eq!(str2col("(0.2 0.5 0.6)"), Some((Space::SRGB, [0.2, 0.5, 0.6])))
+    assert_eq!(str2col("(0.2 0.5 0.6)"), Some((Space::SRGB, [0.2f32, 0.5, 0.6])))
 }
 
 #[test]
 fn str2col_base_paren2() {
-    assert_eq!(str2col("{ 0.2 : 0.5 : 0.6 }"), Some((Space::SRGB, [0.2, 0.5, 0.6])))
+    assert_eq!(str2col("{ 0.2 : 0.5 : 0.6 }"), Some((Space::SRGB, [0.2f32, 0.5, 0.6])))
 }
 
 #[test]
 fn str2col_base_none() {
-    assert_eq!(str2col("  0.2   0.5     f"), None)
+    assert_eq!(str2col::<f32, 3>("  0.2   0.5     f"), None)
 }
 
 #[test]
 fn str2col_base_none2() {
-    assert_eq!(str2col("0.2*0.5 0.6"), None)
+    assert_eq!(str2col::<f32, 3>("0.2*0.5 0.6"), None)
 }
 
 #[test]
 fn str2col_base_paren_none() {
-    assert_eq!(str2col("(0.2 0.5 0.6"), None)
+    assert_eq!(str2col::<f32, 3>("(0.2 0.5 0.6"), None)
 }
 
 #[test]
 fn str2col_base_paren_none2() {
-    assert_eq!(str2col("0.2 0.5 0.6}"), None)
+    assert_eq!(str2col::<f32, 3>("0.2 0.5 0.6}"), None)
 }
 
 #[test]
 fn str2col_lch() {
-    assert_eq!(str2col("lch(50, 30, 160)"), Some((Space::CIELCH, [50.0, 30.0, 160.0])))
+    assert_eq!(
+        str2col("lch(50, 30, 160)"),
+        Some((Space::CIELCH, [50.0f32, 30.0, 160.0]))
+    )
 }
 
 #[test]
 fn str2col_lch_space() {
-    assert_eq!(str2col("lch 50, 30, 160"), Some((Space::CIELCH, [50.0, 30.0, 160.0])))
+    assert_eq!(
+        str2col("lch 50, 30, 160"),
+        Some((Space::CIELCH, [50.0f32, 30.0, 160.0]))
+    )
 }
 
 #[test]
 fn str2col_lch_colon() {
-    assert_eq!(str2col("lch:50:30:160"), Some((Space::CIELCH, [50.0, 30.0, 160.0])))
+    assert_eq!(str2col("lch:50:30:160"), Some((Space::CIELCH, [50.0f32, 30.0, 160.0])))
 }
 
 #[test]
 fn str2col_lch_semicolon() {
-    assert_eq!(str2col("lch;50;30;160"), Some((Space::CIELCH, [50.0, 30.0, 160.0])))
+    assert_eq!(str2col("lch;50;30;160"), Some((Space::CIELCH, [50.0f32, 30.0, 160.0])))
 }
 
 #[test]
 fn str2col_lch_mixed() {
-    assert_eq!(str2col("lch; (50,30,160)"), Some((Space::CIELCH, [50.0, 30.0, 160.0])))
+    assert_eq!(
+        str2col("lch; (50,30,160)"),
+        Some((Space::CIELCH, [50.0f32, 30.0, 160.0]))
+    )
 }
 
 #[test]
 fn str2col_lch_mixed2() {
-    assert_eq!(str2col("lch(50; 30; 160)"), Some((Space::CIELCH, [50.0, 30.0, 160.0])))
+    assert_eq!(
+        str2col("lch(50; 30; 160)"),
+        Some((Space::CIELCH, [50.0f32, 30.0, 160.0]))
+    )
 }
 
 #[test]
 fn str2col_lch_mixed3() {
     assert_eq!(
         str2col("lch   (50   30  160)"),
-        Some((Space::CIELCH, [50.0, 30.0, 160.0]))
+        Some((Space::CIELCH, [50.0f32, 30.0, 160.0]))
     )
 }
 
 #[test]
 fn str2col_hex() {
-    assert_eq!(str2col(HEX), Some((Space::SRGB, irgb_to_srgb(IRGB))))
+    assert_eq!(str2col(HEX), Some((Space::SRGB, irgb_to_srgb::<f32, 3>(IRGB))))
 }
 
 #[test]
@@ -685,7 +697,11 @@ fn str2col_perc100() {
         str2col("oklch 100% 100% 100%"),
         Some((
             Space::OKLCH,
-            [Space::OKLCH.srgb_quant100()[0], Space::OKLCH.srgb_quant100()[1], 360.0]
+            [
+                Space::OKLCH.srgb_quant100()[0],
+                Space::OKLCH.srgb_quant100()[1],
+                360.0f32
+            ]
         ))
     )
 }
@@ -699,7 +715,7 @@ fn str2col_perc50() {
             [
                 (Space::OKLCH.srgb_quant0()[0] + Space::OKLCH.srgb_quant100()[0]) / 2.0,
                 (Space::OKLCH.srgb_quant0()[1] + Space::OKLCH.srgb_quant100()[1]) / 2.0,
-                180.0,
+                180.0f32,
             ]
         ))
     )
@@ -711,7 +727,7 @@ fn str2col_perc0() {
         str2col("oklch 0% 0% 0%"),
         Some((
             Space::OKLCH,
-            [Space::OKLCH.srgb_quant0()[0], Space::OKLCH.srgb_quant0()[1], 0.0]
+            [Space::OKLCH.srgb_quant0()[0], Space::OKLCH.srgb_quant0()[1], 0.0f32]
         ))
     )
 }
@@ -722,40 +738,54 @@ fn str2col_perc_mix() {
         str2col("oklab 0.5 100.000% 0%"),
         Some((
             Space::OKLAB,
-            [0.5, Space::OKLAB.srgb_quant100()[1], Space::OKLAB.srgb_quant0()[2]]
+            [0.5f32, Space::OKLAB.srgb_quant100()[1], Space::OKLAB.srgb_quant0()[2]]
         ))
     )
 }
 
 #[test]
 fn str2col_perc_inval() {
-    assert_eq!(str2col("oklab 0.5 100 % 0%"), None)
-}
-
-#[test]
-fn str2col_perc_inval2() {
-    assert_eq!(str2col("oklab 0.5% %100% 0%"), None)
+    assert_eq!(str2col::<f32, 3>("oklab 0.5 100 % 0%"), None);
+    assert_eq!(str2col::<f32, 3>("oklab 0.5% %100% 0%"), None);
+    assert_eq!(str2col::<f32, 3>("oklab 0.5 100%% 0%"), None);
 }
 
 #[test]
-fn str2col_perc_inval3() {
-    assert_eq!(str2col("oklab 0.5 100%% 0%"), None)
+fn str2col_alpha() {
+    assert_eq!(
+        str2col("srgb 0, 0.5, 0.75, 1.0"),
+        Some((Space::SRGB, [0f32, 0.5, 0.75, 1.0]))
+    );
+    assert_eq!(
+        str2col("srgb 0, 0.5, 0.75, 1.0"),
+        Some((Space::SRGB, [0f32, 0.5, 0.75]))
+    );
+    assert_eq!(
+        str2col("srgb 10%, 20%, 50%, 80%"),
+        Some((Space::SRGB, [0.1f32, 0.2, 0.5, 0.8]))
+    );
+    assert_eq!(
+        str2col("srgb 10%, 20%, 50%, 80%"),
+        Some((Space::SRGB, [0.1f32, 0.2, 0.5]))
+    );
+    let mut will_nan = str2col::<f32, 4>("srgb 0, 0.5, 0.75").unwrap();
+    if will_nan.1[3].is_nan() {
+        will_nan.1[3] = 0.12345
+    }
+    assert_eq!(will_nan, (Space::SRGB, [0f32, 0.5, 0.75, 0.12345]));
 }
 
 #[test]
 fn str2space_base() {
-    let pix: [f64; 3] = str2space("oklch : 0.62792590, 0.25768453, 29.22319405", Space::SRGB)
-        .expect("STR2SPACE_BASE FAIL")
-        .map(|v| v.into());
+    let pix: [f64; 3] =
+        str2space("oklch : 0.62792590, 0.25768453, 29.22319405", Space::SRGB).expect("STR2SPACE_BASE FAIL");
     let reference = [1.00000000, 0.00000000, 0.00000000];
     pix_cmp(&[pix], &[reference], 1e-3, &[]);
 }
 
 #[test]
 fn str2space_hex() {
-    let pix: [f64; 3] = str2space(" { #FF0000 } ", Space::OKLCH)
-        .expect("STR2SPACE_HEX FAIL")
-        .map(|v| v.into());
+    let pix: [f64; 3] = str2space(" { #FF0000 } ", Space::OKLCH).expect("STR2SPACE_HEX FAIL");
     let reference = [0.62792590, 0.25768453, 29.22319405];
     pix_cmp(&[pix], &[reference], 1e-3, &[]);
 }