Struct prisma::Rgi

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

The rgI device-dependent chromaticity color model

rgI is defined by a relative red amount, relative green amount and intensity. The rgI color model is used to keep the color intensity relatively invariant (that is, only the color matters, not how white or black it is), with the caveat that its parent RGB is not perceptually uniform. It is a device-dependent relative to the xyY CIE space.

The r and g components here are not absolute red and green like in RGB, but rather the ratio of red or green to the sum of RGB. That is:

\begin{aligned}
r &= \frac{R}{R+G+B} \\
g &= \frac{G}{R+G+B} \\
b &= \frac{B}{R+G+B} \\
r+g+b &= 1 \\
I &= \frac{R+G+B}{3}
\end{aligned}

Since r+g+b=1, the b component is not stored, but can be reconstructed at will. This also means that setting any of r,g,b will require the others to be changed as well. Rgi does this by proportionally rescaling the other channels with respect to the new value.

Including the intensity channel makes Rgi still a full color model that can convert back to RGB, unlike the sometimes used rg model.

Implementations

impl<T> Rgi<T> where
    T: PosNormalChannelScalar + Float, 

pub fn new(red: T, green: T, intensity: T) -> Self

Construct a Rgi instance from red, green and intensity

Panics:

If red+green is greater than 1.0 or less than 0.0, new will panic.

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

Convert the internal channel scalar format

pub fn red(&self) -> T

Returns the relative red scalar

pub fn green(&self) -> T

Returns the relative green scalar

pub fn blue(&self) -> T

Returns the relative blue scalar

Unlike red and green, this requires a small computation

pub fn intensity(&self) -> T

Returns the intensity scalar

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

Returns a mutable reference to the intensity scalar

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

Set the relative red channel

Panics:

This will panic if val is greater than one or less than zero.

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

Set the relative green channel

Panics:

This will panic if val is greater than one or less than zero.

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

Set the relative blue channel

Panics:

This will panic if val is greater than one or less than zero.

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

Set the intensity value

Trait Implementations

impl<T> AbsDiffEq<Rgi<T>> for Rgi<T> where
    T: PosNormalChannelScalar + AbsDiffEq + Float,
    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 Rgi<T> where
    T: 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 Rgi<T> where
    T: PosNormalChannelScalar + Float, 

fn broadcast(value: T) -> Self

Construct Self with each channel set to value

impl<T: Clone> Clone for Rgi<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

type Tag = RgiTag

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 Rgi<T>

impl<T: Debug> Debug for Rgi<T>

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

Formats the value using the given formatter.

impl<T> Default for Rgi<T> where
    T: PosNormalChannelScalar + Zero + Float, 

fn default() -> Self

Returns the "default value" for a type.

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

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

Formats the value using the given formatter.

impl<T> EncodableColor for Rgi<T> where
    T: PosNormalChannelScalar + Float, 

fn encoded_as<E>(self, encoding: E) -> EncodedColor<Self, E> where
    E: ColorEncoding, 

Specify what encoding the color has. This does not actually encode anything

fn linear(self) -> EncodedColor<Self, LinearEncoding>

Specify that the color is linear

fn srgb_encoded(self) -> EncodedColor<Self, SrgbEncoding>

Specify that the color is sRGB encoded

fn gamma_encoded<T: Float>(
    self,
    gamma: T
) -> EncodedColor<Self, GammaEncoding<T>>

Specify that the color is gamma encoded with a given gamma

impl<T> Flatten for Rgi<T> where
    T: 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<Rgb<T>> for Rgi<T> where
    T: PosNormalChannelScalar + Float, 

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

Construct Self from from

impl<T> FromColor<Rgi<T>> for Rgb<T> where
    T: PosNormalChannelScalar + Float, 

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

Construct Self from from

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

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

Construct Self from a tuple of channel values

impl<T: Hash> Hash for Rgi<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T> HomogeneousColor for Rgi<T> where
    T: 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 Rgi<T> where
    T: PosNormalChannelScalar + Lerp + Float, 

type Position = <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<Rgi<T>> for Rgi<T>

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

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

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

This method tests for !=.

impl<T: PartialOrd> PartialOrd<Rgi<T>> for Rgi<T>

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

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

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

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

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

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

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

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

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

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

impl<T> RelativeEq<Rgi<T>> for Rgi<T> where
    T: PosNormalChannelScalar + RelativeEq + Float,
    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 Rgi<T>

impl<T> UlpsEq<Rgi<T>> for Rgi<T> where
    T: PosNormalChannelScalar + UlpsEq + Float,
    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.