# Struct palette::Rgb
[−]
[src]

`pub struct Rgb<Wp = D65, T = f32> where`

T: Float,

Wp: WhitePoint<T>, {
pub red: T,
pub green: T,
pub blue: T,
pub white_point: PhantomData<Wp>,
}

Linear RGB.

RGB is probably the most common color space, when it comes to computer graphics, and it's defined as an additive mixture of red, green and blue light, where gray scale colors are created when these three channels are equal in strength. This particular RGB type is based on the ITU-R BT.709 primaries, which makes it a linear version of sRGB.

Conversions and operations on this color space assumes that it's linear,
meaning that gamma correction is required when converting to and from a
displayable RGB, such as sRGB. See the `pixel`

module
for encoding types.

## Fields

`red: T`

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

`green: T`

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

`blue: T`

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

`white_point: PhantomData<Wp>`

The white point associated with the color's illuminant and observer. D65 for 2 degree observer is used by default.

## Methods

`impl<T> Rgb<D65, T> where`

T: Float,

[src]

T: Float,

`fn new(red: T, green: T, blue: T) -> Rgb<D65, T>`

Linear RGB with white point D65.

`fn new_u8(red: u8, green: u8, blue: u8) -> Rgb<D65, T>`

Linear RGB from 8 bit values with whtie point D65.

`impl<Wp, T> Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`fn with_wp(red: T, green: T, blue: T) -> Rgb<Wp, T>`

Linear RGB.

`fn with_wp_u8(red: u8, green: u8, blue: u8) -> Rgb<Wp, T>`

Linear RGB from 8 bit values.

`fn from_pixel<P: RgbPixel<T>>(pixel: &P) -> Rgb<Wp, T>`

Linear RGB from a linear pixel value.

`fn to_pixel<P: RgbPixel<T>>(&self) -> P`

Convert to a linear RGB pixel. `Rgb`

is already assumed to be linear,
so the components will just be clamped to [0.0, 1.0] before conversion.

use palette::Rgb; let c = Rgb::new(0.5, 0.3, 0.1); assert_eq!((c.red, c.green, c.blue), c.to_pixel()); assert_eq!((0.5, 0.3, 0.1), c.to_pixel());

## Trait Implementations

`impl<Wp: Debug, T: Debug> Debug for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp: PartialEq, T: PartialEq> PartialEq for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`fn eq(&self, __arg_0: &Rgb<Wp, T>) -> bool`

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

`fn ne(&self, __arg_0: &Rgb<Wp, T>) -> bool`

This method tests for `!=`

.

`impl<Wp, T> Copy for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> Clone for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`fn clone(&self) -> Rgb<Wp, T>`

Returns a copy of the value. Read more

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

1.0.0

Performs copy-assignment from `source`

. Read more

`impl<Wp, T> FromColor<Wp, T> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`fn from_xyz(xyz: Xyz<Wp, T>) -> Self`

Convert from XYZ color space

`fn from_rgb(rgb: Rgb<Wp, T>) -> Self`

Convert from RGB color space

`fn from_hsl(hsl: Hsl<Wp, T>) -> Self`

Convert from HSL color space

`fn from_hsv(hsv: Hsv<Wp, T>) -> Self`

Convert from HSV color space

`fn from_luma(luma: Luma<Wp, T>) -> Self`

Convert from Luma

`fn from_yxy(inp: Yxy<Wp, T>) -> Self`

Convert from Yxy color space

`fn from_lab(inp: Lab<Wp, T>) -> Self`

Convert from Lab* color space

`fn from_lch(inp: Lch<Wp, T>) -> Self`

Convert from LCh° color space

`fn from_hwb(inp: Hwb<Wp, T>) -> Self`

Convert from HWB color space

`impl<Wp, T> Limited for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`fn is_valid(&self) -> bool`

Check if the color's components are within the expected ranges.

`fn clamp(&self) -> Rgb<Wp, T>`

Return a new color where the components has been clamped to the nearest valid values. Read more

`fn clamp_self(&mut self)`

Clamp the color's components to the nearest valid values.

`impl<Wp, T> Mix for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Scalar = T`

The type of the mixing factor.

`fn mix(&self, other: &Rgb<Wp, T>, factor: T) -> Rgb<Wp, T>`

Mix the color with an other color, by `factor`

. Read more

`impl<Wp, T> Shade for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Scalar = T`

The type of the lighten/darken amount.

`fn lighten(&self, amount: T) -> Rgb<Wp, T>`

Lighten the color by `amount`

.

`fn darken(&self, amount: Self::Scalar) -> Self`

Darken the color by `amount`

.

`impl<Wp, T> GetHue for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Hue = RgbHue<T>`

The kind of hue unit this color space uses. Read more

`fn get_hue(&self) -> Option<RgbHue<T>>`

Calculate a hue if possible. Read more

`impl<Wp, T> Blend for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Color = Rgb<Wp, T>`

The core color type. Typically `Self`

for color types without alpha.

`fn into_premultiplied(self) -> PreAlpha<Rgb<Wp, T>, T>`

Convert the color to premultiplied alpha.

`fn from_premultiplied(color: PreAlpha<Rgb<Wp, T>, T>) -> Self`

Convert the color from premultiplied alpha.

`fn blend<F>(self, destination: Self, blend_function: F) -> Self where`

F: BlendFunction<Self::Color>,

F: BlendFunction<Self::Color>,

Blend self, as the source color, with `destination`

, using `blend_function`

. Anything that implements `BlendFunction`

is acceptable, including functions and closures. Read more

`fn over(self, other: Self) -> Self`

Place `self`

over `other`

. This is the good old common alpha composition equation. Read more

`fn inside(self, other: Self) -> Self`

Results in the parts of `self`

that overlaps the visible parts of `other`

. Read more

`fn outside(self, other: Self) -> Self`

Results in the parts of `self`

that lies outside the visible parts of `other`

. Read more

`fn atop(self, other: Self) -> Self`

Place `self`

over only the visible parts of `other`

.

`fn xor(self, other: Self) -> Self`

Results in either `self`

or `other`

, where they do not overlap.

`fn plus(self, other: Self) -> Self`

Add `self`

and `other`

. This uses the alpha component to regulate the effect, so it's not just plain component wise addition. Read more

`fn multiply(self, other: Self) -> Self`

Multiply `self`

with `other`

. This uses the alpha component to regulate the effect, so it's not just plain component wise multiplication. Read more

`fn screen(self, other: Self) -> Self`

Make a color which is at least as light as `self`

or `other`

.

`fn overlay(self, other: Self) -> Self`

Multiply `self`

or `other`

if other is dark, or screen them if `other`

is light. This results in an S curve. Read more

`fn darken(self, other: Self) -> Self`

Return the darkest parts of `self`

and `other`

.

`fn lighten(self, other: Self) -> Self`

Return the lightest parts of `self`

and `other`

.

`fn dodge(self, other: Self) -> Self`

Lighten `other`

to reflect `self`

. Results in `other`

if `self`

is black. Read more

`fn burn(self, other: Self) -> Self`

Darken `other`

to reflect `self`

. Results in `other`

if `self`

is white. Read more

`fn hard_light(self, other: Self) -> Self`

Multiply `self`

or `other`

if other is dark, or screen them if `self`

is light. This is similar to `overlay`

, but depends on `self`

instead of `other`

. Read more

`fn soft_light(self, other: Self) -> Self`

Lighten `other`

if `self`

is light, or darken `other`

as if it's burned if `self`

is dark. The effect is increased if the components of `self`

is further from 0.5. Read more

`fn difference(self, other: Self) -> Self`

Return the absolute difference between `self`

and `other`

. It's basically `abs(self - other)`

, but regulated by the alpha component. Read more

`fn exclusion(self, other: Self) -> Self`

Similar to `difference`

, but appears to result in a lower contrast. `other`

is inverted if `self`

is white, and preserved if `self`

is black. Read more

`impl<Wp, T> ComponentWise for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Scalar = T`

The scalar type for color components.

`fn component_wise<F: FnMut(T, T) -> T>(`

&self,

other: &Rgb<Wp, T>,

f: F

) -> Rgb<Wp, T>

&self,

other: &Rgb<Wp, T>,

f: F

) -> Rgb<Wp, T>

Perform a binary operation on this and an other color.

`fn component_wise_self<F: FnMut(T) -> T>(&self, f: F) -> Rgb<Wp, T>`

Perform a unary operation on this color.

`impl<Wp, T> Default for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> Add<Rgb<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Output = Rgb<Wp, T>`

The resulting type after applying the `+`

operator

`fn add(self, other: Rgb<Wp, T>) -> Rgb<Wp, T>`

The method for the `+`

operator

`impl<Wp, T> Add<T> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Output = Rgb<Wp, T>`

The resulting type after applying the `+`

operator

`fn add(self, c: T) -> Rgb<Wp, T>`

The method for the `+`

operator

`impl<Wp, T> Sub<Rgb<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Output = Rgb<Wp, T>`

The resulting type after applying the `-`

operator

`fn sub(self, other: Rgb<Wp, T>) -> Rgb<Wp, T>`

The method for the `-`

operator

`impl<Wp, T> Sub<T> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Output = Rgb<Wp, T>`

The resulting type after applying the `-`

operator

`fn sub(self, c: T) -> Rgb<Wp, T>`

The method for the `-`

operator

`impl<Wp, T> Mul<Rgb<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Output = Rgb<Wp, T>`

The resulting type after applying the `*`

operator

`fn mul(self, other: Rgb<Wp, T>) -> Rgb<Wp, T>`

The method for the `*`

operator

`impl<Wp, T> Mul<T> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Output = Rgb<Wp, T>`

The resulting type after applying the `*`

operator

`fn mul(self, c: T) -> Rgb<Wp, T>`

The method for the `*`

operator

`impl<Wp, T> Div<Rgb<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Output = Rgb<Wp, T>`

The resulting type after applying the `/`

operator

`fn div(self, other: Rgb<Wp, T>) -> Rgb<Wp, T>`

The method for the `/`

operator

`impl<Wp, T> Div<T> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`type Output = Rgb<Wp, T>`

The resulting type after applying the `/`

operator

`fn div(self, c: T) -> Rgb<Wp, T>`

The method for the `/`

operator

`impl<Wp, T> From<Srgb<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<GammaRgb<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> IntoColor<Wp, T> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`fn into_xyz(self) -> Xyz<Wp, T>`

Convert into XYZ space

`fn into_yxy(self) -> Yxy<Wp, T>`

Convert into Yxy color space

`fn into_lab(self) -> Lab<Wp, T>`

Convert into Lab* color space

`fn into_lch(self) -> Lch<Wp, T>`

Convert into LCh° color space

`fn into_rgb(self) -> Rgb<Wp, T>`

Convert into RGB color space.

`fn into_hsl(self) -> Hsl<Wp, T>`

Convert into HSL color space

`fn into_hsv(self) -> Hsv<Wp, T>`

Convert into HSV color space

`fn into_luma(self) -> Luma<Wp, T>`

Convert into Luma

`fn into_hwb(self) -> Hwb<Wp, T>`

Convert into HWB color space

`impl<Wp, T> From<Alpha<Rgb<Wp, T>, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Color<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Xyz<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Yxy<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Lab<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Lch<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Hsl<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Alpha<Hsl<Wp, T>, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Hsv<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Alpha<Hsv<Wp, T>, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Hwb<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Alpha<Hwb<Wp, T>, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Luma<Wp, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> From<Alpha<Luma<Wp, T>, T>> for Rgb<Wp, T> where`

T: Float,

Wp: WhitePoint<T>,

[src]

T: Float,

Wp: WhitePoint<T>,

`impl<Wp, T> ApproxEq for Rgb<Wp, T> where`

T: Float + ApproxEq,

T::Epsilon: Copy + Float,

Wp: WhitePoint<T>,

[src]

T: Float + ApproxEq,

T::Epsilon: Copy + Float,

Wp: WhitePoint<T>,

`type Epsilon = <T as ApproxEq>::Epsilon`

Used for specifying relative comparisons.

`fn default_epsilon() -> Self::Epsilon`

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

`fn default_max_relative() -> Self::Epsilon`

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

`fn default_max_ulps() -> u32`

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

`fn relative_eq(`

&self,

other: &Self,

epsilon: Self::Epsilon,

max_relative: Self::Epsilon

) -> bool

&self,

other: &Self,

epsilon: Self::Epsilon,

max_relative: Self::Epsilon

) -> bool

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

`fn ulps_eq(&self, other: &Self, epsilon: Self::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: &Self,

epsilon: Self::Epsilon,

max_relative: Self::Epsilon

) -> bool

&self,

other: &Self,

epsilon: Self::Epsilon,

max_relative: Self::Epsilon

) -> bool

The inverse of `ApproxEq::relative_eq`

.

`fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool`

The inverse of `ApproxEq::ulps_eq`

.