altered_perception 0.5.0

`struct HSV/Luma/HSL/etc.` for sharing pixels between crates + other pixel manipulations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#[cfg(test)]
mod tests {
    use crate::{Luma, HSL, HSV};
    use rayon::prelude::*;
    use rgb::RGB;

    #[test]
    fn rgb8_to_hsv_f64() {
        (0..=u8::MAX).into_par_iter().for_each(|r| {
            (0..=u8::MAX).for_each(|g| {
                (0..=u8::MAX).for_each(|b| {
                    let original = RGB::new(r, g, b);
                    let intermediate: HSV<f64> = HSV::from_rgb::<u8>(original);
                    let final_out = HSV::<f64>::to_rgb(intermediate);

                    assert_eq!(original, final_out);
                });
            });
        });
    }

    #[test]
    fn rgb8_to_hsv_f32() {
        (0..=u8::MAX).into_par_iter().for_each(|r| {
            (0..=u8::MAX).for_each(|g| {
                (0..=u8::MAX).for_each(|b| {
                    let original = RGB::new(r, g, b);
                    let intermediate: HSV<f32> = HSV::from_rgb::<u8>(original);
                    let final_out = HSV::<f32>::to_rgb(intermediate);

                    assert_eq!(original, final_out);
                });
            });
        });
    }

    #[test]
    fn rgb8_to_hsl_f64() {
        (0..=u8::MAX).into_par_iter().for_each(|r| {
            (0..=u8::MAX).for_each(|g| {
                (0..=u8::MAX).for_each(|b| {
                    let original = RGB::new(r, g, b);
                    let intermediate: HSL<f64> = HSL::from_rgb::<u8>(original);
                    let final_out = HSL::<f64>::to_rgb(intermediate);

                    assert_eq!(original, final_out);
                });
            });
        });
    }

    #[test]
    fn rgb8_to_hsl_f32() {
        (0..=u8::MAX).into_par_iter().for_each(|r| {
            (0..=u8::MAX).for_each(|g| {
                (0..=u8::MAX).for_each(|b| {
                    let original = RGB::new(r, g, b);
                    let intermediate: HSL<f32> = HSL::from_rgb::<u8>(original);
                    let final_out = HSL::<f32>::to_rgb(intermediate);

                    assert_eq!(original, final_out);
                });
            });
        });
    }

    #[test]
    fn luma8_to_rgb8() {
        (0..=u8::MAX).into_par_iter().for_each(|r| {
            let original = Luma::new(r);
            let intermediate: RGB<u8> = Luma::to_rgb::<u8>(original);
            let final_out = Luma::from_rgb(intermediate);

            assert_eq!(original, final_out);
        });
    }
}