Struct Rgb

Source

pub struct Rgb { /* private fields */ }

Expand description

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)");

Struct Rgb Copy item path

§Example

Implementations§

impl Rgb

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

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

pub fn to_hex_string(&self) -> String

pub fn red(&self) -> f64

pub fn green(&self) -> f64

pub fn blue(&self) -> f64

pub fn get_red(&self) -> f64

pub fn get_green(&self) -> f64

pub fn get_blue(&self) -> f64

pub fn set_red(&mut self, val: f64)

pub fn set_green(&mut self, val: f64)

pub fn set_blue(&mut self, val: f64)

pub fn to_css_string(&self) -> String

§Example

pub fn grayscale(&mut self, method: GrayScaleMethod)

pub fn iter(&self) -> ColorUnitsIter

pub fn as_ratio(&self) -> RgbRatio

Trait Implementations§

impl<'a> Add for &'a Rgb

type Output = Rgb

fn add(self, rhs: &Rgb) -> Rgb

impl<'a> Add for &'a mut Rgb

type Output = Rgb

fn add(self, rhs: &'a mut Rgb) -> Rgb

impl Add for Rgb

type Output = Rgb

fn add(self, rhs: Rgb) -> Rgb

impl AddAssign for Rgb

fn add_assign(&mut self, rhs: Rgb)

impl ApproxEq<Hsl> for Rgb

fn approx_eq(&self, hsl: &Hsl) -> bool

fn approx_eq_clarify(&self, hsl: &Hsl, precision: f64) -> bool

impl ApproxEq<Rgb> for Hsl

fn approx_eq(&self, rgb: &Rgb) -> bool

fn approx_eq_clarify(&self, rgb: &Rgb, precision: f64) -> bool

impl AsRef<Rgb> for Rgb

fn as_ref(&self) -> &Rgb

impl Clone for Rgb

fn clone(&self) -> Rgb

fn clone_from(&mut self, source: &Self)

impl ColorTransform for Rgb

fn lighten(&mut self, amt: f64)

§Example

fn saturate(&mut self, sat: SaturationInSpace)

fn adjust_hue(&mut self, hue: f64)

fn grayscale_simple(&mut self)

fn invert(&mut self)

impl Debug for Rgb

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Default for Rgb

fn default() -> Rgb

impl From<&[f32; 3]> for Rgb

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

impl From<&[f32; 4]> for Rgb

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

impl From<&[f64; 3]> for Rgb

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

impl From<&[f64; 4]> for Rgb

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

impl From<&[i16; 3]> for Rgb

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

impl From<&[i32; 3]> for Rgb

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

impl From<&[i64; 3]> for Rgb

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

impl From<&[u16; 3]> for Rgb

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

impl From<&[u32; 3]> for Rgb

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

impl From<&[u64; 3]> for Rgb

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

impl From<&[u8; 3]> for Rgb

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

impl From<&(f32, f32, f32)> for Rgb

fn from(v: &(f32, f32, f32)) -> Rgb

impl From<&(f32, f32, f32, f32)> for Rgb

Struct Rgb