Struct colorsys::Rgb[−][src]

pub struct Rgb { /* fields omitted */ }

The RGB color model.

Has red, green, blue and optional alpha channel fields. Red, green, blue values are stored between 0.0 and 255.0, alpha is between 0.0 and 1.0. If inputted or received values are exceeds the allowed value, or is less than zero it will be equalize to limit.

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]

Returns a String that can be used in CSS.

Example

use colorsys::{Rgb};

let rgb = Rgb::from([55.0,31.1, 201.9]);
assert_eq!(rgb.to_css_string(), "rgb(55,31,202)");

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

`pub fn iter(&self) -> ColorUnitsIter`[src]

Returns an iterator over three color units and the possibly alpha value.

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

Returns an RGB representation with values converted to floar from 0.0 to 1.0

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 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 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<&'_ Cmyk> for Rgb`[src]

`fn from(cmyk: &Cmyk) -> Self`[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<&'_ Rgb> for Cmyk`[src]

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

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

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

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

`fn from(cmyk: &mut Cmyk) -> 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 Rgb> for Cmyk`[src]

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

`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<Cmyk> for Rgb`[src]

`fn from(cmyk: Cmyk) -> Self`[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%)");