Struct Rgb

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

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

where T: PosNormalChannelScalar + AbsDiffEq, T::Epsilon: Clone,

type Epsilon = <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> 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 duplicate 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, 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<'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 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, 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<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: 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> 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

Converts to this type from the input type.

impl<T, A> From<Hsv<T, A>> for Rgb<T>

where T: PosNormalChannelScalar + Float, A: AngularChannelScalar,

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

Converts to this type from the input type.

impl<T, A> From<Hwb<T, A>> for Rgb<T>

where T: PosNormalChannelScalar + Float, A: AngularChannelScalar,

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

Converts to this type from the input type.

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

Converts to this type from the input type.

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

Converts to this type from the input type.

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

Converts to this type from the input type.

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

Converts to this type from the input type.

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>

Converts to this type from the input type.

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

Converts to this type from the input type.

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 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 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 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 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, 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> 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, Self: Sized,

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.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for Rgb<T>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd 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: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<T> RelativeEq 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> 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 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.

impl<T> Color3 for Rgb<T>

where T: PosNormalChannelScalar,

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

impl<T: Eq> Eq for Rgb<T>

impl<T> StructuralPartialEq for Rgb<T>