Struct colorsys::Rgb[−][src]

pub struct Rgb { /* fields omitted */ }

The RGB color model.

Has r (red), g (green), b(blue) and optional a(alpha channel) fields. Red, green, blue values are stored between 0.0 and 255.0, alpha is between 0.0 and 1.0. If inputed or recieved values are exceeds the allowed value, or is less than zero it will be equalize to limit.

Can be converted into (and from) other color models.

Example

use colorsys::{Rgb, Hsl, prelude::*};
let mut rgb1 = Rgb::from((100.0, 255.0, 17.0));
// Rgb { r: 100.0, g: 255.0, b: 17.0, a: None }

let green = rgb1.green();
// 255.0

rgb1.set_red(108.3);
// Rgb { r: 108.3, g: 255.0, b: 17.0, .. }

let mut hsl: Hsl = rgb1.into();
// ~Hsl { h: 96.98, s: 100.0, l: 53.333, .. }

hsl.saturate( SaturationInSpace::Hsl(-57.901) );
// ~Hsl { h: 96.98, s: 42.099, l: 53.333, .. }

let mut rgb2 = Rgb::from(&hsl);
// ~Rgb { r: 124.34, g: 186.1, b: 85.9, .. }

let rgb2tuple: (f64,f64,f64) = rgb2.as_ref().into();
// (124.34, 186.1,85.9)

rgb2 += Rgb::from_hex_str("#35f15b").unwrap();;
// ~Rgb { r: 177.33, g: 255.0, b: 176.902, .. }

rgb2.set_green(-150.0);
assert_eq!(rgb2.green(), 0.0);

rgb2.lighten(-13.123);
// ~Rgb { r: 110.41, g: 0.0, b: 110.1, .. }

rgb2.grayscale_simple();
// ~Rgb { r: 55.2, g: 55.2, b: 55.2, .. }

let css_string = rgb2.to_css_string();
assert_eq!(css_string, "rgb(55,55,55)");

Implementations

`impl Rgb`[src]

`pub fn new(r: f64, g: f64, b: f64, a: Option<f64>) -> Rgb`[src]

`pub fn from_hex_str(s: &str) -> Result<Rgb, ParseError>`[src]

`pub fn to_hex_string(&self) -> String`[src]

`pub fn red(&self) -> f64`[src]

`pub fn green(&self) -> f64`[src]

`pub fn blue(&self) -> f64`[src]

`pub fn get_red(&self) -> f64`[src]

👎 Deprecated since 0.7.0:

Please use red instead

`pub fn get_green(&self) -> f64`[src]

👎 Deprecated since 0.7.0:

Please use green instead

`pub fn get_blue(&self) -> f64`[src]

👎 Deprecated since 0.7.0:

Please use blue instead

`pub fn set_red(&mut self, val: f64)`[src]

`pub fn set_green(&mut self, val: f64)`[src]

`pub fn set_blue(&mut self, val: f64)`[src]

`pub fn to_css_string(&self) -> String`[src]

`pub fn grayscale(&mut self, method: GrayScaleMethod)`[src]

`pub fn iter(&self) -> ColorIterⓘNotable traits for ColorIter impl Iterator for ColorIter type Item = f64;`[src]

`pub fn as_ratio(&self) -> RgbRatio`[src]

Trait Implementations

`impl<'a> Add<&'a Rgb> for &'a Rgb`[src]

`type Output = Rgb`

The resulting type after applying the + operator.

`fn add(self, rhs: &Rgb) -> Rgb`[src]

`impl<'a> Add<&'a mut Rgb> for &'a mut Rgb`[src]

`type Output = Rgb`

The resulting type after applying the + operator.

`fn add(self, rhs: &'a mut Rgb) -> Rgb`[src]

`impl Add<Rgb> for Rgb`[src]

`type Output = Rgb`

The resulting type after applying the + operator.

`fn add(self, rhs: Self) -> Self`[src]

`impl AddAssign<Rgb> for Rgb`[src]

`fn add_assign(&mut self, rhs: Self)`[src]

`impl ApproxEq<Hsl> for Rgb`[src]

`fn approx_eq(&self, hsl: &Hsl) -> bool`[src]

`fn approx_eq_clarify(&self, hsl: &Hsl, precision: f64) -> bool`[src]

`impl ApproxEq<Rgb> for Hsl`[src]

`fn approx_eq(&self, rgb: &Rgb) -> bool`[src]

`fn approx_eq_clarify(&self, rgb: &Rgb, precision: f64) -> bool`[src]

`impl ApproxEq<Rgb> for Rgb`[src]

`fn approx_eq(&self, other: &Rgb) -> bool`[src]

`fn approx_eq_clarify(&self, other: &Rgb, precision: f64) -> bool`[src]

`impl AsRef<Rgb> for Rgb`[src]

`fn as_ref(&self) -> &Rgb`[src]

`impl Clone for Rgb`[src]

`fn clone(&self) -> Rgb`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl ColorAlpha for Rgb`[src]

`fn get_alpha(&self) -> f64`[src]

`fn set_alpha(&mut self, val: f64)`[src]

`fn opacify(&mut self, val: f64)`[src]

`impl ColorTransform for Rgb`[src]

`fn lighten(&mut self, amt: f64)`[src]

Lighten or darken color. amt is a percent with negative values - -100..100

Example

use colorsys::{Rgb,ColorTransform, ColorTuple};
let tuple = (30.0, 108.0, 77.0);
let mut rgb = Rgb::from(&tuple);

rgb.lighten(20.0);
assert_eq!(rgb.to_css_string(), "rgb(52,188,134)" );

rgb.lighten(-20.0);
assert_eq!(rgb.to_css_string(), "rgb(30,108,77)" );

rgb.lighten(-20.0);
assert_eq!(rgb.to_css_string(), "rgb(8,28,20)" );

rgb.lighten(301.123);
assert_eq!(rgb.to_css_string(), "rgb(255,255,255)" );

`fn saturate(&mut self, sat: SaturationInSpace)`[src]

`fn adjust_hue(&mut self, hue: f64)`[src]

`fn grayscale_simple(&mut self)`[src]

`fn invert(&mut self)`[src]

`impl Debug for Rgb`[src]

`fn fmt(&self, f: &mut Formatter<'_>) -> Result`[src]

`impl Default for Rgb`[src]

`fn default() -> Rgb`[src]

`impl From<&'_ [f32; 3]> for Rgb`[src]

`fn from(v: &[f32; 3]) -> Rgb`[src]

`impl From<&'_ [f32; 4]> for Rgb`[src]

`fn from(v: &[f32; 4]) -> Rgb`[src]

`impl From<&'_ [f64; 3]> for Rgb`[src]

`fn from(v: &[f64; 3]) -> Rgb`[src]

`impl From<&'_ [f64; 4]> for Rgb`[src]

`fn from(v: &[f64; 4]) -> Rgb`[src]

`impl From<&'_ [i16; 3]> for Rgb`[src]

`fn from(v: &[i16; 3]) -> Rgb`[src]

`impl From<&'_ [i32; 3]> for Rgb`[src]

`fn from(v: &[i32; 3]) -> Rgb`[src]

`impl From<&'_ [i64; 3]> for Rgb`[src]

`fn from(v: &[i64; 3]) -> Rgb`[src]

`impl From<&'_ [u16; 3]> for Rgb`[src]

`fn from(v: &[u16; 3]) -> Rgb`[src]

`impl From<&'_ [u32; 3]> for Rgb`[src]

`fn from(v: &[u32; 3]) -> Rgb`[src]

`impl From<&'_ [u64; 3]> for Rgb`[src]

`fn from(v: &[u64; 3]) -> Rgb`[src]

`impl From<&'_ [u8; 3]> for Rgb`[src]

`fn from(v: &[u8; 3]) -> Rgb`[src]

`impl From<&'_ (f32, f32, f32, f32)> for Rgb`[src]

`fn from(v: &(f32, f32, f32, f32)) -> Rgb`[src]

`impl From<&'_ (f32, f32, f32)> for Rgb`[src]

`fn from(v: &(f32, f32, f32)) -> Rgb`[src]

`impl From<&'_ (f64, f64, f64, f64)> for Rgb`[src]

`fn from(v: &(f64, f64, f64, f64)) -> Rgb`[src]

`impl From<&'_ (f64, f64, f64)> for Rgb`[src]

`fn from(v: &(f64, f64, f64)) -> Rgb`[src]

`impl From<&'_ (i16, i16, i16)> for Rgb`[src]

`fn from(v: &(i16, i16, i16)) -> Rgb`[src]

`impl From<&'_ (i32, i32, i32)> for Rgb`[src]

`fn from(v: &(i32, i32, i32)) -> Rgb`[src]

`impl From<&'_ (i64, i64, i64)> for Rgb`[src]

`fn from(v: &(i64, i64, i64)) -> Rgb`[src]

`impl From<&'_ (u16, u16, u16)> for Rgb`[src]

`fn from(v: &(u16, u16, u16)) -> Rgb`[src]

`impl From<&'_ (u32, u32, u32)> for Rgb`[src]

`fn from(v: &(u32, u32, u32)) -> Rgb`[src]

`impl From<&'_ (u64, u64, u64)> for Rgb`[src]

`fn from(v: &(u64, u64, u64)) -> Rgb`[src]

`impl From<&'_ (u8, u8, u8)> for Rgb`[src]

`fn from(v: &(u8, u8, u8)) -> Rgb`[src]

`impl From<&'_ Hsl> for Rgb`[src]

`fn from(hsl: &Hsl) -> Self`[src]

Example

use colorsys::{Rgb,Hsl,prelude::*};
let hsl = Hsl::from(&(48.0, 70.0, 50.0));
let rgb: Rgb = Rgb::from(&hsl);
assert_eq!(rgb.to_css_string(), "rgb(217,181,38)");

`impl From<&'_ Rgb> for Hsl`[src]

`fn from(rgb: &Rgb) -> Self`[src]

Example

use colorsys::{Rgb,Hsl,prelude::*};
let rgb = Rgb::from(&(215.0, 231.0, 236.0));
let hsl = Hsl::from(&rgb);
assert_eq!(hsl.to_css_string(), "hsl(194,36%,88%)");

`impl From<&'_ RgbRatio> for Rgb`[src]

`fn from(r: &RgbRatio) -> Self`[src]

`impl From<&'_ mut Hsl> for Rgb`[src]

`fn from(hsl: &mut Hsl) -> Self`[src]

Example

use colorsys::{Rgb,Hsl,prelude::*};
let mut hsl = Hsl::from(&(359.0, 33.0, 77.0));
let rgb_string = Rgb::from(&mut hsl).to_css_string();
assert_eq!(rgb_string, "rgb(216,177,178)");

`impl From<&'_ mut Rgb> for Hsl`[src]

`fn from(rgb: &mut Rgb) -> Self`[src]

Example

use colorsys::{Rgb,Hsl,prelude::*};
let mut rgb = Rgb::from(&(0.0, 0.0, 0.0));
let hsl_string = Hsl::from(&mut rgb).to_css_string();
assert_eq!(hsl_string, "hsl(0,0%,0%)");

`impl From<&'_ mut RgbRatio> for Rgb`[src]

`fn from(r: &mut RgbRatio) -> Self`[src]

`impl From<[f32; 3]> for Rgb`[src]

`fn from(v: [f32; 3]) -> Rgb`[src]

`impl From<[f32; 4]> for Rgb`[src]

`fn from(v: [f32; 4]) -> Rgb`[src]

`impl From<[f64; 3]> for Rgb`[src]

`fn from(v: [f64; 3]) -> Rgb`[src]

`impl From<[f64; 4]> for Rgb`[src]

`fn from(v: [f64; 4]) -> Rgb`[src]

`impl From<[i16; 3]> for Rgb`[src]

`fn from(v: [i16; 3]) -> Rgb`[src]

`impl From<[i32; 3]> for Rgb`[src]

`fn from(v: [i32; 3]) -> Rgb`[src]

`impl From<[i64; 3]> for Rgb`[src]

`fn from(v: [i64; 3]) -> Rgb`[src]

`impl From<[u16; 3]> for Rgb`[src]

`fn from(v: [u16; 3]) -> Rgb`[src]

`impl From<[u32; 3]> for Rgb`[src]

`fn from(v: [u32; 3]) -> Rgb`[src]

`impl From<[u64; 3]> for Rgb`[src]

`fn from(v: [u64; 3]) -> Rgb`[src]

`impl From<[u8; 3]> for Rgb`[src]

`fn from(v: [u8; 3]) -> Rgb`[src]

`impl From<(f32, f32, f32, f32)> for Rgb`[src]

`fn from(v: (f32, f32, f32, f32)) -> Rgb`[src]

`impl From<(f32, f32, f32)> for Rgb`[src]

`fn from(v: (f32, f32, f32)) -> Rgb`[src]

`impl From<(f64, f64, f64, f64)> for Rgb`[src]

`fn from(v: (f64, f64, f64, f64)) -> Rgb`[src]

`impl From<(f64, f64, f64)> for Rgb`[src]

`fn from(v: (f64, f64, f64)) -> Rgb`[src]

`impl From<(i16, i16, i16)> for Rgb`[src]

`fn from(v: (i16, i16, i16)) -> Rgb`[src]

`impl From<(i32, i32, i32)> for Rgb`[src]

`fn from(v: (i32, i32, i32)) -> Rgb`[src]

`impl From<(i64, i64, i64)> for Rgb`[src]

`fn from(v: (i64, i64, i64)) -> Rgb`[src]

`impl From<(u16, u16, u16)> for Rgb`[src]

`fn from(v: (u16, u16, u16)) -> Rgb`[src]

`impl From<(u32, u32, u32)> for Rgb`[src]

`fn from(v: (u32, u32, u32)) -> Rgb`[src]

`impl From<(u64, u64, u64)> for Rgb`[src]

`fn from(v: (u64, u64, u64)) -> Rgb`[src]

`impl From<(u8, u8, u8)> for Rgb`[src]

`fn from(v: (u8, u8, u8)) -> Rgb`[src]

`impl From<Hsl> for Rgb`[src]

`fn from(hsl: Hsl) -> Self`[src]

Example

use colorsys::{Rgb,Hsl,prelude::*};
let hsl = Hsl::from(&(192.0, 67.0, 28.0));
let rgb_string = Rgb::from(hsl).to_css_string();
assert_eq!(rgb_string, "rgb(24,100,119)");

`impl From<Rgb> for Hsl`[src]

`fn from(rgb: Rgb) -> Self`[src]

Example

use colorsys::{Rgb,Hsl,prelude::*};
let rgb = Rgb::from(&(255.0, 255.0, 255.0));
let hsl_string = Hsl::from(rgb).to_css_string();
assert_eq!(hsl_string, "hsl(0,0%,100%)");