Struct nannou::color::pixel::GammaRgb

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

A gamma encoded color.

Gamma encoding or gamma correction is used to transform the intensity values to either match a non-linear display, like CRT, or to prevent banding among the darker colors. GammaRgb represents a gamma corrected RGB color, where the intensities are encoded using the following power-law expression: V ^γ (where V is the intensity value an γ is the encoding gamma).

This particular implementation is based on the ITU-R BT.709 primaries (same as in sRGB, HDTV, etc.), so decoding it will basically result in decoded sRGB.

use palette::Rgb;
use palette::pixel::GammaRgb;

let c: Rgb = GammaRgb::new_u8(128, 64, 32, 2.2).into();
assert_eq!((128, 64, 32), GammaRgb::linear_to_pixel(c, 2.2));

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.

gamma: T

The decoding gamma value. Commonly 2.2.

Methods

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

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

Create a new opaque gamma encoded color.

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

Create a new gamma encoded color with transparency.

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

Create a new opaque gamma encoded color from u8 values.

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

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

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

Create a new gamma 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, gamma: T) -> GammaRgb<T> where
    C: Into<Alpha<Rgb<T>, T>>, 

Convert linear color components to gamma 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, gamma: T) -> P where
    C: Into<Alpha<Rgb<T>, T>>,
    P: RgbPixel<T>, 

Shortcut to convert a linear color to a gamma encoded pixel.

Trait Implementations

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

type Epsilon = <T as ApproxEq>::Epsilon

Used for specifying relative comparisons.

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

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

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

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

fn default_max_ulps() -> u32

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

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

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

fn ulps_eq(
    &self,
    other: &GammaRgb<T>,
    epsilon: <GammaRgb<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.

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

The inverse of ApproxEq::relative_eq.

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

The inverse of ApproxEq::ulps_eq.

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

fn from(gamma_rgb: GammaRgb<T>) -> Alpha<Rgb<T>, T>

Performs the conversion.

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

fn from(gamma_rgb: GammaRgb<T>) -> Rgb<T>

Performs the conversion.

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

fn from(color: GammaRgb<T>) -> Color<T>

Performs the conversion.

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

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

Formats the value using the given formatter.

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

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

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

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

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

This method tests for !=.

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

fn clone(&self) -> GammaRgb<T>

Returns a copy of the value.

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

Performs copy-assignment from source.