Struct prisma::Rgb

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

The Rgb device-dependent cartesian color model.

Rgb<T> has three primaries: red, green blue, which are always positive and in the normalized range [0, 1]. Rgb<T> accepts both integer and float components.

It is made to be efficient and easy to use in many different applications, and can be transmuted directly to a &[T; N].

Rgb is the base device dependent color space from which all others go through to convert, which can be converted to the other device dependent spaces or to the device independent CIE spaces directly. The color space of Rgb is not specified or assumed, it is up to you to not mix color spaces improperly or use an appropriate wrapper.

Examples:

use prisma::{Broadcast, HomogeneousColor, Lerp, Rgb};

let black = Rgb::broadcast(0.0f32);
let blue = Rgb::new(0, 0, 255u8);
// Convert blue to have float channels and compute the color halfway between blue and black
let blended = black.lerp(&blue.color_cast(), 0.5);

assert_eq!(blended, Rgb::new(0.0, 0.0, 0.5));

Implementations

impl<T> Rgb<T> where
    T: PosNormalChannelScalar, 

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

Construct a new Rgb instance with the given channel values

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

Convert the internal channel scalar format

pub fn red(&self) -> T

Returns the red channel scalar

pub fn green(&self) -> T

Returns the green channel scalar

pub fn blue(&self) -> T

Returns the blue channel scalar

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

Returns a mutable reference to the red channel scalar

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

Returns a mutable reference to the green channel scalar

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

Returns a mutable reference to the blue channel scalar

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

Set the red channel value

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

Set the green channel value

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

Set the blue channel value

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

pub fn chromaticity_coordinates(&self) -> ChromaticityCoordinates<T>

Compute the ChromaticityCooridinates for an Rgb instance

Trait Implementations

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

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 Rgb<T> where
    T: PosNormalChannelScalar, 

fn broadcast(value: T) -> Self

Construct Self with each channel set to value

impl<T: Clone> Clone for Rgb<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Color for Rgb<T> where
    T: PosNormalChannelScalar, 

type Tag = RgbTag

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> Color3 for Rgb<T> where
    T: PosNormalChannelScalar, 

impl<T, E> ConvertToXyz<T, Rgb<T>, E> for SRgb<T> where
    T: Float + FreeChannelScalar + PosNormalChannelScalar + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>,
    E: ColorEncoding, 

type OutputColor = Xyz<T>

The type to output. Always some form of Xyz

fn convert_to_xyz(&self, color: &EncodedColor<Rgb<T>, E>) -> Self::OutputColor

Convert color into the XYZ space

impl<T, E, EIn> ConvertToXyz<T, Rgb<T>, EIn> for EncodedColorSpace<T, E> where
    T: PosNormalChannelScalar + FreeChannelScalar + Float + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>,
    E: ColorEncoding + PartialEq,
    EIn: ColorEncoding + PartialEq, 

type OutputColor = Xyz<T>

The type to output. Always some form of Xyz

fn convert_to_xyz(&self, color: &EncodedColor<Rgb<T>, EIn>) -> Self::OutputColor

Convert color into the XYZ space

impl<'a, T, E, EIn> ConvertToXyz<T, Rgb<T>, EIn> for &'a EncodedColorSpace<T, E> where
    T: PosNormalChannelScalar + FreeChannelScalar + Float + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>,
    E: ColorEncoding + PartialEq,
    EIn: ColorEncoding + PartialEq, 

type OutputColor = Xyz<T>

The type to output. Always some form of Xyz

fn convert_to_xyz(&self, color: &EncodedColor<Rgb<T>, EIn>) -> Self::OutputColor

Convert color into the XYZ space

impl<T, E, EIn> ConvertToXyz<T, Rgb<T>, EIn> for Rc<EncodedColorSpace<T, E>> where
    T: PosNormalChannelScalar + FreeChannelScalar + Float + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>,
    E: ColorEncoding + PartialEq,
    EIn: ColorEncoding + PartialEq, 

type OutputColor = Xyz<T>

The type to output. Always some form of Xyz

fn convert_to_xyz(&self, color: &EncodedColor<Rgb<T>, EIn>) -> Self::OutputColor

Convert color into the XYZ space

impl<T, E, EIn> ConvertToXyz<T, Rgb<T>, EIn> for Arc<EncodedColorSpace<T, E>> where
    T: PosNormalChannelScalar + FreeChannelScalar + Float + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>,
    E: ColorEncoding + PartialEq,
    EIn: ColorEncoding + PartialEq, 

type OutputColor = Xyz<T>

The type to output. Always some form of Xyz

fn convert_to_xyz(&self, color: &EncodedColor<Rgb<T>, EIn>) -> Self::OutputColor

Convert color into the XYZ space

impl<T: Copy> Copy for Rgb<T>

impl<T: Debug> Debug for Rgb<T>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the "default value" for a type.

impl<T> Display for Rgb<T> where
    T: PosNormalChannelScalar + Display, 

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

Formats the value using the given formatter.

impl<T> EncodableColor for Rgb<T> where
    T: PosNormalChannelScalar, 

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> Eq for Rgb<T>

impl<T> Flatten for Rgb<T> where
    T: PosNormalChannelScalar, 

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, A> From<Hsl<T, A>> for Rgb<T> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar, 

fn from(from: Hsl<T, A>) -> Self

Performs the conversion.

impl<T, A> From<Hsv<T, A>> for Rgb<T> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar, 

fn from(from: Hsv<T, A>) -> Self

Performs the conversion.

impl<T, A> From<Hwb<T, A>> for Rgb<T> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar, 

fn from(from: Hwb<T, A>) -> Self

Performs the conversion.

impl<T, A> From<Rgb<T>> for Hsv<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + FromAngle<Turns<T>>, 

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

Performs the conversion.

impl<T, A> From<Rgb<T>> for Hsl<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + FromAngle<Turns<T>>, 

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

Performs the conversion.

impl<T, A> From<Rgb<T>> for Hwb<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + FromAngle<Turns<T>>, 

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

Performs the conversion.

impl<T, A> From<Rgb<T>> for Hsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + FromAngle<Rad<T>>, 

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

Performs the conversion.

impl<T, A> From<Rgb<T>> for eHsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + FromAngle<Rad<T>>, 

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

Performs the conversion.

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, A> FromColor<Hsl<T, A>> for Rgb<T> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar, 

fn from_color(from: &Hsl<T, A>) -> Self

Construct Self from from

impl<T, A> FromColor<Hsv<T, A>> for Rgb<T> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar, 

fn from_color(from: &Hsv<T, A>) -> Self

Construct Self from from

impl<T, A> FromColor<Hwb<T, A>> for Rgb<T> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar, 

fn from_color(from: &Hwb<T, A>) -> Self

Construct Self from from

impl<T, A> FromColor<Rgb<T>> for eHsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + FromAngle<Rad<T>>, 

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

Construct Self from from

impl<T, A> FromColor<Rgb<T>> for Hsi<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + FromAngle<Rad<T>>, 

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

Construct Self from from

impl<T, A> FromColor<Rgb<T>> for Hsv<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + FromAngle<Turns<T>>, 

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

Construct Self from from

impl<T, A> FromColor<Rgb<T>> for Hsl<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + FromAngle<Turns<T>>, 

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

Construct Self from from

impl<T, A> FromColor<Rgb<T>> for Hwb<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + FromAngle<Turns<T>>, 

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

Construct Self from from

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

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

Construct Self from from

impl<T, A> FromColor<eHsi<T, A>> for Rgb<T> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T>, 

fn from_color(from: &eHsi<T, A>) -> Rgb<T>

Construct Self from from

impl<T, A> FromHsi<Hsi<T, A>> for Rgb<T> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + IntoAngle<Rad<T>, OutputScalar = T>, 

fn from_hsi(value: &Hsi<T, A>, out_of_gamut_mode: HsiOutOfGamutMode) -> Rgb<T>

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

impl<T> FromTuple for Rgb<T> where
    T: PosNormalChannelScalar, 

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> Hash for Rgb<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 Rgb<T> where
    T: PosNormalChannelScalar, 

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> Invert for Rgb<T> where
    T: PosNormalChannelScalar, 

fn invert(self) -> Self

Invert Self

impl<T> Lerp for Rgb<T> where
    T: PosNormalChannelScalar + Lerp, 

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: Ord> Ord for Rgb<T>

fn cmp(&self, other: &Rgb<T>) -> 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> PartialEq<Rgb<T>> for Rgb<T>

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

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

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

This method tests for !=.

impl<T: PartialOrd> PartialOrd<Rgb<T>> for Rgb<T>

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

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

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

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

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

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

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

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

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

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

impl<T> RelativeEq<Rgb<T>> for Rgb<T> where
    T: 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> StructuralEq for Rgb<T>

impl<T> StructuralPartialEq for Rgb<T>

impl<T> TranscodableColor for Rgb<T> where
    T: PosNormalChannelScalar + ChannelFormatCast<f64>,
    f64: ChannelFormatCast<T>, 

type IntermediateColor = Rgb<f64>

The color type used internally to do conversions. This will always have floating-point channels

fn encode_color<Encoder>(self, enc: &Encoder) -> Self where
    Encoder: ChannelEncoder, 

Encode self using the encoder enc

fn decode_color<Decoder>(self, dec: &Decoder) -> Self where
    Decoder: ChannelDecoder, 

Decode self using the decoder dec

impl<T> UlpsEq<Rgb<T>> for Rgb<T> where
    T: 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.