Struct Hsv

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

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

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

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, 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 duplicate 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: 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

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

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

fn eq(&self, other: &Hsv<T, A>) -> 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, A: PartialOrd> PartialOrd 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: &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, 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 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> UlpsEq 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.

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

impl<T, A> StructuralPartialEq for Hsv<T, A>