Struct prisma::Hsv

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

The HSV device-dependent polar color model

HSV is defined by a hue (base color), saturation (color richness) and value (color intensity). HSV is modeled as a cylinder, however the underlying space is conical. This causes some level of distortion and a degeneracy at S=0 or V=0. Thus, while easy to reason about, it is not good for perceptual uniformity. It does an okay job with averaging colors or doing other math, but prefer the CIE spaces for uniform gradients.

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

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

For an undistorted device-dependent polar color model, look at Hsi.

Implementations

impl<T, A> Hsv<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

pub fn new(hue: A, saturation: T, value: T) -> Self

Construct an Hsv instance from hue, saturation and value

pub fn color_cast<TOut, AOut>(&self) -> Hsv<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 saturation(&self) -> T

Returns the saturation scalar

pub fn value(&self) -> T

Returns the value scalar

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

Returns a mutable reference to the hue channel scalar

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

Returns a mutable reference to the saturation channel scalar

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

Returns a mutable reference to the value channel scalar

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

Set the hue channel value

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

Set the saturation channel value

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

Set the value channel value

Trait Implementations

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

fn clone(&self) -> Hsv<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 Hsv<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

type Tag = HsvTag

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 Hsv<T, A>

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the "default value" for a type.

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

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

Formats the value using the given formatter.

impl<T, A> EncodableColor for Hsv<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<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<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> 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<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 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 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> FromTuple for Hsv<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

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

Construct Self from a tuple of channel values

impl<T: Hash, A: Hash> Hash for Hsv<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 Hsv<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

fn invert(self) -> Self

Invert Self

impl<T, A> Lerp for Hsv<T, A> where
    T: PosNormalChannelScalar + 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<Hsv<T, A>> for Hsv<T, A>

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

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

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

This method tests for !=.

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

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

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

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

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

fn le(&self, other: &Hsv<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: &Hsv<T, A>) -> bool

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

fn ge(&self, other: &Hsv<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 Hsv<T, A> where
    T: PosNormalChannelScalar,
    A: AngularChannelScalar, 

type Angular = A

The angular channel's scalar type

type Cartesian = T

The remaining channels' scalar types

impl<T, A> RelativeEq<Hsv<T, A>> for Hsv<T, A> where
    T: PosNormalChannelScalar + 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 Hsv<T, A>

impl<T, A> UlpsEq<Hsv<T, A>> for Hsv<T, A> where
    T: PosNormalChannelScalar + 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.