#[repr(C)]pub struct Rgb<S = Srgb, T = f32> {
pub red: T,
pub green: T,
pub blue: T,
pub standard: PhantomData<S>,
}
Expand description
Generic 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.
§Creating a Value
RGB comes in different shapes and formats. You will probably want to start
with either the Srgb
or Srgba
alias,
which represents the common sRGB format that most images and tools use.
Then, depending on your input, you can either just call new
or
convert from another data format.
use palette::Srgb;
let rgb_u8 = Srgb::new(171u8, 193, 35);
let rgb_f32 = Srgb::new(0.3f32, 0.8, 0.1);
// `new` is also `const`:
const RGB_U8: Srgb<u8> = Srgb::new(171, 193, 35);
// Converting from one number format to another can be as simple as this:
let rgb_u8_from_f32_1: Srgb<u8> = Srgb::new(0.3f32, 0.8, 0.1).into();
// ...or more explicitly like this:
let rgb_u8_from_f32_2 = Srgb::new(0.3f32, 0.8, 0.1).into_format::<u8>();
// Hexadecimal is also supported, with or without the #:
let rgb_from_hex1: Srgb<u8> = "#f034e6".parse().unwrap();
let rgb_from_hex2: Srgb<u8> = "f034e6".parse().unwrap();
assert_eq!(rgb_from_hex1, rgb_from_hex2);
// This includes the shorthand format:
let rgb_from_short_hex: Srgb<u8> = "f3e".parse().unwrap();
let rgb_from_long_hex: Srgb<u8> = "ff33ee".parse().unwrap();
assert_eq!(rgb_from_short_hex, rgb_from_long_hex);
// It's also possible to convert from (and to) arrays, tuples and `u32` values:
let rgb_from_array = Srgb::from([171u8, 193, 35]);
let rgb_from_tuple = Srgb::from((171u8, 193, 35));
let rgb_from_u32 = Srgb::from(0x607F00);
§Linear, sRGB and Gamma Correction
Many conversions and operations on RGB require that it’s linear, meaning that gamma correction is required when converting to and from displayable RGB, such as sRGB. It’s common to store and send RGB values where the numbers are on a non-linear scale. In a non-linear format, a value of, for example, 0.5 would not represent a light intensity of 50%, which makes some operations (such as blurring) give incorrect results.
You will probably encounter or use LinSrgb
or
LinSrgba
at some point. These are aliases for linear
sRGB and would usually be obtained by converting an Srgb
value with
into_linear
.
use palette::{LinSrgb, Srgb};
// This function uses linear sRGB for something. But how do we interface with it?
fn uses_linear_srgb(input: LinSrgb<f32>) -> LinSrgb<f32> { todo!() }
// Linear sRGB will usually be created from non-linear sRGB:
let output = uses_linear_srgb(Srgb::new(0.3, 0.8, 0.1).into_linear());
// It's also possible to convert directly from u8 to f32 for sRGB.
// This is much faster than using `into_format` first:
let output = uses_linear_srgb(Srgb::new(171u8, 193, 35).into_linear());
// Converting the output back to `Srgb<u8>` (or `Srgb<f32>`) is just as simple:
let output_u8 = Srgb::<u8>::from_linear(output);
// ..or:
let output_u8: Srgb<u8> = output.into_encoding();
It’s of course also possible to create a linear value from constants, but
it’s not necessarily as intuitive. It’s best to avoid storing them as
LinSrgb<u8>
(or LinRgb<_, u8>
) values, to avoid banding among dark
colors.
See the encoding
module for built-in encoding formats.
§Storage Formats and Pixel Buffers
It’s common to read and write RGB values as bytes, hexadecimal strings, or
sometimes u32
values. A single RGB value can be converted to all of these
formats and more.
use palette::{Srgb, LinSrgb};
let source: LinSrgb<f32> = todo!();
let u8_array: [u8; 3] = Srgb::from_linear(source).into();
let hex_string1 = format!("#{:x}", Srgb::<u8>::from_linear(source)); // The # is optional.
let u32_value: u32 = Srgb::from_linear(source).into();
It’s also possible to control the component order.
PackedArgb
is one of a few aliases for
Packed
, which represents a color that has been “packed” into a specific
data format. This can be a u32
or [u8; 4]
, for example. This is helpful
for reading and writing colors with a different order than the default RGBA.
use palette::{rgb::PackedArgb, Srgba, LinSrgba};
let source: LinSrgba<f32> = todo!();
let u8_array: [u8; 4] = PackedArgb::from(Srgba::from_linear(source)).into();
let u32_value: u32 = PackedArgb::from(Srgba::from_linear(source)).into();
If you need to work with colors in a byte buffer, such as [u8]
, Vec<u8>
or the image
crate, there’s a quick way to borrow that buffer as a slice
of RGB(A) colors. The cast
module has a number of traits
and functions for casting values without copying them.
use image::RgbImage;
use palette::{cast::ComponentsAsMut, Srgb};
let mut image: RgbImage = todo!();
let pixels: &mut [Srgb<u8>] = image.components_as_mut();
for pixel in pixels {
std::mem::swap(&mut pixel.red, &mut pixel.blue);
}
Fields§
§red: T
The amount of red light, where 0.0 is no red light and 1.0 (or 255u8) is the highest displayable amount.
green: T
The amount of green light, where 0.0 is no green light and 1.0 (or 255u8) is the highest displayable amount.
blue: T
The amount of blue light, where 0.0 is no blue light and 1.0 (or 255u8) is the highest displayable amount.
standard: PhantomData<S>
The kind of RGB standard. sRGB is the default.
Implementations§
source§impl<S, T> Rgb<S, T>
impl<S, T> Rgb<S, T>
sourcepub const fn new(red: T, green: T, blue: T) -> Rgb<S, T>
pub const fn new(red: T, green: T, blue: T) -> Rgb<S, T>
Create an RGB color.
It’s possible to create a color in one number format and convert it to
another format with either into_format
or
into_linear
.
use palette::{Srgb, LinSrgb};
// Changes only the number format:
let rgb_f32: Srgb<f32> = Srgb::new(171u8, 193, 35).into_format();
// Changes the number format and converts to linear in one go.
// This is faster than `.into_format().into_linear()`:
let linear: LinSrgb<f32> = Srgb::new(171u8, 193, 35).into_linear();
sourcepub fn into_format<U>(self) -> Rgb<S, U>where
U: FromStimulus<T>,
pub fn into_format<U>(self) -> Rgb<S, U>where
U: FromStimulus<T>,
Convert the RGB components into another number type.
use palette::Srgb;
let rgb_u8: Srgb<u8> = Srgb::new(0.3, 0.7, 0.2).into_format();
See also into_linear
and
into_encoding
for a faster option if you need to
change between linear and non-linear encoding at the same time.
sourcepub fn from_format<U>(color: Rgb<S, U>) -> Selfwhere
T: FromStimulus<U>,
pub fn from_format<U>(color: Rgb<S, U>) -> Selfwhere
T: FromStimulus<U>,
Convert the RGB components from another number type.
use palette::Srgb;
let rgb_u8 = Srgb::<u8>::from_format(Srgb::new(0.3, 0.7, 0.2));
See also from_linear
and
from_encoding
for a faster option if you need to
change between linear and non-linear encoding at the same time.
sourcepub fn into_components(self) -> (T, T, T)
pub fn into_components(self) -> (T, T, T)
Convert to a (red, green, blue)
tuple.
sourcepub fn from_components((red, green, blue): (T, T, T)) -> Self
pub fn from_components((red, green, blue): (T, T, T)) -> Self
Convert from a (red, green, blue)
tuple.
source§impl<S> Rgb<S, u8>
impl<S> Rgb<S, u8>
sourcepub fn into_u32<O>(self) -> u32
pub fn into_u32<O>(self) -> u32
Convert to a packed u32
with with specifiable component order.
use palette::{rgb, Srgb};
let integer = Srgb::new(96u8, 127, 0).into_u32::<rgb::channels::Rgba>();
assert_eq!(0x607F00FF, integer);
It’s also possible to use From
and Into
, which defaults to the
0xAARRGGBB
component order:
use palette::Srgb;
let integer = u32::from(Srgb::new(96u8, 127, 0));
assert_eq!(0xFF607F00, integer);
See Packed for more details.
sourcepub fn from_u32<O>(color: u32) -> Self
pub fn from_u32<O>(color: u32) -> Self
Convert from a packed u32
with specifiable component order.
use palette::{rgb, Srgb};
let rgb = Srgb::from_u32::<rgb::channels::Rgba>(0x607F00FF);
assert_eq!(Srgb::new(96u8, 127, 0), rgb);
It’s also possible to use From
and Into
, which defaults to the
0xAARRGGBB
component order:
use palette::Srgb;
let rgb = Srgb::from(0x607F00);
assert_eq!(Srgb::new(96u8, 127, 0), rgb);
See Packed for more details.
source§impl<S: RgbStandard, T> Rgb<S, T>
impl<S: RgbStandard, T> Rgb<S, T>
sourcepub fn into_linear<U>(self) -> Rgb<Linear<S::Space>, U>where
S::TransferFn: IntoLinear<U, T>,
pub fn into_linear<U>(self) -> Rgb<Linear<S::Space>, U>where
S::TransferFn: IntoLinear<U, T>,
Convert the color to linear RGB.
Some transfer functions allow the component type to be converted at the
same time. This is usually offered with increased performance, compared
to using into_format
.
use palette::{Srgb, LinSrgb};
let linear: LinSrgb<f32> = Srgb::new(96u8, 127, 0).into_linear();
See the transfer function types in the encoding
module for details and performance characteristics.
sourcepub fn from_linear<U>(color: Rgb<Linear<S::Space>, U>) -> Selfwhere
S::TransferFn: FromLinear<U, T>,
pub fn from_linear<U>(color: Rgb<Linear<S::Space>, U>) -> Selfwhere
S::TransferFn: FromLinear<U, T>,
Convert linear RGB to non-linear RGB.
Some transfer functions allow the component type to be converted at the
same time. This is usually offered with increased performance, compared
to using into_format
.
use palette::{Srgb, LinSrgb};
let encoded = Srgb::<u8>::from_linear(LinSrgb::new(0.95f32, 0.90, 0.30));
See the transfer function types in the encoding
module for details and performance characteristics.
source§impl<S: RgbSpace, T> Rgb<Linear<S>, T>
impl<S: RgbSpace, T> Rgb<Linear<S>, T>
sourcepub fn into_encoding<U, St>(self) -> Rgb<St, U>
pub fn into_encoding<U, St>(self) -> Rgb<St, U>
Convert a linear color to a different encoding.
Some transfer functions allow the component type to be converted at the
same time. This is usually offered with increased performance, compared
to using into_format
.
use palette::{Srgb, LinSrgb};
let encoded: Srgb<u8> = LinSrgb::new(0.95f32, 0.90, 0.30).into_encoding();
See the transfer function types in the encoding
module for details and performance characteristics.
sourcepub fn from_encoding<U, St>(color: Rgb<St, U>) -> Self
pub fn from_encoding<U, St>(color: Rgb<St, U>) -> Self
Convert linear RGB from a different encoding.
Some transfer functions allow the component type to be converted at the
same time. This is usually offered with increased performance, compared
to using into_format
.
use palette::{Srgb, LinSrgb};
let linear = LinSrgb::<f32>::from_encoding(Srgb::new(96u8, 127, 0));
See the transfer function types in the encoding
module for details and performance characteristics.
source§impl<S, C> Rgb<S, C>
impl<S, C> Rgb<S, C>
sourcepub fn iter<'a>(&'a self) -> <&'a Self as IntoIterator>::IntoIterwhere
&'a Self: IntoIterator,
pub fn iter<'a>(&'a self) -> <&'a Self as IntoIterator>::IntoIterwhere
&'a Self: IntoIterator,
Return an iterator over the colors in the wrapped collections.
sourcepub fn iter_mut<'a>(&'a mut self) -> <&'a mut Self as IntoIterator>::IntoIterwhere
&'a mut Self: IntoIterator,
pub fn iter_mut<'a>(&'a mut self) -> <&'a mut Self as IntoIterator>::IntoIterwhere
&'a mut Self: IntoIterator,
Return an iterator that allows modifying the colors in the wrapped collections.
sourcepub fn get<'a, I, T>(
&'a self,
index: I,
) -> Option<Rgb<S, &<I as SliceIndex<[T]>>::Output>>
pub fn get<'a, I, T>( &'a self, index: I, ) -> Option<Rgb<S, &<I as SliceIndex<[T]>>::Output>>
Get a color, or slice of colors, with references to the components at index
. See slice::get
for details.
sourcepub fn get_mut<'a, I, T>(
&'a mut self,
index: I,
) -> Option<Rgb<S, &mut <I as SliceIndex<[T]>>::Output>>
pub fn get_mut<'a, I, T>( &'a mut self, index: I, ) -> Option<Rgb<S, &mut <I as SliceIndex<[T]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<S, T> Rgb<S, Vec<T>>
impl<S, T> Rgb<S, Vec<T>>
sourcepub fn with_capacity(capacity: usize) -> Self
pub fn with_capacity(capacity: usize) -> Self
Create a struct of vectors with a minimum capacity. See Vec::with_capacity
for details.
sourcepub fn push(&mut self, value: Rgb<S, T>)
pub fn push(&mut self, value: Rgb<S, T>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Rgb<S, T>>
pub fn pop(&mut self) -> Option<Rgb<S, T>>
Pop a color’s components from the component vectors. See Vec::pop
for details.
sourcepub fn clear(&mut self)
pub fn clear(&mut self)
Clear the component vectors. See Vec::clear
for details.
Trait Implementations§
source§impl<S, T> AbsDiffEq for Rgb<S, T>
impl<S, T> AbsDiffEq for Rgb<S, T>
source§fn default_epsilon() -> Self::Epsilon
fn default_epsilon() -> Self::Epsilon
source§fn abs_diff_eq(&self, other: &Self, epsilon: T::Epsilon) -> bool
fn abs_diff_eq(&self, other: &Self, epsilon: T::Epsilon) -> bool
source§fn abs_diff_ne(&self, other: &Self, epsilon: T::Epsilon) -> bool
fn abs_diff_ne(&self, other: &Self, epsilon: T::Epsilon) -> bool
AbsDiffEq::abs_diff_eq
.source§impl<S, T> AddAssign<T> for Rgb<S, T>
impl<S, T> AddAssign<T> for Rgb<S, T>
source§fn add_assign(&mut self, c: T)
fn add_assign(&mut self, c: T)
+=
operation. Read moresource§impl<S, T> AddAssign for Rgb<S, T>where
T: AddAssign,
impl<S, T> AddAssign for Rgb<S, T>where
T: AddAssign,
source§fn add_assign(&mut self, other: Self)
fn add_assign(&mut self, other: Self)
+=
operation. Read moresource§impl<S, T> ClampAssign for Rgb<S, T>where
T: ClampAssign + Stimulus,
impl<S, T> ClampAssign for Rgb<S, T>where
T: ClampAssign + Stimulus,
source§fn clamp_assign(&mut self)
fn clamp_assign(&mut self)
source§impl<'de, S, T> Deserialize<'de> for Rgb<S, T>where
T: Deserialize<'de>,
impl<'de, S, T> Deserialize<'de> for Rgb<S, T>where
T: Deserialize<'de>,
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
source§impl<S, T> DivAssign<T> for Rgb<S, T>
impl<S, T> DivAssign<T> for Rgb<S, T>
source§fn div_assign(&mut self, c: T)
fn div_assign(&mut self, c: T)
/=
operation. Read moresource§impl<S, T> DivAssign for Rgb<S, T>where
T: DivAssign,
impl<S, T> DivAssign for Rgb<S, T>where
T: DivAssign,
source§fn div_assign(&mut self, other: Self)
fn div_assign(&mut self, other: Self)
/=
operation. Read moresource§impl<S, T> EuclideanDistance for Rgb<S, T>
impl<S, T> EuclideanDistance for Rgb<S, T>
source§impl<S, T, C> Extend<Rgb<S, T>> for Rgb<S, C>where
C: Extend<T>,
impl<S, T, C> Extend<Rgb<S, T>> for Rgb<S, C>where
C: Extend<T>,
source§fn extend<I: IntoIterator<Item = Rgb<S, T>>>(&mut self, iter: I)
fn extend<I: IntoIterator<Item = Rgb<S, T>>>(&mut self, iter: I)
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<S, T, V, const N: usize> From<Rgb<S, V>> for [Rgb<S, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<S, T, V, const N: usize> From<Rgb<S, V>> for [Rgb<S, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Rgb<S, T>where
_C: IntoColorUnclamped<Self>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Rgb<S, T>where
_C: IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Alpha<_C, _A>) -> Self
fn from_color_unclamped(color: Alpha<_C, _A>) -> Self
source§impl<S, T> FromColorUnclamped<Hsl<S, T>> for Rgb<S, T>where
T: Real + RealAngle + UnsignedAngle + Zero + One + Abs + Round + PartialCmp + Arithmetics + Clone,
T::Mask: LazySelect<T> + BitOps + Clone,
impl<S, T> FromColorUnclamped<Hsl<S, T>> for Rgb<S, T>where
T: Real + RealAngle + UnsignedAngle + Zero + One + Abs + Round + PartialCmp + Arithmetics + Clone,
T::Mask: LazySelect<T> + BitOps + Clone,
source§fn from_color_unclamped(hsl: Hsl<S, T>) -> Self
fn from_color_unclamped(hsl: Hsl<S, T>) -> Self
source§impl<S, T> FromColorUnclamped<Hsluv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Hsluv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
impl<S, T> FromColorUnclamped<Hsluv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Hsluv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(
color: Hsluv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Self
fn from_color_unclamped( color: Hsluv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Self
source§impl<S, T> FromColorUnclamped<Hsv<S, T>> for Rgb<S, T>where
T: Real + RealAngle + UnsignedAngle + Round + Zero + One + Abs + PartialCmp + Arithmetics + Clone,
T::Mask: LazySelect<T> + BitOps + Clone,
impl<S, T> FromColorUnclamped<Hsv<S, T>> for Rgb<S, T>where
T: Real + RealAngle + UnsignedAngle + Round + Zero + One + Abs + PartialCmp + Arithmetics + Clone,
T::Mask: LazySelect<T> + BitOps + Clone,
source§fn from_color_unclamped(hsv: Hsv<S, T>) -> Self
fn from_color_unclamped(hsv: Hsv<S, T>) -> Self
source§impl<S, T> FromColorUnclamped<Hwb<S, T>> for Rgb<S, T>
impl<S, T> FromColorUnclamped<Hwb<S, T>> for Rgb<S, T>
source§fn from_color_unclamped(color: Hwb<S, T>) -> Self
fn from_color_unclamped(color: Hwb<S, T>) -> Self
source§impl<S, T> FromColorUnclamped<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
impl<S, T> FromColorUnclamped<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(
color: Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Self
fn from_color_unclamped( color: Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Self
source§impl<S, T> FromColorUnclamped<Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
impl<S, T> FromColorUnclamped<Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(
color: Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Self
fn from_color_unclamped( color: Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Self
source§impl<S, T> FromColorUnclamped<Lchuv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Lchuv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
impl<S, T> FromColorUnclamped<Lchuv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Lchuv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(
color: Lchuv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Self
fn from_color_unclamped( color: Lchuv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Self
source§impl<S, St, T> FromColorUnclamped<Luma<St, T>> for Rgb<S, T>where
S: RgbStandard + 'static,
St: LumaStandard<WhitePoint = <S::Space as RgbSpace>::WhitePoint> + 'static,
S::TransferFn: FromLinear<T, T>,
St::TransferFn: IntoLinear<T, T>,
T: Clone,
impl<S, St, T> FromColorUnclamped<Luma<St, T>> for Rgb<S, T>where
S: RgbStandard + 'static,
St: LumaStandard<WhitePoint = <S::Space as RgbSpace>::WhitePoint> + 'static,
S::TransferFn: FromLinear<T, T>,
St::TransferFn: IntoLinear<T, T>,
T: Clone,
source§fn from_color_unclamped(color: Luma<St, T>) -> Self
fn from_color_unclamped(color: Luma<St, T>) -> Self
source§impl<S, T> FromColorUnclamped<Luv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Luv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
impl<S, T> FromColorUnclamped<Luv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Luv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(
color: Luv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Self
fn from_color_unclamped( color: Luv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Self
source§impl<S, T> FromColorUnclamped<Okhsl<T>> for Rgb<S, T>
impl<S, T> FromColorUnclamped<Okhsl<T>> for Rgb<S, T>
source§fn from_color_unclamped(color: Okhsl<T>) -> Self
fn from_color_unclamped(color: Okhsl<T>) -> Self
source§impl<S, T> FromColorUnclamped<Okhsv<T>> for Rgb<S, T>
impl<S, T> FromColorUnclamped<Okhsv<T>> for Rgb<S, T>
source§fn from_color_unclamped(color: Okhsv<T>) -> Self
fn from_color_unclamped(color: Okhsv<T>) -> Self
source§impl<S, T> FromColorUnclamped<Okhwb<T>> for Rgb<S, T>
impl<S, T> FromColorUnclamped<Okhwb<T>> for Rgb<S, T>
source§fn from_color_unclamped(color: Okhwb<T>) -> Self
fn from_color_unclamped(color: Okhwb<T>) -> Self
source§impl<S, T> FromColorUnclamped<Oklab<T>> for Rgb<S, T>where
T: Real + Arithmetics + Copy,
S: RgbStandard,
S::TransferFn: FromLinear<T, T>,
S::Space: RgbSpace<WhitePoint = D65> + 'static,
Rgb<Linear<Srgb>, T>: IntoColorUnclamped<Self>,
Xyz<D65, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Self>,
impl<S, T> FromColorUnclamped<Oklab<T>> for Rgb<S, T>where
T: Real + Arithmetics + Copy,
S: RgbStandard,
S::TransferFn: FromLinear<T, T>,
S::Space: RgbSpace<WhitePoint = D65> + 'static,
Rgb<Linear<Srgb>, T>: IntoColorUnclamped<Self>,
Xyz<D65, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(oklab: Oklab<T>) -> Self
fn from_color_unclamped(oklab: Oklab<T>) -> Self
source§impl<S, T> FromColorUnclamped<Oklch<T>> for Rgb<S, T>
impl<S, T> FromColorUnclamped<Oklch<T>> for Rgb<S, T>
source§fn from_color_unclamped(color: Oklch<T>) -> Self
fn from_color_unclamped(color: Oklch<T>) -> Self
source§impl<S, T> FromColorUnclamped<Rgb<S, T>> for Hsl<S, T>where
T: RealAngle + Zero + One + MinMax + Arithmetics + PartialCmp + Clone,
T::Mask: BoolMask + BitOps + LazySelect<T> + Clone + 'static,
impl<S, T> FromColorUnclamped<Rgb<S, T>> for Hsl<S, T>where
T: RealAngle + Zero + One + MinMax + Arithmetics + PartialCmp + Clone,
T::Mask: BoolMask + BitOps + LazySelect<T> + Clone + 'static,
source§fn from_color_unclamped(rgb: Rgb<S, T>) -> Self
fn from_color_unclamped(rgb: Rgb<S, T>) -> Self
source§impl<S, T> FromColorUnclamped<Rgb<S, T>> for Hsv<S, T>where
T: RealAngle + One + Zero + MinMax + Arithmetics + PartialCmp + Clone,
T::Mask: BoolMask + BitOps + LazySelect<T> + Clone + 'static,
impl<S, T> FromColorUnclamped<Rgb<S, T>> for Hsv<S, T>where
T: RealAngle + One + Zero + MinMax + Arithmetics + PartialCmp + Clone,
T::Mask: BoolMask + BitOps + LazySelect<T> + Clone + 'static,
source§fn from_color_unclamped(rgb: Rgb<S, T>) -> Self
fn from_color_unclamped(rgb: Rgb<S, T>) -> Self
source§impl<S, T> FromColorUnclamped<Rgb<S, T>> for Hwb<S, T>
impl<S, T> FromColorUnclamped<Rgb<S, T>> for Hwb<S, T>
source§fn from_color_unclamped(color: Rgb<S, T>) -> Self
fn from_color_unclamped(color: Rgb<S, T>) -> Self
source§impl<S, T> FromColorUnclamped<Rgb<S, T>> for Oklab<T>where
T: Real + Cbrt + Arithmetics + Copy,
S: RgbStandard,
S::TransferFn: IntoLinear<T, T>,
S::Space: RgbSpace<WhitePoint = D65> + 'static,
Xyz<D65, T>: FromColorUnclamped<Rgb<S, T>>,
impl<S, T> FromColorUnclamped<Rgb<S, T>> for Oklab<T>where
T: Real + Cbrt + Arithmetics + Copy,
S: RgbStandard,
S::TransferFn: IntoLinear<T, T>,
S::Space: RgbSpace<WhitePoint = D65> + 'static,
Xyz<D65, T>: FromColorUnclamped<Rgb<S, T>>,
source§fn from_color_unclamped(rgb: Rgb<S, T>) -> Self
fn from_color_unclamped(rgb: Rgb<S, T>) -> Self
source§impl<Wp, T, S> FromColorUnclamped<Rgb<S, T>> for Xyz<Wp, T>where
T: Arithmetics + FromScalar,
T::Scalar: Real + Recip + IsValidDivisor<Mask = bool> + Arithmetics + FromScalar<Scalar = T::Scalar> + Clone,
Wp: WhitePoint<T::Scalar>,
S: RgbStandard,
S::TransferFn: IntoLinear<T, T>,
S::Space: RgbSpace<WhitePoint = Wp>,
<S::Space as RgbSpace>::Primaries: Primaries<T::Scalar>,
Yxy<Any, T::Scalar>: IntoColorUnclamped<Xyz<Any, T::Scalar>>,
impl<Wp, T, S> FromColorUnclamped<Rgb<S, T>> for Xyz<Wp, T>where
T: Arithmetics + FromScalar,
T::Scalar: Real + Recip + IsValidDivisor<Mask = bool> + Arithmetics + FromScalar<Scalar = T::Scalar> + Clone,
Wp: WhitePoint<T::Scalar>,
S: RgbStandard,
S::TransferFn: IntoLinear<T, T>,
S::Space: RgbSpace<WhitePoint = Wp>,
<S::Space as RgbSpace>::Primaries: Primaries<T::Scalar>,
Yxy<Any, T::Scalar>: IntoColorUnclamped<Xyz<Any, T::Scalar>>,
source§fn from_color_unclamped(color: Rgb<S, T>) -> Self
fn from_color_unclamped(color: Rgb<S, T>) -> Self
source§impl<S1, S2, T> FromColorUnclamped<Rgb<S2, T>> for Rgb<S1, T>where
S1: RgbStandard + 'static,
S2: RgbStandard + 'static,
S1::TransferFn: FromLinear<T, T>,
S2::TransferFn: IntoLinear<T, T>,
S2::Space: RgbSpace<WhitePoint = <S1::Space as RgbSpace>::WhitePoint>,
Xyz<<S2::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Rgb<S2, T>>,
Rgb<S1, T>: FromColorUnclamped<Xyz<<S1::Space as RgbSpace>::WhitePoint, T>>,
impl<S1, S2, T> FromColorUnclamped<Rgb<S2, T>> for Rgb<S1, T>where
S1: RgbStandard + 'static,
S2: RgbStandard + 'static,
S1::TransferFn: FromLinear<T, T>,
S2::TransferFn: IntoLinear<T, T>,
S2::Space: RgbSpace<WhitePoint = <S1::Space as RgbSpace>::WhitePoint>,
Xyz<<S2::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Rgb<S2, T>>,
Rgb<S1, T>: FromColorUnclamped<Xyz<<S1::Space as RgbSpace>::WhitePoint, T>>,
source§fn from_color_unclamped(rgb: Rgb<S2, T>) -> Self
fn from_color_unclamped(rgb: Rgb<S2, T>) -> Self
source§impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Hsluv<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Lchuv<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Hsluv<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Lchuv<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Lab<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Xyz<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Lab<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Xyz<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Lch<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Lab<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Lch<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Lab<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Lchuv<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Luv<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Lchuv<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Luv<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<S, T, _S> FromColorUnclamped<Rgb<_S, T>> for Luma<S, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>,
S: LumaStandard,
Xyz<<S as LumaStandard>::WhitePoint, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<S, T, _S> FromColorUnclamped<Rgb<_S, T>> for Luma<S, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>,
S: LumaStandard,
Xyz<<S as LumaStandard>::WhitePoint, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Luv<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Xyz<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Luv<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Xyz<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<T, _S> FromColorUnclamped<Rgb<_S, T>> for Okhsl<T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = D65>,
D65: WhitePoint<T>,
Oklab<T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<T, _S> FromColorUnclamped<Rgb<_S, T>> for Okhsl<T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = D65>,
D65: WhitePoint<T>,
Oklab<T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<T, _S> FromColorUnclamped<Rgb<_S, T>> for Okhsv<T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = D65>,
D65: WhitePoint<T>,
Oklab<T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<T, _S> FromColorUnclamped<Rgb<_S, T>> for Okhsv<T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = D65>,
D65: WhitePoint<T>,
Oklab<T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<T, _S> FromColorUnclamped<Rgb<_S, T>> for Okhwb<T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = D65>,
D65: WhitePoint<T>,
Okhsv<T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<T, _S> FromColorUnclamped<Rgb<_S, T>> for Okhwb<T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = D65>,
D65: WhitePoint<T>,
Okhsv<T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<T, _S> FromColorUnclamped<Rgb<_S, T>> for Oklch<T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = D65>,
D65: WhitePoint<T>,
Oklab<T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<T, _S> FromColorUnclamped<Rgb<_S, T>> for Oklch<T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = D65>,
D65: WhitePoint<T>,
Oklab<T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Yxy<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Xyz<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
impl<Wp, T, _S> FromColorUnclamped<Rgb<_S, T>> for Yxy<Wp, T>where
_S: RgbStandard,
_S::Space: RgbSpace<WhitePoint = Wp>,
Wp: WhitePoint<T>,
Xyz<Wp, T>: FromColorUnclamped<Rgb<_S, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(color: Rgb<_S, T>) -> Self
fn from_color_unclamped(color: Rgb<_S, T>) -> Self
source§impl<S, T> FromColorUnclamped<Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
S::TransferFn: FromLinear<T, T>,
<S::Space as RgbSpace>::Primaries: Primaries<T::Scalar>,
<S::Space as RgbSpace>::WhitePoint: WhitePoint<T::Scalar>,
T: Arithmetics + FromScalar,
T::Scalar: Real + Recip + IsValidDivisor<Mask = bool> + Arithmetics + Clone + FromScalar<Scalar = T::Scalar>,
Yxy<Any, T::Scalar>: IntoColorUnclamped<Xyz<Any, T::Scalar>>,
impl<S, T> FromColorUnclamped<Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
S::TransferFn: FromLinear<T, T>,
<S::Space as RgbSpace>::Primaries: Primaries<T::Scalar>,
<S::Space as RgbSpace>::WhitePoint: WhitePoint<T::Scalar>,
T: Arithmetics + FromScalar,
T::Scalar: Real + Recip + IsValidDivisor<Mask = bool> + Arithmetics + Clone + FromScalar<Scalar = T::Scalar>,
Yxy<Any, T::Scalar>: IntoColorUnclamped<Xyz<Any, T::Scalar>>,
source§fn from_color_unclamped(
color: Xyz<<S::Space as RgbSpace>::WhitePoint, T>,
) -> Self
fn from_color_unclamped( color: Xyz<<S::Space as RgbSpace>::WhitePoint, T>, ) -> Self
source§impl<S, T> FromColorUnclamped<Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
impl<S, T> FromColorUnclamped<Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Self>,
source§fn from_color_unclamped(
color: Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Self
fn from_color_unclamped( color: Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Self
source§impl<S, T, C> FromIterator<Rgb<S, T>> for Rgb<S, C>
impl<S, T, C> FromIterator<Rgb<S, T>> for Rgb<S, C>
source§impl<S, T> HasBoolMask for Rgb<S, T>where
T: HasBoolMask,
impl<S, T> HasBoolMask for Rgb<S, T>where
T: HasBoolMask,
source§type Mask = <T as HasBoolMask>::Mask
type Mask = <T as HasBoolMask>::Mask
Self
values.source§impl<'a, 'b, S, T> IntoIterator for &'a Rgb<S, &'b [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Rgb<S, &'b [T]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Rgb<S, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Rgb<S, &'b mut [T]>
source§impl<'a, S, T> IntoIterator for &'a Rgb<S, Vec<T>>
impl<'a, S, T> IntoIterator for &'a Rgb<S, Vec<T>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Rgb<S, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a mut Rgb<S, &'b mut [T]>
source§impl<'a, S, T> IntoIterator for &'a mut Rgb<S, Vec<T>>
impl<'a, S, T> IntoIterator for &'a mut Rgb<S, Vec<T>>
source§impl<'a, S, T> IntoIterator for Rgb<S, &'a [T]>
impl<'a, S, T> IntoIterator for Rgb<S, &'a [T]>
source§impl<'a, S, T> IntoIterator for Rgb<S, &'a mut [T]>
impl<'a, S, T> IntoIterator for Rgb<S, &'a mut [T]>
source§impl<S, T> IntoIterator for Rgb<S, Vec<T>>
impl<S, T> IntoIterator for Rgb<S, Vec<T>>
source§impl<S, T> IsWithinBounds for Rgb<S, T>
impl<S, T> IsWithinBounds for Rgb<S, T>
source§fn is_within_bounds(&self) -> T::Mask
fn is_within_bounds(&self) -> T::Mask
source§impl<S, T> Lighten for Rgb<S, T>where
T: Real + Zero + MinMax + Clamp + Arithmetics + PartialCmp + Clone + Stimulus,
T::Mask: LazySelect<T>,
impl<S, T> Lighten for Rgb<S, T>where
T: Real + Zero + MinMax + Clamp + Arithmetics + PartialCmp + Clone + Stimulus,
T::Mask: LazySelect<T>,
source§impl<S, T> LightenAssign for Rgb<S, T>where
T: Real + Zero + MinMax + ClampAssign + AddAssign + Arithmetics + PartialCmp + Clone + Stimulus,
T::Mask: LazySelect<T>,
impl<S, T> LightenAssign for Rgb<S, T>where
T: Real + Zero + MinMax + ClampAssign + AddAssign + Arithmetics + PartialCmp + Clone + Stimulus,
T::Mask: LazySelect<T>,
source§fn lighten_assign(&mut self, factor: T)
fn lighten_assign(&mut self, factor: T)
source§fn lighten_fixed_assign(&mut self, amount: T)
fn lighten_fixed_assign(&mut self, amount: T)
source§impl<S, T> MulAssign<T> for Rgb<S, T>
impl<S, T> MulAssign<T> for Rgb<S, T>
source§fn mul_assign(&mut self, c: T)
fn mul_assign(&mut self, c: T)
*=
operation. Read moresource§impl<S, T> MulAssign for Rgb<S, T>where
T: MulAssign,
impl<S, T> MulAssign for Rgb<S, T>where
T: MulAssign,
source§fn mul_assign(&mut self, other: Self)
fn mul_assign(&mut self, other: Self)
*=
operation. Read moresource§impl<S, T> Premultiply for Rgb<S, T>where
T: Real + Stimulus + Zero + IsValidDivisor + Mul<T, Output = T> + Div<T, Output = T> + Clone,
T::Mask: LazySelect<T> + Clone,
impl<S, T> Premultiply for Rgb<S, T>where
T: Real + Stimulus + Zero + IsValidDivisor + Mul<T, Output = T> + Div<T, Output = T> + Clone,
T::Mask: LazySelect<T> + Clone,
source§impl<S, T> RelativeContrast for Rgb<S, T>where
T: Real + Arithmetics + PartialCmp,
T::Mask: LazySelect<T>,
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColor<Self>,
impl<S, T> RelativeContrast for Rgb<S, T>where
T: Real + Arithmetics + PartialCmp,
T::Mask: LazySelect<T>,
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColor<Self>,
source§type Scalar = T
type Scalar = T
palette::color_difference::Wcag21RelativeContrast
source§fn get_contrast_ratio(self, other: Self) -> T
fn get_contrast_ratio(self, other: Self) -> T
palette::color_difference::Wcag21RelativeContrast
source§fn has_min_contrast_text(
self,
other: Self,
) -> <Self::Scalar as HasBoolMask>::Mask
fn has_min_contrast_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask
palette::color_difference::Wcag21RelativeContrast
source§fn has_min_contrast_large_text(
self,
other: Self,
) -> <Self::Scalar as HasBoolMask>::Mask
fn has_min_contrast_large_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask
palette::color_difference::Wcag21RelativeContrast
source§fn has_enhanced_contrast_text(
self,
other: Self,
) -> <Self::Scalar as HasBoolMask>::Mask
fn has_enhanced_contrast_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask
palette::color_difference::Wcag21RelativeContrast
source§fn has_enhanced_contrast_large_text(
self,
other: Self,
) -> <Self::Scalar as HasBoolMask>::Mask
fn has_enhanced_contrast_large_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask
palette::color_difference::Wcag21RelativeContrast
source§fn has_min_contrast_graphics(
self,
other: Self,
) -> <Self::Scalar as HasBoolMask>::Mask
fn has_min_contrast_graphics( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask
palette::color_difference::Wcag21RelativeContrast
source§impl<S, T> RelativeEq for Rgb<S, T>
impl<S, T> RelativeEq for Rgb<S, T>
source§fn default_max_relative() -> T::Epsilon
fn default_max_relative() -> T::Epsilon
source§fn relative_eq(
&self,
other: &Self,
epsilon: T::Epsilon,
max_relative: T::Epsilon,
) -> bool
fn relative_eq( &self, other: &Self, epsilon: T::Epsilon, max_relative: T::Epsilon, ) -> bool
source§fn relative_ne(
&self,
other: &Self,
epsilon: T::Epsilon,
max_relative: T::Epsilon,
) -> bool
fn relative_ne( &self, other: &Self, epsilon: T::Epsilon, max_relative: T::Epsilon, ) -> bool
RelativeEq::relative_eq
.source§impl<S, T> SaturatingAdd<T> for Rgb<S, T>where
T: SaturatingAdd<Output = T> + Clone,
impl<S, T> SaturatingAdd<T> for Rgb<S, T>where
T: SaturatingAdd<Output = T> + Clone,
source§impl<S, T> SaturatingAdd for Rgb<S, T>where
T: SaturatingAdd<Output = T>,
impl<S, T> SaturatingAdd for Rgb<S, T>where
T: SaturatingAdd<Output = T>,
source§impl<S, T> SaturatingSub<T> for Rgb<S, T>where
T: SaturatingSub<Output = T> + Clone,
impl<S, T> SaturatingSub<T> for Rgb<S, T>where
T: SaturatingSub<Output = T> + Clone,
source§impl<S, T> SaturatingSub for Rgb<S, T>where
T: SaturatingSub<Output = T>,
impl<S, T> SaturatingSub for Rgb<S, T>where
T: SaturatingSub<Output = T>,
source§impl<S, T> SubAssign<T> for Rgb<S, T>
impl<S, T> SubAssign<T> for Rgb<S, T>
source§fn sub_assign(&mut self, c: T)
fn sub_assign(&mut self, c: T)
-=
operation. Read moresource§impl<S, T> SubAssign for Rgb<S, T>where
T: SubAssign,
impl<S, T> SubAssign for Rgb<S, T>where
T: SubAssign,
source§fn sub_assign(&mut self, other: Self)
fn sub_assign(&mut self, other: Self)
-=
operation. Read moresource§impl<S, T> UlpsEq for Rgb<S, T>
impl<S, T> UlpsEq for Rgb<S, T>
source§impl<S, T> Wcag21RelativeContrast for Rgb<S, T>
impl<S, T> Wcag21RelativeContrast for Rgb<S, T>
source§fn relative_contrast(self, other: Self) -> Self::Scalar
fn relative_contrast(self, other: Self) -> Self::Scalar
source§fn has_min_contrast_text(
self,
other: Self,
) -> <Self::Scalar as HasBoolMask>::Mask
fn has_min_contrast_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask
source§fn has_min_contrast_large_text(
self,
other: Self,
) -> <Self::Scalar as HasBoolMask>::Mask
fn has_min_contrast_large_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask
source§fn has_enhanced_contrast_text(
self,
other: Self,
) -> <Self::Scalar as HasBoolMask>::Mask
fn has_enhanced_contrast_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask
source§fn has_enhanced_contrast_large_text(
self,
other: Self,
) -> <Self::Scalar as HasBoolMask>::Mask
fn has_enhanced_contrast_large_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask
source§fn has_min_contrast_graphics(
self,
other: Self,
) -> <Self::Scalar as HasBoolMask>::Mask
fn has_min_contrast_graphics( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask
source§impl<S, T, _A> WithAlpha<_A> for Rgb<S, T>where
_A: Stimulus,
impl<S, T, _A> WithAlpha<_A> for Rgb<S, T>where
_A: Stimulus,
source§fn with_alpha(self, alpha: _A) -> Self::WithAlpha
fn with_alpha(self, alpha: _A) -> Self::WithAlpha
Self
already has a transparency, it is
overwritten. Read moresource§fn without_alpha(self) -> Self::Color
fn without_alpha(self) -> Self::Color
Self::Color
has
an internal transparency field, that field will be set to
A::max_intensity()
to make it opaque. Read moresource§fn split(self) -> (Self::Color, _A)
fn split(self) -> (Self::Color, _A)
impl<S, T> Copy for Rgb<S, T>where
T: Copy,
impl<S, T> Eq for Rgb<S, T>where
T: Eq,
impl<S, T> StimulusColor for Rgb<S, T>where
T: Stimulus,
Auto Trait Implementations§
impl<S, T> Freeze for Rgb<S, T>where
T: Freeze,
impl<S, T> RefUnwindSafe for Rgb<S, T>where
T: RefUnwindSafe,
S: RefUnwindSafe,
impl<S, T> Send for Rgb<S, T>
impl<S, T> Sync for Rgb<S, T>
impl<S, T> Unpin for Rgb<S, T>
impl<S, T> UnwindSafe for Rgb<S, T>where
T: UnwindSafe,
S: UnwindSafe,
Blanket Implementations§
source§impl<S, D, Swp, Dwp, T> AdaptFrom<S, Swp, Dwp, T> for Dwhere
T: Real + Zero + Arithmetics + Clone,
Swp: WhitePoint<T>,
Dwp: WhitePoint<T>,
S: IntoColorUnclamped<Xyz<Swp, T>>,
D: FromColorUnclamped<Xyz<Dwp, T>>,
impl<S, D, Swp, Dwp, T> AdaptFrom<S, Swp, Dwp, T> for Dwhere
T: Real + Zero + Arithmetics + Clone,
Swp: WhitePoint<T>,
Dwp: WhitePoint<T>,
S: IntoColorUnclamped<Xyz<Swp, T>>,
D: FromColorUnclamped<Xyz<Dwp, T>>,
source§fn adapt_from_using<M>(color: S, method: M) -> Dwhere
M: TransformMatrix<T>,
fn adapt_from_using<M>(color: S, method: M) -> Dwhere
M: TransformMatrix<T>,
source§fn adapt_from(color: S) -> Self
fn adapt_from(color: S) -> Self
source§impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for Swhere
T: Real + Zero + Arithmetics + Clone,
Swp: WhitePoint<T>,
Dwp: WhitePoint<T>,
D: AdaptFrom<S, Swp, Dwp, T>,
impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for Swhere
T: Real + Zero + Arithmetics + Clone,
Swp: WhitePoint<T>,
Dwp: WhitePoint<T>,
D: AdaptFrom<S, Swp, Dwp, T>,
source§fn adapt_into_using<M>(self, method: M) -> Dwhere
M: TransformMatrix<T>,
fn adapt_into_using<M>(self, method: M) -> Dwhere
M: TransformMatrix<T>,
source§fn adapt_into(self) -> D
fn adapt_into(self) -> D
source§impl<T, C> ArraysFrom<C> for Twhere
C: IntoArrays<T>,
impl<T, C> ArraysFrom<C> for Twhere
C: IntoArrays<T>,
source§fn arrays_from(colors: C) -> T
fn arrays_from(colors: C) -> T
source§impl<T, C> ArraysInto<C> for Twhere
C: FromArrays<T>,
impl<T, C> ArraysInto<C> for Twhere
C: FromArrays<T>,
source§fn arrays_into(self) -> C
fn arrays_into(self) -> C
source§impl<C, T, const N: usize> Blend for Cwhere
C: Premultiply<Scalar = T> + StimulusColor + ArrayCast<Array = [T; N]> + Clone,
T: Real + Zero + One + MinMax + Clamp + Sqrt + Abs + Arithmetics + PartialCmp + Clone,
<T as HasBoolMask>::Mask: LazySelect<T>,
impl<C, T, const N: usize> Blend for Cwhere
C: Premultiply<Scalar = T> + StimulusColor + ArrayCast<Array = [T; N]> + Clone,
T: Real + Zero + One + MinMax + Clamp + Sqrt + Abs + Arithmetics + PartialCmp + Clone,
<T as HasBoolMask>::Mask: LazySelect<T>,
source§fn multiply(self, other: C) -> C
fn multiply(self, other: C) -> C
self
with other
. This uses the alpha component to regulate
the effect, so it’s not just plain component wise multiplication.source§fn overlay(self, other: C) -> C
fn overlay(self, other: C) -> C
self
or other
if other is dark, or screen them if other
is light. This results in an S curve.source§fn dodge(self, other: C) -> C
fn dodge(self, other: C) -> C
other
to reflect self
. Results in other
if self
is
black.source§fn hard_light(self, other: C) -> C
fn hard_light(self, other: C) -> C
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
.source§fn soft_light(self, other: C) -> C
fn soft_light(self, other: C) -> C
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.source§fn difference(self, other: C) -> C
fn difference(self, other: C) -> C
self
and other
. It’s
basically abs(self - other)
, but regulated by the alpha component.source§impl<C> BlendWith for C
impl<C> BlendWith for C
source§fn blend_with<F>(self, other: C, blend_function: F) -> C
fn blend_with<F>(self, other: C, blend_function: F) -> C
destination
, using
blend_function
. Anything that implements BlendFunction
is
acceptable, including functions and closures. Read moresource§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<WpParam, T, U> Cam16IntoUnclamped<WpParam, T> for Uwhere
T: FromCam16Unclamped<WpParam, U>,
impl<WpParam, T, U> Cam16IntoUnclamped<WpParam, T> for Uwhere
T: FromCam16Unclamped<WpParam, U>,
source§type Scalar = <T as FromCam16Unclamped<WpParam, U>>::Scalar
type Scalar = <T as FromCam16Unclamped<WpParam, U>>::Scalar
parameters
when converting.source§fn cam16_into_unclamped(
self,
parameters: BakedParameters<WpParam, <U as Cam16IntoUnclamped<WpParam, T>>::Scalar>,
) -> T
fn cam16_into_unclamped( self, parameters: BakedParameters<WpParam, <U as Cam16IntoUnclamped<WpParam, T>>::Scalar>, ) -> T
self
into C
, using the provided parameters.source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T, C> ComponentsFrom<C> for Twhere
C: IntoComponents<T>,
impl<T, C> ComponentsFrom<C> for Twhere
C: IntoComponents<T>,
source§fn components_from(colors: C) -> T
fn components_from(colors: C) -> T
source§impl<C> Compose for C
impl<C> Compose for C
source§fn over(self, other: C) -> C
fn over(self, other: C) -> C
self
over other
. This is the good old common alpha composition
equation.source§fn inside(self, other: C) -> C
fn inside(self, other: C) -> C
self
that overlaps the visible parts of
other
.source§impl<T> FromAngle<T> for T
impl<T> FromAngle<T> for T
source§fn from_angle(angle: T) -> T
fn from_angle(angle: T) -> T
angle
.source§impl<T, U> FromColor<T> for Uwhere
U: FromColorUnclamped<T> + Clamp,
impl<T, U> FromColor<T> for Uwhere
U: FromColorUnclamped<T> + Clamp,
source§fn from_color(t: T) -> U
fn from_color(t: T) -> U
source§impl<T, U> FromColorMut<U> for T
impl<T, U> FromColorMut<U> for T
source§fn from_color_mut(color: &mut U) -> FromColorMutGuard<'_, T, U>
fn from_color_mut(color: &mut U) -> FromColorMutGuard<'_, T, U>
source§impl<T, U> FromColorUnclampedMut<U> for Twhere
T: FromColorUnclamped<U> + ArrayCast + Clone,
U: FromColorUnclamped<T> + ArrayCast<Array = <T as ArrayCast>::Array> + Clone,
impl<T, U> FromColorUnclampedMut<U> for Twhere
T: FromColorUnclamped<U> + ArrayCast + Clone,
U: FromColorUnclamped<T> + ArrayCast<Array = <T as ArrayCast>::Array> + Clone,
source§fn from_color_unclamped_mut(
color: &mut U,
) -> FromColorUnclampedMutGuard<'_, T, U>
fn from_color_unclamped_mut( color: &mut U, ) -> FromColorUnclampedMutGuard<'_, T, U>
source§impl<T, U> FromStimulus<U> for Twhere
U: IntoStimulus<T>,
impl<T, U> FromStimulus<U> for Twhere
U: IntoStimulus<T>,
source§fn from_stimulus(other: U) -> T
fn from_stimulus(other: U) -> T
other
into Self
, while performing the appropriate scaling,
rounding and clamping.source§impl<T, U> IntoAngle<U> for Twhere
U: FromAngle<T>,
impl<T, U> IntoAngle<U> for Twhere
U: FromAngle<T>,
source§fn into_angle(self) -> U
fn into_angle(self) -> U
T
.source§impl<WpParam, T, U> IntoCam16Unclamped<WpParam, T> for Uwhere
T: Cam16FromUnclamped<WpParam, U>,
impl<WpParam, T, U> IntoCam16Unclamped<WpParam, T> for Uwhere
T: Cam16FromUnclamped<WpParam, U>,
source§type Scalar = <T as Cam16FromUnclamped<WpParam, U>>::Scalar
type Scalar = <T as Cam16FromUnclamped<WpParam, U>>::Scalar
parameters
when converting.source§fn into_cam16_unclamped(
self,
parameters: BakedParameters<WpParam, <U as IntoCam16Unclamped<WpParam, T>>::Scalar>,
) -> T
fn into_cam16_unclamped( self, parameters: BakedParameters<WpParam, <U as IntoCam16Unclamped<WpParam, T>>::Scalar>, ) -> T
self
into C
, using the provided parameters.source§impl<T, U> IntoColor<U> for Twhere
U: FromColor<T>,
impl<T, U> IntoColor<U> for Twhere
U: FromColor<T>,
source§fn into_color(self) -> U
fn into_color(self) -> U
source§impl<T, U> IntoColorMut<T> for U
impl<T, U> IntoColorMut<T> for U
source§fn into_color_mut(&mut self) -> FromColorMutGuard<'_, T, U>
fn into_color_mut(&mut self) -> FromColorMutGuard<'_, T, U>
source§impl<T, U> IntoColorUnclamped<U> for Twhere
U: FromColorUnclamped<T>,
impl<T, U> IntoColorUnclamped<U> for Twhere
U: FromColorUnclamped<T>,
source§fn into_color_unclamped(self) -> U
fn into_color_unclamped(self) -> U
source§impl<T, U> IntoColorUnclampedMut<T> for U
impl<T, U> IntoColorUnclampedMut<T> for U
source§fn into_color_unclamped_mut(&mut self) -> FromColorUnclampedMutGuard<'_, T, U>
fn into_color_unclamped_mut(&mut self) -> FromColorUnclampedMutGuard<'_, T, U>
source§impl<T> IntoStimulus<T> for T
impl<T> IntoStimulus<T> for T
source§fn into_stimulus(self) -> T
fn into_stimulus(self) -> T
self
into T
, while performing the appropriate scaling,
rounding and clamping.source§impl<T, C> TryComponentsInto<C> for Twhere
C: TryFromComponents<T>,
impl<T, C> TryComponentsInto<C> for Twhere
C: TryFromComponents<T>,
source§type Error = <C as TryFromComponents<T>>::Error
type Error = <C as TryFromComponents<T>>::Error
try_into_colors
fails to cast.source§fn try_components_into(self) -> Result<C, <T as TryComponentsInto<C>>::Error>
fn try_components_into(self) -> Result<C, <T as TryComponentsInto<C>>::Error>
source§impl<T, U> TryFromColor<T> for U
impl<T, U> TryFromColor<T> for U
source§fn try_from_color(t: T) -> Result<U, OutOfBounds<U>>
fn try_from_color(t: T) -> Result<U, OutOfBounds<U>>
OutOfBounds
error is returned which contains
the unclamped color. Read moresource§impl<T, U> TryIntoColor<U> for Twhere
U: TryFromColor<T>,
impl<T, U> TryIntoColor<U> for Twhere
U: TryFromColor<T>,
source§fn try_into_color(self) -> Result<U, OutOfBounds<U>>
fn try_into_color(self) -> Result<U, OutOfBounds<U>>
OutOfBounds
error is returned which contains
the unclamped color. Read more