Struct prisma::color_space::SpacedColor

pub struct SpacedColor<T: Float, Color, Encoding, Space: ColorSpace<T>> { /* fields omitted */ }

A device-dependent color with an associated color space and encoding

SpacedColor implements Deref and DerefMut, allowing it to act like the underlying color transparently in many situations.

Implementations

impl<T, C, E, S> SpacedColor<T, C, E, S> where
    C: EncodableColor,
    S: ColorSpace<T>,
    E: ColorEncoding,
    T: Float, 

pub fn new(color: EncodedColor<C, E>, space: S) -> SpacedColor<T, C, E, S>

Construct a new SpacedColor from an EncodedColor and a ColorSpace

pub fn decompose(self) -> (EncodedColor<C, E>, S)

Decompose a SpacedColor into the contained EncodedColor and ColorSpace

pub fn strip_space(self) -> EncodedColor<C, E>

Returns the contained EncodedColor without the color space.

pub fn strip(self) -> C

Returns the underlying color without an encoding or space

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

Returns a reference to the contained EncodedColor

pub fn color_mut(&mut self) -> &mut EncodedColor<C, E>

Returns a mutable reference to the contained EncodedColor

pub fn space(&self) -> &S

Returns a reference to the ColorSpace

impl<T, C, E, S> SpacedColor<T, C, E, S> where
    C: EncodableColor + FromTuple,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

pub fn from_tuple(tuple: Self::ChannelsTuple, encoding: E, space: S) -> Self

Construct a SpacedColor from a tuple of channels, an encoding and a color space

impl<T, C, E, S> SpacedColor<T, C, E, S> where
    C: EncodableColor + Broadcast,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

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

Construct a SpacedColor by broadcasting a value to all channels, plus an encoding and a color space

impl<T, C, E, S> SpacedColor<T, C, E, S> where
    C: TranscodableColor,
    S: ColorSpace<T> + ConvertToXyz<T, C, E>,
    E: ColorEncoding + PartialEq,
    T: PosNormalChannelScalar + FreeChannelScalar + Float, 

pub fn to_xyz(&self) -> <S as ConvertToXyz<T, C, E>>::OutputColor

Convert Self into an Xyz value

impl<T, E, S> SpacedColor<T, Rgb<T>, E, S> where
    S: ColorSpace<T, Encoding = E> + PartialEq + Clone + ConvertFromXyz<T, Xyz<T>, OutputColor = Rgb<T>>,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float + FreeChannelScalar + PosNormalChannelScalar + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>, 

pub fn from_xyz(from: &Xyz<T>, space: S) -> Self

Construct Self from an Xyz value and a color space

impl<T, E, S> SpacedColor<T, Rgba<T>, E, S> where
    S: ColorSpace<T, Encoding = E> + PartialEq + Clone + ConvertFromXyz<T, Xyza<T>, OutputColor = Rgba<T>>,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float + FreeChannelScalar + PosNormalChannelScalar + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>, 

pub fn from_xyza(from: &Xyza<T>, space: S) -> Self

Construct Self from an Xyz value and a color space

Methods from Deref<Target = EncodedColor<C, E>>

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 encoding(&self) -> &E

Returns a reference to the encoding object

Trait Implementations

impl<T, C, E, S> AbsDiffEq<SpacedColor<T, C, E, S>> for SpacedColor<T, C, E, S> where
    C: EncodableColor + AbsDiffEq,
    S: ColorSpace<T> + PartialEq,
    E: ColorEncoding + PartialEq,
    T: Float, 

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<T, C, E, S> Bounded for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor + Bounded,
    S: ColorSpace<T> + PartialEq,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + 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: Clone + Float, Color: Clone, Encoding: Clone, Space: Clone + ColorSpace<T>> Clone for SpacedColor<T, Color, Encoding, Space>

fn clone(&self) -> SpacedColor<T, Color, Encoding, Space>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, C, E, S> Color for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

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<T, C, E, S> Color3 for SpacedColor<T, C, E, S> where
    C: Color3 + EncodableColor,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

impl<T, C, E, S> Color4 for SpacedColor<T, C, E, S> where
    C: Color4 + EncodableColor,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

impl<T: Debug + Float, Color: Debug, Encoding: Debug, Space: Debug + ColorSpace<T>> Debug for SpacedColor<T, Color, Encoding, Space>

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

Formats the value using the given formatter.

impl<T, C, E, S> Deref for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

type Target = EncodedColor<C, E>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, C, E, S> DerefMut for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, C, E, S> EncodableColor for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + 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: Eq + Float, Color: Eq, Encoding: Eq, Space: Eq + ColorSpace<T>> Eq for SpacedColor<T, Color, Encoding, Space>

impl<T, C, E, S, C2> FromColor<SpacedColor<T, C2, E, S>> for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor + FromColor<C2>,
    C2: Color + EncodableColor,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

fn from_color(from: &SpacedColor<T, C2, E, S>) -> Self

Construct Self from from

impl<T, C, E, S, A> FromHsi<SpacedColor<T, Hsi<T, A>, E, S>> for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor + FromHsi<Hsi<T, A>>,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PosNormalChannelScalar + Float,
    A: Angle<Scalar = T> + AngularChannelScalar, 

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

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

impl<T, C, E, S, M> FromYCbCr<SpacedColor<T, YCbCr<T, M>, E, S>> for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor + FromYCbCr<YCbCr<T, M>>,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PosNormalChannelScalar + Float,
    M: YCbCrModel<T> + Clone, 

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

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

impl<T, C, E, S> Invert for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor + Invert,
    S: ColorSpace<T> + PartialEq,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

fn invert(self) -> Self

Invert Self

impl<T, C, E, S> Lerp for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor + Lerp,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

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<T: PartialEq + Float, Color: PartialEq, Encoding: PartialEq, Space: PartialEq + ColorSpace<T>> PartialEq<SpacedColor<T, Color, Encoding, Space>> for SpacedColor<T, Color, Encoding, Space>

fn eq(&self, other: &SpacedColor<T, Color, Encoding, Space>) -> bool

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

fn ne(&self, other: &SpacedColor<T, Color, Encoding, Space>) -> bool

This method tests for !=.

impl<T, C, E, S> PolarColor for SpacedColor<T, C, E, S> where
    C: Color + EncodableColor + PolarColor,
    S: ColorSpace<T> + PartialEq + Clone,
    E: ColorEncoding + PartialEq,
    T: PartialEq + Clone + Float, 

type Angular = C::Angular

The angular channel's scalar type

type Cartesian = C::Cartesian

The remaining channels' scalar types

impl<T, C, E, S> RelativeEq<SpacedColor<T, C, E, S>> for SpacedColor<T, C, E, S> where
    C: EncodableColor + RelativeEq,
    S: ColorSpace<T> + PartialEq,
    E: ColorEncoding + PartialEq,
    T: Float, 

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: Float, Color, Encoding, Space: ColorSpace<T>> StructuralEq for SpacedColor<T, Color, Encoding, Space>

impl<T: Float, Color, Encoding, Space: ColorSpace<T>> StructuralPartialEq for SpacedColor<T, Color, Encoding, Space>

impl<T, C, E, S> UlpsEq<SpacedColor<T, C, E, S>> for SpacedColor<T, C, E, S> where
    C: EncodableColor + UlpsEq,
    S: ColorSpace<T> + PartialEq,
    E: ColorEncoding + PartialEq,
    T: Float, 

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.