colours 0.1.1

Color types for different color models with conversions between it.
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

use super::{IsColorChannel, IsColor, HasAlpha, HasntAlpha, Hsl, Hsva, Rgba};

/// Generic HSL color type with alpha component
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Hsla<T> {
    pub hue: T,
    pub saturation: T,
    pub lightness: T,
    pub alpha: T,
}

impl<T: IsColorChannel> IsColor for Hsla<T> {
    type Channel = T;
}

impl<T: IsColorChannel> HasAlpha for Hsla<T> {
    type Alphaless = Hsl<T>;

    fn split_alpha(self) -> (Self::Alphaless, Self::Channel) {
        let Hsla { hue, saturation, lightness, alpha } = self;
        (Hsl { hue, saturation, lightness }, alpha)
    }
}

impl<T> Hsla<T> {
    fn new(hue: T, saturation: T, lightness: T, alpha: T) -> Self {
        Self { hue, saturation, lightness, alpha }
    }
}

impl<T: IsColorChannel> Default for Hsla<T> {
    fn default() -> Self {
        Self::new(T::MIN, T::MIN, T::MIN, T::MAX)
    }
}

impl<T: IsColorChannel> From<Hsl<T>> for Hsla<T> {
    fn from(hsl: Hsl<T>) -> Self {
        hsl.with_alpha(T::MAX)
    }
}

impl From<Hsla<u8>> for Hsla<f32> {
    fn from(Hsla { hue, saturation, lightness, alpha }: Hsla<u8>) -> Self {
        Self::new(
            hue as f32 / 255.0,
            saturation as f32 / 255.0,
            lightness as f32 / 255.0,
            alpha as f32 / 255.0,
        )
    }
}

impl From<Hsla<f32>> for Hsla<u8> {
    fn from(Hsla { hue, saturation, lightness, alpha }: Hsla<f32>) -> Self {
        Self::new(
            (hue.clamp_channel() * 255.0).round() as u8,
            (saturation.clamp_channel() * 255.0).round() as u8,
            (lightness.clamp_channel() * 255.0).round() as u8,
            (alpha.clamp_channel() * 255.0).round() as u8,
        )
    }
}

impl From<Hsva<f32>> for Hsla<f32> {
    fn from(hsva: Hsva<f32>) -> Self {
        let (hsv, alpha) = hsva.split_alpha();
        Hsl::from(hsv).with_alpha(alpha)
    }
}

impl From<Rgba<f32>> for Hsla<f32> {
    fn from(rgba: Rgba<f32>) -> Self {
        let (rgb, alpha) = rgba.split_alpha();
        Hsl::from(rgb).with_alpha(alpha)
    }
}