pub type LinSrgb<T = f32> = Rgb<Linear<Srgb>, T>;
Expand description
Aliased Type§
struct LinSrgb<T = f32> {
pub red: T,
pub green: T,
pub blue: T,
pub standard: PhantomData<Linear<Srgb>>,
}
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<Linear<Srgb>>
The kind of RGB standard. sRGB is the default.
Implementations
source§impl<S, T> Rgb<Linear<S>, T>where
S: RgbSpace,
impl<S, T> Rgb<Linear<S>, T>where
S: RgbSpace,
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>) -> Rgb<Linear<S>, T>
pub fn from_encoding<U, St>(color: Rgb<St, U>) -> Rgb<Linear<S>, T>
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 Rgb<S, C> as IntoIterator>::IntoIterwhere
&'a Rgb<S, C>: IntoIterator,
pub fn iter<'a>(&'a self) -> <&'a Rgb<S, C> as IntoIterator>::IntoIterwhere
&'a Rgb<S, C>: IntoIterator,
Return an iterator over the colors in the wrapped collections.
sourcepub fn iter_mut<'a>(
&'a mut self,
) -> <&'a mut Rgb<S, C> as IntoIterator>::IntoIterwhere
&'a mut Rgb<S, C>: IntoIterator,
pub fn iter_mut<'a>(
&'a mut self,
) -> <&'a mut Rgb<S, C> as IntoIterator>::IntoIterwhere
&'a mut Rgb<S, C>: 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, &'a <I as SliceIndex<[T]>>::Output>>
pub fn get<'a, I, T>( &'a self, index: I, ) -> Option<Rgb<S, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>>
pub fn get_mut<'a, I, T>( &'a mut self, index: I, ) -> Option<Rgb<S, &'a 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, 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>) -> Rgb<S, T>where
T: FromStimulus<U>,
pub fn from_format<U>(color: Rgb<S, U>) -> Rgb<S, T>where
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(_: (T, T, T)) -> Rgb<S, T>
pub fn from_components(_: (T, T, T)) -> Rgb<S, T>
Convert from a (red, green, blue)
tuple.
source§impl<S, T> Rgb<S, T>where
S: RgbStandard,
impl<S, T> Rgb<S, T>where
S: RgbStandard,
sourcepub fn into_linear<U>(self) -> Rgb<Linear<<S as RgbStandard>::Space>, U>
pub fn into_linear<U>(self) -> Rgb<Linear<<S as RgbStandard>::Space>, U>
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 as RgbStandard>::Space>, U>,
) -> Rgb<S, T>
pub fn from_linear<U>( color: Rgb<Linear<<S as RgbStandard>::Space>, U>, ) -> Rgb<S, 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, T> Rgb<S, Vec<T>>
impl<S, T> Rgb<S, Vec<T>>
sourcepub fn with_capacity(capacity: usize) -> Rgb<S, Vec<T>>
pub fn with_capacity(capacity: usize) -> Rgb<S, Vec<T>>
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.
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) -> Rgb<S, u8>
pub fn from_u32<O>(color: u32) -> Rgb<S, u8>
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.
Trait Implementations
source§impl<S, T> AbsDiffEq for Rgb<S, T>
impl<S, T> AbsDiffEq for Rgb<S, T>
source§fn default_epsilon() -> <Rgb<S, T> as AbsDiffEq>::Epsilon
fn default_epsilon() -> <Rgb<S, T> as AbsDiffEq>::Epsilon
source§fn abs_diff_eq(
&self,
other: &Rgb<S, T>,
epsilon: <T as AbsDiffEq>::Epsilon,
) -> bool
fn abs_diff_eq( &self, other: &Rgb<S, T>, epsilon: <T as AbsDiffEq>::Epsilon, ) -> bool
source§fn abs_diff_ne(
&self,
other: &Rgb<S, T>,
epsilon: <T as AbsDiffEq>::Epsilon,
) -> bool
fn abs_diff_ne( &self, other: &Rgb<S, T>, epsilon: <T as AbsDiffEq>::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: Rgb<S, T>)
fn add_assign(&mut self, other: Rgb<S, T>)
+=
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<Rgb<S, T>, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(
__deserializer: __D,
) -> Result<Rgb<S, T>, <__D as Deserializer<'de>>::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: Rgb<S, T>)
fn div_assign(&mut self, other: Rgb<S, T>)
/=
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>(&mut self, iter: I)where
I: IntoIterator<Item = Rgb<S, T>>,
fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = Rgb<S, T>>,
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, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Rgb<S, T>where
_C: IntoColorUnclamped<Rgb<S, T>>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Rgb<S, T>where
_C: IntoColorUnclamped<Rgb<S, T>>,
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 as HasBoolMask>::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 as HasBoolMask>::Mask: LazySelect<T> + BitOps + Clone,
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<Rgb<S, T>>,
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<Rgb<S, T>>,
source§fn from_color_unclamped(
color: Hsluv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Rgb<S, T>
fn from_color_unclamped( color: Hsluv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Rgb<S, T>
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 as HasBoolMask>::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 as HasBoolMask>::Mask: LazySelect<T> + BitOps + Clone,
source§impl<S, T> FromColorUnclamped<Hwb<S, T>> for Rgb<S, T>
impl<S, T> FromColorUnclamped<Hwb<S, T>> for Rgb<S, T>
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<Rgb<S, T>>,
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<Rgb<S, T>>,
source§fn from_color_unclamped(
color: Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Rgb<S, T>
fn from_color_unclamped( color: Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Rgb<S, T>
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<Rgb<S, T>>,
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<Rgb<S, T>>,
source§fn from_color_unclamped(
color: Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Rgb<S, T>
fn from_color_unclamped( color: Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Rgb<S, T>
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<Rgb<S, T>>,
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<Rgb<S, T>>,
source§fn from_color_unclamped(
color: Lchuv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Rgb<S, T>
fn from_color_unclamped( color: Lchuv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Rgb<S, T>
source§impl<S, St, T> FromColorUnclamped<Luma<St, T>> for Rgb<S, T>where
S: RgbStandard + 'static,
St: LumaStandard<WhitePoint = <<S as RgbStandard>::Space as RgbSpace>::WhitePoint> + 'static,
<S as RgbStandard>::TransferFn: FromLinear<T, T>,
<St as LumaStandard>::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 as RgbStandard>::Space as RgbSpace>::WhitePoint> + 'static,
<S as RgbStandard>::TransferFn: FromLinear<T, T>,
<St as LumaStandard>::TransferFn: IntoLinear<T, T>,
T: Clone,
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<Rgb<S, T>>,
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<Rgb<S, T>>,
source§fn from_color_unclamped(
color: Luv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Rgb<S, T>
fn from_color_unclamped( color: Luv<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Rgb<S, T>
source§impl<S, T> FromColorUnclamped<Okhsl<T>> for Rgb<S, T>
impl<S, T> FromColorUnclamped<Okhsl<T>> for Rgb<S, T>
source§impl<S, T> FromColorUnclamped<Okhsv<T>> for Rgb<S, T>
impl<S, T> FromColorUnclamped<Okhsv<T>> for Rgb<S, T>
source§impl<S, T> FromColorUnclamped<Okhwb<T>> for Rgb<S, T>
impl<S, T> FromColorUnclamped<Okhwb<T>> for Rgb<S, T>
source§impl<S, T> FromColorUnclamped<Oklab<T>> for Rgb<S, T>where
T: Real + Arithmetics + Copy,
S: RgbStandard,
<S as RgbStandard>::TransferFn: FromLinear<T, T>,
<S as RgbStandard>::Space: RgbSpace<WhitePoint = D65> + 'static,
Rgb<Linear<Srgb>, T>: IntoColorUnclamped<Rgb<S, T>>,
Xyz<D65, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Rgb<S, T>>,
impl<S, T> FromColorUnclamped<Oklab<T>> for Rgb<S, T>where
T: Real + Arithmetics + Copy,
S: RgbStandard,
<S as RgbStandard>::TransferFn: FromLinear<T, T>,
<S as RgbStandard>::Space: RgbSpace<WhitePoint = D65> + 'static,
Rgb<Linear<Srgb>, T>: IntoColorUnclamped<Rgb<S, T>>,
Xyz<D65, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Rgb<S, T>>,
source§impl<S, T> FromColorUnclamped<Oklch<T>> for Rgb<S, T>
impl<S, T> FromColorUnclamped<Oklch<T>> for Rgb<S, T>
source§impl<S1, S2, T> FromColorUnclamped<Rgb<S2, T>> for Rgb<S1, T>where
S1: RgbStandard + 'static,
S2: RgbStandard + 'static,
<S1 as RgbStandard>::TransferFn: FromLinear<T, T>,
<S2 as RgbStandard>::TransferFn: IntoLinear<T, T>,
<S2 as RgbStandard>::Space: RgbSpace<WhitePoint = <<S1 as RgbStandard>::Space as RgbSpace>::WhitePoint>,
Xyz<<<S2 as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Rgb<S2, T>>,
Rgb<S1, T>: FromColorUnclamped<Xyz<<<S1 as RgbStandard>::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 as RgbStandard>::TransferFn: FromLinear<T, T>,
<S2 as RgbStandard>::TransferFn: IntoLinear<T, T>,
<S2 as RgbStandard>::Space: RgbSpace<WhitePoint = <<S1 as RgbStandard>::Space as RgbSpace>::WhitePoint>,
Xyz<<<S2 as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColorUnclamped<Rgb<S2, T>>,
Rgb<S1, T>: FromColorUnclamped<Xyz<<<S1 as RgbStandard>::Space as RgbSpace>::WhitePoint, T>>,
source§impl<S, T> FromColorUnclamped<Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
<S as RgbStandard>::TransferFn: FromLinear<T, T>,
<<S as RgbStandard>::Space as RgbSpace>::Primaries: Primaries<<T as FromScalar>::Scalar>,
<<S as RgbStandard>::Space as RgbSpace>::WhitePoint: WhitePoint<<T as FromScalar>::Scalar>,
T: Arithmetics + FromScalar,
<T as FromScalar>::Scalar: Real + Recip + IsValidDivisor<Mask = bool> + Arithmetics + Clone + FromScalar<Scalar = <T as FromScalar>::Scalar>,
Yxy<Any, <T as FromScalar>::Scalar>: IntoColorUnclamped<Xyz<Any, <T as FromScalar>::Scalar>>,
impl<S, T> FromColorUnclamped<Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Rgb<S, T>where
S: RgbStandard,
<S as RgbStandard>::TransferFn: FromLinear<T, T>,
<<S as RgbStandard>::Space as RgbSpace>::Primaries: Primaries<<T as FromScalar>::Scalar>,
<<S as RgbStandard>::Space as RgbSpace>::WhitePoint: WhitePoint<<T as FromScalar>::Scalar>,
T: Arithmetics + FromScalar,
<T as FromScalar>::Scalar: Real + Recip + IsValidDivisor<Mask = bool> + Arithmetics + Clone + FromScalar<Scalar = <T as FromScalar>::Scalar>,
Yxy<Any, <T as FromScalar>::Scalar>: IntoColorUnclamped<Xyz<Any, <T as FromScalar>::Scalar>>,
source§fn from_color_unclamped(
color: Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Rgb<S, T>
fn from_color_unclamped( color: Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Rgb<S, T>
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<Rgb<S, T>>,
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<Rgb<S, T>>,
source§fn from_color_unclamped(
color: Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>,
) -> Rgb<S, T>
fn from_color_unclamped( color: Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, ) -> Rgb<S, T>
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, 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>where
T: PartialCmp + Stimulus,
<T as HasBoolMask>::Mask: BitAnd<Output = <T as HasBoolMask>::Mask>,
impl<S, T> IsWithinBounds for Rgb<S, T>where
T: PartialCmp + Stimulus,
<T as HasBoolMask>::Mask: BitAnd<Output = <T as HasBoolMask>::Mask>,
source§fn is_within_bounds(&self) -> <T as HasBoolMask>::Mask
fn is_within_bounds(&self) -> <T as HasBoolMask>::Mask
source§impl<S, T> Lighten for Rgb<S, T>where
T: Real + Zero + MinMax + Clamp + Arithmetics + PartialCmp + Clone + Stimulus,
<T as HasBoolMask>::Mask: LazySelect<T>,
impl<S, T> Lighten for Rgb<S, T>where
T: Real + Zero + MinMax + Clamp + Arithmetics + PartialCmp + Clone + Stimulus,
<T as HasBoolMask>::Mask: LazySelect<T>,
source§impl<S, T> LightenAssign for Rgb<S, T>where
T: Real + Zero + MinMax + ClampAssign + AddAssign + Arithmetics + PartialCmp + Clone + Stimulus,
<T as HasBoolMask>::Mask: LazySelect<T>,
impl<S, T> LightenAssign for Rgb<S, T>where
T: Real + Zero + MinMax + ClampAssign + AddAssign + Arithmetics + PartialCmp + Clone + Stimulus,
<T as HasBoolMask>::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: Rgb<S, T>)
fn mul_assign(&mut self, other: Rgb<S, T>)
*=
operation. Read moresource§impl<S, T> Premultiply for Rgb<S, T>where
T: Real + Stimulus + Zero + IsValidDivisor + Mul<Output = T> + Div<Output = T> + Clone,
<T as HasBoolMask>::Mask: LazySelect<T> + Clone,
impl<S, T> Premultiply for Rgb<S, T>where
T: Real + Stimulus + Zero + IsValidDivisor + Mul<Output = T> + Div<Output = T> + Clone,
<T as HasBoolMask>::Mask: LazySelect<T> + Clone,
source§impl<S, T> RelativeContrast for Rgb<S, T>where
T: Real + Arithmetics + PartialCmp,
<T as HasBoolMask>::Mask: LazySelect<T>,
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColor<Rgb<S, T>>,
impl<S, T> RelativeContrast for Rgb<S, T>where
T: Real + Arithmetics + PartialCmp,
<T as HasBoolMask>::Mask: LazySelect<T>,
S: RgbStandard,
Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>: FromColor<Rgb<S, T>>,
source§type Scalar = T
type Scalar = T
palette::color_difference::Wcag21RelativeContrast
source§fn get_contrast_ratio(self, other: Rgb<S, T>) -> T
fn get_contrast_ratio(self, other: Rgb<S, T>) -> 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 as AbsDiffEq>::Epsilon
fn default_max_relative() -> <T as AbsDiffEq>::Epsilon
source§fn relative_eq(
&self,
other: &Rgb<S, T>,
epsilon: <T as AbsDiffEq>::Epsilon,
max_relative: <T as AbsDiffEq>::Epsilon,
) -> bool
fn relative_eq( &self, other: &Rgb<S, T>, epsilon: <T as AbsDiffEq>::Epsilon, max_relative: <T as AbsDiffEq>::Epsilon, ) -> bool
source§fn relative_ne(
&self,
other: &Rgb<S, T>,
epsilon: <T as AbsDiffEq>::Epsilon,
max_relative: <T as AbsDiffEq>::Epsilon,
) -> bool
fn relative_ne( &self, other: &Rgb<S, T>, epsilon: <T as AbsDiffEq>::Epsilon, max_relative: <T as AbsDiffEq>::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§fn saturating_add(self, c: T) -> <Rgb<S, T> as SaturatingAdd<T>>::Output
fn saturating_add(self, c: T) -> <Rgb<S, T> as SaturatingAdd<T>>::Output
self
and other
, but saturates instead of overflowing.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§fn saturating_sub(self, c: T) -> <Rgb<S, T> as SaturatingSub<T>>::Output
fn saturating_sub(self, c: T) -> <Rgb<S, T> as SaturatingSub<T>>::Output
self
and other
, but saturates instead of overflowing.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> Serialize for Rgb<S, T>where
T: Serialize,
impl<S, T> Serialize for Rgb<S, T>where
T: Serialize,
source§fn serialize<__S>(
&self,
__serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
fn serialize<__S>(
&self,
__serializer: __S,
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
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: Rgb<S, T>)
fn sub_assign(&mut self, other: Rgb<S, T>)
-=
operation. Read moresource§impl<S, T> UlpsEq for Rgb<S, T>
impl<S, T> UlpsEq for Rgb<S, T>
source§fn default_max_ulps() -> u32
fn default_max_ulps() -> u32
source§impl<S, T> Wcag21RelativeContrast for Rgb<S, T>
impl<S, T> Wcag21RelativeContrast for Rgb<S, T>
source§fn relative_luminance(
self,
) -> Luma<Linear<D65>, <Rgb<S, T> as Wcag21RelativeContrast>::Scalar>
fn relative_luminance( self, ) -> Luma<Linear<D65>, <Rgb<S, T> as Wcag21RelativeContrast>::Scalar>
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) -> <Rgb<S, T> as WithAlpha<_A>>::WithAlpha
fn with_alpha(self, alpha: _A) -> <Rgb<S, T> as WithAlpha<_A>>::WithAlpha
Self
already has a transparency, it is
overwritten. Read moresource§fn without_alpha(self) -> <Rgb<S, T> as WithAlpha<_A>>::Color
fn without_alpha(self) -> <Rgb<S, T> as WithAlpha<_A>>::Color
Self::Color
has
an internal transparency field, that field will be set to
A::max_intensity()
to make it opaque. Read more