#[repr(C)]pub struct Alpha<C, T> {
pub color: C,
pub alpha: T,
}
Expand description
An alpha component wrapper for colors, for adding transparency.
Instead of having separate types for “RGB with alpha”, “HSV with alpha”, and
so on, Palette uses this wrapper type to attach the alpha component. The
memory representation is the same as if alpha
was the last member/property
of color
, which is just as space efficient. The perk of having a wrapper
is that the alpha can easily be added to or separated form any color.
§Creating Transparent Values
The color types in Palette have transparent type aliases, such as
Srgba
for Srgb
or Hsla
for Hsl
. These aliases implement new
and other useful
methods. Here’s the same example as for Rgb
, but with
transparency:
use palette::Srgba;
let rgba_u8 = Srgba::new(171u8, 193, 35, 128);
let rgab_f32 = Srgba::new(0.3f32, 0.8, 0.1, 0.5);
// `new` is also `const`:
const RGBA_U8: Srgba<u8> = Srgba::new(171, 193, 35, 128);
// Conversion methods from the color type are usually available for transparent
// values too. For example `into_format` for changing the number format:
let rgb_u8_from_f32 = Srgba::new(0.3f32, 0.8, 0.1, 0.5).into_format::<u8, u8>();
// Hexadecimal is also supported for RGBA, with or without the #:
let rgb_from_hex1: Srgba<u8> = "#f034e65a".parse().unwrap();
let rgb_from_hex2: Srgba<u8> = "f034e65a".parse().unwrap();
assert_eq!(rgb_from_hex1, rgb_from_hex2);
// This includes the shorthand format:
let rgb_from_short_hex: Srgba<u8> = "f3ea".parse().unwrap();
let rgb_from_long_hex: Srgba<u8> = "ff33eeaa".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 = Srgba::from([171u8, 193, 35, 128]);
let rgb_from_tuple = Srgba::from((171u8, 193, 35, 128));
let rgb_from_u32 = Srgba::from(0x607F005A);
Opaque values can be made transparent using the WithAlpha
trait, in
addition to simply wrapping them in Alpha
. WithAlpha
is also useful in
generic code, since it’s implemented for both opaque and transparent types.
use palette::{WithAlpha, Srgb};
let rgb = Srgb::new(171u8, 193, 35);
let rgba = rgb.with_alpha(128u8);
assert_eq!(rgba.alpha, 128);
You may have noticed the u8
in rgb.with_alpha(128u8)
. That’s because
Alpha
allows the transparency component to have a different type than the
color components. It would be just as valid to write
rgb.with_alpha(0.5f32)
, for example.
§Accessing Color Components
To help with the nesting, Alpha
implements Deref
and DerefMut
.
This use of the traits is a bit unconventional, since Alpha
isn’t a smart
pointer. It turned out to be a quite successful experiment that stuck
around.
use palette::Srgba;
let rgba = Srgba::new(171u8, 193, 35, 128);
let red = rgba.red; // Accesses `rgba.color.red`.
let alpha = rgba.alpha; // Accesses `rgba.alpha`.
let rgb = rgba.color; // Accesses `rgba.color`;
The main drawback is in generic code:
use palette::Srgba;
fn get_red<T>(rgba: Srgba<T>) -> T {
rgba.red // Error: cannot move out of dereference of `Alpha<Rgb<_, T>, T>`
}
red
has to be accessed through color
:
use palette::Srgba;
fn get_red<T>(rgba: Srgba<T>) -> T {
rgba.color.red
}
Fields§
§color: C
The color.
alpha: T
The transparency component. 0.0 (or 0u8) is fully transparent and 1.0 (or 255u8) is fully opaque.
Implementations§
source§impl<C, A> Alpha<C, A>
impl<C, A> Alpha<C, A>
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.
source§impl<C: Premultiply> Alpha<C, C::Scalar>
impl<C: Premultiply> Alpha<C, C::Scalar>
sourcepub fn premultiply(self) -> PreAlpha<C>
pub fn premultiply(self) -> PreAlpha<C>
Alpha mask the color by its transparency.
source§impl<T, A> Alpha<Cam16<T>, A>
impl<T, A> Alpha<Cam16<T>, A>
Cam16a
implementations.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
Derive CIE CAM16 attributes with transparency for the provided color, under the provided viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16a, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), example_parameters);
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, IntoColor, cam16::{Cam16a, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
sourcepub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Construct an XYZ color with transparency, that matches these CIE CAM16 attributes, under the provided viewing conditions.
This assumes that all of the correlated attributes are consistent, as only some of them are actually used. You may want to use one of the partial CAM16 representations for more control over which set of attributes that should be.
use palette::{Srgba, FromColor, cam16::{Cam16a, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let cam16a = get_cam16a_value();
let rgba = Srgba::from_color(cam16a.into_xyz(example_parameters));
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, FromColor, cam16::{Cam16a, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let cam16a = get_cam16a_value();
let rgba = Srgba::from_color(cam16a.into_xyz(baked_parameters));
source§impl<T, A> Alpha<Cam16Jch<T>, A>
impl<T, A> Alpha<Cam16Jch<T>, A>
“Cam16Jcha
implementations.
sourcepub fn new<H: Into<Cam16Hue<T>>>(
lightness: T,
chroma: T,
hue: H,
alpha: A,
) -> Self
pub fn new<H: Into<Cam16Hue<T>>>( lightness: T, chroma: T, hue: H, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
lightness: T,
chroma: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Self
pub const fn new_const( lightness: T, chroma: T, hue: Cam16Hue<T>, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency. This is the
same as Cam16Jch::new
without the generic hue type. It’s temporary until
const fn
supports traits.
sourcepub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
Convert to a (lightness, chroma, hue, alpha)
tuple.
sourcepub fn from_components<H: Into<Cam16Hue<T>>>(
(lightness, chroma, hue, alpha): (T, T, H, A),
) -> Self
pub fn from_components<H: Into<Cam16Hue<T>>>( (lightness, chroma, hue, alpha): (T, T, H, A), ) -> Self
Convert from a (lightness, chroma, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jch<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jch<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16Jcha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jcha::from_xyz(rgba.into_color(), example_parameters);
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, IntoColor, cam16::{Cam16Jcha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jcha::from_xyz(rgba.into_color(), baked_parameters);
sourcepub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Jch<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Jch<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.
use palette::{Srgba, FromColor, cam16::{Cam16Jcha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let partial = Cam16Jcha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, FromColor, cam16::{Cam16Jcha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let partial = Cam16Jcha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));
sourcepub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
Create a partial set of CIE CAM16 attributes with transparency.
It’s also possible to use Cam16Jcha::from
or Cam16a::into
.
sourcepub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jch<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jch<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Jcha, Parameters}};
use approx::assert_relative_eq;
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
// Optional, but saves some work:
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Jcha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);
assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);
source§impl<T, A> Alpha<Cam16Jch<&mut T>, &mut A>
impl<T, A> Alpha<Cam16Jch<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Cam16Jch<Ct>, Ca>
impl<Ct, Ca> Alpha<Cam16Jch<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Cam16Jch<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Jch<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Cam16Jch<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Jch<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Cam16Jch<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Cam16Jch<Vec<T>>, Vec<A>>
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: Alpha<Cam16Jch<T>, A>)
pub fn push(&mut self, value: Alpha<Cam16Jch<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Cam16Jch<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Cam16Jch<T>, A>>
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<T, A> Alpha<Cam16Jmh<T>, A>
impl<T, A> Alpha<Cam16Jmh<T>, A>
“Cam16Jmha
implementations.
sourcepub fn new<H: Into<Cam16Hue<T>>>(
lightness: T,
colorfulness: T,
hue: H,
alpha: A,
) -> Self
pub fn new<H: Into<Cam16Hue<T>>>( lightness: T, colorfulness: T, hue: H, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
lightness: T,
colorfulness: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Self
pub const fn new_const( lightness: T, colorfulness: T, hue: Cam16Hue<T>, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency. This is the
same as Cam16Jmh::new
without the generic hue type. It’s temporary until
const fn
supports traits.
sourcepub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
Convert to a (lightness, colorfulness, hue, alpha)
tuple.
sourcepub fn from_components<H: Into<Cam16Hue<T>>>(
(lightness, colorfulness, hue, alpha): (T, T, H, A),
) -> Self
pub fn from_components<H: Into<Cam16Hue<T>>>( (lightness, colorfulness, hue, alpha): (T, T, H, A), ) -> Self
Convert from a (lightness, colorfulness, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jmh<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jmh<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16Jmha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jmha::from_xyz(rgba.into_color(), example_parameters);
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, IntoColor, cam16::{Cam16Jmha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jmha::from_xyz(rgba.into_color(), baked_parameters);
sourcepub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Jmh<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Jmh<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.
use palette::{Srgba, FromColor, cam16::{Cam16Jmha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let partial = Cam16Jmha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, FromColor, cam16::{Cam16Jmha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let partial = Cam16Jmha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));
sourcepub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
Create a partial set of CIE CAM16 attributes with transparency.
It’s also possible to use Cam16Jmha::from
or Cam16a::into
.
sourcepub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jmh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jmh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Jmha, Parameters}};
use approx::assert_relative_eq;
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
// Optional, but saves some work:
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Jmha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);
assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);
source§impl<T, A> Alpha<Cam16Jmh<&mut T>, &mut A>
impl<T, A> Alpha<Cam16Jmh<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Cam16Jmh<Ct>, Ca>
impl<Ct, Ca> Alpha<Cam16Jmh<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Cam16Jmh<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Jmh<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Cam16Jmh<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Jmh<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Cam16Jmh<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Cam16Jmh<Vec<T>>, Vec<A>>
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: Alpha<Cam16Jmh<T>, A>)
pub fn push(&mut self, value: Alpha<Cam16Jmh<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Cam16Jmh<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Cam16Jmh<T>, A>>
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<T, A> Alpha<Cam16Jsh<T>, A>
impl<T, A> Alpha<Cam16Jsh<T>, A>
“Cam16Jsha
implementations.
sourcepub fn new<H: Into<Cam16Hue<T>>>(
lightness: T,
saturation: T,
hue: H,
alpha: A,
) -> Self
pub fn new<H: Into<Cam16Hue<T>>>( lightness: T, saturation: T, hue: H, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
lightness: T,
saturation: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Self
pub const fn new_const( lightness: T, saturation: T, hue: Cam16Hue<T>, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency. This is the
same as Cam16Jsh::new
without the generic hue type. It’s temporary until
const fn
supports traits.
sourcepub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
Convert to a (lightness, saturation, hue, alpha)
tuple.
sourcepub fn from_components<H: Into<Cam16Hue<T>>>(
(lightness, saturation, hue, alpha): (T, T, H, A),
) -> Self
pub fn from_components<H: Into<Cam16Hue<T>>>( (lightness, saturation, hue, alpha): (T, T, H, A), ) -> Self
Convert from a (lightness, saturation, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jsh<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jsh<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16Jsha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jsha::from_xyz(rgba.into_color(), example_parameters);
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, IntoColor, cam16::{Cam16Jsha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jsha::from_xyz(rgba.into_color(), baked_parameters);
sourcepub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Jsh<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Jsh<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.
use palette::{Srgba, FromColor, cam16::{Cam16Jsha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let partial = Cam16Jsha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, FromColor, cam16::{Cam16Jsha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let partial = Cam16Jsha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));
sourcepub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
Create a partial set of CIE CAM16 attributes with transparency.
It’s also possible to use Cam16Jsha::from
or Cam16a::into
.
sourcepub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jsh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jsh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Jsha, Parameters}};
use approx::assert_relative_eq;
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
// Optional, but saves some work:
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Jsha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);
assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);
source§impl<T, A> Alpha<Cam16Jsh<&mut T>, &mut A>
impl<T, A> Alpha<Cam16Jsh<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Cam16Jsh<Ct>, Ca>
impl<Ct, Ca> Alpha<Cam16Jsh<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Cam16Jsh<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Jsh<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Cam16Jsh<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Jsh<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Cam16Jsh<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Cam16Jsh<Vec<T>>, Vec<A>>
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: Alpha<Cam16Jsh<T>, A>)
pub fn push(&mut self, value: Alpha<Cam16Jsh<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Cam16Jsh<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Cam16Jsh<T>, A>>
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<T, A> Alpha<Cam16Qch<T>, A>
impl<T, A> Alpha<Cam16Qch<T>, A>
“Cam16Qcha
implementations.
sourcepub fn new<H: Into<Cam16Hue<T>>>(
brightness: T,
chroma: T,
hue: H,
alpha: A,
) -> Self
pub fn new<H: Into<Cam16Hue<T>>>( brightness: T, chroma: T, hue: H, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
brightness: T,
chroma: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Self
pub const fn new_const( brightness: T, chroma: T, hue: Cam16Hue<T>, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency. This is the
same as Cam16Qch::new
without the generic hue type. It’s temporary until
const fn
supports traits.
sourcepub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
Convert to a (brightness, chroma, hue, alpha)
tuple.
sourcepub fn from_components<H: Into<Cam16Hue<T>>>(
(brightness, chroma, hue, alpha): (T, T, H, A),
) -> Self
pub fn from_components<H: Into<Cam16Hue<T>>>( (brightness, chroma, hue, alpha): (T, T, H, A), ) -> Self
Convert from a (brightness, chroma, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qch<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qch<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16Qcha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qcha::from_xyz(rgba.into_color(), example_parameters);
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, IntoColor, cam16::{Cam16Qcha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qcha::from_xyz(rgba.into_color(), baked_parameters);
sourcepub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Qch<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Qch<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.
use palette::{Srgba, FromColor, cam16::{Cam16Qcha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let partial = Cam16Qcha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, FromColor, cam16::{Cam16Qcha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let partial = Cam16Qcha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));
sourcepub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
Create a partial set of CIE CAM16 attributes with transparency.
It’s also possible to use Cam16Qcha::from
or Cam16a::into
.
sourcepub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qch<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qch<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Qcha, Parameters}};
use approx::assert_relative_eq;
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
// Optional, but saves some work:
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Qcha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);
assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);
source§impl<T, A> Alpha<Cam16Qch<&mut T>, &mut A>
impl<T, A> Alpha<Cam16Qch<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Cam16Qch<Ct>, Ca>
impl<Ct, Ca> Alpha<Cam16Qch<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Cam16Qch<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Qch<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Cam16Qch<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Qch<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Cam16Qch<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Cam16Qch<Vec<T>>, Vec<A>>
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: Alpha<Cam16Qch<T>, A>)
pub fn push(&mut self, value: Alpha<Cam16Qch<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Cam16Qch<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Cam16Qch<T>, A>>
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<T, A> Alpha<Cam16Qmh<T>, A>
impl<T, A> Alpha<Cam16Qmh<T>, A>
“Cam16Qmha
implementations.
sourcepub fn new<H: Into<Cam16Hue<T>>>(
brightness: T,
colorfulness: T,
hue: H,
alpha: A,
) -> Self
pub fn new<H: Into<Cam16Hue<T>>>( brightness: T, colorfulness: T, hue: H, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
brightness: T,
colorfulness: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Self
pub const fn new_const( brightness: T, colorfulness: T, hue: Cam16Hue<T>, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency. This is the
same as Cam16Qmh::new
without the generic hue type. It’s temporary until
const fn
supports traits.
sourcepub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
Convert to a (brightness, colorfulness, hue, alpha)
tuple.
sourcepub fn from_components<H: Into<Cam16Hue<T>>>(
(brightness, colorfulness, hue, alpha): (T, T, H, A),
) -> Self
pub fn from_components<H: Into<Cam16Hue<T>>>( (brightness, colorfulness, hue, alpha): (T, T, H, A), ) -> Self
Convert from a (brightness, colorfulness, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qmh<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qmh<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16Qmha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qmha::from_xyz(rgba.into_color(), example_parameters);
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, IntoColor, cam16::{Cam16Qmha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qmha::from_xyz(rgba.into_color(), baked_parameters);
sourcepub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Qmh<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Qmh<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.
use palette::{Srgba, FromColor, cam16::{Cam16Qmha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let partial = Cam16Qmha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, FromColor, cam16::{Cam16Qmha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let partial = Cam16Qmha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));
sourcepub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
Create a partial set of CIE CAM16 attributes with transparency.
It’s also possible to use Cam16Qmha::from
or Cam16a::into
.
sourcepub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qmh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qmh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Qmha, Parameters}};
use approx::assert_relative_eq;
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
// Optional, but saves some work:
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Qmha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);
assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);
source§impl<T, A> Alpha<Cam16Qmh<&mut T>, &mut A>
impl<T, A> Alpha<Cam16Qmh<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Cam16Qmh<Ct>, Ca>
impl<Ct, Ca> Alpha<Cam16Qmh<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Cam16Qmh<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Qmh<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Cam16Qmh<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Qmh<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Cam16Qmh<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Cam16Qmh<Vec<T>>, Vec<A>>
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: Alpha<Cam16Qmh<T>, A>)
pub fn push(&mut self, value: Alpha<Cam16Qmh<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Cam16Qmh<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Cam16Qmh<T>, A>>
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<T, A> Alpha<Cam16Qsh<T>, A>
impl<T, A> Alpha<Cam16Qsh<T>, A>
“Cam16Qsha
implementations.
sourcepub fn new<H: Into<Cam16Hue<T>>>(
brightness: T,
saturation: T,
hue: H,
alpha: A,
) -> Self
pub fn new<H: Into<Cam16Hue<T>>>( brightness: T, saturation: T, hue: H, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
brightness: T,
saturation: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Self
pub const fn new_const( brightness: T, saturation: T, hue: Cam16Hue<T>, alpha: A, ) -> Self
Create a partial CIE CAM16 color with transparency. This is the
same as Cam16Qsh::new
without the generic hue type. It’s temporary until
const fn
supports traits.
sourcepub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
Convert to a (brightness, saturation, hue, alpha)
tuple.
sourcepub fn from_components<H: Into<Cam16Hue<T>>>(
(brightness, saturation, hue, alpha): (T, T, H, A),
) -> Self
pub fn from_components<H: Into<Cam16Hue<T>>>( (brightness, saturation, hue, alpha): (T, T, H, A), ) -> Self
Convert from a (brightness, saturation, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qsh<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<WpParam::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Selfwhere
Xyz<WpParam::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qsh<T>, Scalar = T::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<T::Scalar>,
Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16Qsha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qsha::from_xyz(rgba.into_color(), example_parameters);
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, IntoColor, cam16::{Cam16Qsha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qsha::from_xyz(rgba.into_color(), baked_parameters);
sourcepub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Qsh<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Xyz<WpParam::StaticWp, T>, A>where
Cam16Qsh<T>: Cam16IntoUnclamped<WpParam, Xyz<WpParam::StaticWp, T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.
use palette::{Srgba, FromColor, cam16::{Cam16Qsha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let partial = Cam16Qsha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));
It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.
use palette::{Srgba, FromColor, cam16::{Cam16Qsha, Parameters}};
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
let baked_parameters = example_parameters.bake();
let partial = Cam16Qsha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));
sourcepub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Self
Create a partial set of CIE CAM16 attributes with transparency.
It’s also possible to use Cam16Qsha::from
or Cam16a::into
.
sourcepub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qsh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, T::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qsh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = T::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.
use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Qsha, Parameters}};
use approx::assert_relative_eq;
// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);
// Optional, but saves some work:
let baked_parameters = example_parameters.bake();
let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Qsha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);
assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);
source§impl<T, A> Alpha<Cam16Qsh<&mut T>, &mut A>
impl<T, A> Alpha<Cam16Qsh<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Cam16Qsh<Ct>, Ca>
impl<Ct, Ca> Alpha<Cam16Qsh<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Cam16Qsh<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Qsh<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Cam16Qsh<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Qsh<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Cam16Qsh<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Cam16Qsh<Vec<T>>, Vec<A>>
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: Alpha<Cam16Qsh<T>, A>)
pub fn push(&mut self, value: Alpha<Cam16Qsh<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Cam16Qsh<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Cam16Qsh<T>, A>>
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<T, A> Alpha<Cam16UcsJab<T>, A>
impl<T, A> Alpha<Cam16UcsJab<T>, A>
Cam16UcsJaba
implementations.
sourcepub const fn new(lightness: T, a: T, b: T, alpha: A) -> Self
pub const fn new(lightness: T, a: T, b: T, alpha: A) -> Self
Create a CAM16-UCS J’ a’ b’ color with transparency.
sourcepub fn into_components(self) -> (T, T, T, A)
pub fn into_components(self) -> (T, T, T, A)
Convert to a (J', a', b', a)
tuple.
sourcepub fn from_components((lightness, a, b, alpha): (T, T, T, A)) -> Self
pub fn from_components((lightness, a, b, alpha): (T, T, T, A)) -> Self
Convert from a (J', a', b', a)
tuple.
source§impl<T, A> Alpha<Cam16UcsJab<&mut T>, &mut A>
impl<T, A> Alpha<Cam16UcsJab<&mut T>, &mut A>
sourcepub fn set(&mut self, value: Alpha<Cam16UcsJab<T>, A>)
pub fn set(&mut self, value: Alpha<Cam16UcsJab<T>, A>)
Update this color with new values.
sourcepub fn as_refs(&self) -> Alpha<Cam16UcsJab<&T>, &A>
pub fn as_refs(&self) -> Alpha<Cam16UcsJab<&T>, &A>
Borrow this color’s components as shared references.
sourcepub fn copied(&self) -> Alpha<Cam16UcsJab<T>, A>
pub fn copied(&self) -> Alpha<Cam16UcsJab<T>, A>
Get an owned, copied version of this color.
source§impl<Ct, Ca> Alpha<Cam16UcsJab<Ct>, Ca>
impl<Ct, Ca> Alpha<Cam16UcsJab<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Cam16UcsJab<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16UcsJab<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Cam16UcsJab<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16UcsJab<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Cam16UcsJab<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Cam16UcsJab<Vec<T>>, Vec<A>>
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: Alpha<Cam16UcsJab<T>, A>)
pub fn push(&mut self, value: Alpha<Cam16UcsJab<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Cam16UcsJab<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Cam16UcsJab<T>, A>>
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<T, A> Alpha<Cam16UcsJmh<T>, A>
impl<T, A> Alpha<Cam16UcsJmh<T>, A>
Cam16UcsJmha
implementations.
sourcepub fn new<H: Into<Cam16Hue<T>>>(
lightness: T,
colorfulness: T,
hue: H,
alpha: A,
) -> Self
pub fn new<H: Into<Cam16Hue<T>>>( lightness: T, colorfulness: T, hue: H, alpha: A, ) -> Self
Create a CAM16-UCS J’ M’ h’ color with transparency.
sourcepub const fn new_const(
lightness: T,
colorfulness: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Self
pub const fn new_const( lightness: T, colorfulness: T, hue: Cam16Hue<T>, alpha: A, ) -> Self
Create a CAM16-UCS J’ M’ h’ color with transparency. This is the same as
Cam16UcsJmha::new
without the generic hue type. It’s temporary until
const fn
supports traits.
sourcepub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)
Convert to a (J', M', h', a)
tuple.
sourcepub fn from_components<H: Into<Cam16Hue<T>>>(
(lightness, colorfulness, hue, alpha): (T, T, H, A),
) -> Self
pub fn from_components<H: Into<Cam16Hue<T>>>( (lightness, colorfulness, hue, alpha): (T, T, H, A), ) -> Self
Convert from a (J', M', h', a)
tuple.
source§impl<T, A> Alpha<Cam16UcsJmh<&mut T>, &mut A>
impl<T, A> Alpha<Cam16UcsJmh<&mut T>, &mut A>
sourcepub fn set(&mut self, value: Alpha<Cam16UcsJmh<T>, A>)
pub fn set(&mut self, value: Alpha<Cam16UcsJmh<T>, A>)
Update this color with new values.
sourcepub fn as_refs(&self) -> Alpha<Cam16UcsJmh<&T>, &A>
pub fn as_refs(&self) -> Alpha<Cam16UcsJmh<&T>, &A>
Borrow this color’s components as shared references.
sourcepub fn copied(&self) -> Alpha<Cam16UcsJmh<T>, A>
pub fn copied(&self) -> Alpha<Cam16UcsJmh<T>, A>
Get an owned, copied version of this color.
source§impl<Ct, Ca> Alpha<Cam16UcsJmh<Ct>, Ca>
impl<Ct, Ca> Alpha<Cam16UcsJmh<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Cam16UcsJmh<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16UcsJmh<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Cam16UcsJmh<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16UcsJmh<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Cam16UcsJmh<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Cam16UcsJmh<Vec<T>>, Vec<A>>
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: Alpha<Cam16UcsJmh<T>, A>)
pub fn push(&mut self, value: Alpha<Cam16UcsJmh<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Cam16UcsJmh<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Cam16UcsJmh<T>, A>>
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<T, A> Alpha<Hsl<Srgb, T>, A>
impl<T, A> Alpha<Hsl<Srgb, T>, A>
Hsla
implementations.
sourcepub fn new_srgb<H: Into<RgbHue<T>>>(
hue: H,
saturation: T,
lightness: T,
alpha: A,
) -> Self
pub fn new_srgb<H: Into<RgbHue<T>>>( hue: H, saturation: T, lightness: T, alpha: A, ) -> Self
Create an sRGB HSL color with transparency. This method can be used
instead of Hsla::new
to help type inference.
sourcepub const fn new_srgb_const(
hue: RgbHue<T>,
saturation: T,
lightness: T,
alpha: A,
) -> Self
pub const fn new_srgb_const( hue: RgbHue<T>, saturation: T, lightness: T, alpha: A, ) -> Self
Create an sRGB HSL color with transparency. This is the same as
Hsla::new_srgb
without the generic hue type. It’s temporary until
const fn
supports traits.
source§impl<S, T, A> Alpha<Hsl<S, T>, A>
impl<S, T, A> Alpha<Hsl<S, T>, A>
Hsla
implementations.
sourcepub fn new<H: Into<RgbHue<T>>>(
hue: H,
saturation: T,
lightness: T,
alpha: A,
) -> Self
pub fn new<H: Into<RgbHue<T>>>( hue: H, saturation: T, lightness: T, alpha: A, ) -> Self
Create an HSL color with transparency.
sourcepub const fn new_const(
hue: RgbHue<T>,
saturation: T,
lightness: T,
alpha: A,
) -> Self
pub const fn new_const( hue: RgbHue<T>, saturation: T, lightness: T, alpha: A, ) -> Self
Create an HSL color with transparency. This is the same as Hsla::new
without the generic hue type. It’s temporary until const fn
supports
traits.
sourcepub fn into_format<U, B>(self) -> Alpha<Hsl<S, U>, B>
pub fn into_format<U, B>(self) -> Alpha<Hsl<S, U>, B>
Convert into another component type.
sourcepub fn from_format<U, B>(color: Alpha<Hsl<S, U>, B>) -> Self
pub fn from_format<U, B>(color: Alpha<Hsl<S, U>, B>) -> Self
Convert from another component type.
sourcepub fn into_components(self) -> (RgbHue<T>, T, T, A)
pub fn into_components(self) -> (RgbHue<T>, T, T, A)
Convert to a (hue, saturation, lightness, alpha)
tuple.
sourcepub fn from_components<H: Into<RgbHue<T>>>(
(hue, saturation, lightness, alpha): (H, T, T, A),
) -> Self
pub fn from_components<H: Into<RgbHue<T>>>( (hue, saturation, lightness, alpha): (H, T, T, A), ) -> Self
Convert from a (hue, saturation, lightness, alpha)
tuple.
source§impl<S, T, A> Alpha<Hsl<S, &mut T>, &mut A>
impl<S, T, A> Alpha<Hsl<S, &mut T>, &mut A>
source§impl<S, Ct, Ca> Alpha<Hsl<S, Ct>, Ca>
impl<S, Ct, Ca> Alpha<Hsl<S, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Hsl<S, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hsl<S, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Hsl<S, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hsl<S, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::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, A> Alpha<Hsl<S, Vec<T>>, Vec<A>>
impl<S, T, A> Alpha<Hsl<S, Vec<T>>, Vec<A>>
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: Alpha<Hsl<S, T>, A>)
pub fn push(&mut self, value: Alpha<Hsl<S, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Hsl<S, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Hsl<S, T>, A>>
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<Wp, T, A> Alpha<Hsluv<Wp, T>, A>
impl<Wp, T, A> Alpha<Hsluv<Wp, T>, A>
Hsluva
implementations.
sourcepub fn new<H: Into<LuvHue<T>>>(hue: H, saturation: T, l: T, alpha: A) -> Self
pub fn new<H: Into<LuvHue<T>>>(hue: H, saturation: T, l: T, alpha: A) -> Self
Create an HSLuv color with transparency.
sourcepub const fn new_const(hue: LuvHue<T>, saturation: T, l: T, alpha: A) -> Self
pub const fn new_const(hue: LuvHue<T>, saturation: T, l: T, alpha: A) -> Self
Create an HSLuv color with transparency. This is the same as
Hsluva::new
without the generic hue type. It’s temporary until const fn
supports traits.
sourcepub fn into_components(self) -> (LuvHue<T>, T, T, A)
pub fn into_components(self) -> (LuvHue<T>, T, T, A)
Convert to a (hue, saturation, l, alpha)
tuple.
sourcepub fn from_components<H: Into<LuvHue<T>>>(
(hue, saturation, l, alpha): (H, T, T, A),
) -> Self
pub fn from_components<H: Into<LuvHue<T>>>( (hue, saturation, l, alpha): (H, T, T, A), ) -> Self
Convert from a (hue, saturation, l, alpha)
tuple.
source§impl<Wp, T, A> Alpha<Hsluv<Wp, &mut T>, &mut A>
impl<Wp, T, A> Alpha<Hsluv<Wp, &mut T>, &mut A>
source§impl<Wp, Ct, Ca> Alpha<Hsluv<Wp, Ct>, Ca>
impl<Wp, Ct, Ca> Alpha<Hsluv<Wp, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Hsluv<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hsluv<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Hsluv<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hsluv<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<Wp, T, A> Alpha<Hsluv<Wp, Vec<T>>, Vec<A>>
impl<Wp, T, A> Alpha<Hsluv<Wp, Vec<T>>, Vec<A>>
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: Alpha<Hsluv<Wp, T>, A>)
pub fn push(&mut self, value: Alpha<Hsluv<Wp, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Hsluv<Wp, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Hsluv<Wp, T>, A>>
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<T, A> Alpha<Hsv<Srgb, T>, A>
impl<T, A> Alpha<Hsv<Srgb, T>, A>
Hsva
implementations.
sourcepub fn new_srgb<H: Into<RgbHue<T>>>(
hue: H,
saturation: T,
value: T,
alpha: A,
) -> Self
pub fn new_srgb<H: Into<RgbHue<T>>>( hue: H, saturation: T, value: T, alpha: A, ) -> Self
Create an sRGB HSV color with transparency. This method can be used
instead of Hsva::new
to help type inference.
sourcepub const fn new_srgb_const(
hue: RgbHue<T>,
saturation: T,
value: T,
alpha: A,
) -> Self
pub const fn new_srgb_const( hue: RgbHue<T>, saturation: T, value: T, alpha: A, ) -> Self
Create an sRGB HSV color with transparency. This is the same as
Hsva::new_srgb
without the generic hue type. It’s temporary until
const fn
supports traits.
source§impl<S, T, A> Alpha<Hsv<S, T>, A>
impl<S, T, A> Alpha<Hsv<S, T>, A>
Hsva
implementations.
sourcepub fn new<H: Into<RgbHue<T>>>(
hue: H,
saturation: T,
value: T,
alpha: A,
) -> Self
pub fn new<H: Into<RgbHue<T>>>( hue: H, saturation: T, value: T, alpha: A, ) -> Self
Create an HSV color with transparency.
sourcepub const fn new_const(
hue: RgbHue<T>,
saturation: T,
value: T,
alpha: A,
) -> Self
pub const fn new_const( hue: RgbHue<T>, saturation: T, value: T, alpha: A, ) -> Self
Create an HSV color with transparency. This is the same as Hsva::new
without the generic hue type. It’s temporary until const fn
supports
traits.
sourcepub fn into_format<U, B>(self) -> Alpha<Hsv<S, U>, B>
pub fn into_format<U, B>(self) -> Alpha<Hsv<S, U>, B>
Convert into another component type.
sourcepub fn from_format<U, B>(color: Alpha<Hsv<S, U>, B>) -> Self
pub fn from_format<U, B>(color: Alpha<Hsv<S, U>, B>) -> Self
Convert from another component type.
sourcepub fn into_components(self) -> (RgbHue<T>, T, T, A)
pub fn into_components(self) -> (RgbHue<T>, T, T, A)
Convert to a (hue, saturation, value, alpha)
tuple.
sourcepub fn from_components<H: Into<RgbHue<T>>>(
(hue, saturation, value, alpha): (H, T, T, A),
) -> Self
pub fn from_components<H: Into<RgbHue<T>>>( (hue, saturation, value, alpha): (H, T, T, A), ) -> Self
Convert from a (hue, saturation, value, alpha)
tuple.
source§impl<S, T, A> Alpha<Hsv<S, &mut T>, &mut A>
impl<S, T, A> Alpha<Hsv<S, &mut T>, &mut A>
source§impl<S, Ct, Ca> Alpha<Hsv<S, Ct>, Ca>
impl<S, Ct, Ca> Alpha<Hsv<S, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Hsv<S, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hsv<S, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Hsv<S, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hsv<S, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::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, A> Alpha<Hsv<S, Vec<T>>, Vec<A>>
impl<S, T, A> Alpha<Hsv<S, Vec<T>>, Vec<A>>
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: Alpha<Hsv<S, T>, A>)
pub fn push(&mut self, value: Alpha<Hsv<S, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Hsv<S, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Hsv<S, T>, A>>
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<T, A> Alpha<Hwb<Srgb, T>, A>
impl<T, A> Alpha<Hwb<Srgb, T>, A>
Hwba
implementations.
sourcepub fn new_srgb<H: Into<RgbHue<T>>>(
hue: H,
whiteness: T,
blackness: T,
alpha: A,
) -> Self
pub fn new_srgb<H: Into<RgbHue<T>>>( hue: H, whiteness: T, blackness: T, alpha: A, ) -> Self
Create an sRGB HWB color with transparency. This method can be used
instead of Hwba::new
to help type inference.
sourcepub const fn new_srgb_const(
hue: RgbHue<T>,
whiteness: T,
blackness: T,
alpha: A,
) -> Self
pub const fn new_srgb_const( hue: RgbHue<T>, whiteness: T, blackness: T, alpha: A, ) -> Self
Create an sRGB HWB color with transparency. This is the same as
Hwba::new_srgb
without the generic hue type. It’s temporary until const fn
supports traits.
source§impl<S, T, A> Alpha<Hwb<S, T>, A>
impl<S, T, A> Alpha<Hwb<S, T>, A>
Hwba
implementations.
sourcepub fn new<H: Into<RgbHue<T>>>(
hue: H,
whiteness: T,
blackness: T,
alpha: A,
) -> Self
pub fn new<H: Into<RgbHue<T>>>( hue: H, whiteness: T, blackness: T, alpha: A, ) -> Self
Create an HWB color with transparency.
sourcepub const fn new_const(
hue: RgbHue<T>,
whiteness: T,
blackness: T,
alpha: A,
) -> Self
pub const fn new_const( hue: RgbHue<T>, whiteness: T, blackness: T, alpha: A, ) -> Self
Create an HWB color with transparency. This is the same as Hwba::new
without the
generic hue type. It’s temporary until const fn
supports traits.
sourcepub fn into_format<U, B>(self) -> Alpha<Hwb<S, U>, B>
pub fn into_format<U, B>(self) -> Alpha<Hwb<S, U>, B>
Convert into another component type.
sourcepub fn from_format<U, B>(color: Alpha<Hwb<S, U>, B>) -> Self
pub fn from_format<U, B>(color: Alpha<Hwb<S, U>, B>) -> Self
Convert from another component type.
sourcepub fn into_components(self) -> (RgbHue<T>, T, T, A)
pub fn into_components(self) -> (RgbHue<T>, T, T, A)
Convert to a (hue, whiteness, blackness, alpha)
tuple.
sourcepub fn from_components<H: Into<RgbHue<T>>>(
(hue, whiteness, blackness, alpha): (H, T, T, A),
) -> Self
pub fn from_components<H: Into<RgbHue<T>>>( (hue, whiteness, blackness, alpha): (H, T, T, A), ) -> Self
Convert from a (hue, whiteness, blackness, alpha)
tuple.
source§impl<S, T, A> Alpha<Hwb<S, &mut T>, &mut A>
impl<S, T, A> Alpha<Hwb<S, &mut T>, &mut A>
source§impl<S, Ct, Ca> Alpha<Hwb<S, Ct>, Ca>
impl<S, Ct, Ca> Alpha<Hwb<S, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Hwb<S, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hwb<S, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Hwb<S, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hwb<S, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::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, A> Alpha<Hwb<S, Vec<T>>, Vec<A>>
impl<S, T, A> Alpha<Hwb<S, Vec<T>>, Vec<A>>
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: Alpha<Hwb<S, T>, A>)
pub fn push(&mut self, value: Alpha<Hwb<S, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Hwb<S, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Hwb<S, T>, A>>
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<Wp, T, A> Alpha<Lab<Wp, T>, A>
impl<Wp, T, A> Alpha<Lab<Wp, T>, A>
Laba
implementations.
sourcepub fn into_components(self) -> (T, T, T, A)
pub fn into_components(self) -> (T, T, T, A)
Convert to a (L\*, a\*, b\*, alpha)
tuple.
sourcepub fn from_components((l, a, b, alpha): (T, T, T, A)) -> Self
pub fn from_components((l, a, b, alpha): (T, T, T, A)) -> Self
Convert from a (L\*, a\*, b\*, alpha)
tuple.
source§impl<Wp, T, A> Alpha<Lab<Wp, &mut T>, &mut A>
impl<Wp, T, A> Alpha<Lab<Wp, &mut T>, &mut A>
source§impl<Wp, Ct, Ca> Alpha<Lab<Wp, Ct>, Ca>
impl<Wp, Ct, Ca> Alpha<Lab<Wp, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Lab<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Lab<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Lab<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Lab<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<Wp, T, A> Alpha<Lab<Wp, Vec<T>>, Vec<A>>
impl<Wp, T, A> Alpha<Lab<Wp, Vec<T>>, Vec<A>>
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: Alpha<Lab<Wp, T>, A>)
pub fn push(&mut self, value: Alpha<Lab<Wp, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Lab<Wp, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Lab<Wp, T>, A>>
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<Wp, T, A> Alpha<Lch<Wp, T>, A>
impl<Wp, T, A> Alpha<Lch<Wp, T>, A>
Lcha
implementations.
sourcepub fn new<H: Into<LabHue<T>>>(l: T, chroma: T, hue: H, alpha: A) -> Self
pub fn new<H: Into<LabHue<T>>>(l: T, chroma: T, hue: H, alpha: A) -> Self
Create a CIE L*C*h° color with transparency.
sourcepub const fn new_const(l: T, chroma: T, hue: LabHue<T>, alpha: A) -> Self
pub const fn new_const(l: T, chroma: T, hue: LabHue<T>, alpha: A) -> Self
Create a CIE L*C*h° color with transparency. This is the same as
Lcha::new
without the generic hue type. It’s temporary until const fn
supports traits.
sourcepub fn into_components(self) -> (T, T, LabHue<T>, A)
pub fn into_components(self) -> (T, T, LabHue<T>, A)
Convert to a (L\*, C\*, h°, alpha)
tuple.
sourcepub fn from_components<H: Into<LabHue<T>>>(
(l, chroma, hue, alpha): (T, T, H, A),
) -> Self
pub fn from_components<H: Into<LabHue<T>>>( (l, chroma, hue, alpha): (T, T, H, A), ) -> Self
Convert from a (L\*, C\*, h°, alpha)
tuple.
source§impl<Wp, T, A> Alpha<Lch<Wp, &mut T>, &mut A>
impl<Wp, T, A> Alpha<Lch<Wp, &mut T>, &mut A>
source§impl<Wp, Ct, Ca> Alpha<Lch<Wp, Ct>, Ca>
impl<Wp, Ct, Ca> Alpha<Lch<Wp, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Lch<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Lch<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Lch<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Lch<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<Wp, T, A> Alpha<Lch<Wp, Vec<T>>, Vec<A>>
impl<Wp, T, A> Alpha<Lch<Wp, Vec<T>>, Vec<A>>
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: Alpha<Lch<Wp, T>, A>)
pub fn push(&mut self, value: Alpha<Lch<Wp, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Lch<Wp, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Lch<Wp, T>, A>>
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<Wp, T, A> Alpha<Lchuv<Wp, T>, A>
impl<Wp, T, A> Alpha<Lchuv<Wp, T>, A>
Lchuva
implementations.
sourcepub fn new<H: Into<LuvHue<T>>>(l: T, chroma: T, hue: H, alpha: A) -> Self
pub fn new<H: Into<LuvHue<T>>>(l: T, chroma: T, hue: H, alpha: A) -> Self
Create a CIE L*C*uv h°uv color with transparency.
sourcepub const fn new_const(l: T, chroma: T, hue: LuvHue<T>, alpha: A) -> Self
pub const fn new_const(l: T, chroma: T, hue: LuvHue<T>, alpha: A) -> Self
Create a CIE L*C*uv h°uv color with transparency. This is the same as
Lchuva::new
without the generic hue type. It’s temporary until const fn
supports traits.
sourcepub fn into_components(self) -> (T, T, LuvHue<T>, A)
pub fn into_components(self) -> (T, T, LuvHue<T>, A)
Convert to a (L\*, C\*uv, h°uv, alpha)
tuple.
sourcepub fn from_components<H: Into<LuvHue<T>>>(
(l, chroma, hue, alpha): (T, T, H, A),
) -> Self
pub fn from_components<H: Into<LuvHue<T>>>( (l, chroma, hue, alpha): (T, T, H, A), ) -> Self
Convert from a (L\*, C\*uv, h°uv, alpha)
tuple.
source§impl<Wp, T, A> Alpha<Lchuv<Wp, &mut T>, &mut A>
impl<Wp, T, A> Alpha<Lchuv<Wp, &mut T>, &mut A>
source§impl<Wp, Ct, Ca> Alpha<Lchuv<Wp, Ct>, Ca>
impl<Wp, Ct, Ca> Alpha<Lchuv<Wp, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Lchuv<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Lchuv<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Lchuv<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Lchuv<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<Wp, T, A> Alpha<Lchuv<Wp, Vec<T>>, Vec<A>>
impl<Wp, T, A> Alpha<Lchuv<Wp, Vec<T>>, Vec<A>>
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: Alpha<Lchuv<Wp, T>, A>)
pub fn push(&mut self, value: Alpha<Lchuv<Wp, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Lchuv<Wp, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Lchuv<Wp, T>, A>>
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, T, A> Alpha<Luma<S, T>, A>
impl<S, T, A> Alpha<Luma<S, T>, A>
Lumaa
implementations.
sourcepub fn into_format<U, B>(self) -> Alpha<Luma<S, U>, B>where
U: FromStimulus<T>,
B: FromStimulus<A>,
pub fn into_format<U, B>(self) -> Alpha<Luma<S, U>, B>where
U: FromStimulus<T>,
B: FromStimulus<A>,
Convert into another component type.
sourcepub fn from_format<U, B>(color: Alpha<Luma<S, U>, B>) -> Selfwhere
T: FromStimulus<U>,
A: FromStimulus<B>,
pub fn from_format<U, B>(color: Alpha<Luma<S, U>, B>) -> Selfwhere
T: FromStimulus<U>,
A: FromStimulus<B>,
Convert from another component type.
sourcepub fn into_components(self) -> (T, A)
pub fn into_components(self) -> (T, A)
Convert to a (luma, alpha)
tuple.
sourcepub fn from_components((luma, alpha): (T, A)) -> Self
pub fn from_components((luma, alpha): (T, A)) -> Self
Convert from a (luma, alpha)
tuple.
source§impl<S> Alpha<Luma<S, u8>, u8>
impl<S> Alpha<Luma<S, u8>, u8>
sourcepub fn into_u16<O>(self) -> u16
pub fn into_u16<O>(self) -> u16
Convert to a packed u16
with with a specific component order.
use palette::{luma, SrgbLumaa};
let integer = SrgbLumaa::new(96u8, 255).into_u16::<luma::channels::Al>();
assert_eq!(0xFF60, integer);
It’s also possible to use From
and Into
, which defaults to the
0xLLAA
component order:
use palette::SrgbLumaa;
let integer = u16::from(SrgbLumaa::new(96u8, 255));
assert_eq!(0x60FF, integer);
See Packed for more details.
sourcepub fn from_u16<O>(color: u16) -> Self
pub fn from_u16<O>(color: u16) -> Self
Convert from a packed u16
with a specific component order.
use palette::{luma, SrgbLumaa};
let luma = SrgbLumaa::from_u16::<luma::channels::Al>(0xFF60);
assert_eq!(SrgbLumaa::new(96u8, 255), luma);
It’s also possible to use From
and Into
, which defaults to the
0xLLAA
component order:
use palette::SrgbLumaa;
let luma = SrgbLumaa::from(0x60FF);
assert_eq!(SrgbLumaa::new(96u8, 255), luma);
See Packed for more details.
source§impl<S, T, A> Alpha<Luma<S, T>, A>where
S: LumaStandard,
impl<S, T, A> Alpha<Luma<S, T>, A>where
S: LumaStandard,
sourcepub fn into_linear<U, B>(self) -> Alpha<Luma<Linear<S::WhitePoint>, U>, B>
pub fn into_linear<U, B>(self) -> Alpha<Luma<Linear<S::WhitePoint>, U>, B>
Convert the color to linear luminance with transparency.
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::{SrgbLumaa, LinLumaa};
let linear: LinLumaa<_, f32> = SrgbLumaa::new(96u8, 38).into_linear();
See the transfer function types in the encoding
module for details and performance characteristics.
sourcepub fn from_linear<U, B>(
color: Alpha<Luma<Linear<S::WhitePoint>, U>, B>,
) -> Self
pub fn from_linear<U, B>( color: Alpha<Luma<Linear<S::WhitePoint>, U>, B>, ) -> Self
Convert linear luminance to non-linear luminance with transparency.
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::{SrgbLumaa, LinLumaa};
let encoded = SrgbLumaa::<u8>::from_linear(LinLumaa::new(0.95f32, 0.75));
See the transfer function types in the encoding
module for details and performance characteristics.
source§impl<Wp, T, A> Alpha<Luma<Linear<Wp>, T>, A>
impl<Wp, T, A> Alpha<Luma<Linear<Wp>, T>, A>
sourcepub fn into_encoding<U, B, St>(self) -> Alpha<Luma<St, U>, B>
pub fn into_encoding<U, B, St>(self) -> Alpha<Luma<St, U>, B>
Convert a linear color to a different encoding with transparency.
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::{SrgbLumaa, LinLumaa};
let encoded: SrgbLumaa<u8> = LinLumaa::new(0.95f32, 0.75).into_encoding();
See the transfer function types in the encoding
module for details and performance characteristics.
sourcepub fn from_encoding<U, B, St>(color: Alpha<Luma<St, U>, B>) -> Self
pub fn from_encoding<U, B, St>(color: Alpha<Luma<St, U>, B>) -> Self
Convert to linear luminance from a different encoding with transparency.
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::{SrgbLumaa, LinLumaa};
let linear = LinLumaa::<_, f32>::from_encoding(SrgbLumaa::new(96u8, 38));
See the transfer function types in the encoding
module for details and performance characteristics.
source§impl<S, T, A> Alpha<Luma<S, &mut T>, &mut A>
impl<S, T, A> Alpha<Luma<S, &mut T>, &mut A>
source§impl<S, Ct, Ca> Alpha<Luma<S, Ct>, Ca>
impl<S, Ct, Ca> Alpha<Luma<S, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Luma<S, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Luma<S, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Luma<S, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Luma<S, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::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, A> Alpha<Luma<S, Vec<T>>, Vec<A>>
impl<S, T, A> Alpha<Luma<S, Vec<T>>, Vec<A>>
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: Alpha<Luma<S, T>, A>)
pub fn push(&mut self, value: Alpha<Luma<S, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Luma<S, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Luma<S, T>, A>>
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<Wp, T, A> Alpha<Luv<Wp, T>, A>
impl<Wp, T, A> Alpha<Luv<Wp, T>, A>
Luva
implementations.
sourcepub const fn new(l: T, u: T, v: T, alpha: A) -> Self
pub const fn new(l: T, u: T, v: T, alpha: A) -> Self
Create a CIE L*u*v* color with transparency.
sourcepub fn into_components(self) -> (T, T, T, A)
pub fn into_components(self) -> (T, T, T, A)
Convert to u (L\*, u\*, v\*, alpha)
tuple.
sourcepub fn from_components((l, u, v, alpha): (T, T, T, A)) -> Self
pub fn from_components((l, u, v, alpha): (T, T, T, A)) -> Self
Convert from u (L\*, u\*, v\*, alpha)
tuple.
source§impl<Wp, T, A> Alpha<Luv<Wp, &mut T>, &mut A>
impl<Wp, T, A> Alpha<Luv<Wp, &mut T>, &mut A>
source§impl<Wp, Ct, Ca> Alpha<Luv<Wp, Ct>, Ca>
impl<Wp, Ct, Ca> Alpha<Luv<Wp, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Luv<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Luv<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Luv<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Luv<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<Wp, T, A> Alpha<Luv<Wp, Vec<T>>, Vec<A>>
impl<Wp, T, A> Alpha<Luv<Wp, Vec<T>>, Vec<A>>
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: Alpha<Luv<Wp, T>, A>)
pub fn push(&mut self, value: Alpha<Luv<Wp, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Luv<Wp, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Luv<Wp, T>, A>>
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<T, A> Alpha<Okhsl<T>, A>
impl<T, A> Alpha<Okhsl<T>, A>
Okhsla
implementations.
sourcepub fn new<H: Into<OklabHue<T>>>(
hue: H,
saturation: T,
lightness: T,
alpha: A,
) -> Self
pub fn new<H: Into<OklabHue<T>>>( hue: H, saturation: T, lightness: T, alpha: A, ) -> Self
Create an Okhsl
color with transparency.
sourcepub const fn new_const(
hue: OklabHue<T>,
saturation: T,
lightness: T,
alpha: A,
) -> Self
pub const fn new_const( hue: OklabHue<T>, saturation: T, lightness: T, alpha: A, ) -> Self
Create an Okhsla
color. This is the same as Okhsla::new
without the
generic hue type. It’s temporary until const fn
supports traits.
sourcepub fn into_format<U, B>(self) -> Alpha<Okhsl<U>, B>
pub fn into_format<U, B>(self) -> Alpha<Okhsl<U>, B>
Convert into another component type.
sourcepub fn from_format<U, B>(color: Alpha<Okhsl<U>, B>) -> Self
pub fn from_format<U, B>(color: Alpha<Okhsl<U>, B>) -> Self
Convert from another component type.
sourcepub fn into_components(self) -> (OklabHue<T>, T, T, A)
pub fn into_components(self) -> (OklabHue<T>, T, T, A)
Convert to a (hue, saturation, lightness, alpha)
tuple.
sourcepub fn from_components<H: Into<OklabHue<T>>>(
(hue, saturation, lightness, alpha): (H, T, T, A),
) -> Self
pub fn from_components<H: Into<OklabHue<T>>>( (hue, saturation, lightness, alpha): (H, T, T, A), ) -> Self
Convert from a (hue, saturation, lightness, alpha)
tuple.
source§impl<T, A> Alpha<Okhsl<&mut T>, &mut A>
impl<T, A> Alpha<Okhsl<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Okhsl<Ct>, Ca>
impl<Ct, Ca> Alpha<Okhsl<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Okhsl<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Okhsl<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Okhsl<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Okhsl<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Okhsl<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Okhsl<Vec<T>>, Vec<A>>
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: Alpha<Okhsl<T>, A>)
pub fn push(&mut self, value: Alpha<Okhsl<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Okhsl<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Okhsl<T>, A>>
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<T, A> Alpha<Okhsv<T>, A>
impl<T, A> Alpha<Okhsv<T>, A>
Hsva
implementations.
sourcepub fn new<H: Into<OklabHue<T>>>(
hue: H,
saturation: T,
value: T,
alpha: A,
) -> Self
pub fn new<H: Into<OklabHue<T>>>( hue: H, saturation: T, value: T, alpha: A, ) -> Self
Create an Okhsv
color with transparency.
sourcepub const fn new_const(
hue: OklabHue<T>,
saturation: T,
value: T,
alpha: A,
) -> Self
pub const fn new_const( hue: OklabHue<T>, saturation: T, value: T, alpha: A, ) -> Self
Create an Okhsva
color. This is the same as Okhsva::new
without the
generic hue type. It’s temporary until const fn
supports traits.
sourcepub fn into_format<U, B>(self) -> Alpha<Okhsv<U>, B>
pub fn into_format<U, B>(self) -> Alpha<Okhsv<U>, B>
Convert into another component type.
sourcepub fn from_format<U, B>(color: Alpha<Okhsv<U>, B>) -> Self
pub fn from_format<U, B>(color: Alpha<Okhsv<U>, B>) -> Self
Convert from another component type.
sourcepub fn into_components(self) -> (OklabHue<T>, T, T, A)
pub fn into_components(self) -> (OklabHue<T>, T, T, A)
Convert to a (hue, saturation, value, alpha)
tuple.
sourcepub fn from_components<H: Into<OklabHue<T>>>(
(hue, saturation, value, alpha): (H, T, T, A),
) -> Self
pub fn from_components<H: Into<OklabHue<T>>>( (hue, saturation, value, alpha): (H, T, T, A), ) -> Self
Convert from a (hue, saturation, value, alpha)
tuple.
source§impl<T, A> Alpha<Okhsv<&mut T>, &mut A>
impl<T, A> Alpha<Okhsv<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Okhsv<Ct>, Ca>
impl<Ct, Ca> Alpha<Okhsv<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Okhsv<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Okhsv<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Okhsv<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Okhsv<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Okhsv<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Okhsv<Vec<T>>, Vec<A>>
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: Alpha<Okhsv<T>, A>)
pub fn push(&mut self, value: Alpha<Okhsv<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Okhsv<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Okhsv<T>, A>>
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<T, A> Alpha<Okhwb<T>, A>
impl<T, A> Alpha<Okhwb<T>, A>
Okhwba
implementations.
sourcepub fn new<H: Into<OklabHue<T>>>(
hue: H,
whiteness: T,
blackness: T,
alpha: A,
) -> Self
pub fn new<H: Into<OklabHue<T>>>( hue: H, whiteness: T, blackness: T, alpha: A, ) -> Self
Create an Okhwb
color with transparency.
sourcepub const fn new_const(
hue: OklabHue<T>,
whiteness: T,
blackness: T,
alpha: A,
) -> Self
pub const fn new_const( hue: OklabHue<T>, whiteness: T, blackness: T, alpha: A, ) -> Self
Create an Okhwba
color. This is the same as Okhwba::new
without the
generic hue type. It’s temporary until const fn
supports traits.
sourcepub fn into_format<U, B>(self) -> Alpha<Okhwb<U>, B>
pub fn into_format<U, B>(self) -> Alpha<Okhwb<U>, B>
Convert into another component type.
sourcepub fn from_format<U, B>(color: Alpha<Okhwb<U>, B>) -> Self
pub fn from_format<U, B>(color: Alpha<Okhwb<U>, B>) -> Self
Convert from another component type.
sourcepub fn into_components(self) -> (OklabHue<T>, T, T, A)
pub fn into_components(self) -> (OklabHue<T>, T, T, A)
Convert to a (hue, whiteness, blackness, alpha)
tuple.
sourcepub fn from_components<H: Into<OklabHue<T>>>(
(hue, whiteness, blackness, alpha): (H, T, T, A),
) -> Self
pub fn from_components<H: Into<OklabHue<T>>>( (hue, whiteness, blackness, alpha): (H, T, T, A), ) -> Self
Convert from a (hue, whiteness, blackness, alpha)
tuple.
source§impl<T, A> Alpha<Okhwb<&mut T>, &mut A>
impl<T, A> Alpha<Okhwb<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Okhwb<Ct>, Ca>
impl<Ct, Ca> Alpha<Okhwb<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Okhwb<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Okhwb<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Okhwb<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Okhwb<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Okhwb<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Okhwb<Vec<T>>, Vec<A>>
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: Alpha<Okhwb<T>, A>)
pub fn push(&mut self, value: Alpha<Okhwb<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Okhwb<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Okhwb<T>, A>>
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<T, A> Alpha<Oklab<T>, A>
impl<T, A> Alpha<Oklab<T>, A>
Oklaba
implementations.
sourcepub fn into_components(self) -> (T, T, T, A)
pub fn into_components(self) -> (T, T, T, A)
Convert to a (L, a, b, alpha)
tuple.
sourcepub fn from_components((l, a, b, alpha): (T, T, T, A)) -> Self
pub fn from_components((l, a, b, alpha): (T, T, T, A)) -> Self
Convert from a (L, a, b, alpha)
tuple.
source§impl<T, A> Alpha<Oklab<&mut T>, &mut A>
impl<T, A> Alpha<Oklab<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Oklab<Ct>, Ca>
impl<Ct, Ca> Alpha<Oklab<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Oklab<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Oklab<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Oklab<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Oklab<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Oklab<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Oklab<Vec<T>>, Vec<A>>
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: Alpha<Oklab<T>, A>)
pub fn push(&mut self, value: Alpha<Oklab<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Oklab<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Oklab<T>, A>>
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<T, A> Alpha<Oklch<T>, A>
impl<T, A> Alpha<Oklch<T>, A>
Oklcha
implementations.
sourcepub fn new<H: Into<OklabHue<T>>>(l: T, chroma: T, hue: H, alpha: A) -> Self
pub fn new<H: Into<OklabHue<T>>>(l: T, chroma: T, hue: H, alpha: A) -> Self
Create an Oklch color with transparency.
sourcepub const fn new_const(l: T, chroma: T, hue: OklabHue<T>, alpha: A) -> Self
pub const fn new_const(l: T, chroma: T, hue: OklabHue<T>, alpha: A) -> Self
Create an Oklcha
color. This is the same as Oklcha::new
without the
generic hue type. It’s temporary until const fn
supports traits.
sourcepub fn into_components(self) -> (T, T, OklabHue<T>, A)
pub fn into_components(self) -> (T, T, OklabHue<T>, A)
Convert to a (L, C, h, alpha)
tuple.
sourcepub fn from_components<H: Into<OklabHue<T>>>(
(l, chroma, hue, alpha): (T, T, H, A),
) -> Self
pub fn from_components<H: Into<OklabHue<T>>>( (l, chroma, hue, alpha): (T, T, H, A), ) -> Self
Convert from a (L, C, h, alpha)
tuple.
source§impl<T, A> Alpha<Oklch<&mut T>, &mut A>
impl<T, A> Alpha<Oklch<&mut T>, &mut A>
source§impl<Ct, Ca> Alpha<Oklch<Ct>, Ca>
impl<Ct, Ca> Alpha<Oklch<Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Oklch<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Oklch<&<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Oklch<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Oklch<&mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<T, A> Alpha<Oklch<Vec<T>>, Vec<A>>
impl<T, A> Alpha<Oklch<Vec<T>>, Vec<A>>
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: Alpha<Oklch<T>, A>)
pub fn push(&mut self, value: Alpha<Oklch<T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Oklch<T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Oklch<T>, A>>
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, T, A> Alpha<Rgb<S, T>, A>
impl<S, T, A> Alpha<Rgb<S, T>, A>
Rgba
implementations.
sourcepub fn into_format<U, B>(self) -> Alpha<Rgb<S, U>, B>where
U: FromStimulus<T>,
B: FromStimulus<A>,
pub fn into_format<U, B>(self) -> Alpha<Rgb<S, U>, B>where
U: FromStimulus<T>,
B: FromStimulus<A>,
Convert the RGBA components into other number types.
use palette::Srgba;
let rgba_u8: Srgba<u8> = Srgba::new(0.3, 0.7, 0.2, 0.5).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, B>(color: Alpha<Rgb<S, U>, B>) -> Selfwhere
T: FromStimulus<U>,
A: FromStimulus<B>,
pub fn from_format<U, B>(color: Alpha<Rgb<S, U>, B>) -> Selfwhere
T: FromStimulus<U>,
A: FromStimulus<B>,
Convert the RGBA components from other number types.
use palette::Srgba;
let rgba_u8 = Srgba::<u8>::from_format(Srgba::new(0.3, 0.7, 0.2, 0.5));
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, A)
pub fn into_components(self) -> (T, T, T, A)
Convert to a (red, green, blue, alpha)
tuple.
sourcepub fn from_components((red, green, blue, alpha): (T, T, T, A)) -> Self
pub fn from_components((red, green, blue, alpha): (T, T, T, A)) -> Self
Convert from a (red, green, blue, alpha)
tuple.
source§impl<S> Alpha<Rgb<S, u8>, u8>
impl<S> Alpha<Rgb<S, u8>, 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, Srgba};
let integer = Srgba::new(96u8, 127, 0, 255).into_u32::<rgb::channels::Argb>();
assert_eq!(0xFF607F00, integer);
It’s also possible to use From
and Into
, which defaults to the
0xRRGGBBAA
component order:
use palette::Srgba;
let integer = u32::from(Srgba::new(96u8, 127, 0, 255));
assert_eq!(0x607F00FF, 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, Srgba};
let rgba = Srgba::from_u32::<rgb::channels::Argb>(0xFF607F00);
assert_eq!(Srgba::new(96u8, 127, 0, 255), rgba);
It’s also possible to use From
and Into
, which defaults to the
0xRRGGBBAA
component order:
use palette::Srgba;
let rgba = Srgba::from(0x607F00FF);
assert_eq!(Srgba::new(96u8, 127, 0, 255), rgba);
See Packed for more details.
source§impl<S: RgbStandard, T, A> Alpha<Rgb<S, T>, A>
impl<S: RgbStandard, T, A> Alpha<Rgb<S, T>, A>
sourcepub fn into_linear<U, B>(self) -> Alpha<Rgb<Linear<S::Space>, U>, B>
pub fn into_linear<U, B>(self) -> Alpha<Rgb<Linear<S::Space>, U>, B>
Convert the color to linear RGB with transparency.
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::{Srgba, LinSrgba};
let linear: LinSrgba<f32> = Srgba::new(96u8, 127, 0, 38).into_linear();
See the transfer function types in the encoding
module for details and performance characteristics.
sourcepub fn from_linear<U, B>(color: Alpha<Rgb<Linear<S::Space>, U>, B>) -> Self
pub fn from_linear<U, B>(color: Alpha<Rgb<Linear<S::Space>, U>, B>) -> Self
Convert linear RGB to non-linear RGB with transparency.
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::{Srgba, LinSrgba};
let encoded = Srgba::<u8>::from_linear(LinSrgba::new(0.95f32, 0.90, 0.30, 0.75));
See the transfer function types in the encoding
module for details and performance characteristics.
source§impl<S: RgbSpace, T, A> Alpha<Rgb<Linear<S>, T>, A>
impl<S: RgbSpace, T, A> Alpha<Rgb<Linear<S>, T>, A>
sourcepub fn into_encoding<U, B, St>(self) -> Alpha<Rgb<St, U>, B>
pub fn into_encoding<U, B, St>(self) -> Alpha<Rgb<St, U>, B>
Convert a linear color to a different encoding with transparency.
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::{Srgba, LinSrgba};
let encoded: Srgba<u8> = LinSrgba::new(0.95f32, 0.90, 0.30, 0.75).into_encoding();
See the transfer function types in the encoding
module for details and performance characteristics.
sourcepub fn from_encoding<U, B, St>(color: Alpha<Rgb<St, U>, B>) -> Self
pub fn from_encoding<U, B, St>(color: Alpha<Rgb<St, U>, B>) -> Self
Convert RGB from a different encoding to linear with transparency.
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::{Srgba, LinSrgba};
let linear = LinSrgba::<f32>::from_encoding(Srgba::new(96u8, 127, 0, 38));
See the transfer function types in the encoding
module for details and performance characteristics.
source§impl<S, T, A> Alpha<Rgb<S, &mut T>, &mut A>
impl<S, T, A> Alpha<Rgb<S, &mut T>, &mut A>
source§impl<S, Ct, Ca> Alpha<Rgb<S, Ct>, Ca>
impl<S, Ct, Ca> Alpha<Rgb<S, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Rgb<S, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Rgb<S, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Rgb<S, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Rgb<S, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::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, A> Alpha<Rgb<S, Vec<T>>, Vec<A>>
impl<S, T, A> Alpha<Rgb<S, Vec<T>>, Vec<A>>
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: Alpha<Rgb<S, T>, A>)
pub fn push(&mut self, value: Alpha<Rgb<S, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Rgb<S, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Rgb<S, T>, A>>
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<Wp, T, A> Alpha<Xyz<Wp, T>, A>
impl<Wp, T, A> Alpha<Xyz<Wp, T>, A>
Xyza
implementations.
sourcepub fn into_components(self) -> (T, T, T, A)
pub fn into_components(self) -> (T, T, T, A)
Convert to a (X, Y, Z, alpha)
tuple.
sourcepub fn from_components((x, y, z, alpha): (T, T, T, A)) -> Self
pub fn from_components((x, y, z, alpha): (T, T, T, A)) -> Self
Convert from a (X, Y, Z, alpha)
tuple.
sourcepub fn with_white_point<NewWp>(self) -> Alpha<Xyz<NewWp, T>, A>
pub fn with_white_point<NewWp>(self) -> Alpha<Xyz<NewWp, T>, A>
Changes the reference white point without changing the color value.
This function doesn’t change the numerical values, and thus the color it represents in an absolute sense. However, the appearance of the color may not be the same when observed with the new white point. The effect would be similar to taking a photo with an incorrect white balance.
See chromatic_adaptation for operations that can change the white point while preserving the color’s appearance.
source§impl<Wp, T, A> Alpha<Xyz<Wp, &mut T>, &mut A>
impl<Wp, T, A> Alpha<Xyz<Wp, &mut T>, &mut A>
source§impl<Wp, Ct, Ca> Alpha<Xyz<Wp, Ct>, Ca>
impl<Wp, Ct, Ca> Alpha<Xyz<Wp, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Xyz<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Xyz<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Xyz<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Xyz<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<Wp, T, A> Alpha<Xyz<Wp, Vec<T>>, Vec<A>>
impl<Wp, T, A> Alpha<Xyz<Wp, Vec<T>>, Vec<A>>
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: Alpha<Xyz<Wp, T>, A>)
pub fn push(&mut self, value: Alpha<Xyz<Wp, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Xyz<Wp, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Xyz<Wp, T>, A>>
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<Wp, T, A> Alpha<Yxy<Wp, T>, A>
impl<Wp, T, A> Alpha<Yxy<Wp, T>, A>
Yxya
implementations.
sourcepub const fn new(x: T, y: T, luma: T, alpha: A) -> Self
pub const fn new(x: T, y: T, luma: T, alpha: A) -> Self
Create a CIE Yxy color with transparency.
sourcepub fn into_components(self) -> (T, T, T, A)
pub fn into_components(self) -> (T, T, T, A)
Convert to a (x, y, luma)
, a.k.a. (x, y, Y)
tuple.
sourcepub fn from_components((x, y, luma, alpha): (T, T, T, A)) -> Self
pub fn from_components((x, y, luma, alpha): (T, T, T, A)) -> Self
Convert from a (x, y, luma)
, a.k.a. (x, y, Y)
tuple.
sourcepub fn with_white_point<NewWp>(self) -> Alpha<Yxy<NewWp, T>, A>
pub fn with_white_point<NewWp>(self) -> Alpha<Yxy<NewWp, T>, A>
Changes the reference white point without changing the color value.
This function doesn’t change the numerical values, and thus the color it represents in an absolute sense. However, the appearance of the color may not be the same when observed with the new white point. The effect would be similar to taking a photo with an incorrect white balance.
See chromatic_adaptation for operations that can change the white point while preserving the color’s appearance.
source§impl<Wp, T, A> Alpha<Yxy<Wp, &mut T>, &mut A>
impl<Wp, T, A> Alpha<Yxy<Wp, &mut T>, &mut A>
source§impl<Wp, Ct, Ca> Alpha<Yxy<Wp, Ct>, Ca>
impl<Wp, Ct, Ca> Alpha<Yxy<Wp, Ct>, Ca>
sourcepub fn get<'a, I, T, A>(
&'a self,
index: I,
) -> Option<Alpha<Yxy<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Yxy<Wp, &<I as SliceIndex<[T]>>::Output>, &<I as SliceIndex<[A]>>::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>(
&'a mut self,
index: I,
) -> Option<Alpha<Yxy<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Yxy<Wp, &mut <I as SliceIndex<[T]>>::Output>, &mut <I as SliceIndex<[A]>>::Output>>
Get a color, or slice of colors, that allows modifying the components at index
. See slice::get_mut
for details.
source§impl<Wp, T, A> Alpha<Yxy<Wp, Vec<T>>, Vec<A>>
impl<Wp, T, A> Alpha<Yxy<Wp, Vec<T>>, Vec<A>>
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: Alpha<Yxy<Wp, T>, A>)
pub fn push(&mut self, value: Alpha<Yxy<Wp, T>, A>)
Push an additional color’s components onto the component vectors. See Vec::push
for details.
sourcepub fn pop(&mut self) -> Option<Alpha<Yxy<Wp, T>, A>>
pub fn pop(&mut self) -> Option<Alpha<Yxy<Wp, T>, A>>
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<C, T> AbsDiffEq for Alpha<C, T>
impl<C, T> AbsDiffEq for Alpha<C, 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: &Rhs, epsilon: Self::Epsilon) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
AbsDiffEq::abs_diff_eq
.source§impl<T, C> AddAssign<T> for Alpha<C, T>
impl<T, C> AddAssign<T> for Alpha<C, T>
source§fn add_assign(&mut self, c: T)
fn add_assign(&mut self, c: T)
+=
operation. Read moresource§impl<C, T> AddAssign for Alpha<C, T>
impl<C, T> AddAssign for Alpha<C, T>
source§fn add_assign(&mut self, other: Alpha<C, T>)
fn add_assign(&mut self, other: Alpha<C, T>)
+=
operation. Read moresource§impl<C, T, const N: usize> Blend for Alpha<C, T>where
C: Premultiply<Scalar = T> + StimulusColor + ArrayCast<Array = [T; N]> + Clone,
T: Real + Zero + One + MinMax + Clamp + Sqrt + Abs + Arithmetics + PartialCmp + Clone,
T::Mask: LazySelect<T>,
impl<C, T, const N: usize> Blend for Alpha<C, T>where
C: Premultiply<Scalar = T> + StimulusColor + ArrayCast<Array = [T; N]> + Clone,
T: Real + Zero + One + MinMax + Clamp + Sqrt + Abs + Arithmetics + PartialCmp + Clone,
T::Mask: LazySelect<T>,
source§fn multiply(self, other: Self) -> Self
fn multiply(self, other: Self) -> Self
self
with other
. This uses the alpha component to regulate
the effect, so it’s not just plain component wise multiplication.source§fn screen(self, other: Self) -> Self
fn screen(self, other: Self) -> Self
self
or other
.source§fn overlay(self, other: Self) -> Self
fn overlay(self, other: Self) -> Self
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: Self) -> Self
fn dodge(self, other: Self) -> Self
other
to reflect self
. Results in other
if self
is
black.source§fn burn(self, other: Self) -> Self
fn burn(self, other: Self) -> Self
other
to reflect self
. Results in other
if self
is
white.source§fn hard_light(self, other: Self) -> Self
fn hard_light(self, other: Self) -> Self
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: Self) -> Self
fn soft_light(self, other: Self) -> Self
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: Self) -> Self
fn difference(self, other: Self) -> Self
self
and other
. It’s
basically abs(self - other)
, but regulated by the alpha component.source§impl<C> BlendWith for Alpha<C, C::Scalar>where
C: Premultiply,
impl<C> BlendWith for Alpha<C, C::Scalar>where
C: Premultiply,
source§fn blend_with<F>(self, destination: Self, blend_function: F) -> Selfwhere
F: BlendFunction<Self::Color>,
fn blend_with<F>(self, destination: Self, blend_function: F) -> Selfwhere
F: BlendFunction<Self::Color>,
destination
, using
blend_function
. Anything that implements BlendFunction
is
acceptable, including functions and closures. Read moresource§impl<C, T> ClampAssign for Alpha<C, T>
impl<C, T> ClampAssign for Alpha<C, T>
source§fn clamp_assign(&mut self)
fn clamp_assign(&mut self)
source§impl<T, A> Complementary for Alpha<Cam16UcsJab<T>, A>where
Cam16UcsJab<T>: Complementary,
impl<T, A> Complementary for Alpha<Cam16UcsJab<T>, A>where
Cam16UcsJab<T>: Complementary,
source§fn complementary(self) -> Self
fn complementary(self) -> Self
self
. Read moresource§impl<Wp, T, A> Complementary for Alpha<Lab<Wp, T>, A>where
Lab<Wp, T>: Complementary,
impl<Wp, T, A> Complementary for Alpha<Lab<Wp, T>, A>where
Lab<Wp, T>: Complementary,
source§fn complementary(self) -> Self
fn complementary(self) -> Self
self
. Read moresource§impl<Wp, T, A> Complementary for Alpha<Luv<Wp, T>, A>where
Luv<Wp, T>: Complementary,
impl<Wp, T, A> Complementary for Alpha<Luv<Wp, T>, A>where
Luv<Wp, T>: Complementary,
source§fn complementary(self) -> Self
fn complementary(self) -> Self
self
. Read moresource§impl<T, A> Complementary for Alpha<Oklab<T>, A>where
Oklab<T>: Complementary,
impl<T, A> Complementary for Alpha<Oklab<T>, A>where
Oklab<T>: Complementary,
source§fn complementary(self) -> Self
fn complementary(self) -> Self
self
. Read moresource§impl<C> Compose for Alpha<C, C::Scalar>
impl<C> Compose for Alpha<C, C::Scalar>
source§fn over(self, other: Self) -> Self
fn over(self, other: Self) -> Self
self
over other
. This is the good old common alpha composition
equation.source§fn inside(self, other: Self) -> Self
fn inside(self, other: Self) -> Self
self
that overlaps the visible parts of
other
.source§impl<'de, C, T> Deserialize<'de> for Alpha<C, T>where
C: Deserialize<'de>,
T: Deserialize<'de>,
impl<'de, C, T> Deserialize<'de> for Alpha<C, T>where
C: Deserialize<'de>,
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<T, C> DivAssign<T> for Alpha<C, T>
impl<T, C> DivAssign<T> for Alpha<C, T>
source§fn div_assign(&mut self, c: T)
fn div_assign(&mut self, c: T)
/=
operation. Read moresource§impl<C, T> DivAssign for Alpha<C, T>
impl<C, T> DivAssign for Alpha<C, T>
source§fn div_assign(&mut self, other: Alpha<C, T>)
fn div_assign(&mut self, other: Alpha<C, T>)
/=
operation. Read moresource§impl<Tc, Ta, C, A> Extend<Alpha<Tc, Ta>> for Alpha<C, A>
impl<Tc, Ta, C, A> Extend<Alpha<Tc, Ta>> for Alpha<C, A>
source§fn extend<T: IntoIterator<Item = Alpha<Tc, Ta>>>(&mut self, iter: T)
fn extend<T: IntoIterator<Item = Alpha<Tc, Ta>>>(&mut self, iter: 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<T, V, const N: usize> From<[Alpha<Cam16UcsJab<T>, T>; N]> for Alpha<Cam16UcsJab<V>, V>
impl<T, V, const N: usize> From<[Alpha<Cam16UcsJab<T>, T>; N]> for Alpha<Cam16UcsJab<V>, V>
source§impl<T, V, const N: usize> From<[Alpha<Cam16UcsJmh<T>, T>; N]> for Alpha<Cam16UcsJmh<V>, V>
impl<T, V, const N: usize> From<[Alpha<Cam16UcsJmh<T>, T>; N]> for Alpha<Cam16UcsJmh<V>, V>
source§impl<S, T, H: Into<RgbHue<T>>, A> From<(H, T, T, A)> for Alpha<Hsl<S, T>, A>
impl<S, T, H: Into<RgbHue<T>>, A> From<(H, T, T, A)> for Alpha<Hsl<S, T>, A>
source§fn from(components: (H, T, T, A)) -> Self
fn from(components: (H, T, T, A)) -> Self
source§impl<Wp, T, H: Into<LuvHue<T>>, A> From<(H, T, T, A)> for Alpha<Hsluv<Wp, T>, A>
impl<Wp, T, H: Into<LuvHue<T>>, A> From<(H, T, T, A)> for Alpha<Hsluv<Wp, T>, A>
source§fn from(components: (H, T, T, A)) -> Self
fn from(components: (H, T, T, A)) -> Self
source§impl<S, T, H: Into<RgbHue<T>>, A> From<(H, T, T, A)> for Alpha<Hsv<S, T>, A>
impl<S, T, H: Into<RgbHue<T>>, A> From<(H, T, T, A)> for Alpha<Hsv<S, T>, A>
source§fn from(components: (H, T, T, A)) -> Self
fn from(components: (H, T, T, A)) -> Self
source§impl<S, T, H: Into<RgbHue<T>>, A> From<(H, T, T, A)> for Alpha<Hwb<S, T>, A>
impl<S, T, H: Into<RgbHue<T>>, A> From<(H, T, T, A)> for Alpha<Hwb<S, T>, A>
source§fn from(components: (H, T, T, A)) -> Self
fn from(components: (H, T, T, A)) -> Self
source§impl<T, H: Into<OklabHue<T>>, A> From<(H, T, T, A)> for Alpha<Okhsv<T>, A>
impl<T, H: Into<OklabHue<T>>, A> From<(H, T, T, A)> for Alpha<Okhsv<T>, A>
source§fn from(components: (H, T, T, A)) -> Self
fn from(components: (H, T, T, A)) -> Self
source§impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Jch<T>, A>
impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Jch<T>, A>
source§fn from(components: (T, T, H, A)) -> Self
fn from(components: (T, T, H, A)) -> Self
source§impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Jmh<T>, A>
impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Jmh<T>, A>
source§fn from(components: (T, T, H, A)) -> Self
fn from(components: (T, T, H, A)) -> Self
source§impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Jsh<T>, A>
impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Jsh<T>, A>
source§fn from(components: (T, T, H, A)) -> Self
fn from(components: (T, T, H, A)) -> Self
source§impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Qch<T>, A>
impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Qch<T>, A>
source§fn from(components: (T, T, H, A)) -> Self
fn from(components: (T, T, H, A)) -> Self
source§impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Qmh<T>, A>
impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Qmh<T>, A>
source§fn from(components: (T, T, H, A)) -> Self
fn from(components: (T, T, H, A)) -> Self
source§impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Qsh<T>, A>
impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16Qsh<T>, A>
source§fn from(components: (T, T, H, A)) -> Self
fn from(components: (T, T, H, A)) -> Self
source§impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16UcsJmh<T>, A>
impl<T, H: Into<Cam16Hue<T>>, A> From<(T, T, H, A)> for Alpha<Cam16UcsJmh<T>, A>
source§fn from(components: (T, T, H, A)) -> Self
fn from(components: (T, T, H, A)) -> Self
source§impl<Wp, T, H: Into<LabHue<T>>, A> From<(T, T, H, A)> for Alpha<Lch<Wp, T>, A>
impl<Wp, T, H: Into<LabHue<T>>, A> From<(T, T, H, A)> for Alpha<Lch<Wp, T>, A>
source§fn from(components: (T, T, H, A)) -> Self
fn from(components: (T, T, H, A)) -> Self
source§impl<Wp, T, H: Into<LuvHue<T>>, A> From<(T, T, H, A)> for Alpha<Lchuv<Wp, T>, A>
impl<Wp, T, H: Into<LuvHue<T>>, A> From<(T, T, H, A)> for Alpha<Lchuv<Wp, T>, A>
source§fn from(components: (T, T, H, A)) -> Self
fn from(components: (T, T, H, A)) -> Self
source§impl<T, H: Into<OklabHue<T>>, A> From<(T, T, H, A)> for Alpha<Oklch<T>, A>
impl<T, H: Into<OklabHue<T>>, A> From<(T, T, H, A)> for Alpha<Oklch<T>, A>
source§fn from(components: (T, T, H, A)) -> Self
fn from(components: (T, T, H, A)) -> Self
source§impl<T, A> From<(T, T, T, A)> for Alpha<Cam16UcsJab<T>, A>
impl<T, A> From<(T, T, T, A)> for Alpha<Cam16UcsJab<T>, A>
source§fn from(components: (T, T, T, A)) -> Self
fn from(components: (T, T, T, A)) -> Self
source§impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Lab<Wp, T>, A>
impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Lab<Wp, T>, A>
source§fn from(components: (T, T, T, A)) -> Self
fn from(components: (T, T, T, A)) -> Self
source§impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Luv<Wp, T>, A>
impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Luv<Wp, T>, A>
source§fn from(components: (T, T, T, A)) -> Self
fn from(components: (T, T, T, A)) -> Self
source§impl<T, A> From<(T, T, T, A)> for Alpha<Oklab<T>, A>
impl<T, A> From<(T, T, T, A)> for Alpha<Oklab<T>, A>
source§fn from(components: (T, T, T, A)) -> Self
fn from(components: (T, T, T, A)) -> Self
source§impl<S, T, A> From<(T, T, T, A)> for Alpha<Rgb<S, T>, A>
impl<S, T, A> From<(T, T, T, A)> for Alpha<Rgb<S, T>, A>
source§fn from(components: (T, T, T, A)) -> Self
fn from(components: (T, T, T, A)) -> Self
source§impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Xyz<Wp, T>, A>
impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Xyz<Wp, T>, A>
source§fn from(components: (T, T, T, A)) -> Self
fn from(components: (T, T, T, A)) -> Self
source§impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Yxy<Wp, T>, A>
impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Yxy<Wp, T>, A>
source§fn from(components: (T, T, T, A)) -> Self
fn from(components: (T, T, T, A)) -> Self
source§impl<C> From<Alpha<C, <C as Premultiply>::Scalar>> for PreAlpha<C>where
C: Premultiply,
impl<C> From<Alpha<C, <C as Premultiply>::Scalar>> for PreAlpha<C>where
C: Premultiply,
source§impl<T, V, const N: usize> From<Alpha<Cam16<V>, V>> for [Alpha<Cam16<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Cam16<V>, V>> for [Alpha<Cam16<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Cam16Jch<V>, V>> for [Alpha<Cam16Jch<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Cam16Jch<V>, V>> for [Alpha<Cam16Jch<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Cam16Jmh<V>, V>> for [Alpha<Cam16Jmh<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Cam16Jmh<V>, V>> for [Alpha<Cam16Jmh<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Cam16Jsh<V>, V>> for [Alpha<Cam16Jsh<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Cam16Jsh<V>, V>> for [Alpha<Cam16Jsh<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Cam16Qch<V>, V>> for [Alpha<Cam16Qch<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Cam16Qch<V>, V>> for [Alpha<Cam16Qch<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Cam16Qmh<V>, V>> for [Alpha<Cam16Qmh<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Cam16Qmh<V>, V>> for [Alpha<Cam16Qmh<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Cam16Qsh<V>, V>> for [Alpha<Cam16Qsh<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Cam16Qsh<V>, V>> for [Alpha<Cam16Qsh<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, A> From<Alpha<Cam16UcsJab<T>, A>> for (T, T, T, A)
impl<T, A> From<Alpha<Cam16UcsJab<T>, A>> for (T, T, T, A)
source§fn from(color: Alpha<Cam16UcsJab<T>, A>) -> (T, T, T, A)
fn from(color: Alpha<Cam16UcsJab<T>, A>) -> (T, T, T, A)
source§impl<T, V, const N: usize> From<Alpha<Cam16UcsJab<V>, V>> for [Alpha<Cam16UcsJab<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Cam16UcsJab<V>, V>> for [Alpha<Cam16UcsJab<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§fn from(color: Alpha<Cam16UcsJab<V>, V>) -> Self
fn from(color: Alpha<Cam16UcsJab<V>, V>) -> Self
source§impl<T, V, const N: usize> From<Alpha<Cam16UcsJmh<V>, V>> for [Alpha<Cam16UcsJmh<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Cam16UcsJmh<V>, V>> for [Alpha<Cam16UcsJmh<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§fn from(color: Alpha<Cam16UcsJmh<V>, V>) -> Self
fn from(color: Alpha<Cam16UcsJmh<V>, V>) -> Self
source§impl<S, T, V, const N: usize> From<Alpha<Hsl<S, V>, V>> for [Alpha<Hsl<S, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<S, T, V, const N: usize> From<Alpha<Hsl<S, V>, V>> for [Alpha<Hsl<S, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<Wp, T, V, const N: usize> From<Alpha<Hsluv<Wp, V>, V>> for [Alpha<Hsluv<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<Wp, T, V, const N: usize> From<Alpha<Hsluv<Wp, V>, V>> for [Alpha<Hsluv<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<S, T, V, const N: usize> From<Alpha<Hsv<S, V>, V>> for [Alpha<Hsv<S, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<S, T, V, const N: usize> From<Alpha<Hsv<S, V>, V>> for [Alpha<Hsv<S, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<S, T, V, const N: usize> From<Alpha<Hwb<S, V>, V>> for [Alpha<Hwb<S, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<S, T, V, const N: usize> From<Alpha<Hwb<S, V>, V>> for [Alpha<Hwb<S, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<Wp, T, V, const N: usize> From<Alpha<Lab<Wp, V>, V>> for [Alpha<Lab<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<Wp, T, V, const N: usize> From<Alpha<Lab<Wp, V>, V>> for [Alpha<Lab<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<Wp, T, V, const N: usize> From<Alpha<Lch<Wp, V>, V>> for [Alpha<Lch<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<Wp, T, V, const N: usize> From<Alpha<Lch<Wp, V>, V>> for [Alpha<Lch<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<Wp, T, V, const N: usize> From<Alpha<Lchuv<Wp, V>, V>> for [Alpha<Lchuv<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<Wp, T, V, const N: usize> From<Alpha<Lchuv<Wp, V>, V>> for [Alpha<Lchuv<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<S, T, O, P> From<Alpha<Luma<S, T>, T>> for Packed<O, P>where
O: ComponentOrder<Lumaa<S, T>, P>,
impl<S, T, O, P> From<Alpha<Luma<S, T>, T>> for Packed<O, P>where
O: ComponentOrder<Lumaa<S, T>, P>,
source§impl<S, T, V, const N: usize> From<Alpha<Luma<S, V>, V>> for [Alpha<Luma<S, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<S, T, V, const N: usize> From<Alpha<Luma<S, V>, V>> for [Alpha<Luma<S, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<Wp, T, V, const N: usize> From<Alpha<Luv<Wp, V>, V>> for [Alpha<Luv<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<Wp, T, V, const N: usize> From<Alpha<Luv<Wp, V>, V>> for [Alpha<Luv<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Okhsl<V>, V>> for [Alpha<Okhsl<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Okhsl<V>, V>> for [Alpha<Okhsl<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Okhsv<V>, V>> for [Alpha<Okhsv<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Okhsv<V>, V>> for [Alpha<Okhsv<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Okhwb<V>, V>> for [Alpha<Okhwb<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Okhwb<V>, V>> for [Alpha<Okhwb<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Oklab<V>, V>> for [Alpha<Oklab<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Oklab<V>, V>> for [Alpha<Oklab<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, V, const N: usize> From<Alpha<Oklch<V>, V>> for [Alpha<Oklch<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<T, V, const N: usize> From<Alpha<Oklch<V>, V>> for [Alpha<Oklch<T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<S, T, O, P> From<Alpha<Rgb<S, T>, T>> for Packed<O, P>where
O: ComponentOrder<Rgba<S, T>, P>,
impl<S, T, O, P> From<Alpha<Rgb<S, T>, T>> for Packed<O, P>where
O: ComponentOrder<Rgba<S, T>, P>,
source§impl<S, T, V, const N: usize> From<Alpha<Rgb<S, V>, V>> for [Alpha<Rgb<S, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<S, T, V, const N: usize> From<Alpha<Rgb<S, V>, V>> for [Alpha<Rgb<S, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<Wp, T, V, const N: usize> From<Alpha<Xyz<Wp, V>, V>> for [Alpha<Xyz<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<Wp, T, V, const N: usize> From<Alpha<Xyz<Wp, V>, V>> for [Alpha<Xyz<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<Wp, T, V, const N: usize> From<Alpha<Yxy<Wp, V>, V>> for [Alpha<Yxy<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
impl<Wp, T, V, const N: usize> From<Alpha<Yxy<Wp, V>, V>> for [Alpha<Yxy<Wp, T>, T>; N]where
Self: Default,
V: IntoScalarArray<N, Scalar = T>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jch<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jch<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jmh<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jmh<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jsh<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jsh<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qch<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qch<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qmh<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qmh<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qsh<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qsh<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16UcsJab<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16UcsJab<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16UcsJmh<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16UcsJmh<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, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsl<S, T>where
_C: IntoColorUnclamped<Self>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsl<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<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsluv<Wp, T>where
_C: IntoColorUnclamped<Self>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsluv<Wp, 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, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsv<S, T>where
_C: IntoColorUnclamped<Self>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsv<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, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hwb<S, T>where
_C: IntoColorUnclamped<Self>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hwb<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<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lab<Wp, T>where
_C: IntoColorUnclamped<Self>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lab<Wp, 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<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lch<Wp, T>where
_C: IntoColorUnclamped<Self>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lch<Wp, 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<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lchuv<Wp, T>where
_C: IntoColorUnclamped<Self>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lchuv<Wp, 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, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Luma<S, T>where
_C: IntoColorUnclamped<Self>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Luma<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<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Luv<Wp, T>where
_C: IntoColorUnclamped<Self>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Luv<Wp, 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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhsl<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhsl<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhsv<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhsv<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhwb<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhwb<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklab<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklab<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<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklch<T>where
_C: IntoColorUnclamped<Self>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklch<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, _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<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Xyz<Wp, T>where
_C: IntoColorUnclamped<Self>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Xyz<Wp, 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<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Yxy<Wp, T>where
_C: IntoColorUnclamped<Self>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Yxy<Wp, 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<C1: WithAlpha<T>, C2, T> FromColorUnclamped<C1> for Alpha<C2, T>where
C1::Color: IntoColorUnclamped<C2>,
impl<C1: WithAlpha<T>, C2, T> FromColorUnclamped<C1> for Alpha<C2, T>where
C1::Color: IntoColorUnclamped<C2>,
source§fn from_color_unclamped(other: C1) -> Self
fn from_color_unclamped(other: C1) -> Self
source§impl<Tc, Ta, C, A> FromIterator<Alpha<Tc, Ta>> for Alpha<C, A>
impl<Tc, Ta, C, A> FromIterator<Alpha<Tc, Ta>> for Alpha<C, A>
source§impl<C, T> HasBoolMask for Alpha<C, T>
impl<C, T> HasBoolMask for Alpha<C, T>
source§type Mask = <C as HasBoolMask>::Mask
type Mask = <C as HasBoolMask>::Mask
Self
values.source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16UcsJab<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16UcsJab<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16UcsJmh<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16UcsJmh<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jch<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jch<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Jch<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Jch<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jch<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jch<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jch<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jch<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jmh<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jmh<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Jmh<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Jmh<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jmh<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jmh<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jmh<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jmh<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jsh<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jsh<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Jsh<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Jsh<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jsh<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jsh<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jsh<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jsh<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qch<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qch<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Qch<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Qch<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qch<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qch<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qch<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qch<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qmh<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qmh<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Qmh<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Qmh<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qmh<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qmh<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qmh<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qmh<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qsh<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qsh<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Qsh<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Qsh<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qsh<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qsh<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qsh<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qsh<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJab<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJab<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16UcsJab<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16UcsJab<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJab<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJab<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJmh<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJmh<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16UcsJmh<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16UcsJmh<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJmh<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJmh<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsl<S, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsl<S, &'b mut [T]>, &'b mut [T]>
source§impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Hsl<S, [T; N]>, [T; N]>
impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Hsl<S, [T; N]>, [T; N]>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsl<S, Box<[T]>>, Box<[T]>>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsl<S, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsl<S, Vec<T>>, Vec<T>>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsl<S, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Hsluv<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Hsluv<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Hsluv<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Hsluv<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Hsluv<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Hsluv<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Hsluv<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Hsluv<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsv<S, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsv<S, &'b mut [T]>, &'b mut [T]>
source§impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Hsv<S, [T; N]>, [T; N]>
impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Hsv<S, [T; N]>, [T; N]>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsv<S, Box<[T]>>, Box<[T]>>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsv<S, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsv<S, Vec<T>>, Vec<T>>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsv<S, Vec<T>>, Vec<T>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hwb<S, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hwb<S, &'b mut [T]>, &'b mut [T]>
source§impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Hwb<S, [T; N]>, [T; N]>
impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Hwb<S, [T; N]>, [T; N]>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hwb<S, Box<[T]>>, Box<[T]>>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hwb<S, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hwb<S, Vec<T>>, Vec<T>>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hwb<S, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lab<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lab<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Lab<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Lab<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lab<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lab<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lab<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lab<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lch<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lch<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Lch<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Lch<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lch<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lch<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lch<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lch<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lchuv<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lchuv<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Lchuv<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Lchuv<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lchuv<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lchuv<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lchuv<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lchuv<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Luma<S, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Luma<S, &'b mut [T]>, &'b mut [T]>
source§impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Luma<S, [T; N]>, [T; N]>
impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Luma<S, [T; N]>, [T; N]>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Luma<S, Box<[T]>>, Box<[T]>>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Luma<S, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Luma<S, Vec<T>>, Vec<T>>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Luma<S, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Luv<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Luv<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Luv<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Luv<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Luv<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Luv<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Luv<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Luv<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Rgb<S, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Rgb<S, &'b mut [T]>, &'b mut [T]>
source§impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Rgb<S, [T; N]>, [T; N]>
impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Rgb<S, [T; N]>, [T; N]>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Rgb<S, Box<[T]>>, Box<[T]>>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Rgb<S, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Rgb<S, Vec<T>>, Vec<T>>
impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Rgb<S, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Xyz<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Xyz<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Xyz<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Xyz<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Xyz<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Xyz<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Xyz<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Xyz<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Yxy<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Yxy<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Yxy<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Yxy<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Yxy<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Yxy<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Yxy<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Yxy<Wp, Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Cam16Jch<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Jch<&'a mut [T]>, &'a mut [T]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Jmh<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Jmh<&'a mut [T]>, &'a mut [T]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Jsh<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Jsh<&'a mut [T]>, &'a mut [T]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Qch<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Qch<&'a mut [T]>, &'a mut [T]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Qmh<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Qmh<&'a mut [T]>, &'a mut [T]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Qsh<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Qsh<&'a mut [T]>, &'a mut [T]>
source§impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<&'a [T]>, &'a [T]>
source§impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<&'a mut [T]>, &'a mut [T]>
source§impl<T, const N: usize> IntoIterator for Alpha<Cam16UcsJab<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Cam16UcsJab<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<&'a [T]>, &'a [T]>
source§impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<&'a mut [T]>, &'a mut [T]>
source§impl<T, const N: usize> IntoIterator for Alpha<Cam16UcsJmh<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Cam16UcsJmh<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>
source§impl<'a, S, T> IntoIterator for Alpha<Hsl<S, &'a mut [T]>, &'a mut [T]>
impl<'a, S, T> IntoIterator for Alpha<Hsl<S, &'a mut [T]>, &'a mut [T]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Hsluv<Wp, &'a mut [T]>, &'a mut [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Hsluv<Wp, &'a mut [T]>, &'a mut [T]>
source§impl<'a, S, T> IntoIterator for Alpha<Hsv<S, &'a mut [T]>, &'a mut [T]>
impl<'a, S, T> IntoIterator for Alpha<Hsv<S, &'a mut [T]>, &'a mut [T]>
source§impl<'a, S, T> IntoIterator for Alpha<Hwb<S, &'a mut [T]>, &'a mut [T]>
impl<'a, S, T> IntoIterator for Alpha<Hwb<S, &'a mut [T]>, &'a mut [T]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Lab<Wp, &'a mut [T]>, &'a mut [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Lab<Wp, &'a mut [T]>, &'a mut [T]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Lch<Wp, &'a mut [T]>, &'a mut [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Lch<Wp, &'a mut [T]>, &'a mut [T]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Lchuv<Wp, &'a mut [T]>, &'a mut [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Lchuv<Wp, &'a mut [T]>, &'a mut [T]>
source§impl<'a, S, T> IntoIterator for Alpha<Luma<S, &'a mut [T]>, &'a mut [T]>
impl<'a, S, T> IntoIterator for Alpha<Luma<S, &'a mut [T]>, &'a mut [T]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Luv<Wp, &'a mut [T]>, &'a mut [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Luv<Wp, &'a mut [T]>, &'a mut [T]>
source§impl<'a, S, T> IntoIterator for Alpha<Rgb<S, &'a mut [T]>, &'a mut [T]>
impl<'a, S, T> IntoIterator for Alpha<Rgb<S, &'a mut [T]>, &'a mut [T]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Xyz<Wp, &'a mut [T]>, &'a mut [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Xyz<Wp, &'a mut [T]>, &'a mut [T]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Yxy<Wp, &'a mut [T]>, &'a mut [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Yxy<Wp, &'a mut [T]>, &'a mut [T]>
source§impl<C, T> IsWithinBounds for Alpha<C, T>where
C: IsWithinBounds,
T: Stimulus + PartialCmp + IsWithinBounds<Mask = C::Mask>,
C::Mask: BitAnd<Output = C::Mask>,
impl<C, T> IsWithinBounds for Alpha<C, T>where
C: IsWithinBounds,
T: Stimulus + PartialCmp + IsWithinBounds<Mask = C::Mask>,
C::Mask: BitAnd<Output = C::Mask>,
source§fn is_within_bounds(&self) -> C::Mask
fn is_within_bounds(&self) -> C::Mask
source§impl<C: Lighten> Lighten for Alpha<C, C::Scalar>
impl<C: Lighten> Lighten for Alpha<C, C::Scalar>
source§impl<C: LightenAssign> LightenAssign for Alpha<C, C::Scalar>
impl<C: LightenAssign> LightenAssign for Alpha<C, C::Scalar>
source§type Scalar = <C as LightenAssign>::Scalar
type Scalar = <C as LightenAssign>::Scalar
source§fn lighten_assign(&mut self, factor: C::Scalar)
fn lighten_assign(&mut self, factor: C::Scalar)
source§fn lighten_fixed_assign(&mut self, amount: C::Scalar)
fn lighten_fixed_assign(&mut self, amount: C::Scalar)
source§impl<T, C> MulAssign<T> for Alpha<C, T>
impl<T, C> MulAssign<T> for Alpha<C, T>
source§fn mul_assign(&mut self, c: T)
fn mul_assign(&mut self, c: T)
*=
operation. Read moresource§impl<C, T> MulAssign for Alpha<C, T>
impl<C, T> MulAssign for Alpha<C, T>
source§fn mul_assign(&mut self, other: Alpha<C, T>)
fn mul_assign(&mut self, other: Alpha<C, T>)
*=
operation. Read moresource§impl<C, T> RelativeEq for Alpha<C, T>
impl<C, T> RelativeEq for Alpha<C, T>
source§fn default_max_relative() -> Self::Epsilon
fn default_max_relative() -> Self::Epsilon
source§fn relative_eq(
&self,
other: &Alpha<C, T>,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon,
) -> bool
fn relative_eq( &self, other: &Alpha<C, T>, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool
source§fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon,
) -> bool
fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool
RelativeEq::relative_eq
.source§impl<C: Saturate> Saturate for Alpha<C, C::Scalar>
impl<C: Saturate> Saturate for Alpha<C, C::Scalar>
source§impl<C: SaturateAssign> SaturateAssign for Alpha<C, C::Scalar>
impl<C: SaturateAssign> SaturateAssign for Alpha<C, C::Scalar>
source§type Scalar = <C as SaturateAssign>::Scalar
type Scalar = <C as SaturateAssign>::Scalar
source§fn saturate_assign(&mut self, factor: C::Scalar)
fn saturate_assign(&mut self, factor: C::Scalar)
factor
, a value
ranging from 0.0
to 1.0
. Read moresource§fn saturate_fixed_assign(&mut self, amount: C::Scalar)
fn saturate_fixed_assign(&mut self, amount: C::Scalar)
source§impl<T, C> SaturatingAdd<T> for Alpha<C, T>
impl<T, C> SaturatingAdd<T> for Alpha<C, T>
source§type Output = Alpha<<C as SaturatingAdd<T>>::Output, <T as SaturatingAdd>::Output>
type Output = Alpha<<C as SaturatingAdd<T>>::Output, <T as SaturatingAdd>::Output>
source§fn saturating_add(self, c: T) -> Self::Output
fn saturating_add(self, c: T) -> Self::Output
self
and other
, but saturates instead of overflowing.source§impl<C, T> SaturatingAdd for Alpha<C, T>where
C: SaturatingAdd,
T: SaturatingAdd,
impl<C, T> SaturatingAdd for Alpha<C, T>where
C: SaturatingAdd,
T: SaturatingAdd,
source§type Output = Alpha<<C as SaturatingAdd>::Output, <T as SaturatingAdd>::Output>
type Output = Alpha<<C as SaturatingAdd>::Output, <T as SaturatingAdd>::Output>
source§fn saturating_add(self, other: Alpha<C, T>) -> Self::Output
fn saturating_add(self, other: Alpha<C, T>) -> Self::Output
self
and other
, but saturates instead of overflowing.source§impl<T, C> SaturatingSub<T> for Alpha<C, T>
impl<T, C> SaturatingSub<T> for Alpha<C, T>
source§type Output = Alpha<<C as SaturatingSub<T>>::Output, <T as SaturatingSub>::Output>
type Output = Alpha<<C as SaturatingSub<T>>::Output, <T as SaturatingSub>::Output>
source§fn saturating_sub(self, c: T) -> Self::Output
fn saturating_sub(self, c: T) -> Self::Output
self
and other
, but saturates instead of overflowing.source§impl<C, T> SaturatingSub for Alpha<C, T>where
C: SaturatingSub,
T: SaturatingSub,
impl<C, T> SaturatingSub for Alpha<C, T>where
C: SaturatingSub,
T: SaturatingSub,
source§type Output = Alpha<<C as SaturatingSub>::Output, <T as SaturatingSub>::Output>
type Output = Alpha<<C as SaturatingSub>::Output, <T as SaturatingSub>::Output>
source§fn saturating_sub(self, other: Alpha<C, T>) -> Self::Output
fn saturating_sub(self, other: Alpha<C, T>) -> Self::Output
self
and other
, but saturates instead of overflowing.source§impl<C, T> ShiftHueAssign for Alpha<C, T>where
C: ShiftHueAssign,
impl<C, T> ShiftHueAssign for Alpha<C, T>where
C: ShiftHueAssign,
source§type Scalar = <C as ShiftHueAssign>::Scalar
type Scalar = <C as ShiftHueAssign>::Scalar
source§fn shift_hue_assign(&mut self, amount: Self::Scalar)
fn shift_hue_assign(&mut self, amount: Self::Scalar)
amount
.source§impl<T, C> SubAssign<T> for Alpha<C, T>
impl<T, C> SubAssign<T> for Alpha<C, T>
source§fn sub_assign(&mut self, c: T)
fn sub_assign(&mut self, c: T)
-=
operation. Read moresource§impl<C, T> SubAssign for Alpha<C, T>
impl<C, T> SubAssign for Alpha<C, T>
source§fn sub_assign(&mut self, other: Alpha<C, T>)
fn sub_assign(&mut self, other: Alpha<C, T>)
-=
operation. Read moresource§impl<T, A> Tetradic for Alpha<Cam16UcsJab<T>, A>
impl<T, A> Tetradic for Alpha<Cam16UcsJab<T>, A>
source§impl<C, T> UlpsEq for Alpha<C, T>
impl<C, T> UlpsEq for Alpha<C, T>
source§impl<C, A> WithAlpha<A> for Alpha<C, A>
impl<C, A> WithAlpha<A> for Alpha<C, A>
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 moreimpl<C: Copy, T: Copy> Copy for Alpha<C, T>
impl<C, T> Eq for Alpha<C, T>
Auto Trait Implementations§
impl<C, T> Freeze for Alpha<C, T>
impl<C, T> RefUnwindSafe for Alpha<C, T>where
C: RefUnwindSafe,
T: RefUnwindSafe,
impl<C, T> Send for Alpha<C, T>
impl<C, T> Sync for Alpha<C, T>
impl<C, T> Unpin for Alpha<C, T>
impl<C, T> UnwindSafe for Alpha<C, T>where
C: UnwindSafe,
T: 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<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<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