Struct prisma::Lab

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

The CIELAB perceptually uniform device-independent color space

Lab is a color space obtained by a non-linear transformation for XYZ that is intended to be perceptually uniform, that is, such that a euclidean distance in any direction appears to change the same amount. Unlike XYZ, Lab spaces require a reference white point in order to be defined. This means that there are many different lab spaces that are incompatible because of having different white points. Like XYZ, most values in Lab lie outside the visible gamut of the eye.

The L value represents lightness, while a and b are green vs red and blue vs yellow respectively. Lab is one of two commonly used perceptually uniform spaces, the other being Luv.

A polar version of Lab exists as Lchab. Lchab is to Lab as Hsv is to Rgb, and is generally easier to reason about.

Implementations

impl<T, W> Lab<T, W> where
    T: FreeChannelScalar,
    W: UnitWhitePoint<T>, 

pub fn new(L: T, a: T, b: T) -> Self

Construct a new Lab 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> Lab<T, W> where
    T: FreeChannelScalar,
    W: WhitePoint<T>, 

pub fn new_with_whitepoint(L: T, a: T, b: T, white_point: W) -> Self

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

pub fn color_cast<TOut>(&self) -> Lab<TOut, W> where
    T: ChannelFormatCast<TOut>,
    TOut: FreeChannelScalar, 

Convert the internal channel scalar format

pub fn L(&self) -> T

Returns the L lightness channel scalar

pub fn a(&self) -> T

Returns the a green-red channel scalar

pub fn b(&self) -> T

Returns the b yellow-blue channel scalar

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

Returns a mutable reference to the L lightness channel scalar

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

Returns a mutable reference to the a green-red channel scalar

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

Returns a mutable reference to the b yellow-blue channel scalar

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

Set the L channel scalar

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

Set the a channel scalar

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

Set the b channel scalar

pub fn white_point(&self) -> &W

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

impl<T, W> Lab<T, W> where
    T: FreeChannelScalar,
    W: WhitePoint<T>, 

pub fn from_xyz(from: &Xyz<T>, wp: W) -> Lab<T, W>

Construct an Lab value from an Xyz instance and a white point

pub fn to_xyz(&self) -> Xyz<T>

Construct an Xyz value from self

pub fn epsilon() -> T

Return the $\epsilon$ constant used in the Lab conversion

For a description of the value, visit BruceLindbloom.com.

pub fn kappa() -> T

Return the $\kappa$ constant used in the Lab conversion

For a description of the value, visit BruceLindbloom.com.

Trait Implementations

impl<T, W> AbsDiffEq<Lab<T, W>> for Lab<T, W> where
    T: FreeChannelScalar + AbsDiffEq,
    T::Epsilon: Clone,
    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> Bounded for Lab<T, W> where
    T: FreeChannelScalar,
    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, W> Broadcast for Lab<T, W> where
    T: FreeChannelScalar,
    W: UnitWhitePoint<T>, 

fn broadcast(value: T) -> Self

Construct Self with each channel set to value

impl<T: Clone, W: Clone> Clone for Lab<T, W>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, W> Color for Lab<T, W> where
    T: FreeChannelScalar,
    W: WhitePoint<T>, 

type Tag = LabTag

The unique tag unit struct identifying the color type

type ChannelsTuple = (T, T, T)

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> Copy for Lab<T, W>

impl<T: Debug, W: Debug> Debug for Lab<T, W>

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

Formats the value using the given formatter.

impl<T, W> Default for Lab<T, W> where
    T: FreeChannelScalar,
    W: UnitWhitePoint<T>, 

fn default() -> Self

Returns the "default value" for a type.

impl<T, W> Display for Lab<T, W> where
    T: FreeChannelScalar + 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> FromTuple for Lab<T, W> where
    T: FreeChannelScalar,
    W: UnitWhitePoint<T>, 

fn from_tuple(values: (T, T, T)) -> Self

Construct Self from a tuple of channel values

impl<T, W> HomogeneousColor for Lab<T, W> where
    T: FreeChannelScalar,
    W: WhitePoint<T>, 

type ChannelFormat = T

The scalar type of each channel

fn clamp(self, min: T, max: T) -> Self

Clamp the value of each channel between min and max

impl<T, W> Lerp for Lab<T, W> where
    T: FreeChannelScalar + Lerp,
    W: WhitePoint<T>, 

type Position = <FreeChannel<T> as Lerp>::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> PartialEq<Lab<T, W>> for Lab<T, W>

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

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

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

This method tests for !=.

impl<T: PartialOrd, W: PartialOrd> PartialOrd<Lab<T, W>> for Lab<T, W>

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

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

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

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

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

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

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

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

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

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

impl<T, W> RelativeEq<Lab<T, W>> for Lab<T, W> where
    T: FreeChannelScalar + RelativeEq,
    T::Epsilon: Clone,
    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> StructuralPartialEq for Lab<T, W>

impl<T, W> UlpsEq<Lab<T, W>> for Lab<T, W> where
    T: FreeChannelScalar + UlpsEq,
    T::Epsilon: Clone,
    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.