Struct prisma::encoding::EncodedColor

pub struct EncodedColor<C, E> { /* fields omitted */ }

A color decorated with its encoding. This is the primary way to use encodings.

As most encodings are zero-sized structs except for GammaEncoding, there will be no size penalty for using EncodedColor.

Implementations

impl<C, E> EncodedColor<C, E> where
    C: Color + EncodableColor,
    E: ColorEncoding, 

pub fn new(color: C, encoding: E) -> Self

Construct a new EncodedColor from a color and an encoding.

impl<C, E> EncodedColor<C, E> where
    C: Color,
    E: ColorEncoding, 

pub fn decompose(self) -> (C, E)

Decompose a EncodedColor into it's color and encoding objects

pub fn color(&self) -> &C

Returns a reference to the color object

pub fn color_mut(&mut self) -> &mut C

Returns a mutable reference to the color object

pub fn strip_encoding(self) -> C

Discard the encoding, returning the bare color object

pub fn encoding(&self) -> &E

Returns a reference to the encoding object

impl<C, E> EncodedColor<C, E> where
    E: ColorEncoding,
    C: TranscodableColor, 

pub fn decode(self) -> EncodedColor<C, LinearEncoding>

Decode the color, making it linearly encoded

Note: This only is implemented for Rgb. All other encoded colors must convert to Rgb first.

pub fn transcode<Encoder>(
    self,
    new_encoding: Encoder
) -> EncodedColor<C, Encoder> where
    Encoder: ColorEncoding, 

Change the encoding of the color

Note: This only is implemented for Rgb. All other encoded colors must convert to Rgb first.

impl<C> EncodedColor<C, LinearEncoding> where
    C: TranscodableColor, 

pub fn encode<Encoder>(self, encoding: Encoder) -> EncodedColor<C, Encoder> where
    Encoder: ColorEncoding, 

Encode a linear RGB color with encoding

impl<C, E> EncodedColor<C, E> where
    C: Color + Broadcast + EncodableColor,
    E: ColorEncoding + PartialEq, 

pub fn broadcast(value: C::ChannelFormat, encoding: E) -> Self

Construct a new EncodedColor with all channels set to value and with encoding

impl<C, E> EncodedColor<C, E> where
    C: Color + FromTuple + EncodableColor,
    E: ColorEncoding + PartialEq, 

pub fn from_tuple(values: C::ChannelsTuple, encoding: E) -> Self

Construct a new EncodedColor from a tuple of channels and an encoding

Trait Implementations

impl<C, E> AbsDiffEq<EncodedColor<C, E>> for EncodedColor<C, E> where
    C: Color + EncodableColor + AbsDiffEq,
    E: ColorEncoding + PartialEq, 

type Epsilon = C::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<C, E> Bounded for EncodedColor<C, E> where
    C: Color + Bounded + EncodableColor,
    E: ColorEncoding + PartialEq, 

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<C: Clone, E: Clone> Clone for EncodedColor<C, E>

fn clone(&self) -> EncodedColor<C, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C, E> Color for EncodedColor<C, E> where
    C: Color + EncodableColor,
    E: ColorEncoding + PartialEq, 

type Tag = C::Tag

The unique tag unit struct identifying the color type

type ChannelsTuple = C::ChannelsTuple

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<C, E> Color3 for EncodedColor<C, E> where
    C: Color3 + EncodableColor,
    E: ColorEncoding + PartialEq, 

impl<C, E> Color4 for EncodedColor<C, E> where
    C: Color4 + EncodableColor,
    E: ColorEncoding + PartialEq, 

impl<C: Copy, E: Copy> Copy for EncodedColor<C, E>

impl<C: Debug, E: Debug> Debug for EncodedColor<C, E>

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

Formats the value using the given formatter.

impl<C, E> Deref for EncodedColor<C, E> where
    C: EncodableColor,
    E: ColorEncoding, 

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &C

Dereferences the value.

impl<C, E> DerefMut for EncodedColor<C, E> where
    C: EncodableColor,
    E: ColorEncoding, 

fn deref_mut(&mut self) -> &mut C

Mutably dereferences the value.

impl<C, E> Display for EncodedColor<C, E> where
    C: Color + EncodableColor + Display,
    E: ColorEncoding + Display, 

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

Formats the value using the given formatter.

impl<C, E> EncodableColor for EncodedColor<C, E> where
    C: EncodableColor,
    E: ColorEncoding + PartialEq, 

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<C: Eq, E: Eq> Eq for EncodedColor<C, E>

impl<C, E, C2> FromColor<EncodedColor<C2, E>> for EncodedColor<C, E> where
    C: Color + FromColor<C2> + EncodableColor,
    E: ColorEncoding,
    C2: EncodableColor, 

fn from_color(from: &EncodedColor<C2, E>) -> Self

Construct Self from from

impl<C, E, T, A> FromHsi<EncodedColor<Hsi<T, A>, E>> for EncodedColor<C, E> where
    C: Color + EncodableColor + FromHsi<Hsi<T, A>>,
    E: ColorEncoding,
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T>, 

fn from_hsi(
    from: &EncodedColor<Hsi<T, A>, E>,
    out_of_gamut_mode: HsiOutOfGamutMode
) -> Self

Construct Self from from, describing what to do if the color is out of gamut for Self

impl<C, E, T, M> FromYCbCr<EncodedColor<YCbCr<T, M>, E>> for EncodedColor<C, E> where
    C: Color + EncodableColor + FromYCbCr<YCbCr<T, M>>,
    E: ColorEncoding,
    T: PosNormalChannelScalar + Float,
    M: YCbCrModel<T>, 

fn from_ycbcr(
    from: &EncodedColor<YCbCr<T, M>, E>,
    out_of_gamut_mode: YCbCrOutOfGamutMode
) -> Self

Construct Self from from, describing what to do if the color is out of gamut for Self

impl<C, E> Invert for EncodedColor<C, E> where
    C: Color + Invert + EncodableColor,
    E: ColorEncoding + PartialEq, 

fn invert(self) -> Self

Invert Self

impl<C, E> Lerp for EncodedColor<C, E> where
    C: Color + Lerp + EncodableColor,
    E: ColorEncoding + PartialEq, 

type Position = C::Position

The type of the pos argument

fn lerp(&self, right: &Self, pos: Self::Position) -> Self

Interpolate between self and right

impl<C: PartialEq, E: PartialEq> PartialEq<EncodedColor<C, E>> for EncodedColor<C, E>

fn eq(&self, other: &EncodedColor<C, E>) -> bool

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

fn ne(&self, other: &EncodedColor<C, E>) -> bool

This method tests for !=.

impl<C, E> PolarColor for EncodedColor<C, E> where
    C: Color + EncodableColor + PolarColor,
    E: ColorEncoding + PartialEq, 

type Angular = C::Angular

The angular channel's scalar type

type Cartesian = C::Cartesian

The remaining channels' scalar types

impl<C, E> RelativeEq<EncodedColor<C, E>> for EncodedColor<C, E> where
    C: Color + EncodableColor + RelativeEq,
    E: ColorEncoding + PartialEq, 

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<C, E> StructuralEq for EncodedColor<C, E>

impl<C, E> StructuralPartialEq for EncodedColor<C, E>

impl<C, E> UlpsEq<EncodedColor<C, E>> for EncodedColor<C, E> where
    C: Color + EncodableColor + UlpsEq,
    E: ColorEncoding + PartialEq, 

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.

impl<T, C, E, S> WithColorSpace<T, C, E, S> for EncodedColor<C, E> where
    C: EncodableColor,
    S: ColorSpace<T>,
    E: ColorEncoding,
    T: Float, 

fn with_color_space(self, space: S) -> SpacedColor<T, C, E, S>

Create a new spaced color from self and a color space