Struct prisma::XyY

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

The xyY device-independent chromaticity space

xyY is a chromaticity transformation of XYZ, defined by a relative amount of X, Y and Z. It is a direct analog to the rgI model for Rgb, but without being bound to a specific Rgb space (see Rgi). xyY carries along the absolute luminosity to allow a reconstruction of the XYZ value. xy is often plotted together in what is often referred to as the "horseshoe diagram" which is used to show the gamut of various RGB color spaces.

The x and y components here are not absolute X and Y as in XYZ, but rather the ratio of each to the sum. That is:

\begin{aligned}
x &= \frac{X}{X+Y+Z} \\
y &= \frac{Y}{X+Y+Z} \\
z &= \frac{Z}{X+Y+Z} \\
x+y+z &= 1
\end{aligned}

The value of z is implicit given that x + y + z = 1 thus z can be computed via x = 1 - x - y.

XyY can be converted back to XYZ as follows:

\begin{aligned}
X &= \frac{Y}{y}x \\
Y &= Y \\
Z &= \frac{Y}{y}(1-x-y)
\end{aligned}

Prisma uses xy chromaticity coordinates in the specification of primaries. Together with a reference white point, this can uniquely define a RGB space.

Implementations

impl<T> XyY<T> where
    T: FreeChannelScalar + Float + PosNormalChannelScalar, 

pub fn new(x: T, y: T, Y: T) -> Self

Construct an XyY instance from x, y and Y

Panics:

new will panic if x + y is greater than 1 or less than zero, or if either x or y are negative.

pub fn color_cast<TOut>(&self) -> XyY<TOut> where
    T: ChannelFormatCast<TOut>,
    TOut: FreeChannelScalar + PosNormalChannelScalar, 

Convert the internal channel scalar format

pub fn x(&self) -> T

Returns the x chromaticity value

pub fn y(&self) -> T

Returns the y chromaticity value

pub fn z(&self) -> T

Returns the z chromaticity value

The z chromaticity value is computed from x and y based on the fact x + y + z = 1.

pub fn Y(&self) -> T

Returns the luminosity Y

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

Returns a mutable reference to the luminosity Y

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

Set the x value, rescaling y to maintain x + y + z = 1

Panics:

Panics if x is greater than one or less than zero

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

Set the y value, rescaling x to maintain x + y + z = 1

Panics:

Panics if x is greater than one or less than zero

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

Set the implicit z value, rescaling x and y to maintain x + y + z = 1

Panics:

Panics if x is greater than one or less than zero

Trait Implementations

impl<T> AbsDiffEq<XyY<T>> for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + AbsDiffEq,
    T::Epsilon: Clone, 

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> Bounded for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float, 

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> Broadcast for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float, 

fn broadcast(val: T) -> Self

Construct Self with each channel set to value

impl<T: Clone> Clone for XyY<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Color for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float, 

type Tag = XyYTag

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> Copy for XyY<T>

impl<T: Debug> Debug for XyY<T>

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

Formats the value using the given formatter.

impl<T> Default for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float, 

fn default() -> Self

Returns the "default value" for a type.

impl<T> Display for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float + Display, 

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

Formats the value using the given formatter.

impl<T> Flatten for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float, 

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> FromColor<XyY<T>> for Xyz<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float, 

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

Construct Self from from

impl<T> FromColor<Xyz<T>> for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float, 

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

Construct Self from from

impl<T> FromTuple for XyY<T> where
    T: FreeChannelScalar + Float + PosNormalChannelScalar, 

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

Construct Self from a tuple of channel values

impl<T> HomogeneousColor for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float, 

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> Lerp for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + Float,
    FreeChannel<T>: Lerp,
    PosNormalBoundedChannel<T>: Lerp<Position = <FreeChannel<T> as Lerp>::Position>, 

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> PartialEq<XyY<T>> for XyY<T>

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

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

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

This method tests for !=.

impl<T: PartialOrd> PartialOrd<XyY<T>> for XyY<T>

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

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

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

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

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

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

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

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

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

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

impl<T> RelativeEq<XyY<T>> for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + RelativeEq,
    T::Epsilon: Clone, 

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> StructuralPartialEq for XyY<T>

impl<T> UlpsEq<XyY<T>> for XyY<T> where
    T: FreeChannelScalar + PosNormalChannelScalar + UlpsEq,
    T::Epsilon: Clone, 

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.