Struct chocodye::Rgb

pub struct Rgb {
    pub r: u8,
    pub g: u8,
    pub b: u8,
}

A color represented by three u8 components.

Fields

r: u8

The red component.

g: u8

The green component.

b: u8

The blue component.

Implementations

impl Rgb

pub const WHITE: Rgb = _

(255, 255, 255)

pub const BLACK: Rgb = _

(0, 0, 0)

pub const RED: Rgb = _

(255, 0, 0)

pub const GREEN: Rgb = _

(0, 255, 0)

pub const BLUE: Rgb = _

(0, 0, 255)

pub const YELLOW: Rgb = _

(255, 255, 0)

pub const CYAN: Rgb = _

(0, 255, 255)

pub const MAGENTA: Rgb = _

(255, 0, 255)

pub const fn new(r: u8, g: u8, b: u8) -> Rgb

Creates a new color.

Examples

use chocodye::Rgb;

assert_eq!(Rgb::new(5, 7, 11), Rgb { r: 5, g: 7, b: 11 });

pub const fn gray(rgb: u8) -> Rgb

Creates a new color with all three components set to the same value.

Examples

use chocodye::Rgb;

assert_eq!(Rgb::gray(127), Rgb::new(127, 127, 127));

pub fn from_hex(s: &str) -> Result<Rgb, ParseHexError>

Parses a hex color.

Examples

use chocodye::Rgb;

assert_eq!(Rgb::from_hex("#ffffff"), Ok(Rgb::new(255, 255, 255)));
assert!(Rgb::from_hex("#fff").is_err());
assert!(Rgb::from_hex("ffffff").is_err());

pub const fn checked_add_signed(self, r: i8, g: i8, b: i8) -> Option<Rgb>

Checked addition with three signed components. Computes self + rgb, returning None if overflow occured.

Examples

use chocodye::Rgb;

assert_eq!(Rgb::new(20, 30, 40).checked_add_signed(2, -2, 0), Some(Rgb::new(22, 28, 40)));
assert_eq!(Rgb::new(10, 2, 250).checked_add_signed(4, -5, 1), None); // `g` would underflow.

pub const fn distance(self, other: Rgb) -> u32

Computes the squared Euclidian distance between self and other. Does not take human perception into consideration. Useful for intermediate algorithms.

Examples

use chocodye::Rgb;

assert_eq!(Rgb::WHITE.distance(Rgb::WHITE), 0);
assert_eq!(Rgb::gray(8).distance(Rgb::gray(16)), Rgb::gray(24).distance(Rgb::gray(16)));

pub fn luma(self) -> u8

Computes the luma, the brightness of self. Takes human perception into account. Useful for sorting colors.

Examples

use chocodye::Rgb;

assert_eq!(Rgb::WHITE.luma(), 255);
assert_eq!(Rgb::BLACK.luma(), 0);

assert_eq!(Rgb::new(10, 20, 30).luma(), 18);
assert_eq!(Rgb::new(20, 40, 60).luma(), 36);

assert!(Rgb::GREEN.luma() > Rgb::RED.luma()); // Humans are more sensitive to green.

pub fn grayscale(self) -> Rgb

Converts this color into a gray shade. Takes human perception into account.

Examples

use chocodye::Rgb;

assert_eq!(Rgb::RED.grayscale(), Rgb::gray(76));
assert_eq!(Rgb::WHITE.grayscale(), Rgb::WHITE);
assert_eq!(Rgb::BLACK.grayscale(), Rgb::BLACK);

Trait Implementations

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

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

Formats the value using the given formatter.

impl Default for Rgb

fn default() -> Rgb

The default color is arbitrarily set to #5bcefa, a light blue.

impl From<Dye> for Rgb

fn from(dye: Dye) -> Rgb

Converts a dye into its color.

impl From<Rgb> for u32

fn from(value: Rgb) -> u32

Converts this color to an u32 in RRGGBBAA format. The alpha bits are set to 0xFF.

Examples

use chocodye::Rgb;

assert_eq!(u32::from(Rgb::new(1, 2, 3)), 0x010203FF);
assert_ne!(u32::from(Rgb::from(0x0ABCDEF0)), 0x0ABCDEF0); // The alpha bits are lost.

impl From<u32> for Rgb

fn from(value: u32) -> Rgb

Converts an u32 in RRGGBBAA format to its corresponding color. The alpha bits are ignored.

Examples

use chocodye::Rgb;

assert_eq!(Rgb::from(0x01020300), Rgb::new(1, 2, 3));

impl Hash for Rgb

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl LowerHex for Rgb

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

Formats self as a hex color.

Examples

use chocodye::Rgb;

assert_eq!(format!("{:x}", Rgb::RED), "#ff0000");

impl PartialEq 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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<Rgb> for Dye

type Error = Dye

The closest match if there is no exact match.

fn try_from(value: Rgb) -> Result<Dye, Self::Error>

Converts a color to a dye, returning Ok(_) for an exact match, or Err(_) for the closest match.

Examples

use chocodye::{Dye, Rgb};

assert_eq!(Dye::AppleGreen.color(), Rgb::new(155, 179, 99));
assert_eq!(Dye::try_from(Rgb::new(155, 179, 99)), Ok(Dye::AppleGreen));
assert_eq!(Dye::try_from(Rgb::new(155, 179, 98)), Err(Dye::AppleGreen));

// use `std::convert::identity` if you don't care about exact matches
assert_eq!(Dye::try_from(Rgb::WHITE).unwrap_or_else(identity), Dye::LotusPink);
assert_eq!(Dye::try_from(Rgb::BLACK).unwrap_or_else(identity), Dye::InkBlue);

impl UpperHex for Rgb

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

Formats self as a hex color.

Examples

use chocodye::Rgb;

assert_eq!(format!("{:X}", Rgb::RED), "#FF0000");

impl Copy for Rgb

impl Eq for Rgb

impl StructuralPartialEq for Rgb