Struct prisma::ycbcr::YCbCr

#[repr(C)]pub struct YCbCr<T, M = JpegModel> { /* fields omitted */ }

A color in the YCbCr family of color spaces.

See the parent module description for a discussion on the properties of the color space. The YCbCr type is represented with a set of channel values, plus a model. The model is stored with the color, and comes in two forms:

• A unit struct, defining the model at compile time. These do not store any value and thus do not increase the size of a color instance. JpegModel, Bt709Model and YiqModel and of this type. These types implement the UnitModel trait, and do not need to be passed to most functions.
• A type which stores its transformations in memory at runtime. For these models, it is usually preferable to store a reference to the model in the color to minimize the size impact. However, this will still increase the size of the type by one pointer size. Only CustomYCbCrModel is of this type.

Implementations

impl<T, M> YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar,
    M: YCbCrModel<T> + UnitModel<T>, 

pub fn new(y: T, cb: T, cr: T) -> Self

Construct a YCbCr from channel values.

This method does not take a model parameter, and is only usable for colors where the model is a stateless type implementing UnitModel. For such types, it sets the model to M::unit_value(). For colors that have a stateful model, the new_and_model method should be used instead.

impl<T, M> YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar,
    M: YCbCrModel<T>, 

pub fn from_color_and_model(ycbcr: BareYCbCr<T>, model: M) -> Self

Construct a YCbCr from a BareYCbCr and model.

pub fn new_and_model(y: T, cb: T, cr: T, model: M) -> Self

Construct a YCbCr from channel values and a model.

pub fn color_cast<TOut>(&self) -> YCbCr<TOut, M> where
    T: ChannelFormatCast<TOut>,
    TOut: NormalChannelScalar + PosNormalChannelScalar, 

Cast between different channel scalar representation.

pub fn model(&self) -> &M

Get a reference to the model of the given YCbCr.

pub fn bare_ycbcr(&self) -> &BareYCbCr<T>

Get a reference to the "bare" color.

pub fn luma(&self) -> T

Get the luma (Y') channel.

pub fn cb(&self) -> T

Get the Cb channel.

pub fn cr(&self) -> T

Get the Cr channel.

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

Get a mutable reference to the luma (Y') channel.

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

Get a mutable reference to the Cb channel.

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

Get a mutable reference to the Cr channel.

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

Set the luma (Y') channel to a value.

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

Set the Cb channel to a value.

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

Set the Cr channel to a value.

pub fn strip_model(self) -> BareYCbCr<T>

Remove the model information from the given YCbCr.

This returns a BareYCbCr with all the same channel values. No conversion is necessary, the model information is simply dropped.

impl<T, M> YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar + NumCast,
    M: YCbCrModel<T> + Canonicalize<T>, 

pub fn to_canonical_representation(&self) -> (T, T, T)

Return the channels rescaled to their canonical range for the given YCbCr's model.

Most YUV and YIQ standards define the channel range to be different than the [-1, 1] used by this library. This function returns the values for the same color rescaled to the defined range.

impl<T> YCbCr<T, YiqModel> where
    T: NormalChannelScalar + PosNormalChannelScalar + NumCast,
    YiqModel: YCbCrModel<T>, 

pub fn i(&self) -> T

The I channel of a YIQ color.

Because YIQ is implemented as a model on top of YCbCr, this is equivalent to self.cb().

pub fn q(&self) -> T

The Q channel of a YIQ color.

Because YIQ is implemented as a model on top of YCbCr, this is equivalent to self.cr().

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

Return a mutable reference to the I channel.

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

Return a mutable reference to the Q channel.

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

Set the I channel to a value.

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

Set the Q channel to a value.

impl<T, M> YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar + NumCast,
    M: YCbCrModel<T> + UnitModel<T>, 

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

Convert from RGB to YCbCr for UnitModels.

impl<T, M> YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar + NumCast,
    M: YCbCrModel<T>, 

pub fn from_rgb_and_model(from: &Rgb<T>, model: M) -> Self

Convert from RGB to YCbCr, using model.

The returned value stores the passed model.

pub fn to_rgb(&self, out_of_gamut_mode: YCbCrOutOfGamutMode) -> Rgb<T>

Convert from YCbCr to RGB.

Params

• out_of_gamut_mode - How to handle out of gamut colors. See YCbCrOutOfGamutMode for a description of the options.

Trait Implementations

impl<T, M> AbsDiffEq<YCbCr<T, M>> for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar + AbsDiffEq,
    T::Epsilon: Clone,
    M: YCbCrModel<T>, 

type Epsilon = <BareYCbCr<T> as AbsDiffEq>::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, M> Bounded for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar,
    M: YCbCrModel<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, M> Broadcast for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar,
    M: YCbCrModel<T> + UnitModel<T>, 

fn broadcast(value: T) -> Self

Construct Self with each channel set to value

impl<T: Clone, M: Clone> Clone for YCbCr<T, M>

fn clone(&self) -> YCbCr<T, M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, M> Color for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar,
    M: YCbCrModel<T>, 

type Tag = YCbCrTag

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, M: Copy> Copy for YCbCr<T, M>

impl<T: Debug, M: Debug> Debug for YCbCr<T, M>

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

Formats the value using the given formatter.

impl<T, M> Default for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar + Zero + Default,
    M: YCbCrModel<T> + UnitModel<T>, 

fn default() -> Self

Returns the "default value" for a type.

impl<T, M> Display for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar + Display,
    M: YCbCrModel<T>, 

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

Formats the value using the given formatter.

impl<T, M> EncodableColor for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar,
    M: YCbCrModel<T>, 

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, M: Eq> Eq for YCbCr<T, M>

impl<T, M> Flatten for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar,
    M: YCbCrModel<T> + UnitModel<T>, 

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

Return Self constructed from values

fn as_slice(&self) -> &[T]

Return a slice representation of Self

impl<T, M> From<Rgb<T>> for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar + NumCast,
    M: YCbCrModel<T> + UnitModel<T>, 

fn from(from: Rgb<T>) -> YCbCr<T, M>

Performs the conversion.

impl<T, M> FromColor<Rgb<T>> for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar + NumCast,
    M: YCbCrModel<T> + UnitModel<T>, 

fn from_color(from: &Rgb<T>) -> YCbCr<T, M>

Construct Self from from

impl<T, M> FromTuple for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar,
    M: YCbCrModel<T> + UnitModel<T>, 

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

Construct Self from a tuple of channel values

impl<T, M> FromYCbCr<YCbCr<T, M>> for Rgb<T> where
    T: NormalChannelScalar + PosNormalChannelScalar + NumCast,
    M: YCbCrModel<T>, 

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

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

impl<T: Hash, M: Hash> Hash for YCbCr<T, M>

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, M> HomogeneousColor for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar,
    M: YCbCrModel<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, M> Invert for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar,
    M: YCbCrModel<T>, 

fn invert(self) -> Self

Invert Self

impl<T, M> Lerp for YCbCr<T, M> where
    T: NormalChannelScalar + Lerp + PosNormalChannelScalar,
    M: YCbCrModel<T>, 

type Position = <T as Lerp>::Position

The type of the pos argument

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

Interpolate between self and right

impl<T: Ord, M: Ord> Ord for YCbCr<T, M>

fn cmp(&self, other: &YCbCr<T, M>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T: PartialEq, M: PartialEq> PartialEq<YCbCr<T, M>> for YCbCr<T, M>

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

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

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

This method tests for !=.

impl<T: PartialOrd, M: PartialOrd> PartialOrd<YCbCr<T, M>> for YCbCr<T, M>

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

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

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

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

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

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

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

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

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

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

impl<T, M> RelativeEq<YCbCr<T, M>> for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar + RelativeEq,
    T::Epsilon: Clone,
    M: YCbCrModel<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, M> StructuralEq for YCbCr<T, M>

impl<T, M> StructuralPartialEq for YCbCr<T, M>

impl<T, M> UlpsEq<YCbCr<T, M>> for YCbCr<T, M> where
    T: NormalChannelScalar + PosNormalChannelScalar + UlpsEq,
    T::Epsilon: Clone,
    M: YCbCrModel<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.