Struct prisma::Luv

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

The CIELUV perceptually uniform device-independent color space

Luv is a perceptually uniform color space introduced by CIE at the same time as Lab. Luv is especially well suited for dealing with colored lighting computations, with the additive mixture of two lights falling along a line in its the chromaticity space. It is an extension to the previous CIE UVW space.

Like Lab, Luv has a polar representation: Lchuv.

Implementations

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

pub fn new(L: T, u: T, v: T) -> Self

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

pub fn new_with_whitepoint(L: T, u: T, v: T, white_point: W) -> Self

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

pub fn color_cast<TOut>(&self) -> Luv<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 u(&self) -> T

Returns the u green-red channel scalar

pub fn v(&self) -> T

Returns the v blue-yellow channel scalar

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

Returns a mutable reference to the L lightness channel scalar

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

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

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

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

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

Set the L channel scalar

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

Set the u channel scalar

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

Set the v channel scalar

pub fn white_point(&self) -> &W

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

impl<T, W> Luv<T, W> where
    T: FreeChannelScalar + Display,
    W: WhitePoint<T>, 

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

Construct a Luv value from an Xyz value and white point

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

Construct an Xyz value from a Luv value

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

fn clone(&self) -> Luv<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 Luv<T, W> where
    T: FreeChannelScalar,
    W: WhitePoint<T>, 

type Tag = LuvTag

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 Luv<T, W>

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the "default value" for a type.

impl<T, W> Display for Luv<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<Lchuv<T, W, A>> for Luv<T, W> where
    T: FreeChannelScalar,
    A: AngularChannelScalar + Angle<Scalar = T>,
    W: WhitePoint<T>, 

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

Construct a Lab value from an Lchuv value

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

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

Construct an Lchuv value from a Lab value

impl<T, W> FromTuple for Luv<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 Luv<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 Luv<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<Luv<T, W>> for Luv<T, W>

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

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

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

This method tests for !=.

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

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

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

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

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

fn le(&self, other: &Luv<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: &Luv<T, W>) -> bool

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

fn ge(&self, other: &Luv<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<Luv<T, W>> for Luv<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 Luv<T, W>

impl<T, W> UlpsEq<Luv<T, W>> for Luv<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.