Struct prisma::Lchab

#[repr(C)]pub struct Lchab<T, W, A = Deg<T>> { /* fields omitted */ }

The $\textrm{Lch}_{(\textrm{ab})}$ device-independent polar color space

Lchab is a simple polar transformation from Lab defined as:

\begin{aligned}
    L &= L \\
    C &= \sqrt{a^2 + b^2} \\
    H &= atan2(b, a)
\end{aligned}

It is a useful space for computing smooth gradients in a polar space, but like Lab is out of gamut for many values which are not bounded by a simple geometric object.

Implementations

impl<T, W, A> Lchab<T, W, A> where
    T: FreeChannelScalar,
    A: AngularChannelScalar,
    W: UnitWhitePoint<T>, 

pub fn new(L: T, chroma: T, hue: A) -> Self

Construct a new Lchab value with a named white point and channels

Unlike new_with_whitepoint, new constructs a default instance of a UnitWhitePoint. It is only valid when W is a UnitWhitePoint.

impl<T, W, A> Lchab<T, W, A> where
    T: FreeChannelScalar,
    A: AngularChannelScalar,
    W: WhitePoint<T>, 

pub fn new_with_whitepoint(L: T, chroma: T, hue: A, white_point: W) -> Self

Construct a new Lchab value with a given white point and channels

pub fn color_cast<TOut, AOut>(&self) -> Lchab<TOut, W, AOut> where
    T: ChannelFormatCast<TOut>,
    TOut: FreeChannelScalar,
    A: ChannelFormatCast<AOut>,
    AOut: AngularChannelScalar, 

Convert the internal channel scalar format

pub fn L(&self) -> T

Returns the L lightness channel scalar

pub fn chroma(&self) -> T

Returns the C chroma channel scalar

pub fn hue(&self) -> A

Returns the H hue channel scalar

pub fn L_mut(&mut self) -> &mut T

Returns a mutable reference to the the L lightness channel scalar

pub fn chroma_mut(&mut self) -> &mut T

Returns a mutable reference to the the C chroma channel scalar

pub fn hue_mut(&mut self) -> &mut A

Returns a mutable reference to the the L hue channel scalar

pub fn set_L(&mut self, val: T)

Sets the L channel scalar

pub fn set_chroma(&mut self, val: T)

Sets the chroma channel scalar

pub fn set_hue(&mut self, val: A)

Sets the hue channel scalar

pub fn white_point(&self) -> &W

Returns a reference to the white point for the Lchab color space

Trait Implementations

impl<T, W, A> AbsDiffEq<Lchab<T, W, A>> for Lchab<T, W, A> where
    T: FreeChannelScalar + AbsDiffEq<Epsilon = A::Epsilon>,
    A: AngularChannelScalar + AbsDiffEq,
    A::Epsilon: Clone + Float,
    W: WhitePoint<T>, 

type Epsilon = T::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

fn abs_diff_eq(&self, other: &Self, epsilon: Self::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: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of ApproxEq::abs_diff_eq.

impl<T, W, A> Bounded for Lchab<T, W, A> where
    T: FreeChannelScalar,
    A: AngularChannelScalar,
    W: WhitePoint<T>, 

fn normalize(self) -> Self

Return a value clipped inside the normalized range

fn is_normalized(&self) -> bool

Return true if the value is normalized

impl<T: Clone, W: Clone, A: Clone> Clone for Lchab<T, W, A>

fn clone(&self) -> Lchab<T, W, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, W, A> Color for Lchab<T, W, A> where
    T: FreeChannelScalar,
    A: AngularChannelScalar,
    W: WhitePoint<T>, 

type Tag = LchabTag

The unique tag unit struct identifying the color type

type ChannelsTuple = (T, T, A)

A tuple of types for each channel in the color

fn num_channels() -> u32

Return how many channels the color has

fn to_tuple(self) -> Self::ChannelsTuple

Convert a color into a tuple of channels

impl<T: Copy, W: Copy, A: Copy> Copy for Lchab<T, W, A>

impl<T: Debug, W: Debug, A: Debug> Debug for Lchab<T, W, A>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, W, A> Default for Lchab<T, W, A> where
    T: FreeChannelScalar + Zero,
    A: AngularChannelScalar + Zero,
    W: UnitWhitePoint<T>, 

fn default() -> Self

Returns the "default value" for a type.

impl<T, W, A> Display for Lchab<T, W, A> where
    T: FreeChannelScalar + Display,
    A: AngularChannelScalar + Display,
    W: WhitePoint<T>, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, W, A> FromColor<Lab<T, W>> for Lchab<T, W, A> where
    T: FreeChannelScalar,
    A: AngularChannelScalar + FromAngle<Rad<T>> + Angle,
    W: WhitePoint<T>, 

fn from_color(from: &Lab<T, W>) -> Self

Construct an Lchab value from a Lab value

impl<T, W, A> FromColor<Lchab<T, W, A>> for Lab<T, W> where
    T: FreeChannelScalar,
    A: AngularChannelScalar + Angle<Scalar = T>,
    W: WhitePoint<T>, 

fn from_color(from: &Lchab<T, W, A>) -> Self

Construct a Lab value from an Lchab value

impl<T, W, A> FromTuple for Lchab<T, W, A> where
    T: FreeChannelScalar,
    A: AngularChannelScalar,
    W: UnitWhitePoint<T>, 

fn from_tuple(values: Self::ChannelsTuple) -> Self

Construct Self from a tuple of channel values

impl<T, W, A> Lerp for Lchab<T, W, A> where
    T: FreeChannelScalar + Lerp,
    A: AngularChannelScalar + Lerp,
    W: WhitePoint<T>, 

type Position = A::Position

The type of the pos argument

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

Interpolate between self and right

impl<T: PartialEq, W: PartialEq, A: PartialEq> PartialEq<Lchab<T, W, A>> for Lchab<T, W, A>

fn eq(&self, other: &Lchab<T, W, A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Lchab<T, W, A>) -> bool

This method tests for !=.

impl<T: PartialOrd, W: PartialOrd, A: PartialOrd> PartialOrd<Lchab<T, W, A>> for Lchab<T, W, A>

fn partial_cmp(&self, other: &Lchab<T, W, A>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Lchab<T, W, A>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Lchab<T, W, A>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Lchab<T, W, A>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Lchab<T, W, A>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, W, A> PolarColor for Lchab<T, W, A> where
    T: FreeChannelScalar,
    A: AngularChannelScalar,
    W: WhitePoint<T>, 

type Angular = A

The angular channel's scalar type

type Cartesian = T

The remaining channels' scalar types

impl<T, W, A> RelativeEq<Lchab<T, W, A>> for Lchab<T, W, A> where
    T: FreeChannelScalar + RelativeEq<Epsilon = A::Epsilon>,
    A: AngularChannelScalar + RelativeEq,
    A::Epsilon: Clone + Float,
    W: WhitePoint<T>, 

fn default_max_relative() -> Self::Epsilon

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

fn relative_eq(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

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

fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of ApproxEq::relative_eq.

impl<T, W, A> StructuralPartialEq for Lchab<T, W, A>

impl<T, W, A> UlpsEq<Lchab<T, W, A>> for Lchab<T, W, A> where
    T: FreeChannelScalar + UlpsEq<Epsilon = A::Epsilon>,
    A: AngularChannelScalar + UlpsEq,
    A::Epsilon: Clone + Float,
    W: WhitePoint<T>, 

fn default_max_ulps() -> u32

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

fn ulps_eq(&self, other: &Self, epsilon: Self::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: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.