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

use super::{IsColorChannel, IsColor, HasAlpha, HasntAlpha, Hsv, Hsla, Rgba};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Hsva<T> {
    pub hue: T,
    pub saturation: T,
    pub value: T,
    pub alpha: T,
}

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

impl<T: IsColorChannel> HasAlpha for Hsva<T> {
    type Alphaless = Hsv<T>;

    fn split_alpha(self) -> (Self::Alphaless, Self::Channel) {
        let Hsva { hue, saturation, value, alpha } = self;
        (Hsv { hue, saturation, value }, alpha)
    }
}

impl<T> Hsva<T> {
    pub fn new(hue: T, saturation: T, value: T, alpha: T) -> Self {
        Self { hue, saturation, value, alpha }
    }
}

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

impl<T: IsColorChannel> From<Hsv<T>> for Hsva<T> {
    fn from(hsv: Hsv<T>) -> Self {
        hsv.with_alpha(T::MAX)
    }
}

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

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

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

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