Struct cosmic::cosmic_theme::palette::Oklab

#[repr(C)]
pub struct Oklab<T = f32> {
    pub l: T,
    pub a: T,
    pub b: T,
}

The Oklab color space.

Characteristics

Oklab is a perceptual color space. It does not relate to an output device (a monitor or printer) but instead relates to the CIE standard observer – an averaging of the results of color matching experiments under laboratory conditions.

Oklab is a uniform color space (Compare to the HSV color space). It is useful for things like:

• Turning an image grayscale, while keeping the perceived lightness the same
• Increasing the saturation of colors, while maintaining perceived hue and lightness
• Creating smooth and uniform looking transitions between colors

Oklab’s structure is similar to L*a*b*. It is based on the opponent color model of human vision, where red and green form an opponent pair, and blue and yellow form an opponent pair.

Oklab uses D65’s whitepoint – daylight illumination, which is also used by sRGB, rec2020 and Display P3 color spaces – and assumes normal well-lit viewing conditions, to which the eye is adapted. Thus Oklabs lightness l technically is a measure of relative brightness – a subjective measure – not relative luminance. The lightness is scale/exposure-independend, i.e. independent of the actual luminance of the color, as displayed by some medium, and even for blindingly bright colors or very bright or dark viewing conditions assumes, that the eye is adapted to the color’s luminance and the hue and chroma are perceived linearly.

Oklab’s chroma is unlimited. Thus it can represent colors of any color space (including HDR). l is in the range 0.0 .. 1.0 and a and b are unbounded.

Conversions

Oklch is a cylindrical form of Oklab.

Oklab colors converted from valid (i.e. clamped) sRGB will be in the sRGB gamut.

Okhsv, Okhwb and Okhsl reference the sRGB gamut. The transformation from Oklab to one of them is based on the assumption, that the transformed Oklab value is within sRGB.

Okhsv, Okhwb and Okhsl are not applicable to HDR, which also come with color spaces with wider gamuts. They require additional research.

When a Oklab color is converted from Srgb or a equivalent color space, e.g. Hsv, Okhsv, Hsl, Okhsl, Hwb, Okhwb, it’s lightness will be relative to the (user controlled) maximum contrast and luminance of the display device, to which the eye is assumed to be adapted.

Clamping

Clamping will only clamp l. Clamping does not guarantee the color to be inside the perceptible or any display-dependent color space (like sRGB).

To ensure a color is within the sRGB gamut, it can first be converted to Okhsv, clamped there and converted it back to Oklab.

// Display P3 yellow according to https://colorjs.io/apps/convert/?color=color(display-p3%201%201%200)&precision=17
let oklab = Oklab::from_color_unclamped(LinSrgb::new(1.0, 1.0, -0.098273600140966));
let okhsv: Okhsv<f64> = Okhsv::from_color_unclamped(oklab);
assert!(!okhsv.is_within_bounds());
let clamped_okhsv = okhsv.clamp();
assert!(clamped_okhsv.is_within_bounds());
let linsrgb = LinSrgb::from_color_unclamped(clamped_okhsv);
let  expected = LinSrgb::new(1.0, 0.9876530763223166, 0.0);
assert_abs_diff_eq!(expected, linsrgb, epsilon = 0.02);

Since the conversion contains a gamut mapping, it will map the color to one of the perceptually closest locations in the sRGB gamut. Gamut mapping – unlike clamping – is an expensive operation. To get computationally cheaper (and perceptually much worse) results, convert directly to Srgb and clamp there.

Lightening / Darkening

Lightening and Darkening will change l, as expected. However, either operation may leave an implicit color space (the percetible or a display dependent color space like sRGB).

To ensure a color is within the sRGB gamut, first convert it to Okhsl, lighten/darken it there and convert it back to Oklab.

Fields

l: T

l is the lightness of the color. 0 gives absolute black and 1 gives the full white point luminance of the display medium.

D65 (normalized with Y=1, i.e. white according to the adaption of the eye) transforms to L=1,a=0,b=0. However intermediate values differ from those of CIELab non-linearly.

a: T

a changes the hue from reddish to greenish, when moving from positive to negative values and becomes more intense with larger absolute values.

The exact orientation is determined by b

b: T

b changes the hue from yellowish to blueish, when moving from positive to negative values and becomes more intense with larger absolute values.

Positive b is oriented to the same yellow color as CAM16

Implementations

impl<T> Oklab<T>

pub const fn new(l: T, a: T, b: T) -> Oklab<T>

Create an Oklab color.

pub fn into_components(self) -> (T, T, T)

Convert to a (L, a, b) tuple.

pub fn from_components(_: (T, T, T)) -> Oklab<T>

Convert from a (L, a, b) tuple.

impl<T> Oklab<T>

where T: Zero + One,

pub fn min_l() -> T

Return the l value minimum.

pub fn max_l() -> T

Return the l value maximum.

impl<T> Oklab<&T>

pub fn copied(&self) -> Oklab<T>

where T: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Oklab<T>

where T: Clone,

Get an owned, cloned version of this color.

impl<T> Oklab<&mut T>

pub fn set(&mut self, value: Oklab<T>)

Update this color with new values.

pub fn as_refs(&self) -> Oklab<&T>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Oklab<T>

where T: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Oklab<T>

where T: Clone,

Get an owned, cloned version of this color.

impl<C> Oklab<C>

pub fn iter<'a>(&'a self) -> <&'a Oklab<C> as IntoIterator>::IntoIter

where &'a Oklab<C>: IntoIterator,

Return an iterator over the colors in the wrapped collections.

pub fn iter_mut<'a>( &'a mut self, ) -> <&'a mut Oklab<C> as IntoIterator>::IntoIter

where &'a mut Oklab<C>: IntoIterator,

Return an iterator that allows modifying the colors in the wrapped collections.

pub fn get<'a, I, T>( &'a self, index: I, ) -> Option<Oklab<&'a <I as SliceIndex<[T]>>::Output>>

where T: 'a, C: AsRef<[T]>, I: SliceIndex<[T]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T>( &'a mut self, index: I, ) -> Option<Oklab<&'a mut <I as SliceIndex<[T]>>::Output>>

where T: 'a, C: AsMut<[T]>, I: SliceIndex<[T]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T> Oklab<Vec<T>>

pub fn with_capacity(capacity: usize) -> Oklab<Vec<T>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Oklab<T>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Oklab<T>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Drain<'_, T>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

Trait Implementations

impl<T> AbsDiffEq for Oklab<T>

where T: AbsDiffEq, <T as AbsDiffEq>::Epsilon: Clone,

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> <Oklab<T> as AbsDiffEq>::Epsilon

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

fn abs_diff_eq( &self, other: &Oklab<T>, epsilon: <T as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne( &self, other: &Oklab<T>, epsilon: <T as AbsDiffEq>::Epsilon, ) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T> Add<T> for Oklab<T>

where T: Add<Output = T> + Clone,

type Output = Oklab<T>

The resulting type after applying the + operator.

fn add(self, c: T) -> <Oklab<T> as Add<T>>::Output

Performs the + operation.

impl<T> Add for Oklab<T>

where T: Add<Output = T>,

type Output = Oklab<T>

The resulting type after applying the + operator.

fn add(self, other: Oklab<T>) -> <Oklab<T> as Add>::Output

Performs the + operation.

impl<T> AddAssign<T> for Oklab<T>

where T: AddAssign + Clone,

fn add_assign(&mut self, c: T)

Performs the += operation.

impl<T> AddAssign for Oklab<T>

where T: AddAssign,

fn add_assign(&mut self, other: Oklab<T>)

Performs the += operation.

impl<T> ArrayCast for Oklab<T>

type Array = [T; 3]

The output type of a cast to an array.

impl<T> AsMut<[T]> for Oklab<T>

fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsMut<[T; 3]> for Oklab<T>

fn as_mut(&mut self) -> &mut [T; 3]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<[T]> for Oklab<T>

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> AsRef<[T; 3]> for Oklab<T>

fn as_ref(&self) -> &[T; 3]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Clamp for Oklab<T>

where T: Clamp + Zero + One,

fn clamp(self) -> Oklab<T>

Return a new color where out-of-bounds components have been changed to the nearest valid values.

impl<T> ClampAssign for Oklab<T>

where T: ClampAssign + Zero + One,

fn clamp_assign(&mut self)

Changes out-of-bounds components to the nearest valid values.

impl<T> Clone for Oklab<T>

where T: Clone,

fn clone(&self) -> Oklab<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Complementary for Oklab<T>

where T: Neg<Output = T>,

fn complementary(self) -> Oklab<T>

Return the complementary color of self.

impl<T> Debug for Oklab<T>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for Oklab<T>

where T: Zero,

fn default() -> Oklab<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Oklab<T>

where T: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Oklab<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Div<T> for Oklab<T>

where T: Div<Output = T> + Clone,

type Output = Oklab<T>

The resulting type after applying the / operator.

fn div(self, c: T) -> <Oklab<T> as Div<T>>::Output

Performs the / operation.

impl<T> Div for Oklab<T>

where T: Div<Output = T>,

type Output = Oklab<T>

The resulting type after applying the / operator.

fn div(self, other: Oklab<T>) -> <Oklab<T> as Div>::Output

Performs the / operation.

impl<T> DivAssign<T> for Oklab<T>

where T: DivAssign + Clone,

fn div_assign(&mut self, c: T)

Performs the /= operation.

impl<T> DivAssign for Oklab<T>

where T: DivAssign,

fn div_assign(&mut self, other: Oklab<T>)

Performs the /= operation.

impl<T> EuclideanDistance for Oklab<T>

where T: Add<Output = T> + Real + Mul<Output = T> + Sub<Output = T> + Clone,

type Scalar = T

The type for the distance value.

fn distance_squared( self, other: Oklab<T>, ) -> <Oklab<T> as EuclideanDistance>::Scalar

Calculate the squared Euclidean distance from self to other.

impl<T, C> Extend<Oklab<T>> for Oklab<C>

where C: Extend<T>,

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = Oklab<T>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, T> From<&'a [T; 3]> for &'a Oklab<T>

fn from(array: &'a [T; 3]) -> &'a Oklab<T>

Converts to this type from the input type.

impl<'a, T> From<&'a Oklab<T>> for &'a [T]

fn from(color: &'a Oklab<T>) -> &'a [T]

Converts to this type from the input type.

impl<'a, T> From<&'a mut [T; 3]> for &'a mut Oklab<T>

fn from(array: &'a mut [T; 3]) -> &'a mut Oklab<T>

Converts to this type from the input type.

impl<'a, T> From<&'a mut Oklab<T>> for &'a mut [T]

fn from(color: &'a mut Oklab<T>) -> &'a mut [T]

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Oklab<T>; N]> for Oklab<V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Oklab<T>; N]) -> Oklab<V>

Converts to this type from the input type.

impl<T> From<[T; 3]> for Oklab<T>

fn from(array: [T; 3]) -> Oklab<T>

Converts to this type from the input type.

impl<T> From<(T, T, T)> for Oklab<T>

fn from(components: (T, T, T)) -> Oklab<T>

Converts to this type from the input type.

impl<T> From<Box<[T; 3]>> for Box<Oklab<T>>

fn from(array: Box<[T; 3]>) -> Box<Oklab<T>>

Converts to this type from the input type.

impl<T> From<PreAlpha<Oklab<T>>> for Oklab<T>

where Oklab<T>: Premultiply<Scalar = T>,

fn from(premultiplied: PreAlpha<Oklab<T>>) -> Oklab<T>

Converts to this type from the input type.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklab<T>

where _C: IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _S> FromColorUnclamped<Hsl<_S, T>> for Oklab<T>

where _S: RgbStandard, <_S as RgbStandard>::Space: RgbSpace<WhitePoint = D65>, D65: WhitePoint<T>, Rgb<_S, T>: FromColorUnclamped<Hsl<_S, T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Hsl<_S, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Hsluv<D65, T>> for Oklab<T>

where D65: WhitePoint<T>, Xyz<D65, T>: FromColorUnclamped<Hsluv<D65, T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Hsluv<D65, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _S> FromColorUnclamped<Hsv<_S, T>> for Oklab<T>

where _S: RgbStandard, <_S as RgbStandard>::Space: RgbSpace<WhitePoint = D65>, D65: WhitePoint<T>, Rgb<_S, T>: FromColorUnclamped<Hsv<_S, T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Hsv<_S, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _S> FromColorUnclamped<Hwb<_S, T>> for Oklab<T>

where _S: RgbStandard, <_S as RgbStandard>::Space: RgbSpace<WhitePoint = D65>, D65: WhitePoint<T>, Rgb<_S, T>: FromColorUnclamped<Hwb<_S, T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Hwb<_S, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Lab<D65, T>> for Oklab<T>

where D65: WhitePoint<T>, Xyz<D65, T>: FromColorUnclamped<Lab<D65, T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Lab<D65, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Lch<D65, T>> for Oklab<T>

where D65: WhitePoint<T>, Xyz<D65, T>: FromColorUnclamped<Lch<D65, T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Lch<D65, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Lchuv<D65, T>> for Oklab<T>

where D65: WhitePoint<T>, Xyz<D65, T>: FromColorUnclamped<Lchuv<D65, T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Lchuv<D65, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _S> FromColorUnclamped<Luma<_S, T>> for Oklab<T>

where _S: LumaStandard<WhitePoint = D65>, D65: WhitePoint<T>, Xyz<D65, T>: FromColorUnclamped<Luma<_S, T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Luma<_S, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Luv<D65, T>> for Oklab<T>

where D65: WhitePoint<T>, Xyz<D65, T>: FromColorUnclamped<Luv<D65, T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Luv<D65, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Okhsl<T>> for Oklab<T>

where T: RealAngle + One + Zero + Arithmetics + Sqrt + MinMax + PartialOrd + HasBoolMask<Mask = bool> + Powi + Cbrt + Trigonometry + Clone, Oklab<T>: IntoColorUnclamped<Rgb<Linear<Srgb>, T>>,

See

See okhsl_to_srgb

fn from_color_unclamped(hsl: Okhsl<T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Okhsv<T>> for Oklab<T>

where T: RealAngle + PartialOrd + HasBoolMask<Mask = bool> + MinMax + Powi + Arithmetics + Clone + One + Zero + Cbrt + Trigonometry, Oklab<T>: IntoColorUnclamped<Rgb<Linear<Srgb>, T>>,

fn from_color_unclamped(hsv: Okhsv<T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Okhwb<T>> for Oklab<T>

where Okhsv<T>: FromColorUnclamped<Okhwb<T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Okhwb<T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T> FromColorUnclamped<Oklab<T>> for Hsl<S, T>

where Rgb<S, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Hsl<S, T>>,

fn from_color_unclamped(color: Oklab<T>) -> Hsl<S, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T> FromColorUnclamped<Oklab<T>> for Hsluv<Wp, T>

where Wp: WhitePoint<T>, Lchuv<Wp, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Hsluv<Wp, T>>,

fn from_color_unclamped(color: Oklab<T>) -> Hsluv<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T> FromColorUnclamped<Oklab<T>> for Hsv<S, T>

where Rgb<S, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Hsv<S, T>>,

fn from_color_unclamped(color: Oklab<T>) -> Hsv<S, T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T> FromColorUnclamped<Oklab<T>> for Hwb<S, T>

where Hsv<S, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Hwb<S, T>>,

fn from_color_unclamped(color: Oklab<T>) -> Hwb<S, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T> FromColorUnclamped<Oklab<T>> for Lab<Wp, T>

where Wp: WhitePoint<T>, Xyz<Wp, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Lab<Wp, T>>,

fn from_color_unclamped(color: Oklab<T>) -> Lab<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T> FromColorUnclamped<Oklab<T>> for Lch<Wp, T>

where Wp: WhitePoint<T>, Lab<Wp, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Lch<Wp, T>>,

fn from_color_unclamped(color: Oklab<T>) -> Lch<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T> FromColorUnclamped<Oklab<T>> for Lchuv<Wp, T>

where Wp: WhitePoint<T>, Luv<Wp, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Lchuv<Wp, T>>,

fn from_color_unclamped(color: Oklab<T>) -> Lchuv<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T> FromColorUnclamped<Oklab<T>> for Luma<S, T>

where S: LumaStandard, Xyz<<S as LumaStandard>::WhitePoint, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Luma<S, T>>,

fn from_color_unclamped(color: Oklab<T>) -> Luma<S, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T> FromColorUnclamped<Oklab<T>> for Luv<Wp, T>

where Wp: WhitePoint<T>, Xyz<Wp, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Luv<Wp, T>>,

fn from_color_unclamped(color: Oklab<T>) -> Luv<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Oklab<T>> for Okhsl<T>

where T: Zero + Arithmetics + Powi + Sqrt + Hypot + MinMax + Cbrt + IsValidDivisor<Mask = bool, Mask = bool> + HasBoolMask + Real + PartialOrd + Clone + One, Oklab<T>: GetHue<Hue = OklabHue<T>> + IntoColorUnclamped<Rgb<Linear<Srgb>, T>>,

See

See srgb_to_okhsl

fn from_color_unclamped(lab: Oklab<T>) -> Okhsl<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Oklab<T>> for Okhsv<T>

where T: Clone + Powi + Sqrt + Cbrt + Arithmetics + Trigonometry + Zero + Hypot + One + IsValidDivisor<Mask = bool, Mask = bool> + HasBoolMask + Real + PartialOrd + MinMax, Oklab<T>: GetHue<Hue = OklabHue<T>> + IntoColorUnclamped<Rgb<Linear<Srgb>, T>>,

Converts lab to Okhsv in the bounds of sRGB.

See

See srgb_to_okhsv. This implementation differs from srgb_to_okhsv in that it starts with the lab value and produces hues in degrees, whereas srgb_to_okhsv produces degree/360.

fn from_color_unclamped(lab: Oklab<T>) -> Okhsv<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Oklab<T>> for Okhwb<T>

where Okhsv<T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Okhwb<T>>,

fn from_color_unclamped(color: Oklab<T>) -> Okhwb<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Oklab<T>> for Oklab<T>

fn from_color_unclamped(color: Oklab<T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Oklab<T>> for Oklch<T>

where T: Hypot + Clone, Oklab<T>: GetHue<Hue = OklabHue<T>>,

fn from_color_unclamped(color: Oklab<T>) -> Oklch<T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T> FromColorUnclamped<Oklab<T>> for Rgb<S, T>

where T: Real + Arithmetics + Copy, S: RgbStandard, <S as RgbStandard>::TransferFn: FromLinear<T, T>, <S as RgbStandard>::Space: RgbSpace<WhitePoint = D65> + 'static, Rgb<Linear<Srgb>, T>: IntoColorUnclamped<Rgb<S, T>>, Xyz<D65, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Rgb<S, T>>,

fn from_color_unclamped(oklab: Oklab<T>) -> Rgb<S, T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Oklab<T>> for Xyz<D65, T>

where T: Real + Powi + Arithmetics,

fn from_color_unclamped(color: Oklab<T>) -> Xyz<D65, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T> FromColorUnclamped<Oklab<T>> for Yxy<Wp, T>

where Wp: WhitePoint<T>, Xyz<Wp, T>: FromColorUnclamped<Oklab<T>> + IntoColorUnclamped<Yxy<Wp, T>>,

fn from_color_unclamped(color: Oklab<T>) -> Yxy<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Oklch<T>> for Oklab<T>

where T: RealAngle + Zero + MinMax + Trigonometry + Mul<Output = T> + Clone,

fn from_color_unclamped(color: Oklch<T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T> FromColorUnclamped<Rgb<S, T>> for Oklab<T>

where T: Real + Cbrt + Arithmetics + Copy, S: RgbStandard, <S as RgbStandard>::TransferFn: IntoLinear<T, T>, <S as RgbStandard>::Space: RgbSpace<WhitePoint = D65> + 'static, Xyz<D65, T>: FromColorUnclamped<Rgb<S, T>>,

fn from_color_unclamped(rgb: Rgb<S, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Xyz<D65, T>> for Oklab<T>

where T: Real + Cbrt + Arithmetics,

fn from_color_unclamped(color: Xyz<D65, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T> FromColorUnclamped<Yxy<D65, T>> for Oklab<T>

where D65: WhitePoint<T>, Xyz<D65, T>: FromColorUnclamped<Yxy<D65, T>> + IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Yxy<D65, T>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, C> FromIterator<Oklab<T>> for Oklab<C>

where Oklab<C>: Extend<Oklab<T>>, C: Default,

fn from_iter<I>(iter: I) -> Oklab<C>

where I: IntoIterator<Item = Oklab<T>>,

Creates a value from an iterator.

impl<T> GetHue for Oklab<T>

where T: Trigonometry + Add<Output = T> + Neg<Output = T> + RealAngle + Clone,

type Hue = OklabHue<T>

The kind of hue unit this color space uses.

fn get_hue(&self) -> OklabHue<T>

Calculate a hue if possible.

impl<T> HasBoolMask for Oklab<T>

where T: HasBoolMask,

type Mask = <T as HasBoolMask>::Mask

The mask type to use for selecting Self values.

impl<T> HyAb for Oklab<T>

where T: Sqrt + Sub<Output = T> + Add<Output = T> + Real + Mul<Output = T> + Abs + Clone,

type Scalar = T

The type for the distance value.

fn hybrid_distance(self, other: Oklab<T>) -> <Oklab<T> as HyAb>::Scalar

Calculate the hybrid distance between self and other.

impl<'a, 'b, T> IntoIterator for &'a Oklab<&'b [T]>

type Item = Oklab<&'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Oklab<&'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Oklab<&'b mut [T]>

type Item = Oklab<&'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Oklab<&'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Oklab<[T; N]>

type Item = Oklab<&'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Oklab<[T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Oklab<Box<[T]>>

type Item = Oklab<&'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Oklab<Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a Oklab<Vec<T>>

type Item = Oklab<&'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Oklab<Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Oklab<&'b mut [T]>

type Item = Oklab<&'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut Oklab<&'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Oklab<[T; N]>

type Item = Oklab<&'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut Oklab<[T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Oklab<Box<[T]>>

where T: 'a,

type Item = Oklab<&'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut Oklab<Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Oklab<Vec<T>>

type Item = Oklab<&'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut Oklab<Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Oklab<&'a [T]>

type Item = Oklab<&'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Oklab<&'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Oklab<&'a mut [T]>

type Item = Oklab<&'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Oklab<&'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Oklab<[T; N]>

type Item = Oklab<T>

The type of the elements being iterated over.

type IntoIter = Iter<IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Oklab<[T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Oklab<Vec<T>>

type Item = Oklab<T>

The type of the elements being iterated over.

type IntoIter = Iter<IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Oklab<Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> IsWithinBounds for Oklab<T>

where T: PartialCmp + Zero + One, <T as HasBoolMask>::Mask: BitAnd<Output = <T as HasBoolMask>::Mask>,

fn is_within_bounds(&self) -> <T as HasBoolMask>::Mask

Check if the color’s components are within the expected range bounds.

impl<T> Lighten for Oklab<T>

where T: Real + Zero + MinMax + Clamp + Arithmetics + PartialCmp + Clone + One, <T as HasBoolMask>::Mask: LazySelect<T>,

type Scalar = T

The type of the lighten modifier.

fn lighten(self, factor: T) -> Oklab<T>

Scale the color towards the maximum lightness by factor, a value ranging from 0.0 to 1.0.

fn lighten_fixed(self, amount: T) -> Oklab<T>

Lighten the color by amount, a value ranging from 0.0 to 1.0.

impl<T> LightenAssign for Oklab<T>

where T: Real + Zero + MinMax + ClampAssign + AddAssign + Arithmetics + PartialCmp + Clone + One, <T as HasBoolMask>::Mask: LazySelect<T>,

type Scalar = T

The type of the lighten modifier.

fn lighten_assign(&mut self, factor: T)

Scale the color towards the maximum lightness by factor, a value ranging from 0.0 to 1.0.

fn lighten_fixed_assign(&mut self, amount: T)

Lighten the color by amount, a value ranging from 0.0 to 1.0.

impl<T> Mix for Oklab<T>

where T: Real + Zero + One + Arithmetics + Clamp + Clone,

type Scalar = T

The type of the mixing factor.

fn mix(self, other: Oklab<T>, factor: T) -> Oklab<T>

Mix the color with an other color, by factor.

impl<T> MixAssign for Oklab<T>

where T: Real + Zero + One + AddAssign + Arithmetics + Clamp + Clone,

type Scalar = T

The type of the mixing factor.

fn mix_assign(&mut self, other: Oklab<T>, factor: T)

Mix the color with an other color, by factor.

impl<T> Mul<T> for Oklab<T>

where T: Mul<Output = T> + Clone,

type Output = Oklab<T>

The resulting type after applying the * operator.

fn mul(self, c: T) -> <Oklab<T> as Mul<T>>::Output

Performs the * operation.

impl<T> Mul for Oklab<T>

where T: Mul<Output = T>,

type Output = Oklab<T>

The resulting type after applying the * operator.

fn mul(self, other: Oklab<T>) -> <Oklab<T> as Mul>::Output

Performs the * operation.

impl<T> MulAssign<T> for Oklab<T>

where T: MulAssign + Clone,

fn mul_assign(&mut self, c: T)

Performs the *= operation.

impl<T> MulAssign for Oklab<T>

where T: MulAssign,

fn mul_assign(&mut self, other: Oklab<T>)

Performs the *= operation.

impl<T> PartialEq for Oklab<T>

where T: PartialEq,

fn eq(&self, other: &Oklab<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Premultiply for Oklab<T>

where T: Stimulus + Zero + IsValidDivisor + Mul<Output = T> + Div<Output = T> + Real + Clone, <T as HasBoolMask>::Mask: LazySelect<T> + Clone,

type Scalar = T

The color’s component type.

fn premultiply(self, alpha: T) -> PreAlpha<Oklab<T>>

Alpha mask the color.

fn unpremultiply(premultiplied: PreAlpha<Oklab<T>>) -> (Oklab<T>, T)

Alpha unmask the color, resulting in a color and transparency pair.

impl<T> RelativeContrast for Oklab<T>

where T: Real + Arithmetics + PartialCmp, <T as HasBoolMask>::Mask: LazySelect<T>, Xyz<D65, T>: FromColor<Oklab<T>>,

type Scalar = T

👎Deprecated since 0.7.2: replaced by palette::color_difference::Wcag21RelativeContrast

The type of the contrast ratio.

fn get_contrast_ratio(self, other: Oklab<T>) -> T

👎Deprecated since 0.7.2: replaced by palette::color_difference::Wcag21RelativeContrast

Calculate the contrast ratio between two colors.

fn has_min_contrast_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask

👎Deprecated since 0.7.2: replaced by palette::color_difference::Wcag21RelativeContrast

Verify the contrast between two colors satisfies SC 1.4.3. Contrast is at least 4.5:1 (Level AA).

fn has_min_contrast_large_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask

👎Deprecated since 0.7.2: replaced by palette::color_difference::Wcag21RelativeContrast

Verify the contrast between two colors satisfies SC 1.4.3 for large text. Contrast is at least 3:1 (Level AA).

fn has_enhanced_contrast_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask

👎Deprecated since 0.7.2: replaced by palette::color_difference::Wcag21RelativeContrast

Verify the contrast between two colors satisfies SC 1.4.6. Contrast is at least 7:1 (Level AAA).

fn has_enhanced_contrast_large_text( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask

👎Deprecated since 0.7.2: replaced by palette::color_difference::Wcag21RelativeContrast

Verify the contrast between two colors satisfies SC 1.4.6 for large text. Contrast is at least 4.5:1 (Level AAA).

fn has_min_contrast_graphics( self, other: Self, ) -> <Self::Scalar as HasBoolMask>::Mask

👎Deprecated since 0.7.2: replaced by palette::color_difference::Wcag21RelativeContrast

Verify the contrast between two colors satisfies SC 1.4.11 for graphical objects. Contrast is at least 3:1 (Level AA).

impl<T> RelativeEq for Oklab<T>

where T: RelativeEq, <T as AbsDiffEq>::Epsilon: Clone,

fn default_max_relative() -> <T as AbsDiffEq>::Epsilon

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

fn relative_eq( &self, other: &Oklab<T>, epsilon: <T as AbsDiffEq>::Epsilon, max_relative: <T as AbsDiffEq>::Epsilon, ) -> bool

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

fn relative_ne( &self, other: &Oklab<T>, epsilon: <T as AbsDiffEq>::Epsilon, max_relative: <T as AbsDiffEq>::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl<T> SaturatingAdd<T> for Oklab<T>

where T: SaturatingAdd<Output = T> + Clone,

type Output = Oklab<T>

The resulting type.

fn saturating_add(self, c: T) -> <Oklab<T> as SaturatingAdd<T>>::Output

Returns the sum of self and other, but saturates instead of overflowing.

impl<T> SaturatingAdd for Oklab<T>

where T: SaturatingAdd<Output = T>,

type Output = Oklab<T>

The resulting type.

fn saturating_add(self, other: Oklab<T>) -> <Oklab<T> as SaturatingAdd>::Output

Returns the sum of self and other, but saturates instead of overflowing.

impl<T> SaturatingSub<T> for Oklab<T>

where T: SaturatingSub<Output = T> + Clone,

type Output = Oklab<T>

The resulting type.

fn saturating_sub(self, c: T) -> <Oklab<T> as SaturatingSub<T>>::Output

Returns the difference of self and other, but saturates instead of overflowing.

impl<T> SaturatingSub for Oklab<T>

where T: SaturatingSub<Output = T>,

type Output = Oklab<T>

The resulting type.

fn saturating_sub(self, other: Oklab<T>) -> <Oklab<T> as SaturatingSub>::Output

Returns the difference of self and other, but saturates instead of overflowing.

impl<T> Serialize for Oklab<T>

where T: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Sub<T> for Oklab<T>

where T: Sub<Output = T> + Clone,

type Output = Oklab<T>

The resulting type after applying the - operator.

fn sub(self, c: T) -> <Oklab<T> as Sub<T>>::Output

Performs the - operation.

impl<T> Sub for Oklab<T>

where T: Sub<Output = T>,

type Output = Oklab<T>

The resulting type after applying the - operator.

fn sub(self, other: Oklab<T>) -> <Oklab<T> as Sub>::Output

Performs the - operation.

impl<T> SubAssign<T> for Oklab<T>

where T: SubAssign + Clone,

fn sub_assign(&mut self, c: T)

Performs the -= operation.

impl<T> SubAssign for Oklab<T>

where T: SubAssign,

fn sub_assign(&mut self, other: Oklab<T>)

Performs the -= operation.

impl<T> Tetradic for Oklab<T>

where T: Neg<Output = T> + Clone,

fn tetradic(self) -> (Oklab<T>, Oklab<T>, Oklab<T>)

Return the three additional colors of a tetradic color scheme.

impl<'a, T> TryFrom<&'a [T]> for &'a Oklab<T>

type Error = <&'a [T; 3] as TryFrom<&'a [T]>>::Error

The type returned in the event of a conversion error.

fn try_from( slice: &'a [T], ) -> Result<&'a Oklab<T>, <&'a Oklab<T> as TryFrom<&'a [T]>>::Error>

Performs the conversion.

impl<'a, T> TryFrom<&'a mut [T]> for &'a mut Oklab<T>

type Error = <&'a mut [T; 3] as TryFrom<&'a mut [T]>>::Error

The type returned in the event of a conversion error.

fn try_from( slice: &'a mut [T], ) -> Result<&'a mut Oklab<T>, <&'a mut Oklab<T> as TryFrom<&'a mut [T]>>::Error>

Performs the conversion.

impl<T> UlpsEq for Oklab<T>

where T: UlpsEq, <T as AbsDiffEq>::Epsilon: Clone,

fn default_max_ulps() -> u32

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

fn ulps_eq( &self, other: &Oklab<T>, epsilon: <T as AbsDiffEq>::Epsilon, max_ulps: u32, ) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne( &self, other: &Oklab<T>, epsilon: <T as AbsDiffEq>::Epsilon, max_ulps: u32, ) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T, _A> WithAlpha<_A> for Oklab<T>

where _A: Stimulus,

type Color = Oklab<T>

The opaque color type, without any transparency.

type WithAlpha = Alpha<Oklab<T>, _A>

The color type with transparency applied.

fn with_alpha(self, alpha: _A) -> <Oklab<T> as WithAlpha<_A>>::WithAlpha

Transforms the color into a transparent color with the provided alpha value. If Self already has a transparency, it is overwritten.

fn without_alpha(self) -> <Oklab<T> as WithAlpha<_A>>::Color

Removes the transparency from the color. If Self::Color has an internal transparency field, that field will be set to A::max_intensity() to make it opaque.

fn split(self) -> (<Oklab<T> as WithAlpha<_A>>::Color, _A)

Splits the color into separate color and transparency values.

fn opaque(self) -> Self::WithAlpha

where A: Stimulus,

Transforms the color into a fully opaque color with a transparency field. If Self already has a transparency, it is overwritten.

fn transparent(self) -> Self::WithAlpha

where A: Zero,

Transforms the color into a fully transparent color. If Self already has a transparency, it is overwritten.

impl<T> Copy for Oklab<T>

where T: Copy,

impl<T> Eq for Oklab<T>

where T: Eq,