#[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 Alpha<C, A> as IntoIterator>::IntoIterwhere
&'a Alpha<C, A>: IntoIterator,
pub fn iter<'a>(&'a self) -> <&'a Alpha<C, A> as IntoIterator>::IntoIterwhere
&'a Alpha<C, A>: IntoIterator,
Return an iterator over the colors in the wrapped collections.
sourcepub fn iter_mut<'a>(
&'a mut self,
) -> <&'a mut Alpha<C, A> as IntoIterator>::IntoIterwhere
&'a mut Alpha<C, A>: IntoIterator,
pub fn iter_mut<'a>(
&'a mut self,
) -> <&'a mut Alpha<C, A> as IntoIterator>::IntoIterwhere
&'a mut Alpha<C, A>: IntoIterator,
Return an iterator that allows modifying the colors in the wrapped collections.
source§impl<C> Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
impl<C> Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
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 as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::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 as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::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>(
lightness: T,
chroma: T,
hue: H,
alpha: A,
) -> Alpha<Cam16Jch<T>, A>
pub fn new<H>( lightness: T, chroma: T, hue: H, alpha: A, ) -> Alpha<Cam16Jch<T>, A>
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
lightness: T,
chroma: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Alpha<Cam16Jch<T>, A>
pub const fn new_const( lightness: T, chroma: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Jch<T>, A>
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>(_: (T, T, H, A)) -> Alpha<Cam16Jch<T>, A>
pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Jch<T>, A>
Convert from a (lightness, chroma, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Jch<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jch<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Jch<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jch<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::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 as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Jch<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Jch<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::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>) -> Alpha<Cam16Jch<T>, A>
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Jch<T>, A>
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 as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jch<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jch<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Jch<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Jch<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Cam16Jch<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Cam16Jch<Vec<T>>, Vec<A>>
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>(
lightness: T,
colorfulness: T,
hue: H,
alpha: A,
) -> Alpha<Cam16Jmh<T>, A>
pub fn new<H>( lightness: T, colorfulness: T, hue: H, alpha: A, ) -> Alpha<Cam16Jmh<T>, A>
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
lightness: T,
colorfulness: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Alpha<Cam16Jmh<T>, A>
pub const fn new_const( lightness: T, colorfulness: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Jmh<T>, A>
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>(_: (T, T, H, A)) -> Alpha<Cam16Jmh<T>, A>
pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Jmh<T>, A>
Convert from a (lightness, colorfulness, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Jmh<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jmh<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Jmh<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jmh<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::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 as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Jmh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Jmh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::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>) -> Alpha<Cam16Jmh<T>, A>
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Jmh<T>, A>
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 as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jmh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jmh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Jmh<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Jmh<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Cam16Jmh<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Cam16Jmh<Vec<T>>, Vec<A>>
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>(
lightness: T,
saturation: T,
hue: H,
alpha: A,
) -> Alpha<Cam16Jsh<T>, A>
pub fn new<H>( lightness: T, saturation: T, hue: H, alpha: A, ) -> Alpha<Cam16Jsh<T>, A>
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
lightness: T,
saturation: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Alpha<Cam16Jsh<T>, A>
pub const fn new_const( lightness: T, saturation: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Jsh<T>, A>
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>(_: (T, T, H, A)) -> Alpha<Cam16Jsh<T>, A>
pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Jsh<T>, A>
Convert from a (lightness, saturation, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Jsh<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jsh<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Jsh<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jsh<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::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 as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Jsh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Jsh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::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>) -> Alpha<Cam16Jsh<T>, A>
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Jsh<T>, A>
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 as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jsh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Jsh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Jsh<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Jsh<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Cam16Jsh<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Cam16Jsh<Vec<T>>, Vec<A>>
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>(
brightness: T,
chroma: T,
hue: H,
alpha: A,
) -> Alpha<Cam16Qch<T>, A>
pub fn new<H>( brightness: T, chroma: T, hue: H, alpha: A, ) -> Alpha<Cam16Qch<T>, A>
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
brightness: T,
chroma: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Alpha<Cam16Qch<T>, A>
pub const fn new_const( brightness: T, chroma: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Qch<T>, A>
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>(_: (T, T, H, A)) -> Alpha<Cam16Qch<T>, A>
pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Qch<T>, A>
Convert from a (brightness, chroma, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Qch<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qch<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Qch<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qch<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::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 as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Qch<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Qch<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::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>) -> Alpha<Cam16Qch<T>, A>
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Qch<T>, A>
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 as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qch<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qch<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Qch<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Qch<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Cam16Qch<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Cam16Qch<Vec<T>>, Vec<A>>
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>(
brightness: T,
colorfulness: T,
hue: H,
alpha: A,
) -> Alpha<Cam16Qmh<T>, A>
pub fn new<H>( brightness: T, colorfulness: T, hue: H, alpha: A, ) -> Alpha<Cam16Qmh<T>, A>
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
brightness: T,
colorfulness: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Alpha<Cam16Qmh<T>, A>
pub const fn new_const( brightness: T, colorfulness: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Qmh<T>, A>
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>(_: (T, T, H, A)) -> Alpha<Cam16Qmh<T>, A>
pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Qmh<T>, A>
Convert from a (brightness, colorfulness, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Qmh<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qmh<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Qmh<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qmh<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::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 as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Qmh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Qmh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::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>) -> Alpha<Cam16Qmh<T>, A>
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Qmh<T>, A>
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 as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qmh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qmh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Qmh<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Qmh<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Cam16Qmh<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Cam16Qmh<Vec<T>>, Vec<A>>
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>(
brightness: T,
saturation: T,
hue: H,
alpha: A,
) -> Alpha<Cam16Qsh<T>, A>
pub fn new<H>( brightness: T, saturation: T, hue: H, alpha: A, ) -> Alpha<Cam16Qsh<T>, A>
Create a partial CIE CAM16 color with transparency.
sourcepub const fn new_const(
brightness: T,
saturation: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Alpha<Cam16Qsh<T>, A>
pub const fn new_const( brightness: T, saturation: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Qsh<T>, A>
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>(_: (T, T, H, A)) -> Alpha<Cam16Qsh<T>, A>
pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Qsh<T>, A>
Convert from a (brightness, saturation, hue, alpha)
tuple.
sourcepub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Qsh<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qsh<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,
pub fn from_xyz<WpParam>(
color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16Qsh<T>, A>where
Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qsh<T>, Scalar = <T as FromScalar>::Scalar>,
T: FromScalar,
WpParam: WhitePointParameter<<T as FromScalar>::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 as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Qsh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_xyz<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>where
Cam16Qsh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::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>) -> Alpha<Cam16Qsh<T>, A>
pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Qsh<T>, A>
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 as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qsh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>,
WpParam: WhitePointParameter<T>,
T: FromScalar,
pub fn into_full<WpParam>(
self,
parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>,
) -> Alpha<Cam16<T>, A>where
Cam16Qsh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Qsh<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Qsh<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Cam16Qsh<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Cam16Qsh<Vec<T>>, Vec<A>>
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) -> Alpha<Cam16UcsJab<T>, A>
pub const fn new(lightness: T, a: T, b: T, alpha: A) -> Alpha<Cam16UcsJab<T>, A>
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(_: (T, T, T, A)) -> Alpha<Cam16UcsJab<T>, A>
pub fn from_components(_: (T, T, T, A)) -> Alpha<Cam16UcsJab<T>, A>
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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16UcsJab<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16UcsJab<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Cam16UcsJab<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Cam16UcsJab<Vec<T>>, Vec<A>>
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>(
lightness: T,
colorfulness: T,
hue: H,
alpha: A,
) -> Alpha<Cam16UcsJmh<T>, A>
pub fn new<H>( lightness: T, colorfulness: T, hue: H, alpha: A, ) -> Alpha<Cam16UcsJmh<T>, A>
Create a CAM16-UCS J’ M’ h’ color with transparency.
sourcepub const fn new_const(
lightness: T,
colorfulness: T,
hue: Cam16Hue<T>,
alpha: A,
) -> Alpha<Cam16UcsJmh<T>, A>
pub const fn new_const( lightness: T, colorfulness: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16UcsJmh<T>, A>
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>(_: (T, T, H, A)) -> Alpha<Cam16UcsJmh<T>, A>
pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16UcsJmh<T>, A>
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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16UcsJmh<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16UcsJmh<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Cam16UcsJmh<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Cam16UcsJmh<Vec<T>>, Vec<A>>
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.
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>(
hue: H,
saturation: T,
lightness: T,
alpha: A,
) -> Alpha<Hsl<S, T>, A>
pub fn new<H>( hue: H, saturation: T, lightness: T, alpha: A, ) -> Alpha<Hsl<S, T>, A>
Create an HSL color with transparency.
sourcepub const fn new_const(
hue: RgbHue<T>,
saturation: T,
lightness: T,
alpha: A,
) -> Alpha<Hsl<S, T>, A>
pub const fn new_const( hue: RgbHue<T>, saturation: T, lightness: T, alpha: A, ) -> Alpha<Hsl<S, T>, A>
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>) -> Alpha<Hsl<S, T>, A>
pub fn from_format<U, B>(color: Alpha<Hsl<S, U>, B>) -> Alpha<Hsl<S, T>, A>
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>(_: (H, T, T, A)) -> Alpha<Hsl<S, T>, A>
pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Hsl<S, T>, A>
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hsl<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hsl<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Hsl<S, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Hsl<S, Vec<T>>, Vec<A>>
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>(hue: H, saturation: T, l: T, alpha: A) -> Alpha<Hsluv<Wp, T>, A>
pub fn new<H>(hue: H, saturation: T, l: T, alpha: A) -> Alpha<Hsluv<Wp, T>, A>
Create an HSLuv color with transparency.
sourcepub const fn new_const(
hue: LuvHue<T>,
saturation: T,
l: T,
alpha: A,
) -> Alpha<Hsluv<Wp, T>, A>
pub const fn new_const( hue: LuvHue<T>, saturation: T, l: T, alpha: A, ) -> Alpha<Hsluv<Wp, T>, A>
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>(_: (H, T, T, A)) -> Alpha<Hsluv<Wp, T>, A>
pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Hsluv<Wp, T>, A>
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hsluv<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hsluv<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Hsluv<Wp, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Hsluv<Wp, Vec<T>>, Vec<A>>
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.
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>(hue: H, saturation: T, value: T, alpha: A) -> Alpha<Hsv<S, T>, A>
pub fn new<H>(hue: H, saturation: T, value: T, alpha: A) -> Alpha<Hsv<S, T>, A>
Create an HSV color with transparency.
sourcepub const fn new_const(
hue: RgbHue<T>,
saturation: T,
value: T,
alpha: A,
) -> Alpha<Hsv<S, T>, A>
pub const fn new_const( hue: RgbHue<T>, saturation: T, value: T, alpha: A, ) -> Alpha<Hsv<S, T>, A>
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>) -> Alpha<Hsv<S, T>, A>
pub fn from_format<U, B>(color: Alpha<Hsv<S, U>, B>) -> Alpha<Hsv<S, T>, A>
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>(_: (H, T, T, A)) -> Alpha<Hsv<S, T>, A>
pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Hsv<S, T>, A>
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hsv<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hsv<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Hsv<S, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Hsv<S, Vec<T>>, Vec<A>>
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.
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>(
hue: H,
whiteness: T,
blackness: T,
alpha: A,
) -> Alpha<Hwb<S, T>, A>
pub fn new<H>( hue: H, whiteness: T, blackness: T, alpha: A, ) -> Alpha<Hwb<S, T>, A>
Create an HWB color with transparency.
sourcepub const fn new_const(
hue: RgbHue<T>,
whiteness: T,
blackness: T,
alpha: A,
) -> Alpha<Hwb<S, T>, A>
pub const fn new_const( hue: RgbHue<T>, whiteness: T, blackness: T, alpha: A, ) -> Alpha<Hwb<S, T>, A>
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>) -> Alpha<Hwb<S, T>, A>
pub fn from_format<U, B>(color: Alpha<Hwb<S, U>, B>) -> Alpha<Hwb<S, T>, A>
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>(_: (H, T, T, A)) -> Alpha<Hwb<S, T>, A>
pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Hwb<S, T>, A>
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hwb<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hwb<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Hwb<S, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Hwb<S, Vec<T>>, Vec<A>>
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 const fn new(l: T, a: T, b: T, alpha: A) -> Alpha<Lab<Wp, T>, A>
pub const fn new(l: T, a: T, b: T, alpha: A) -> Alpha<Lab<Wp, T>, A>
Create a CIE L*a*b* with transparency.
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(_: (T, T, T, A)) -> Alpha<Lab<Wp, T>, A>
pub fn from_components(_: (T, T, T, A)) -> Alpha<Lab<Wp, T>, A>
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Lab<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Lab<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Lab<Wp, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Lab<Wp, Vec<T>>, Vec<A>>
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>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Lch<Wp, T>, A>
pub fn new<H>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Lch<Wp, T>, A>
Create a CIE L*C*h° color with transparency.
sourcepub const fn new_const(
l: T,
chroma: T,
hue: LabHue<T>,
alpha: A,
) -> Alpha<Lch<Wp, T>, A>
pub const fn new_const( l: T, chroma: T, hue: LabHue<T>, alpha: A, ) -> Alpha<Lch<Wp, T>, A>
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>(_: (T, T, H, A)) -> Alpha<Lch<Wp, T>, A>
pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Lch<Wp, T>, A>
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Lch<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Lch<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Lch<Wp, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Lch<Wp, Vec<T>>, Vec<A>>
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>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Lchuv<Wp, T>, A>
pub fn new<H>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Lchuv<Wp, T>, A>
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,
) -> Alpha<Lchuv<Wp, T>, A>
pub const fn new_const( l: T, chroma: T, hue: LuvHue<T>, alpha: A, ) -> Alpha<Lchuv<Wp, T>, A>
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>(_: (T, T, H, A)) -> Alpha<Lchuv<Wp, T>, A>
pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Lchuv<Wp, T>, A>
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Lchuv<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Lchuv<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Lchuv<Wp, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Lchuv<Wp, Vec<T>>, Vec<A>>
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 const fn new(luma: T, alpha: A) -> Alpha<Luma<S, T>, A>
pub const fn new(luma: T, alpha: A) -> Alpha<Luma<S, T>, A>
Create a luminance color with transparency.
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>) -> Alpha<Luma<S, T>, A>where
T: FromStimulus<U>,
A: FromStimulus<B>,
pub fn from_format<U, B>(color: Alpha<Luma<S, U>, B>) -> Alpha<Luma<S, T>, A>where
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(_: (T, A)) -> Alpha<Luma<S, T>, A>
pub fn from_components(_: (T, A)) -> Alpha<Luma<S, T>, A>
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) -> Alpha<Luma<S, u8>, u8>
pub fn from_u16<O>(color: u16) -> Alpha<Luma<S, u8>, u8>
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 as LumaStandard>::WhitePoint>, U>, B>
pub fn into_linear<U, B>( self, ) -> Alpha<Luma<Linear<<S as LumaStandard>::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 as LumaStandard>::WhitePoint>, U>, B>,
) -> Alpha<Luma<S, T>, A>
pub fn from_linear<U, B>( color: Alpha<Luma<Linear<<S as LumaStandard>::WhitePoint>, U>, B>, ) -> Alpha<Luma<S, T>, A>
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>where
St: LumaStandard<WhitePoint = Wp>,
<St as LumaStandard>::TransferFn: FromLinear<T, U>,
B: FromStimulus<A>,
pub fn into_encoding<U, B, St>(self) -> Alpha<Luma<St, U>, B>where
St: LumaStandard<WhitePoint = Wp>,
<St as LumaStandard>::TransferFn: FromLinear<T, U>,
B: FromStimulus<A>,
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>,
) -> Alpha<Luma<Linear<Wp>, T>, A>where
St: LumaStandard<WhitePoint = Wp>,
<St as LumaStandard>::TransferFn: IntoLinear<T, U>,
A: FromStimulus<B>,
pub fn from_encoding<U, B, St>(
color: Alpha<Luma<St, U>, B>,
) -> Alpha<Luma<Linear<Wp>, T>, A>where
St: LumaStandard<WhitePoint = Wp>,
<St as LumaStandard>::TransferFn: IntoLinear<T, U>,
A: FromStimulus<B>,
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Luma<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Luma<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Luma<S, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Luma<S, Vec<T>>, Vec<A>>
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) -> Alpha<Luv<Wp, T>, A>
pub const fn new(l: T, u: T, v: T, alpha: A) -> Alpha<Luv<Wp, T>, A>
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(_: (T, T, T, A)) -> Alpha<Luv<Wp, T>, A>
pub fn from_components(_: (T, T, T, A)) -> Alpha<Luv<Wp, T>, A>
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Luv<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Luv<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Luv<Wp, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Luv<Wp, Vec<T>>, Vec<A>>
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>(
hue: H,
saturation: T,
lightness: T,
alpha: A,
) -> Alpha<Okhsl<T>, A>
pub fn new<H>( hue: H, saturation: T, lightness: T, alpha: A, ) -> Alpha<Okhsl<T>, A>
Create an Okhsl
color with transparency.
sourcepub const fn new_const(
hue: OklabHue<T>,
saturation: T,
lightness: T,
alpha: A,
) -> Alpha<Okhsl<T>, A>
pub const fn new_const( hue: OklabHue<T>, saturation: T, lightness: T, alpha: A, ) -> Alpha<Okhsl<T>, A>
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>) -> Alpha<Okhsl<T>, A>
pub fn from_format<U, B>(color: Alpha<Okhsl<U>, B>) -> Alpha<Okhsl<T>, A>
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>(_: (H, T, T, A)) -> Alpha<Okhsl<T>, A>
pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Okhsl<T>, A>
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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Okhsl<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Okhsl<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Okhsl<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Okhsl<Vec<T>>, Vec<A>>
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>(hue: H, saturation: T, value: T, alpha: A) -> Alpha<Okhsv<T>, A>
pub fn new<H>(hue: H, saturation: T, value: T, alpha: A) -> Alpha<Okhsv<T>, A>
Create an Okhsv
color with transparency.
sourcepub const fn new_const(
hue: OklabHue<T>,
saturation: T,
value: T,
alpha: A,
) -> Alpha<Okhsv<T>, A>
pub const fn new_const( hue: OklabHue<T>, saturation: T, value: T, alpha: A, ) -> Alpha<Okhsv<T>, A>
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>) -> Alpha<Okhsv<T>, A>
pub fn from_format<U, B>(color: Alpha<Okhsv<U>, B>) -> Alpha<Okhsv<T>, A>
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>(_: (H, T, T, A)) -> Alpha<Okhsv<T>, A>
pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Okhsv<T>, A>
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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Okhsv<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Okhsv<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Okhsv<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Okhsv<Vec<T>>, Vec<A>>
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>(
hue: H,
whiteness: T,
blackness: T,
alpha: A,
) -> Alpha<Okhwb<T>, A>
pub fn new<H>( hue: H, whiteness: T, blackness: T, alpha: A, ) -> Alpha<Okhwb<T>, A>
Create an Okhwb
color with transparency.
sourcepub const fn new_const(
hue: OklabHue<T>,
whiteness: T,
blackness: T,
alpha: A,
) -> Alpha<Okhwb<T>, A>
pub const fn new_const( hue: OklabHue<T>, whiteness: T, blackness: T, alpha: A, ) -> Alpha<Okhwb<T>, A>
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>) -> Alpha<Okhwb<T>, A>
pub fn from_format<U, B>(color: Alpha<Okhwb<U>, B>) -> Alpha<Okhwb<T>, A>
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>(_: (H, T, T, A)) -> Alpha<Okhwb<T>, A>
pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Okhwb<T>, A>
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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Okhwb<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Okhwb<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Okhwb<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Okhwb<Vec<T>>, Vec<A>>
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 const fn new(l: T, a: T, b: T, alpha: A) -> Alpha<Oklab<T>, A>
pub const fn new(l: T, a: T, b: T, alpha: A) -> Alpha<Oklab<T>, A>
Create an Oklab color with transparency.
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(_: (T, T, T, A)) -> Alpha<Oklab<T>, A>
pub fn from_components(_: (T, T, T, A)) -> Alpha<Oklab<T>, A>
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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Oklab<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Oklab<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Oklab<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Oklab<Vec<T>>, Vec<A>>
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>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Oklch<T>, A>
pub fn new<H>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Oklch<T>, A>
Create an Oklch color with transparency.
sourcepub const fn new_const(
l: T,
chroma: T,
hue: OklabHue<T>,
alpha: A,
) -> Alpha<Oklch<T>, A>
pub const fn new_const( l: T, chroma: T, hue: OklabHue<T>, alpha: A, ) -> Alpha<Oklch<T>, A>
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>(_: (T, T, H, A)) -> Alpha<Oklch<T>, A>
pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Oklch<T>, A>
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<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Oklch<&'a <I as SliceIndex<[T]>>::Output>, &'a <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<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Oklch<&'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Oklch<Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Oklch<Vec<T>>, Vec<A>>
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>) -> Alpha<Rgb<S, T>, A>where
T: FromStimulus<U>,
A: FromStimulus<B>,
pub fn from_format<U, B>(color: Alpha<Rgb<S, U>, B>) -> Alpha<Rgb<S, T>, A>where
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(_: (T, T, T, A)) -> Alpha<Rgb<S, T>, A>
pub fn from_components(_: (T, T, T, A)) -> Alpha<Rgb<S, T>, A>
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) -> Alpha<Rgb<S, u8>, u8>
pub fn from_u32<O>(color: u32) -> Alpha<Rgb<S, u8>, u8>
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, T, A> Alpha<Rgb<S, T>, A>where
S: RgbStandard,
impl<S, T, A> Alpha<Rgb<S, T>, A>where
S: RgbStandard,
sourcepub fn into_linear<U, B>(
self,
) -> Alpha<Rgb<Linear<<S as RgbStandard>::Space>, U>, B>
pub fn into_linear<U, B>( self, ) -> Alpha<Rgb<Linear<<S as RgbStandard>::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 as RgbStandard>::Space>, U>, B>,
) -> Alpha<Rgb<S, T>, A>
pub fn from_linear<U, B>( color: Alpha<Rgb<Linear<<S as RgbStandard>::Space>, U>, B>, ) -> Alpha<Rgb<S, T>, A>
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, T, A> Alpha<Rgb<Linear<S>, T>, A>where
S: RgbSpace,
impl<S, T, A> Alpha<Rgb<Linear<S>, T>, A>where
S: RgbSpace,
sourcepub fn into_encoding<U, B, St>(self) -> Alpha<Rgb<St, U>, B>where
St: RgbStandard<Space = S>,
<St as RgbStandard>::TransferFn: FromLinear<T, U>,
B: FromStimulus<A>,
pub fn into_encoding<U, B, St>(self) -> Alpha<Rgb<St, U>, B>where
St: RgbStandard<Space = S>,
<St as RgbStandard>::TransferFn: FromLinear<T, U>,
B: FromStimulus<A>,
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>,
) -> Alpha<Rgb<Linear<S>, T>, A>where
St: RgbStandard<Space = S>,
<St as RgbStandard>::TransferFn: IntoLinear<T, U>,
A: FromStimulus<B>,
pub fn from_encoding<U, B, St>(
color: Alpha<Rgb<St, U>, B>,
) -> Alpha<Rgb<Linear<S>, T>, A>where
St: RgbStandard<Space = S>,
<St as RgbStandard>::TransferFn: IntoLinear<T, U>,
A: FromStimulus<B>,
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Rgb<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Rgb<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Rgb<S, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Rgb<S, Vec<T>>, Vec<A>>
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 const fn new(x: T, y: T, z: T, alpha: A) -> Alpha<Xyz<Wp, T>, A>
pub const fn new(x: T, y: T, z: T, alpha: A) -> Alpha<Xyz<Wp, T>, A>
Create a CIE XYZ 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, Z, alpha)
tuple.
sourcepub fn from_components(_: (T, T, T, A)) -> Alpha<Xyz<Wp, T>, A>
pub fn from_components(_: (T, T, T, A)) -> Alpha<Xyz<Wp, T>, A>
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Xyz<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Xyz<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Xyz<Wp, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Xyz<Wp, Vec<T>>, Vec<A>>
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) -> Alpha<Yxy<Wp, T>, A>
pub const fn new(x: T, y: T, luma: T, alpha: A) -> Alpha<Yxy<Wp, T>, A>
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(_: (T, T, T, A)) -> Alpha<Yxy<Wp, T>, A>
pub fn from_components(_: (T, T, T, A)) -> Alpha<Yxy<Wp, T>, A>
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, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>
pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Yxy<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <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, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>
pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Yxy<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a 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) -> Alpha<Yxy<Wp, Vec<T>>, Vec<A>>
pub fn with_capacity(capacity: usize) -> Alpha<Yxy<Wp, Vec<T>>, Vec<A>>
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() -> <Alpha<C, T> as AbsDiffEq>::Epsilon
fn default_epsilon() -> <Alpha<C, T> as AbsDiffEq>::Epsilon
source§fn abs_diff_eq(
&self,
other: &Alpha<C, T>,
epsilon: <T as AbsDiffEq>::Epsilon,
) -> bool
fn abs_diff_eq( &self, other: &Alpha<C, T>, epsilon: <T as AbsDiffEq>::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 as HasBoolMask>::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 as HasBoolMask>::Mask: LazySelect<T>,
source§fn multiply(self, other: Alpha<C, T>) -> Alpha<C, T>
fn multiply(self, other: Alpha<C, T>) -> Alpha<C, T>
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: Alpha<C, T>) -> Alpha<C, T>
fn screen(self, other: Alpha<C, T>) -> Alpha<C, T>
self
or other
.source§fn overlay(self, other: Alpha<C, T>) -> Alpha<C, T>
fn overlay(self, other: Alpha<C, T>) -> Alpha<C, T>
self
or other
if other is dark, or screen them if other
is light. This results in an S curve.source§fn darken(self, other: Alpha<C, T>) -> Alpha<C, T>
fn darken(self, other: Alpha<C, T>) -> Alpha<C, T>
self
and other
.source§fn lighten(self, other: Alpha<C, T>) -> Alpha<C, T>
fn lighten(self, other: Alpha<C, T>) -> Alpha<C, T>
self
and other
.source§fn dodge(self, other: Alpha<C, T>) -> Alpha<C, T>
fn dodge(self, other: Alpha<C, T>) -> Alpha<C, T>
other
to reflect self
. Results in other
if self
is
black.source§fn burn(self, other: Alpha<C, T>) -> Alpha<C, T>
fn burn(self, other: Alpha<C, T>) -> Alpha<C, T>
other
to reflect self
. Results in other
if self
is
white.source§fn hard_light(self, other: Alpha<C, T>) -> Alpha<C, T>
fn hard_light(self, other: Alpha<C, T>) -> Alpha<C, T>
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: Alpha<C, T>) -> Alpha<C, T>
fn soft_light(self, other: Alpha<C, T>) -> Alpha<C, T>
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: Alpha<C, T>) -> Alpha<C, T>
fn difference(self, other: Alpha<C, T>) -> Alpha<C, T>
self
and other
. It’s
basically abs(self - other)
, but regulated by the alpha component.source§impl<C> BlendWith for Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
impl<C> BlendWith for Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
source§fn blend_with<F>(
self,
destination: Alpha<C, <C as Premultiply>::Scalar>,
blend_function: F,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn blend_with<F>( self, destination: Alpha<C, <C as Premultiply>::Scalar>, blend_function: F, ) -> Alpha<C, <C as Premultiply>::Scalar>
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) -> Alpha<Cam16UcsJab<T>, A>
fn complementary(self) -> Alpha<Cam16UcsJab<T>, A>
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§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§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§impl<C> Compose for Alpha<C, <C as Premultiply>::Scalar>
impl<C> Compose for Alpha<C, <C as Premultiply>::Scalar>
source§fn over(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn over( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
over other
. This is the good old common alpha composition
equation.source§fn inside(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn inside( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
that overlaps the visible parts of
other
.source§fn outside(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn outside( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
that lies outside the visible parts of
other
.source§fn atop(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn atop( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
over only the visible parts of other
.source§fn xor(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn xor( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
or other
, where they do not overlap.source§fn plus(
self,
other: Alpha<C, <C as Premultiply>::Scalar>,
) -> Alpha<C, <C as Premultiply>::Scalar>
fn plus( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>
self
and other
. This uses the alpha component to regulate the
effect, so it’s not just plain component wise addition.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<Alpha<C, T>, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<Alpha<C, T>, <D as Deserializer<'de>>::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>(&mut self, iter: T)where
T: IntoIterator<Item = Alpha<Tc, Ta>>,
fn extend<T>(&mut self, iter: T)where
T: IntoIterator<Item = Alpha<Tc, Ta>>,
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§fn from(colors: [Alpha<Cam16UcsJab<T>, T>; N]) -> Alpha<Cam16UcsJab<V>, V>
fn from(colors: [Alpha<Cam16UcsJab<T>, T>; N]) -> 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§fn from(colors: [Alpha<Cam16UcsJmh<T>, T>; N]) -> Alpha<Cam16UcsJmh<V>, V>
fn from(colors: [Alpha<Cam16UcsJmh<T>, T>; N]) -> Alpha<Cam16UcsJmh<V>, V>
source§impl<T, H, A> From<(T, T, H, A)> for Alpha<Cam16UcsJmh<T>, A>
impl<T, H, A> From<(T, T, H, A)> for Alpha<Cam16UcsJmh<T>, A>
source§fn from(components: (T, T, H, A)) -> Alpha<Cam16UcsJmh<T>, A>
fn from(components: (T, T, H, A)) -> Alpha<Cam16UcsJmh<T>, A>
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)) -> Alpha<Cam16UcsJab<T>, A>
fn from(components: (T, T, T, A)) -> Alpha<Cam16UcsJab<T>, A>
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<C> From<PreAlpha<C>> for Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
impl<C> From<PreAlpha<C>> for Alpha<C, <C as Premultiply>::Scalar>where
C: Premultiply,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jch<T>where
_C: IntoColorUnclamped<Cam16Jch<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jch<T>where
_C: IntoColorUnclamped<Cam16Jch<T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jmh<T>where
_C: IntoColorUnclamped<Cam16Jmh<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jmh<T>where
_C: IntoColorUnclamped<Cam16Jmh<T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jsh<T>where
_C: IntoColorUnclamped<Cam16Jsh<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jsh<T>where
_C: IntoColorUnclamped<Cam16Jsh<T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qch<T>where
_C: IntoColorUnclamped<Cam16Qch<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qch<T>where
_C: IntoColorUnclamped<Cam16Qch<T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qmh<T>where
_C: IntoColorUnclamped<Cam16Qmh<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qmh<T>where
_C: IntoColorUnclamped<Cam16Qmh<T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qsh<T>where
_C: IntoColorUnclamped<Cam16Qsh<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qsh<T>where
_C: IntoColorUnclamped<Cam16Qsh<T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16UcsJab<T>where
_C: IntoColorUnclamped<Cam16UcsJab<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16UcsJab<T>where
_C: IntoColorUnclamped<Cam16UcsJab<T>>,
source§fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16UcsJab<T>
fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16UcsJab<T>
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16UcsJmh<T>where
_C: IntoColorUnclamped<Cam16UcsJmh<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16UcsJmh<T>where
_C: IntoColorUnclamped<Cam16UcsJmh<T>>,
source§fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16UcsJmh<T>
fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16UcsJmh<T>
source§impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsl<S, T>where
_C: IntoColorUnclamped<Hsl<S, T>>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsl<S, T>where
_C: IntoColorUnclamped<Hsl<S, T>>,
source§impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsluv<Wp, T>where
_C: IntoColorUnclamped<Hsluv<Wp, T>>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsluv<Wp, T>where
_C: IntoColorUnclamped<Hsluv<Wp, T>>,
source§impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsv<S, T>where
_C: IntoColorUnclamped<Hsv<S, T>>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsv<S, T>where
_C: IntoColorUnclamped<Hsv<S, T>>,
source§impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hwb<S, T>where
_C: IntoColorUnclamped<Hwb<S, T>>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hwb<S, T>where
_C: IntoColorUnclamped<Hwb<S, T>>,
source§impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lab<Wp, T>where
_C: IntoColorUnclamped<Lab<Wp, T>>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lab<Wp, T>where
_C: IntoColorUnclamped<Lab<Wp, T>>,
source§impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lch<Wp, T>where
_C: IntoColorUnclamped<Lch<Wp, T>>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lch<Wp, T>where
_C: IntoColorUnclamped<Lch<Wp, T>>,
source§impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lchuv<Wp, T>where
_C: IntoColorUnclamped<Lchuv<Wp, T>>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lchuv<Wp, T>where
_C: IntoColorUnclamped<Lchuv<Wp, T>>,
source§impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Luma<S, T>where
_C: IntoColorUnclamped<Luma<S, T>>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Luma<S, T>where
_C: IntoColorUnclamped<Luma<S, T>>,
source§impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Luv<Wp, T>where
_C: IntoColorUnclamped<Luv<Wp, T>>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Luv<Wp, T>where
_C: IntoColorUnclamped<Luv<Wp, T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhsl<T>where
_C: IntoColorUnclamped<Okhsl<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhsl<T>where
_C: IntoColorUnclamped<Okhsl<T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhsv<T>where
_C: IntoColorUnclamped<Okhsv<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhsv<T>where
_C: IntoColorUnclamped<Okhsv<T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhwb<T>where
_C: IntoColorUnclamped<Okhwb<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhwb<T>where
_C: IntoColorUnclamped<Okhwb<T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklab<T>where
_C: IntoColorUnclamped<Oklab<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklab<T>where
_C: IntoColorUnclamped<Oklab<T>>,
source§impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklch<T>where
_C: IntoColorUnclamped<Oklch<T>>,
impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklch<T>where
_C: IntoColorUnclamped<Oklch<T>>,
source§impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Rgb<S, T>where
_C: IntoColorUnclamped<Rgb<S, T>>,
impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Rgb<S, T>where
_C: IntoColorUnclamped<Rgb<S, T>>,
source§impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Xyz<Wp, T>where
_C: IntoColorUnclamped<Xyz<Wp, T>>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Xyz<Wp, T>where
_C: IntoColorUnclamped<Xyz<Wp, T>>,
source§impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Yxy<Wp, T>where
_C: IntoColorUnclamped<Yxy<Wp, T>>,
impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Yxy<Wp, T>where
_C: IntoColorUnclamped<Yxy<Wp, T>>,
source§impl<C1, C2, T> FromColorUnclamped<C1> for Alpha<C2, T>
impl<C1, C2, T> FromColorUnclamped<C1> for Alpha<C2, T>
source§fn from_color_unclamped(other: C1) -> Alpha<C2, T>
fn from_color_unclamped(other: C1) -> Alpha<C2, T>
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<S> FromStr for Alpha<Rgb<S, u8>, u8>
impl<S> FromStr for Alpha<Rgb<S, u8>, u8>
source§fn from_str(
hex: &str,
) -> Result<Alpha<Rgb<S, u8>, u8>, <Alpha<Rgb<S, u8>, u8> as FromStr>::Err>
fn from_str( hex: &str, ) -> Result<Alpha<Rgb<S, u8>, u8>, <Alpha<Rgb<S, u8>, u8> as FromStr>::Err>
Parses a color hex code of format ‘#ff00bbff’ or ‘#abcd’ (with or without the leading ‘#’) into a
Rgba<S, u8>
instance.
source§type Err = FromHexError
type Err = FromHexError
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<Cam16Jch<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Jch<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Jch<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Jmh<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Jmh<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Jsh<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Jsh<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Qch<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Qch<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Qmh<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Qmh<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Qsh<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Qsh<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<Vec<T>>, Vec<T>>
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, S, T> IntoIterator for &'a Alpha<Hsl<S, &'b [T]>, &'b [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, &'b [T]>, &'b [T]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, &'b mut [T]>, &'b mut [T]>
source§impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Hsl<S, [T; N]>, [T; N]>
impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Hsl<S, [T; N]>, [T; N]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, Box<[T]>>, Box<[T]>>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, Vec<T>>, Vec<T>>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, &'b [T]>, &'b [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, &'b [T]>, &'b [T]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Hsluv<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Hsluv<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, &'b [T]>, &'b [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, &'b [T]>, &'b [T]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, &'b mut [T]>, &'b mut [T]>
source§impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Hsv<S, [T; N]>, [T; N]>
impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Hsv<S, [T; N]>, [T; N]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, Box<[T]>>, Box<[T]>>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, Vec<T>>, Vec<T>>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, Vec<T>>, Vec<T>>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, &'b [T]>, &'b [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, &'b [T]>, &'b [T]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, &'b mut [T]>, &'b mut [T]>
source§impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Hwb<S, [T; N]>, [T; N]>
impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Hwb<S, [T; N]>, [T; N]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, Box<[T]>>, Box<[T]>>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, Vec<T>>, Vec<T>>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, &'b [T]>, &'b [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, &'b [T]>, &'b [T]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Lab<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Lab<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, &'b [T]>, &'b [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, &'b [T]>, &'b [T]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Lch<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Lch<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, &'b [T]>, &'b [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, &'b [T]>, &'b [T]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Lchuv<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Lchuv<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, &'b [T]>, &'b [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, &'b [T]>, &'b [T]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, &'b mut [T]>, &'b mut [T]>
source§impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Luma<S, [T; N]>, [T; N]>
impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Luma<S, [T; N]>, [T; N]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, Box<[T]>>, Box<[T]>>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, Vec<T>>, Vec<T>>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, &'b [T]>, &'b [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, &'b [T]>, &'b [T]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Luv<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Luv<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Okhsl<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Okhsl<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Okhsv<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Okhsv<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Okhwb<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Okhwb<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Oklab<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Oklab<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<&'b [T]>, &'b [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<&'b [T]>, &'b [T]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Oklch<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Oklch<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<Vec<T>>, Vec<T>>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, &'b [T]>, &'b [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, &'b [T]>, &'b [T]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, &'b mut [T]>, &'b mut [T]>
source§impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Rgb<S, [T; N]>, [T; N]>
impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Rgb<S, [T; N]>, [T; N]>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, Box<[T]>>, Box<[T]>>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, Vec<T>>, Vec<T>>
impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, &'b [T]>, &'b [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, &'b [T]>, &'b [T]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Xyz<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Xyz<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, Vec<T>>, Vec<T>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, &'b [T]>, &'b [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, &'b [T]>, &'b [T]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, &'b mut [T]>, &'b mut [T]>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, &'b mut [T]>, &'b mut [T]>
source§impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Yxy<Wp, [T; N]>, [T; N]>
impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Yxy<Wp, [T; N]>, [T; N]>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, Box<[T]>>, Box<[T]>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, Vec<T>>, Vec<T>>
impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, 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§type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>
type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>
source§type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
source§fn into_iter(
self,
) -> <&'a mut Alpha<Cam16UcsJab<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJab<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter
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§type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>
type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>
source§type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
source§fn into_iter(
self,
) -> <&'a mut Alpha<Cam16UcsJab<[T; N]>, [T; N]> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJab<[T; N]>, [T; N]> as IntoIterator>::IntoIter
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§type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>
type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>
source§type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
source§fn into_iter(
self,
) -> <&'a mut Alpha<Cam16UcsJab<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJab<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter
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§type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>
type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>
source§type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
source§fn into_iter(
self,
) -> <&'a mut Alpha<Cam16UcsJmh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJmh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter
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§type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>
type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>
source§type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
source§fn into_iter(
self,
) -> <&'a mut Alpha<Cam16UcsJmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter
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§type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>
type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>
source§type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
source§fn into_iter(
self,
) -> <&'a mut Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter
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, T> IntoIterator for &'a mut Alpha<Okhsl<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsl<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Okhsl<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Okhsl<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsl<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsl<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsl<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsl<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsv<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsv<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Okhsv<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Okhsv<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsv<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsv<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsv<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsv<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhwb<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhwb<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Okhwb<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Okhwb<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhwb<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhwb<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhwb<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhwb<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklab<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklab<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Oklab<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Oklab<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklab<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklab<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklab<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklab<Vec<T>>, Vec<T>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklch<&'b mut [T]>, &'b mut [T]>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklch<&'b mut [T]>, &'b mut [T]>
source§impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Oklch<[T; N]>, [T; N]>
impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Oklch<[T; N]>, [T; N]>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklch<Box<[T]>>, Box<[T]>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklch<Box<[T]>>, Box<[T]>>
source§impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklch<Vec<T>>, Vec<T>>
impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklch<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 [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Jch<&'a [T]>, &'a [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<T, const N: usize> IntoIterator for Alpha<Cam16Jch<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Cam16Jch<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Jch<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Cam16Jch<Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Cam16Jmh<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Jmh<&'a [T]>, &'a [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<T, const N: usize> IntoIterator for Alpha<Cam16Jmh<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Cam16Jmh<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Jmh<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Cam16Jmh<Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Cam16Jsh<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Jsh<&'a [T]>, &'a [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<T, const N: usize> IntoIterator for Alpha<Cam16Jsh<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Cam16Jsh<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Jsh<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Cam16Jsh<Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Cam16Qch<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Qch<&'a [T]>, &'a [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<T, const N: usize> IntoIterator for Alpha<Cam16Qch<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Cam16Qch<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Qch<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Cam16Qch<Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Cam16Qmh<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Qmh<&'a [T]>, &'a [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<T, const N: usize> IntoIterator for Alpha<Cam16Qmh<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Cam16Qmh<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Qmh<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Cam16Qmh<Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Cam16Qsh<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Cam16Qsh<&'a [T]>, &'a [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<T, const N: usize> IntoIterator for Alpha<Cam16Qsh<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Cam16Qsh<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Cam16Qsh<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Cam16Qsh<Vec<T>>, Vec<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§type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>
type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>
source§type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
source§fn into_iter(
self,
) -> <Alpha<Cam16UcsJab<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <Alpha<Cam16UcsJab<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter
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§type Item = Alpha<Cam16UcsJab<T>, T>
type Item = Alpha<Cam16UcsJab<T>, T>
source§type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>
type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>
source§fn into_iter(
self,
) -> <Alpha<Cam16UcsJab<[T; N]>, [T; N]> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <Alpha<Cam16UcsJab<[T; N]>, [T; N]> as IntoIterator>::IntoIter
source§impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>
source§type Item = Alpha<Cam16UcsJab<T>, T>
type Item = Alpha<Cam16UcsJab<T>, T>
source§type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>
type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>
source§fn into_iter(
self,
) -> <Alpha<Cam16UcsJab<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <Alpha<Cam16UcsJab<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter
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§type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>
type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>
source§type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>
source§fn into_iter(
self,
) -> <Alpha<Cam16UcsJmh<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <Alpha<Cam16UcsJmh<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter
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§type Item = Alpha<Cam16UcsJmh<T>, T>
type Item = Alpha<Cam16UcsJmh<T>, T>
source§type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>
type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>
source§fn into_iter(
self,
) -> <Alpha<Cam16UcsJmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <Alpha<Cam16UcsJmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter
source§impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>
source§type Item = Alpha<Cam16UcsJmh<T>, T>
type Item = Alpha<Cam16UcsJmh<T>, T>
source§type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>
type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>
source§fn into_iter(
self,
) -> <Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter
fn into_iter( self, ) -> <Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter
source§impl<'a, S, T> IntoIterator for Alpha<Hsl<S, &'a [T]>, &'a [T]>
impl<'a, S, T> IntoIterator for Alpha<Hsl<S, &'a [T]>, &'a [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<S, T, const N: usize> IntoIterator for Alpha<Hsl<S, [T; N]>, [T; N]>
impl<S, T, const N: usize> IntoIterator for Alpha<Hsl<S, [T; N]>, [T; N]>
source§impl<'a, S, T> IntoIterator for Alpha<Hsl<S, Vec<T>>, Vec<T>>
impl<'a, S, T> IntoIterator for Alpha<Hsl<S, Vec<T>>, Vec<T>>
source§impl<'a, Wp, T> IntoIterator for Alpha<Hsluv<Wp, &'a [T]>, &'a [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Hsluv<Wp, &'a [T]>, &'a [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<Wp, T, const N: usize> IntoIterator for Alpha<Hsluv<Wp, [T; N]>, [T; N]>
impl<Wp, T, const N: usize> IntoIterator for Alpha<Hsluv<Wp, [T; N]>, [T; N]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Hsluv<Wp, Vec<T>>, Vec<T>>
impl<'a, Wp, T> IntoIterator for Alpha<Hsluv<Wp, Vec<T>>, Vec<T>>
source§impl<'a, S, T> IntoIterator for Alpha<Hsv<S, &'a [T]>, &'a [T]>
impl<'a, S, T> IntoIterator for Alpha<Hsv<S, &'a [T]>, &'a [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<S, T, const N: usize> IntoIterator for Alpha<Hsv<S, [T; N]>, [T; N]>
impl<S, T, const N: usize> IntoIterator for Alpha<Hsv<S, [T; N]>, [T; N]>
source§impl<'a, S, T> IntoIterator for Alpha<Hsv<S, Vec<T>>, Vec<T>>
impl<'a, S, T> IntoIterator for Alpha<Hsv<S, Vec<T>>, Vec<T>>
source§impl<'a, S, T> IntoIterator for Alpha<Hwb<S, &'a [T]>, &'a [T]>
impl<'a, S, T> IntoIterator for Alpha<Hwb<S, &'a [T]>, &'a [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<S, T, const N: usize> IntoIterator for Alpha<Hwb<S, [T; N]>, [T; N]>
impl<S, T, const N: usize> IntoIterator for Alpha<Hwb<S, [T; N]>, [T; N]>
source§impl<'a, S, T> IntoIterator for Alpha<Hwb<S, Vec<T>>, Vec<T>>
impl<'a, S, T> IntoIterator for Alpha<Hwb<S, Vec<T>>, Vec<T>>
source§impl<'a, Wp, T> IntoIterator for Alpha<Lab<Wp, &'a [T]>, &'a [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Lab<Wp, &'a [T]>, &'a [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<Wp, T, const N: usize> IntoIterator for Alpha<Lab<Wp, [T; N]>, [T; N]>
impl<Wp, T, const N: usize> IntoIterator for Alpha<Lab<Wp, [T; N]>, [T; N]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Lab<Wp, Vec<T>>, Vec<T>>
impl<'a, Wp, T> IntoIterator for Alpha<Lab<Wp, Vec<T>>, Vec<T>>
source§impl<'a, Wp, T> IntoIterator for Alpha<Lch<Wp, &'a [T]>, &'a [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Lch<Wp, &'a [T]>, &'a [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<Wp, T, const N: usize> IntoIterator for Alpha<Lch<Wp, [T; N]>, [T; N]>
impl<Wp, T, const N: usize> IntoIterator for Alpha<Lch<Wp, [T; N]>, [T; N]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Lch<Wp, Vec<T>>, Vec<T>>
impl<'a, Wp, T> IntoIterator for Alpha<Lch<Wp, Vec<T>>, Vec<T>>
source§impl<'a, Wp, T> IntoIterator for Alpha<Lchuv<Wp, &'a [T]>, &'a [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Lchuv<Wp, &'a [T]>, &'a [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<Wp, T, const N: usize> IntoIterator for Alpha<Lchuv<Wp, [T; N]>, [T; N]>
impl<Wp, T, const N: usize> IntoIterator for Alpha<Lchuv<Wp, [T; N]>, [T; N]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Lchuv<Wp, Vec<T>>, Vec<T>>
impl<'a, Wp, T> IntoIterator for Alpha<Lchuv<Wp, Vec<T>>, Vec<T>>
source§impl<'a, S, T> IntoIterator for Alpha<Luma<S, &'a [T]>, &'a [T]>
impl<'a, S, T> IntoIterator for Alpha<Luma<S, &'a [T]>, &'a [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<S, T, const N: usize> IntoIterator for Alpha<Luma<S, [T; N]>, [T; N]>
impl<S, T, const N: usize> IntoIterator for Alpha<Luma<S, [T; N]>, [T; N]>
source§impl<'a, S, T> IntoIterator for Alpha<Luma<S, Vec<T>>, Vec<T>>
impl<'a, S, T> IntoIterator for Alpha<Luma<S, Vec<T>>, Vec<T>>
source§impl<'a, Wp, T> IntoIterator for Alpha<Luv<Wp, &'a [T]>, &'a [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Luv<Wp, &'a [T]>, &'a [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<Wp, T, const N: usize> IntoIterator for Alpha<Luv<Wp, [T; N]>, [T; N]>
impl<Wp, T, const N: usize> IntoIterator for Alpha<Luv<Wp, [T; N]>, [T; N]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Luv<Wp, Vec<T>>, Vec<T>>
impl<'a, Wp, T> IntoIterator for Alpha<Luv<Wp, Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Okhsl<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Okhsl<&'a [T]>, &'a [T]>
source§impl<'a, T> IntoIterator for Alpha<Okhsl<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Okhsl<&'a mut [T]>, &'a mut [T]>
source§impl<T, const N: usize> IntoIterator for Alpha<Okhsl<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Okhsl<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Okhsl<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Okhsl<Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Okhsv<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Okhsv<&'a [T]>, &'a [T]>
source§impl<'a, T> IntoIterator for Alpha<Okhsv<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Okhsv<&'a mut [T]>, &'a mut [T]>
source§impl<T, const N: usize> IntoIterator for Alpha<Okhsv<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Okhsv<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Okhsv<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Okhsv<Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Okhwb<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Okhwb<&'a [T]>, &'a [T]>
source§impl<'a, T> IntoIterator for Alpha<Okhwb<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Okhwb<&'a mut [T]>, &'a mut [T]>
source§impl<T, const N: usize> IntoIterator for Alpha<Okhwb<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Okhwb<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Okhwb<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Okhwb<Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Oklab<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Oklab<&'a [T]>, &'a [T]>
source§impl<'a, T> IntoIterator for Alpha<Oklab<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Oklab<&'a mut [T]>, &'a mut [T]>
source§impl<T, const N: usize> IntoIterator for Alpha<Oklab<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Oklab<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Oklab<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Oklab<Vec<T>>, Vec<T>>
source§impl<'a, T> IntoIterator for Alpha<Oklch<&'a [T]>, &'a [T]>
impl<'a, T> IntoIterator for Alpha<Oklch<&'a [T]>, &'a [T]>
source§impl<'a, T> IntoIterator for Alpha<Oklch<&'a mut [T]>, &'a mut [T]>
impl<'a, T> IntoIterator for Alpha<Oklch<&'a mut [T]>, &'a mut [T]>
source§impl<T, const N: usize> IntoIterator for Alpha<Oklch<[T; N]>, [T; N]>
impl<T, const N: usize> IntoIterator for Alpha<Oklch<[T; N]>, [T; N]>
source§impl<'a, T> IntoIterator for Alpha<Oklch<Vec<T>>, Vec<T>>
impl<'a, T> IntoIterator for Alpha<Oklch<Vec<T>>, Vec<T>>
source§impl<'a, S, T> IntoIterator for Alpha<Rgb<S, &'a [T]>, &'a [T]>
impl<'a, S, T> IntoIterator for Alpha<Rgb<S, &'a [T]>, &'a [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<S, T, const N: usize> IntoIterator for Alpha<Rgb<S, [T; N]>, [T; N]>
impl<S, T, const N: usize> IntoIterator for Alpha<Rgb<S, [T; N]>, [T; N]>
source§impl<'a, S, T> IntoIterator for Alpha<Rgb<S, Vec<T>>, Vec<T>>
impl<'a, S, T> IntoIterator for Alpha<Rgb<S, Vec<T>>, Vec<T>>
source§impl<'a, Wp, T> IntoIterator for Alpha<Xyz<Wp, &'a [T]>, &'a [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Xyz<Wp, &'a [T]>, &'a [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<Wp, T, const N: usize> IntoIterator for Alpha<Xyz<Wp, [T; N]>, [T; N]>
impl<Wp, T, const N: usize> IntoIterator for Alpha<Xyz<Wp, [T; N]>, [T; N]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Xyz<Wp, Vec<T>>, Vec<T>>
impl<'a, Wp, T> IntoIterator for Alpha<Xyz<Wp, Vec<T>>, Vec<T>>
source§impl<'a, Wp, T> IntoIterator for Alpha<Yxy<Wp, &'a [T]>, &'a [T]>
impl<'a, Wp, T> IntoIterator for Alpha<Yxy<Wp, &'a [T]>, &'a [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<Wp, T, const N: usize> IntoIterator for Alpha<Yxy<Wp, [T; N]>, [T; N]>
impl<Wp, T, const N: usize> IntoIterator for Alpha<Yxy<Wp, [T; N]>, [T; N]>
source§impl<'a, Wp, T> IntoIterator for Alpha<Yxy<Wp, Vec<T>>, Vec<T>>
impl<'a, Wp, T> IntoIterator for Alpha<Yxy<Wp, Vec<T>>, Vec<T>>
source§impl<C, T> IsWithinBounds for Alpha<C, T>where
C: IsWithinBounds,
T: Stimulus + PartialCmp<Mask = <C as HasBoolMask>::Mask> + IsWithinBounds,
<C as HasBoolMask>::Mask: BitAnd<Output = <C as HasBoolMask>::Mask>,
impl<C, T> IsWithinBounds for Alpha<C, T>where
C: IsWithinBounds,
T: Stimulus + PartialCmp<Mask = <C as HasBoolMask>::Mask> + IsWithinBounds,
<C as HasBoolMask>::Mask: BitAnd<Output = <C as HasBoolMask>::Mask>,
source§fn is_within_bounds(&self) -> <C as HasBoolMask>::Mask
fn is_within_bounds(&self) -> <C as HasBoolMask>::Mask
source§impl<C> Lighten for Alpha<C, <C as Lighten>::Scalar>where
C: Lighten,
impl<C> Lighten for Alpha<C, <C as Lighten>::Scalar>where
C: Lighten,
source§impl<C> LightenAssign for Alpha<C, <C as LightenAssign>::Scalar>where
C: LightenAssign,
impl<C> LightenAssign for Alpha<C, <C as LightenAssign>::Scalar>where
C: LightenAssign,
source§type Scalar = <C as LightenAssign>::Scalar
type Scalar = <C as LightenAssign>::Scalar
source§fn lighten_assign(&mut self, factor: <C as LightenAssign>::Scalar)
fn lighten_assign(&mut self, factor: <C as LightenAssign>::Scalar)
source§fn lighten_fixed_assign(&mut self, amount: <C as LightenAssign>::Scalar)
fn lighten_fixed_assign(&mut self, amount: <C as LightenAssign>::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>where
C: RelativeEq<Epsilon = <T as AbsDiffEq>::Epsilon>,
T: RelativeEq,
<T as AbsDiffEq>::Epsilon: Clone,
impl<C, T> RelativeEq for Alpha<C, T>where
C: RelativeEq<Epsilon = <T as AbsDiffEq>::Epsilon>,
T: RelativeEq,
<T as AbsDiffEq>::Epsilon: Clone,
source§fn default_max_relative() -> <Alpha<C, T> as AbsDiffEq>::Epsilon
fn default_max_relative() -> <Alpha<C, T> as AbsDiffEq>::Epsilon
source§fn relative_eq(
&self,
other: &Alpha<C, T>,
epsilon: <Alpha<C, T> as AbsDiffEq>::Epsilon,
max_relative: <Alpha<C, T> as AbsDiffEq>::Epsilon,
) -> bool
fn relative_eq( &self, other: &Alpha<C, T>, epsilon: <Alpha<C, T> as AbsDiffEq>::Epsilon, max_relative: <Alpha<C, T> as AbsDiffEq>::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 for Alpha<C, <C as Saturate>::Scalar>where
C: Saturate,
impl<C> Saturate for Alpha<C, <C as Saturate>::Scalar>where
C: Saturate,
source§impl<C> SaturateAssign for Alpha<C, <C as SaturateAssign>::Scalar>where
C: SaturateAssign,
impl<C> SaturateAssign for Alpha<C, <C as SaturateAssign>::Scalar>where
C: SaturateAssign,
source§type Scalar = <C as SaturateAssign>::Scalar
type Scalar = <C as SaturateAssign>::Scalar
source§fn saturate_assign(&mut self, factor: <C as SaturateAssign>::Scalar)
fn saturate_assign(&mut self, factor: <C as SaturateAssign>::Scalar)
factor
, a value
ranging from 0.0
to 1.0
. Read moresource§fn saturate_fixed_assign(&mut self, amount: <C as SaturateAssign>::Scalar)
fn saturate_fixed_assign(&mut self, amount: <C as SaturateAssign>::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) -> <Alpha<C, T> as SaturatingAdd<T>>::Output
fn saturating_add(self, c: T) -> <Alpha<C, T> as SaturatingAdd<T>>::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>,
) -> <Alpha<C, T> as SaturatingAdd>::Output
fn saturating_add( self, other: Alpha<C, T>, ) -> <Alpha<C, T> as SaturatingAdd>::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) -> <Alpha<C, T> as SaturatingSub<T>>::Output
fn saturating_sub(self, c: T) -> <Alpha<C, T> as SaturatingSub<T>>::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>,
) -> <Alpha<C, T> as SaturatingSub>::Output
fn saturating_sub( self, other: Alpha<C, T>, ) -> <Alpha<C, T> as SaturatingSub>::Output
self
and other
, but saturates instead of overflowing.source§impl<C, T> Serialize for Alpha<C, T>
impl<C, T> Serialize for Alpha<C, T>
source§fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
source§impl<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: <Alpha<C, T> as ShiftHueAssign>::Scalar)
fn shift_hue_assign(&mut self, amount: <Alpha<C, T> as ShiftHueAssign>::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§fn tetradic(
self,
) -> (Alpha<Cam16UcsJab<T>, A>, Alpha<Cam16UcsJab<T>, A>, Alpha<Cam16UcsJab<T>, A>)
fn tetradic( self, ) -> (Alpha<Cam16UcsJab<T>, A>, Alpha<Cam16UcsJab<T>, A>, Alpha<Cam16UcsJab<T>, A>)
source§impl<C, T> UlpsEq for Alpha<C, T>
impl<C, T> UlpsEq for Alpha<C, T>
source§fn default_max_ulps() -> u32
fn default_max_ulps() -> u32
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) -> <Alpha<C, A> as WithAlpha<A>>::WithAlpha
fn with_alpha(self, alpha: A) -> <Alpha<C, A> as WithAlpha<A>>::WithAlpha
Self
already has a transparency, it is
overwritten. Read moreimpl<C, T> 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, Res> Apply<Res> for Twhere
T: ?Sized,
impl<T, Res> Apply<Res> for Twhere
T: ?Sized,
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> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.source§impl<T> DowncastSync for T
impl<T> DowncastSync for T
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
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> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
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> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§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> Pointable for T
impl<T> Pointable for T
source§impl<R, P> ReadPrimitive<R> for P
impl<R, P> ReadPrimitive<R> for P
source§fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
ReadEndian::read_from_little_endian()
.source§impl<T> ToHex for T
impl<T> ToHex for T
source§fn encode_hex<U>(&self) -> Uwhere
U: FromIterator<char>,
fn encode_hex<U>(&self) -> Uwhere
U: FromIterator<char>,
self
into the result. Lower case
letters are used (e.g. f9b4ca
)source§fn encode_hex_upper<U>(&self) -> Uwhere
U: FromIterator<char>,
fn encode_hex_upper<U>(&self) -> Uwhere
U: FromIterator<char>,
self
into the result. Upper case
letters are used (e.g. F9B4CA
)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