Struct cosmic::cosmic_theme::palette::LabHue

#[repr(C)]
pub struct LabHue<T = f32>(/* private fields */);

A hue type for the CIE L*a*b* family of color spaces.

It’s measured in degrees and it’s based on the four physiological elementary colors red, yellow, green and blue. This makes it different from the hue of RGB based color spaces.

The hue is a circular type, where 0 and 360 is the same, and it’s normalized to (-180, 180] when it’s converted to a linear number (like f32). This makes many calculations easier, but may also have some surprising effects if it’s expected to act as a linear number.

Implementations

impl<T> LabHue<T>

pub const fn new(angle: T) -> LabHue<T>

Create a new hue, specified in the default unit for the angle type T.

f32, f64 and other real number types represent degrees, while u8 simply represents the range [0, 360] as [0, 256].

pub fn into_inner(self) -> T

Get the internal representation without normalizing or converting it.

f32, f64 and other real number types represent degrees, while u8 simply represents the range [0, 360] as [0, 256].

pub fn into_format<U>(self) -> LabHue<U>

where U: FromAngle<T>,

Convert into another angle type.

pub fn from_format<U>(hue: LabHue<U>) -> LabHue<T>

where T: FromAngle<U>,

Convert from another angle type.

impl<T> LabHue<T>

where T: RealAngle,

pub fn from_degrees(degrees: T) -> LabHue<T>

Create a new hue from degrees. This is an alias for new.

pub fn from_radians(radians: T) -> LabHue<T>

Create a new hue from radians, instead of degrees.

pub fn into_raw_degrees(self) -> T

Get the internal representation as degrees, without normalizing it.

pub fn into_raw_radians(self) -> T

Get the internal representation as radians, without normalizing it.

impl<T> LabHue<T>

where T: RealAngle + SignedAngle,

pub fn into_degrees(self) -> T

Get the hue as degrees, in the range (-180, 180].

pub fn into_radians(self) -> T

Convert the hue to radians, in the range (-π, π].

impl<T> LabHue<T>

where T: RealAngle + UnsignedAngle,

pub fn into_positive_degrees(self) -> T

Convert the hue to positive degrees, in the range [0, 360).

pub fn into_positive_radians(self) -> T

Convert the hue to positive radians, in the range [0, 2π).

impl<T> LabHue<T>

where T: RealAngle + Trigonometry,

pub fn from_cartesian(a: T, b: T) -> LabHue<T>

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

Returns a hue from a and b, normalized to [0°, 360°).

If a and b are both 0, returns 0,

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

Returns a and b values for this hue, normalized to [-1, 1].

They will have to be multiplied by a radius values, such as saturation, value, chroma, etc., to represent a specific color.

impl<T> LabHue<&T>

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

where T: Copy,

Get an owned, copied version of this hue.

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

where T: Clone,

Get an owned, cloned version of this hue.

impl<T> LabHue<&mut T>

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

Update this hue with a new value.

pub fn as_ref(&self) -> LabHue<&T>

Borrow this hue’s value as shared references.

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

where T: Copy,

Get an owned, copied version of this hue.

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

where T: Clone,

Get an owned, cloned version of this hue.

impl<C> LabHue<C>

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

where &'a LabHue<C>: IntoIterator,

Return an iterator over the hues in the wrapped collection.

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

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

Return an iterator that allows modifying the hues in the wrapped collection.

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

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

Get a hue, or slice of hues, with references to the values at index. See slice::get for details.

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

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

Get a hue, or slice of hues, that allows modifying the values at index. See slice::get_mut for details.

impl<T> LabHue<Vec<T>>

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

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

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

Push an additional hue onto the hue vector. See Vec::push for details.

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

Pop a hue from the hue vector. See Vec::pop for details.

pub fn clear(&mut self)

Clear the hue vector. See Vec::clear for details.

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

where R: RangeBounds<usize> + Clone,

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

Trait Implementations

impl<T> AbsDiffEq for LabHue<T>

where T: Zero + AngleEq<Mask = bool> + Sub<Output = T> + RealAngle + AbsDiffEq + Clone + SignedAngle, <T as AbsDiffEq>::Epsilon: HalfRotation + Mul<Output = <T as AbsDiffEq>::Epsilon>,

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

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

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

fn abs_diff_eq( &self, other: &LabHue<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: &LabHue<T>, epsilon: <T as AbsDiffEq>::Epsilon, ) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T> Add<T> for LabHue<T>

where T: Add<Output = T>,

type Output = LabHue<T>

The resulting type after applying the + operator.

fn add(self, other: T) -> LabHue<T>

Performs the + operation.

impl<T> Add for LabHue<T>

where T: Add<Output = T>,

type Output = LabHue<T>

The resulting type after applying the + operator.

fn add(self, other: LabHue<T>) -> LabHue<T>

Performs the + operation.

impl<T> AddAssign<T> for LabHue<T>

where T: AddAssign,

fn add_assign(&mut self, other: T)

Performs the += operation.

impl<T> AddAssign for LabHue<T>

where T: AddAssign,

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

Performs the += operation.

impl<T> Clone for LabHue<T>

where T: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for LabHue<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for LabHue<T>

where T: Default,

fn default() -> LabHue<T>

Returns the “default value” for a type.

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

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

where C: Extend<T>,

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

where I: IntoIterator<Item = 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<T> From<T> for LabHue<T>

fn from(degrees: T) -> LabHue<T>

Converts to this type from the input type.

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

type Item = LabHue<&'a T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<&'a T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<&'a T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<&'a T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<&'a T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<&'a mut T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<&'a mut T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<&'a mut T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<&'a mut T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<&'a T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<&'a mut T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

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

type Item = LabHue<T>

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl<T> IntoIterator for LabHue<Vec<T>>

type Item = LabHue<T>

The type of the elements being iterated over.

type IntoIter = LabHueIter<IntoIter<T>>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl<T> PartialEq<T> for LabHue<T>

where T: AngleEq<Mask = bool> + PartialEq,

fn eq(&self, other: &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> PartialEq for LabHue<T>

where T: AngleEq<Mask = bool> + PartialEq,

fn eq(&self, other: &LabHue<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> RelativeEq for LabHue<T>

where T: Zero + AngleEq<Mask = bool> + Sub<Output = T> + RealAngle + Clone + RelativeEq + SignedAngle, <T as AbsDiffEq>::Epsilon: HalfRotation + Mul<Output = <T as AbsDiffEq>::Epsilon>,

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

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

fn relative_eq( &self, other: &LabHue<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: &LabHue<T>, epsilon: <LabHue<T> as AbsDiffEq>::Epsilon, max_relative: <LabHue<T> as AbsDiffEq>::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl<T> SaturatingAdd<T> for LabHue<T>

where T: SaturatingAdd<Output = T>,

type Output = LabHue<T>

The resulting type.

fn saturating_add(self, other: T) -> LabHue<T>

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

impl<T> SaturatingAdd for LabHue<T>

where T: SaturatingAdd<Output = T>,

type Output = LabHue<T>

The resulting type.

fn saturating_add(self, other: LabHue<T>) -> LabHue<T>

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

impl<T> SaturatingSub<T> for LabHue<T>

where T: SaturatingSub<Output = T>,

type Output = LabHue<T>

The resulting type.

fn saturating_sub(self, other: T) -> LabHue<T>

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

impl<T> SaturatingSub for LabHue<T>

where T: SaturatingSub<Output = T>,

type Output = LabHue<T>

The resulting type.

fn saturating_sub(self, other: LabHue<T>) -> LabHue<T>

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

impl<T> Serialize for LabHue<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 LabHue<T>

where T: Sub<Output = T>,

type Output = LabHue<T>

The resulting type after applying the - operator.

fn sub(self, other: T) -> LabHue<T>

Performs the - operation.

impl<T> Sub for LabHue<T>

where T: Sub<Output = T>,

type Output = LabHue<T>

The resulting type after applying the - operator.

fn sub(self, other: LabHue<T>) -> LabHue<T>

Performs the - operation.

impl<T> SubAssign<T> for LabHue<T>

where T: SubAssign,

fn sub_assign(&mut self, other: T)

Performs the -= operation.

impl<T> SubAssign for LabHue<T>

where T: SubAssign,

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

Performs the -= operation.

impl<T> UlpsEq for LabHue<T>

where T: Zero + AngleEq<Mask = bool> + Sub<Output = T> + RealAngle + Clone + UlpsEq + SignedAngle, <T as AbsDiffEq>::Epsilon: HalfRotation + Mul<Output = <T as AbsDiffEq>::Epsilon>,

fn default_max_ulps() -> u32

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

fn ulps_eq( &self, other: &LabHue<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: &LabHue<T>, epsilon: <LabHue<T> as AbsDiffEq>::Epsilon, max_ulps: u32, ) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T> Copy for LabHue<T>

where T: Copy,

impl<T> Eq for LabHue<T>

where T: AngleEq<Mask = bool> + Eq,