Struct prisma::Hwb

#[repr(C)]pub struct Hwb<T, A = Deg<T>> { /* fields omitted */ }

The HWB device-dependent polar color model

HWB is defined by a hue (base color), whiteness and blackness. HWB is a conical space that is not distorted into a cylinder like HSV and HSL are, but with the property that any value of W+B greater than 1 loses any chroma and is technically not inside the space. HWB is a relatively recent color model, and was designed to be easy for a human to reason about and use to build colors.

Hwb takes two type parameters: the cartesian channel scalar, and an angular channel scalar.

Hwb is in the same color space and encoding as the parent RGB space, it is merely a geometric transformation and distortion.

Implementations

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

pub fn new(hue: A, whiteness: T, blackness: T) -> Self

Construct a Hwb instance from hue, whiteness and blackness

pub fn color_cast<TOut, AOut>(&self) -> Hwb<TOut, AOut> where
    T: ChannelFormatCast<TOut>,
    A: ChannelFormatCast<AOut>,
    AOut: AngularChannelScalar,
    TOut: PosNormalChannelScalar, 

Convert the internal channel scalar format

pub fn hue(&self) -> A

Returns the hue scalar

pub fn whiteness(&self) -> T

Returns the whiteness scalar

pub fn blackness(&self) -> T

Returns the blackness scalar

pub fn hue_mut(&mut self) -> &mut A

Returns a mutable reference to the hue channel scalar

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

Returns a mutable reference to the white channel scalar

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

Returns a mutable reference to the black channel scalar

pub fn set_hue(&mut self, val: A)

Set the hue channel value

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

Set the whiteness channel value

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

Set the blackness channel value

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

pub fn wb_needs_rescaled(&self) -> bool

Returns whether the whiteness + blackness is outside the cylinder (greater than 1)

pub fn rescale_wb(self) -> Self

Rescale such that whiteness + blackness is no greater than 1

Trait Implementations

impl<T, A> AbsDiffEq<Hwb<T, A>> for Hwb<T, A> where
    T: PosNormalChannelScalar + Float + AbsDiffEq<Epsilon = A::Epsilon>,
    A: AngularChannelScalar + AbsDiffEq,
    A::Epsilon: Clone + Float, 

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, A> Bounded for Hwb<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar, 

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, A: Clone> Clone for Hwb<T, A>

fn clone(&self) -> Hwb<T, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

type Tag = HwbTag

The unique tag unit struct identifying the color type

type ChannelsTuple = (A, 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, A: Copy> Copy for Hwb<T, A>

impl<T: Debug, A: Debug> Debug for Hwb<T, A>

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

Formats the value using the given formatter.

impl<T, A> Default for Hwb<T, A> where
    T: PosNormalChannelScalar + Float + Zero,
    A: AngularChannelScalar + Zero, 

fn default() -> Self

Returns the "default value" for a type.

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

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

Formats the value using the given formatter.

impl<T, A> EncodableColor for Hwb<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + Angle<Scalar = T> + FromAngle<Turns<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, 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 Hwb<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar + FromAngle<Turns<T>>, 

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

Performs the conversion.

impl<T, A> FromColor<Hsv<T, A>> for Hwb<T, A> 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<Hwb<T, A>> for Hsv<T, A> 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 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, A> FromTuple for Hwb<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar, 

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

Construct Self from a tuple of channel values

impl<T: Hash, A: Hash> Hash for Hwb<T, A>

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, A> Invert for Hwb<T, A> where
    T: PosNormalChannelScalar + Float,
    A: AngularChannelScalar, 

fn invert(self) -> Self

Invert Self

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

type Position = A::Position

The type of the pos argument

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

Interpolate between self and right

impl<T: PartialEq, A: PartialEq> PartialEq<Hwb<T, A>> for Hwb<T, A>

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

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

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

This method tests for !=.

impl<T: PartialOrd, A: PartialOrd> PartialOrd<Hwb<T, A>> for Hwb<T, A>

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

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

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

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

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

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

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

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

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

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

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

type Angular = A

The angular channel's scalar type

type Cartesian = T

The remaining channels' scalar types

impl<T, A> RelativeEq<Hwb<T, A>> for Hwb<T, A> where
    T: PosNormalChannelScalar + Float + RelativeEq<Epsilon = A::Epsilon>,
    A: AngularChannelScalar + RelativeEq,
    A::Epsilon: Clone + 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, A> StructuralPartialEq for Hwb<T, A>

impl<T, A> UlpsEq<Hwb<T, A>> for Hwb<T, A> where
    T: PosNormalChannelScalar + Float + UlpsEq<Epsilon = A::Epsilon>,
    A: AngularChannelScalar + UlpsEq,
    A::Epsilon: Clone + 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.