Struct colorsys::Rgb

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

Methods

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 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

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

pub fn iter(&self) -> ColorIter

Trait Implementations

impl ApproxEq<Rgb> for Hsl

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

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

impl ApproxEq<Rgb> for Rgb

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

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

impl ApproxEq<Hsl> for Rgb

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

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

impl ColorAlpha for Rgb

fn get_alpha(&self) -> f64

Returns alpha channel. If it not setted will returns 1.0

fn set_alpha(&mut self, val: f64)

Sets alpha channel use colorsys::{Hsl,ColorAlpha}; let mut hsl = Hsl::default(); // Hsl { a: None, .. } hsl.set_alpha(0.45); // Hsl { a: 0.45, .. } hsl.set_alpha(123.015); // Hsl { a: 1.0, .. } hsl.set_alpha(-123.3); // Hsl { a: 0.0, .. }

fn opacify(&mut self, val: f64)

Increase/decrease color alpha channel with specified value. Value can be negative. # Example use colorsys::{Hsl,ColorAlpha}; let mut hsl = Hsl::default(); // Hsl { a: None, .. } hsl.opacify(-0.3); // Hsl { a: 0.7, .. } hsl.opacify(0.015); // Hsl { a: 0.715, .. }

impl ColorTransform for Rgb

fn lighten(&mut self, amt: f64)

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)

Saturate/desaturate color. Value is percent: -100..100. You need specify in what color space you want to increase/decrease saturation.

fn adjust_hue(&mut self, hue: f64)

increase/decrease color tone. Value is degree - -360..360.

fn grayscale_simple(&mut self)

Brings color to a shade of gray. For more specific grayscale methods see Rgb.grayscale

fn invert(&mut self)

Just inverts color

impl<'a> Into<(f64, f64, f64)> for &'a Rgb

fn into(self) -> ColorTuple

Performs the conversion.

impl<'a> Into<(f64, f64, f64)> for &'a mut Rgb

fn into(self) -> ColorTuple

Performs the conversion.

impl Into<(f64, f64, f64)> for Rgb

fn into(self) -> ColorTuple

Performs the conversion.

impl<'a> Into<(f64, f64, f64, f64)> for &'a Rgb

fn into(self) -> ColorTupleA

Performs the conversion.

impl<'a> Into<(f64, f64, f64, f64)> for &'a mut Rgb

fn into(self) -> ColorTupleA

Performs the conversion.

impl Into<(f64, f64, f64, f64)> for Rgb

fn into(self) -> ColorTupleA

Performs the conversion.

impl Default for Rgb

fn default() -> Rgb

Returns the "default value" for a type.

impl PartialEq<Rgb> for Rgb

fn eq(&self, other: &Rgb) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rgb) -> bool

This method tests for !=.

impl<'_> From<&'_ Rgb> for Hsl

fn from(rgb: &Rgb) -> Self

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<&'_ mut Rgb> for Hsl

fn from(rgb: &mut Rgb) -> Self

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<Rgb> for Hsl

fn from(rgb: Rgb) -> Self

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

impl<'_> From<&'_ (f64, f64, f64)> for Rgb

fn from(t: &ColorTuple) -> Rgb

Performs the conversion.

impl From<(f64, f64, f64)> for Rgb

fn from(t: ColorTuple) -> Rgb

Performs the conversion.

impl<'_> From<&'_ (f64, f64, f64, f64)> for Rgb

fn from(t: &ColorTupleA) -> Rgb

Performs the conversion.

impl From<(f64, f64, f64, f64)> for Rgb

fn from(t: ColorTupleA) -> Rgb

Performs the conversion.

impl<'_> From<&'_ Hsl> for Rgb

fn from(hsl: &Hsl) -> Self

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<&'_ mut Hsl> for Rgb

fn from(hsl: &mut Hsl) -> Self

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<Hsl> for Rgb

fn from(hsl: Hsl) -> Self

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 AsRef<Rgb> for Rgb

fn as_ref(&self) -> &Rgb

Performs the conversion.

impl Clone for Rgb

fn clone(&self) -> Rgb

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> IntoIterator for &'a Rgb

type Item = f64

The type of the elements being iterated over.

type IntoIter = ColorIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> ColorIter

Creates an iterator from a value.

impl IntoIterator for Rgb

type Item = f64

The type of the elements being iterated over.

type IntoIter = ColorIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> ColorIter

Creates an iterator from a value.

impl Debug for Rgb

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

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

type Output = Rgb

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Rgb

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rgb> for Rgb

type Output = Rgb

The resulting type after applying the + operator.

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

Performs the + operation.

impl Sub<Rgb> for Rgb

type Output = Rgb

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<'a> Sub<&'a Rgb> for &'a Rgb

type Output = Rgb

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Rgb

Performs the - operation.

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

type Output = Rgb

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Rgb

Performs the - operation.

impl AddAssign<Rgb> for Rgb

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl SubAssign<Rgb> for Rgb

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl FromStr for Rgb

type Err = ParseError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.