Struct Hsl

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

The HSL device-dependent polar color model

HSL is defined by a hue (base color), saturation (color richness) and value (whiteness). Like HSV, HSL is modeled as a cylinder, however the underlying space is two cones stacked bottom-to-bottom. /// This causes some level of distortion and a degeneracy at S=0 or L={0,1}. 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.

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

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

where T: PosNormalChannelScalar, A: AngularChannelScalar,

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

Construct an Hsl instance from hue, saturation and lightness

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

Returns the lightness scalar

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

Returns a mutable reference to the hue scalar

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

Returns a mutable reference to the saturation scalar

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

Returns a mutable reference to the lightness 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_lightness(&mut self, val: T)

Set the lightness channel value

Trait Implementations

impl<T, A> AbsDiffEq for Hsl<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 Hsl<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 Hsl<T, A>

fn clone(&self) -> Hsl<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 Hsl<T, A>

where T: PosNormalChannelScalar, A: AngularChannelScalar,

type Tag = HslTag

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

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

Formats the value using the given formatter.

impl<T, A> Default for Hsl<T, A>

where T: PosNormalChannelScalar + Zero, A: AngularChannelScalar + Zero,

fn default() -> Self

Returns the “default value” for a type.

impl<T, A> Display for Hsl<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 Hsl<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<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<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> 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<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> FromTuple for Hsl<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 Hsl<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 Hsl<T, A>

where T: PosNormalChannelScalar, A: AngularChannelScalar,

fn invert(self) -> Self

Invert Self

impl<T, A> Lerp for Hsl<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 Hsl<T, A>

fn eq(&self, other: &Hsl<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 Hsl<T, A>

fn partial_cmp(&self, other: &Hsl<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 Hsl<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 Hsl<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 Hsl<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 Hsl<T, A>

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