cowor 0.1.0

A color conversion and manipulation library
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

mod conversions;
#[cfg(test)]
mod tests;

/// A struct representing a color in the CIELCh color space.
#[derive(Debug, Clone, Copy)]
pub struct Cielch(f32, f32, f32); // lightness, chroma, hue

impl Cielch {
    /// Creates a Cielch instance from 3 float
    /// representing the lightness, chroma, and hue components.
    ///
    /// The lightness component must between 0 and 100 included
    /// otherwise it doesn't represent a valid CIELCh color
    /// and the return value is None.
    ///
    /// The hue component is in radians.
    ///
    /// # Examples
    ///
    /// ```
    /// use cowor::Cielch;
    /// let valid = Cielch::new(10.0, 20.0, 30f32.to_radians()); // Ok.
    /// let invalid = Cielch::new(110.0, 20.0, 30f32.to_radians()); // Not ok. The lightness component is greater than 100.
    /// assert!(valid.is_some());
    /// assert!(invalid.is_none());
    /// ```
    pub fn new(lightness: f32, chroma: f32, hue: f32) -> Option<Self> {
        match (0f32..=100f32).contains(&lightness) {
            true    => Some(Self(lightness, chroma, hue)),
            false   => None,
        }
    }

    /// Lightness component of a CIELCh color.
    /// Value is between 0 and 100 included.
    ///
    /// # Examples
    ///
    /// ```
    /// use cowor::Cielch;
    /// let cielab = Cielch::new(10.0, 20.0, 30f32.to_radians()).unwrap();
    /// assert_eq!(cielab.lightness(), 10.0);
    /// ```
    pub fn lightness(&self) -> f32 {
        self.0
    }

    /// Chroma component of a CIELCh color.
    ///
    /// # Examples
    ///
    /// ```
    /// use cowor::Cielch;
    /// let cielab = Cielch::new(10.0, 20.0, 30f32.to_radians()).unwrap();
    /// assert_eq!(cielab.chroma(), 20.0);
    /// ```
    pub fn chroma(&self) -> f32 {
        self.1
    }

    /// Hue component of a CIELCh color.
    /// Value is in radians.
    ///
    /// # Examples
    ///
    /// ```
    /// use cowor::Cielch;
    /// let cielab = Cielch::new(10.0, 20.0, 30f32.to_radians()).unwrap();
    /// assert_eq!(cielab.hue(), 30f32.to_radians());
    /// ```
    pub fn hue(&self) -> f32 {
        self.2
    }
}

/// Two Cielch instances are equal if all their components are equal
/// unless the chroma components are both 0 in which case
/// only the lightness components are compared.
///
/// # Examples
///
/// ```
/// use cowor::Cielch;
/// let a = Cielch::new(10.0, 20.0, 30f32.to_radians()).unwrap();
/// let b = Cielch::new(10.0, 0.0, 30f32.to_radians()).unwrap();
/// let c = Cielch::new(10.0, 0.0, 60f32.to_radians()).unwrap();
/// assert_ne!(a, b);
/// assert_eq!(b, c);
/// assert_eq!(a, a);
/// ```
impl PartialEq for Cielch {
    fn eq(&self, other: &Self) -> bool {
        let lhs = [self.lightness(), self.chroma(), self.hue()];
        let rhs = [other.lightness(), other.chroma(), other.hue()];
        match self.chroma() != 0f32 || other.chroma() != 0f32 {
            true    => (0..3).all(|x| lhs[x] == rhs[x]),
            false   => self.lightness() == other.lightness(),
        }
    }
}