Struct prisma::lms::Lms

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

The LMS cone response device-independent color space

LMS is a device-independent color space created to map to the average response of the three cones in the human eye. There is no single LMS space, but rather several different models defining a transformation from XYZ to LMS. LMS is well suited for use in chromatic adaptation as well as for simulating the effects of color blindness in humans. LMS is also widely used in "color adaptation models" such as CIECAM2002.

LMS is a linear transformation from XYZ, and each model is defined by a matrix M that multiplies a XYZ value to produce an LMS value.

Note that presently, the Model type parameter to LMS must be data-less. This may be changed in the future if a use case arises.

Implementations

impl<T, Model> Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<T>, 

pub fn new(l: T, m: T, s: T) -> Self

Construct an LMS instance from l, m and s

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

Cast the channel representation type

pub fn l(&self) -> T

Returns the L value

pub fn m(&self) -> T

Returns the M value

pub fn s(&self) -> T

Returns the S value

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

Returns a mutable reference to the L value

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

Returns a mutable reference to the M value

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

Returns a mutable reference to the S value

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

Set the L value

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

Set the M value

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

Set the S value

Trait Implementations

impl<T, Model> AbsDiffEq<Lms<T, Model>> for Lms<T, Model> where
    T: FreeChannelScalar + AbsDiffEq,
    T::Epsilon: Clone,
    Model: LmsModel<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, Model> Bounded for Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<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, Model> Broadcast for Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<T>, 

fn broadcast(value: T) -> Self

Construct Self with each channel set to value

impl<T: Clone, Model: Clone> Clone for Lms<T, Model>

fn clone(&self) -> Lms<T, Model>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, Model> Color for Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<T>, 

type Tag = LmsTag

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, Model: Copy> Copy for Lms<T, Model>

impl<T: Debug, Model: Debug> Debug for Lms<T, Model>

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

Formats the value using the given formatter.

impl<T, Model> Default for Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<T>, 

fn default() -> Self

Returns the "default value" for a type.

impl<T, Model> Display for Lms<T, Model> where
    T: FreeChannelScalar + Display,
    Model: LmsModel<T>, 

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

Formats the value using the given formatter.

impl<T, Model> Flatten for Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<T>, 

fn as_slice(&self) -> &[Self::ChannelFormat]

Return a slice representation of Self

fn from_slice(vals: &[T]) -> Self

Return Self constructed from values

impl<T, Model> FromColor<Lms<T, Model>> for Xyz<T> where
    T: FreeChannelScalar,
    Model: LmsModel<T>, 

fn from_color(from: &Lms<T, Model>) -> Self

Construct Self from from

impl<T, Model> FromColor<Xyz<T>> for Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<T>, 

fn from_color(from: &Xyz<T>) -> Self

Construct Self from from

impl<T, Model> FromTuple for Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<T>, 

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

Construct Self from a tuple of channel values

impl<T, Model> HomogeneousColor for Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<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, Model> Lerp for Lms<T, Model> where
    T: FreeChannelScalar,
    Model: LmsModel<T>,
    FreeChannel<T>: Lerp, 

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, Model: PartialEq> PartialEq<Lms<T, Model>> for Lms<T, Model>

fn eq(&self, other: &Lms<T, Model>) -> bool

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

fn ne(&self, other: &Lms<T, Model>) -> bool

This method tests for !=.

impl<T: PartialOrd, Model: PartialOrd> PartialOrd<Lms<T, Model>> for Lms<T, Model>

fn partial_cmp(&self, other: &Lms<T, Model>) -> Option<Ordering>

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

fn lt(&self, other: &Lms<T, Model>) -> bool

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

fn le(&self, other: &Lms<T, Model>) -> bool

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

fn gt(&self, other: &Lms<T, Model>) -> bool

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

fn ge(&self, other: &Lms<T, Model>) -> bool

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

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

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