Struct Lab

source

#[repr(C)]
pub struct Lab<Wp = D65, T = f32> {
    pub l: T,
    pub a: T,
    pub b: T,
    pub white_point: PhantomData<Wp>,
}

Expand description

The CIE L*a*b* (CIELAB) color space.

CIE L*a*b* is a device independent color space which includes all perceivable colors. It’s sometimes used to convert between other color spaces, because of its ability to represent all of their colors, and sometimes in color manipulation, because of its perceptual uniformity. This means that the perceptual difference between two colors is equal to their numerical difference. It was, however, never designed for the perceptual qualities required for gamut mapping. For perceptually uniform color manipulation the newer color spaces based on Oklab are preferable: Oklch, Okhsv, Okhsl, Okhwb (Note that the latter three are tied to the sRGB gamut and reference white).

The parameters of L*a*b* are quite different, compared to many other color spaces, so manipulating them manually may be unintuitive.

Fields§

§l: T

L* is the lightness of the color. 0.0 gives absolute black and 100 give the brightest white.

§a: T

a* goes from red at -128 to green at 127.

§b: T

b* goes from yellow at -128 to blue at 127.

§white_point: PhantomData<Wp>

The white point associated with the color’s illuminant and observer. D65 for 2 degree observer is used by default.

Struct LabCopy item path

Fields§

Implementations§

impl<Wp, T> Lab<Wp, T>

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

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

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

impl<Wp, T> Lab<Wp, T>where T: Zero + Real,

pub fn min_l() -> T

pub fn max_l() -> T

pub fn min_a() -> T

pub fn max_a() -> T

pub fn min_b() -> T

pub fn max_b() -> T

impl<Wp, T> Lab<Wp, &T>

pub fn copied(&self) -> Lab<Wp, T>where T: Copy,

pub fn cloned(&self) -> Lab<Wp, T>where T: Clone,

impl<Wp, T> Lab<Wp, &mut T>

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

pub fn as_refs(&self) -> Lab<Wp, &T>

pub fn copied(&self) -> Lab<Wp, T>where T: Copy,

pub fn cloned(&self) -> Lab<Wp, T>where T: Clone,

impl<Wp, C> Lab<Wp, C>

pub fn iter<'a>(&'a self) -> <&'a Lab<Wp, C> as IntoIterator>::IntoIterwhere &'a Lab<Wp, C>: IntoIterator,

pub fn iter_mut<'a>( &'a mut self, ) -> <&'a mut Lab<Wp, C> as IntoIterator>::IntoIterwhere &'a mut Lab<Wp, C>: IntoIterator,

pub fn get<'a, I, T>( &'a self, index: I, ) -> Option<Lab<Wp, &'a <I as SliceIndex<[T]>>::Output>>where T: 'a, C: AsRef<[T]>, I: SliceIndex<[T]> + Clone,

pub fn get_mut<'a, I, T>( &'a mut self, index: I, ) -> Option<Lab<Wp, &'a mut <I as SliceIndex<[T]>>::Output>>where T: 'a, C: AsMut<[T]>, I: SliceIndex<[T]> + Clone,

impl<Wp, T> Lab<Wp, Vec<T>>

pub fn with_capacity(capacity: usize) -> Lab<Wp, Vec<T>>

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

pub fn pop(&mut self) -> Option<Lab<Wp, T>>

pub fn clear(&mut self)

pub fn drain<R>(&mut self, range: R) -> Iter<Drain<'_, T>, Wp> ⓘwhere R: RangeBounds<usize> + Clone,

Trait Implementations§

impl<Wp, T> AbsDiffEq for Lab<Wp, T>where T: AbsDiffEq, <T as AbsDiffEq>::Epsilon: Clone,

type Epsilon = <T as AbsDiffEq>::Epsilon

fn default_epsilon() -> <Lab<Wp, T> as AbsDiffEq>::Epsilon

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

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

impl<Wp, T> Add<T> for Lab<Wp, T>where T: Add<Output = T> + Clone,

type Output = Lab<Wp, T>

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

impl<Wp, T> Add for Lab<Wp, T>where T: Add<Output = T>,

type Output = Lab<Wp, T>

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

impl<Wp, T> AddAssign<T> for Lab<Wp, T>where T: AddAssign + Clone,

fn add_assign(&mut self, c: T)

impl<Wp, T> AddAssign for Lab<Wp, T>where T: AddAssign,

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

impl<Wp, T> ArrayCast for Lab<Wp, T>

type Array = [T; 3]

impl<Wp, T> AsMut<[T]> for Lab<Wp, T>

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

impl<Wp, T> AsMut<[T; 3]> for Lab<Wp, T>

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

impl<Wp, T> AsRef<[T]> for Lab<Wp, T>

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

impl<Wp, T> AsRef<[T; 3]> for Lab<Wp, T>

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

impl<Wp, T> Ciede2000 for Lab<Wp, T>where T: Real + RealAngle + One + Zero + Powi + Exp + Trigonometry + Abs + Sqrt + Arithmetics + PartialCmp + Hypot + Clone, <T as HasBoolMask>::Mask: LazySelect<T> + BitAnd<Output = <T as HasBoolMask>::Mask> + BitOr<Output = <T as HasBoolMask>::Mask>,

type Scalar = T

fn difference(self, other: Lab<Wp, T>) -> <Lab<Wp, T> as Ciede2000>::Scalar

impl<Wp, T> Clamp for Lab<Wp, T>where T: Clamp + Real + Zero,

fn clamp(self) -> Lab<Wp, T>

impl<Wp, T> ClampAssign for Lab<Wp, T>where T: ClampAssign + Real + Zero,

fn clamp_assign(&mut self)

impl<Wp, T> Clone for Lab<Wp, T>where T: Clone,

fn clone(&self) -> Lab<Wp, T>

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

type Scalar = T

fn get_color_difference( self, other: Lab<Wp, T>, ) -> <Lab<Wp, T> as ColorDifference>::Scalar

impl<Wp, T> Complementary for Lab<Wp, T>where T: Neg<Output = T>,

fn complementary(self) -> Lab<Wp, T>

impl<Wp, T> Debug for Lab<Wp, T>where Wp: Debug, T: Debug,

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

impl<Wp, T> Default for Lab<Wp, T>where T: Zero,

fn default() -> Lab<Wp, T>

impl<Wp, T> DeltaE for Lab<Wp, T>where Lab<Wp, T>: EuclideanDistance<Scalar = T>, T: Sqrt,

type Scalar = T

fn delta_e(self, other: Lab<Wp, T>) -> <Lab<Wp, T> as DeltaE>::Scalar

Struct Lab

impl<Wp, T> Lab<Wp, T>
where T: Zero + Real,

pub fn copied(&self) -> Lab<Wp, T>
where T: Copy,

pub fn cloned(&self) -> Lab<Wp, T>
where T: Clone,

pub fn copied(&self) -> Lab<Wp, T>
where T: Copy,

pub fn cloned(&self) -> Lab<Wp, T>
where T: Clone,

pub fn iter<'a>(&'a self) -> <&'a Lab<Wp, C> as IntoIterator>::IntoIter
where &'a Lab<Wp, C>: IntoIterator,

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

pub fn get<'a, I, T>( &'a self, index: I, ) -> Option<Lab<Wp, &'a <I as SliceIndex<[T]>>::Output>>
where T: 'a, C: AsRef<[T]>, I: SliceIndex<[T]> + Clone,

pub fn get_mut<'a, I, T>( &'a mut self, index: I, ) -> Option<Lab<Wp, &'a mut <I as SliceIndex<[T]>>::Output>>
where T: 'a, C: AsMut<[T]>, I: SliceIndex<[T]> + Clone,

pub fn drain<R>(&mut self, range: R) -> Iter<Drain<'_, T>, Wp> ⓘ
where R: RangeBounds<usize> + Clone,

impl<Wp, T> AbsDiffEq for Lab<Wp, T>
where T: AbsDiffEq, <T as AbsDiffEq>::Epsilon: Clone,

impl<Wp, T> Add<T> for Lab<Wp, T>
where T: Add<Output = T> + Clone,

impl<Wp, T> Add for Lab<Wp, T>
where T: Add<Output = T>,

impl<Wp, T> AddAssign<T> for Lab<Wp, T>
where T: AddAssign + Clone,

impl<Wp, T> AddAssign for Lab<Wp, T>
where T: AddAssign,

impl<Wp, T> Ciede2000 for Lab<Wp, T>
where T: Real + RealAngle + One + Zero + Powi + Exp + Trigonometry + Abs + Sqrt + Arithmetics + PartialCmp + Hypot + Clone, <T as HasBoolMask>::Mask: LazySelect<T> + BitAnd<Output = <T as HasBoolMask>::Mask> + BitOr<Output = <T as HasBoolMask>::Mask>,

impl<Wp, T> Clamp for Lab<Wp, T>
where T: Clamp + Real + Zero,

impl<Wp, T> ClampAssign for Lab<Wp, T>
where T: ClampAssign + Real + Zero,

impl<Wp, T> Clone for Lab<Wp, T>
where T: Clone,

impl<Wp, T> Complementary for Lab<Wp, T>
where T: Neg<Output = T>,

impl<Wp, T> Debug for Lab<Wp, T>
where Wp: Debug, T: Debug,

impl<Wp, T> Default for Lab<Wp, T>
where T: Zero,

impl<Wp, T> DeltaE for Lab<Wp, T>
where Lab<Wp, T>: EuclideanDistance<Scalar = T>, T: Sqrt,

impl<'de, Wp, T> Deserialize<'de> for Lab<Wp, T>
where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<Lab<Wp, T>, <D as Deserializer<'de>>::Error>
where __D: Deserializer<'de>,

impl<Wp, T> Div<T> for Lab<Wp, T>
where T: Div<Output = T> + Clone,

impl<Wp, T> Div for Lab<Wp, T>
where T: Div<Output = T>,

impl<Wp, T> DivAssign<T> for Lab<Wp, T>
where T: DivAssign + Clone,

impl<Wp, T> DivAssign for Lab<Wp, T>
where T: DivAssign,

impl<Wp, T> EuclideanDistance for Lab<Wp, T>
where T: Sub<Output = T> + Add<Output = T> + Mul<Output = T> + Real + Clone,

impl<Wp, T, C> Extend<Lab<Wp, T>> for Lab<Wp, C>
where C: Extend<T>,

fn extend<I>(&mut self, iter: I)
where I: IntoIterator<Item = Lab<Wp, T>>,

impl<Wp, T, V, const N: usize> From<[Lab<Wp, T>; N]> for Lab<Wp, V>
where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

impl<Wp, T> From<PreAlpha<Lab<Wp, T>>> for Lab<Wp, T>
where Lab<Wp, T>: Premultiply<Scalar = T>,

impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lab<Wp, T>
where _C: IntoColorUnclamped<Lab<Wp, T>>,

impl<Wp, T, _S> FromColorUnclamped<Hsl<_S, T>> for Lab<Wp, T>
where _S: RgbStandard, <_S as RgbStandard>::Space: RgbSpace<WhitePoint = Wp>, Wp: WhitePoint<T>, Xyz<Wp, T>: FromColorUnclamped<Hsl<_S, T>> + IntoColorUnclamped<Lab<Wp, T>>,

impl<Wp, T> FromColorUnclamped<Hsluv<Wp, T>> for Lab<Wp, T>
where Wp: WhitePoint<T>, Xyz<Wp, T>: FromColorUnclamped<Hsluv<Wp, T>> + IntoColorUnclamped<Lab<Wp, T>>,

impl<Wp, T, _S> FromColorUnclamped<Hsv<_S, T>> for Lab<Wp, T>
where _S: RgbStandard, <_S as RgbStandard>::Space: RgbSpace<WhitePoint = Wp>, Wp: WhitePoint<T>, Xyz<Wp, T>: FromColorUnclamped<Hsv<_S, T>> + IntoColorUnclamped<Lab<Wp, T>>,

impl<Wp, T, _S> FromColorUnclamped<Hwb<_S, T>> for Lab<Wp, T>
where _S: RgbStandard, <_S as RgbStandard>::Space: RgbSpace<WhitePoint = Wp>, Wp: WhitePoint<T>, Xyz<Wp, T>: FromColorUnclamped<Hwb<_S, T>> + IntoColorUnclamped<Lab<Wp, T>>,

impl<S, T> FromColorUnclamped<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Hsl<S, T>
where S: RgbStandard, Rgb<S, T>: FromColorUnclamped<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Hsl<S, T>>,

impl<S, T> FromColorUnclamped<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Hsv<S, T>
where S: RgbStandard, Rgb<S, T>: FromColorUnclamped<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Hsv<S, T>>,

impl<S, T> FromColorUnclamped<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Hwb<S, T>
where S: RgbStandard, Hsv<S, T>: FromColorUnclamped<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> + IntoColorUnclamped<Hwb<S, T>>,

impl<S, T> FromColorUnclamped<Lab<<S as LumaStandard>::WhitePoint, T>> for Luma<S, T>
where S: LumaStandard, Xyz<<S as LumaStandard>::WhitePoint, T>: FromColorUnclamped<Lab<<S as LumaStandard>::WhitePoint, T>> + IntoColorUnclamped<Luma<S, T>>,

impl<T> FromColorUnclamped<Lab<D65, T>> for Okhsl<T>
where D65: WhitePoint<T>, Oklab<T>: FromColorUnclamped<Lab<D65, T>> + IntoColorUnclamped<Okhsl<T>>,

impl<T> FromColorUnclamped<Lab<D65, T>> for Okhsv<T>
where D65: WhitePoint<T>, Oklab<T>: FromColorUnclamped<Lab<D65, T>> + IntoColorUnclamped<Okhsv<T>>,