Struct picto::color::Srgb

pub struct Srgb<T = f32> where
    T: Float,  {
    pub red: T,
    pub green: T,
    pub blue: T,
    pub alpha: T,
}

An sRGB encoded color.

sRGB is a common kind of gamma encoding, but it doesn’t exactly follow the power-law, as in GammaRgb. It’s perhaps the most common color space for monitors and on the Internet, so it’s usually safe to assume that an image or pixel with unknown gamma is sRGB encoded.

use palette::Rgb;
use palette::pixel::Srgb;

let c: Rgb = Srgb::new(0.5, 0.3, 0.1).into();
assert_eq!((0.5f32, 0.3, 0.1), Srgb::from(c).to_pixel());

Fields

red: T

The red component, where 0.0 is no red light and 1.0 is the highest displayable amount.

green: T

The green component, where 0.0 is no red light and 1.0 is the highest displayable amount.

blue: T

The blue component, where 0.0 is no red light and 1.0 is the highest displayable amount.

alpha: T

The transparency of the color. 0.0 is completely transparent and 1.0 is completely opaque.

Implementations

impl<T> Srgb<T> where
    T: Float, 

pub fn new(red: T, green: T, blue: T) -> Srgb<T>

Create a new opaque sRGB encoded color.

pub fn with_alpha(red: T, green: T, blue: T, alpha: T) -> Srgb<T>

Create a new sRGB encoded color with transparency.

pub fn new_u8(red: u8, green: u8, blue: u8) -> Srgb<T>

Create a new opaque sRGB encoded color from u8 values.

pub fn with_alpha_u8(red: u8, green: u8, blue: u8, alpha: u8) -> Srgb<T>

Create a new sRGB encoded color, with transparency, from u8 values.

pub fn from_pixel<P>(pixel: &P) -> Srgb<T> where
    P: RgbPixel<T>, 

Create a new sRGB encoded color from a pixel value.

pub fn to_pixel<P>(&self) -> P where
    P: RgbPixel<T>, 

Transform this color into a pixel representation.

pub fn from_linear<C>(color: C) -> Srgb<T> where
    C: Into<Alpha<Rgb<T>, T>>, 

Convert linear color components to sRGB encoding.

pub fn to_linear(&self) -> Alpha<Rgb<T>, T>

Decode this color to a linear representation.

pub fn linear_to_pixel<C, P>(color: C) -> P where
    C: Into<Alpha<Rgb<T>, T>>,
    P: RgbPixel<T>, 

Shortcut to convert a linear color to an sRGB encoded pixel.

Trait Implementations

impl<T> ApproxEq for Srgb<T> where
    T: Float + ApproxEq,
    <T as ApproxEq>::Epsilon: Copy,
    <T as ApproxEq>::Epsilon: Float, 

type Epsilon = <T as ApproxEq>::Epsilon

Used for specifying relative comparisons.

pub fn default_epsilon() -> <Srgb<T> as ApproxEq>::Epsilon

The default tolerance to use when testing values that are close together.

pub fn default_max_relative() -> <Srgb<T> as ApproxEq>::Epsilon

The default relative tolerance for testing values that are far-apart.

pub fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

pub fn relative_eq(
    &self,
    other: &Srgb<T>,
    epsilon: <Srgb<T> as ApproxEq>::Epsilon,
    max_relative: <Srgb<T> as ApproxEq>::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

pub fn ulps_eq(
    &self,
    other: &Srgb<T>,
    epsilon: <Srgb<T> as ApproxEq>::Epsilon,
    max_ulps: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

pub fn relative_ne(
    &self,
    other: &Srgb<T>,
    epsilon: <Srgb<T> as ApproxEq>::Epsilon,
    max_relative: <Srgb<T> as ApproxEq>::Epsilon
) -> bool

The inverse of ApproxEq::relative_eq.

pub fn ulps_ne(
    &self,
    other: &Srgb<T>,
    epsilon: <Srgb<T> as ApproxEq>::Epsilon,
    max_ulps: u32
) -> bool

The inverse of ApproxEq::ulps_eq.

impl<T> Clone for Srgb<T> where
    T: Clone + Float, 

pub fn clone(&self) -> Srgb<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Srgb<T> where
    T: Debug + Float, 

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

Formats the value using the given formatter.

impl<T> From<Alpha<Rgb<T>, T>> for Srgb<T> where
    T: Float, 

pub fn from(rgba: Alpha<Rgb<T>, T>) -> Srgb<T>

Performs the conversion.

impl<T> From<Color<T>> for Srgb<T> where
    T: Float, 

pub fn from(color: Color<T>) -> Srgb<T>

Performs the conversion.

impl<T> From<Rgb<T>> for Srgb<T> where
    T: Float, 

pub fn from(rgb: Rgb<T>) -> Srgb<T>

Performs the conversion.

impl<T> From<Srgb<T>> for Rgb<T> where
    T: Float, 

pub fn from(srgb: Srgb<T>) -> Rgb<T>

Performs the conversion.

impl<T> From<Srgb<T>> for Alpha<Rgb<T>, T> where
    T: Float, 

pub fn from(srgb: Srgb<T>) -> Alpha<Rgb<T>, T>

Performs the conversion.

impl<T> From<Srgb<T>> for Color<T> where
    T: Float, 

pub fn from(color: Srgb<T>) -> Color<T>

Performs the conversion.

impl<T> PartialEq<Srgb<T>> for Srgb<T> where
    T: PartialEq<T> + Float, 

pub fn eq(&self, other: &Srgb<T>) -> bool

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

pub fn ne(&self, other: &Srgb<T>) -> bool

This method tests for !=.

impl<C: Channel, T: Float + 'static> Pixel<C> for Srgb<T>

fn channels() -> usize

The number of channels in the Pixel.

impl<T: Float + 'static> Read<f32> for Srgb<T>

fn read(data: &[f32]) -> Self

Read a Pixel from the slice.

impl<T: Float + 'static> Read<f64> for Srgb<T>

fn read(data: &[f64]) -> Self

Read a Pixel from the slice.

impl<T: Float + 'static> Read<u16> for Srgb<T>

fn read(data: &[u16]) -> Self

Read a Pixel from the slice.

impl<T: Float + 'static> Read<u32> for Srgb<T>

fn read(data: &[u32]) -> Self

Read a Pixel from the slice.

impl<T: Float + 'static> Read<u8> for Srgb<T>

fn read(data: &[u8]) -> Self

Read a Pixel from the slice.

impl<C: Channel, T: Float + 'static> Write<C> for Srgb<T>

fn write(&self, data: &mut [C])

Write the Pixel to the slice.

impl<T> Copy for Srgb<T> where
    T: Copy + Float, 

impl<T> StructuralPartialEq for Srgb<T> where
    T: Float,