colorsys 0.7.3

A module for color conversion and mutation. Works with RGB(a)( as hexadecimal too), HSL(a), CMYK color models and with ANSI color codes
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

#[cfg(not(feature = "std"))]
use alloc::string::String;

pub use ratio::HslRatio;

use crate::{ColorAlpha, ColorTupleA, ColorUnitsIter, ParseError, Rgb};
use crate::common::{Hs, hsl_hsv_from_str, tuple_to_string};
use crate::units::{Alpha, GetColorUnits, Unit, Units};

#[cfg(test)]
mod tests;

mod from;
mod ops;
mod ratio;
mod transform;

/// The HSL or HSI (hue, saturation, lightness (intensity)) color model
///
/// Ranges:
/// * hue: 0.0 - 360.0
/// * saturation: 0.0 - 100.0
/// * saturation: 0.0 - 100.0
/// * alpha: 0.0 - 1.0
#[derive(Debug, PartialEq, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Hsl {
  pub(crate) units: Units,
}

iter_def!(Hsl);
pub(crate) fn new_hsl_units(h: f64, s: f64, l: f64) -> Units {
  let ul = [Unit::new_hue(h), Unit::new_percent(s), Unit::new_percent(l), Unit::default()];
  Units { len: 3, list: ul, alpha: Alpha::default() }
}


impl Hsl {
  pub fn new(h: f64, s: f64, l: f64, a: Option<f64>) -> Hsl {
    let mut units = new_hsl_units(h, s, l);
    units.alpha.set_opt(a);
    units.restrict();
    Hsl { units }
  }

  pub(crate) fn from_units(u: Units) -> Self { Hsl { units: u } }

  pub fn to_css_string(&self) -> String {
    let t: ColorTupleA = self.into();
    tuple_to_string(&t, "hsl")
  }

  pub fn hue(&self) -> f64 { self.units[0] }
  pub fn saturation(&self) -> f64 { self.units[1] }
  pub fn lightness(&self) -> f64 { self.units[2] }

  #[deprecated(since = "0.7.0", note = "Please use `hue` instead")]
  pub fn get_hue(&self) -> f64 {
    self.hue()
  }
  #[deprecated(since = "0.7.0", note = "Please use `saturation` instead")]
  pub fn get_saturation(&self) -> f64 {
    self.saturation()
  }
  #[deprecated(since = "0.7.0", note = "Please use `lightness` instead")]
  pub fn get_lightness(&self) -> f64 {
    self.lightness()
  }

  pub fn set_hue(&mut self, val: f64) { self.units.list[0].set(val); }
  pub fn set_saturation(&mut self, val: f64) { self.units.list[1].set(val); }
  pub fn set_lightness(&mut self, val: f64) { self.units.list[2].set(val); }

  /// Returns an iterator over three color units and the possibly alpha value.
  pub fn iter(&self) -> ColorUnitsIter {
    ColorUnitsIter::from_units(&self.units)
  }

  /// Returns an HSL representation with values converted to floar from 0.0 to 1.0
  pub fn as_ratio(&self) -> HslRatio {
    HslRatio::from_units(self.units.as_ratio())
  }
}

//
//
//
// Default
//
impl Default for Hsl {
  fn default() -> Hsl {
    Hsl::from_units(new_hsl_units(0.0, 0.0, 0.0))
  }
}

//
//
//
// AsRef<Hsl>
//
impl AsRef<Hsl> for Hsl {
  fn as_ref(&self) -> &Hsl {
    self
  }
}

//
//
//
// FromStr
//
impl core::str::FromStr for Hsl {
  type Err = ParseError;
  fn from_str(s: &str) -> Result<Hsl, ParseError> {
    let (tuple, alpha) = hsl_hsv_from_str(s, Hs::Hsl)?;
    let mut hsl = Hsl::from(&tuple);
    if let Some(a) = alpha {
      hsl.set_alpha(a);
    }
    Ok(hsl)
  }
}


impl GetColorUnits for Hsl {
  fn get_units(&self) -> &Units {
    &self.units
  }
  fn get_units_mut(&mut self) -> &mut Units {
    &mut self.units
  }
}