Trait palette::Saturate

pub trait Saturate: Sized {
    type Scalar: Float;
    fn saturate(&self, factor: Self::Scalar) -> Self;
    fn saturate_fixed(&self, amount: Self::Scalar) -> Self;

    fn desaturate(&self, factor: Self::Scalar) -> Self { ... }
    fn desaturate_fixed(&self, amount: Self::Scalar) -> Self { ... }
}

A trait for colors where the saturation (or chroma) can be manipulated without conversion.

The trait’s functions are split into two groups of functions: relative and fixed/absolute.

The relative functions, saturate and saturate, scale the saturation towards the maximum saturation value and minimum saturation value, respectively. This means that for a color with 50% saturation, if saturate(0.5) is applied to it, the color will scale halfway to the maximum value of 100% resulting in a new saturation value of 75%. desaturate(0.5) applied to the original color will result in a new color with 25% saturation since the saturation moves halfway toward the minimum value of 0%.

The fixed or absolute functions, saturate_fixed and desaturate_fixed, increase or descrease the saturation by an amount that is independent of the current saturation of the color. So for a color with 50% saturation, if saturate_fixed(0.5) is applied to it, the color will have 50% saturation added to its saturation value resulting in a new value of 100%. desaturate_fixed(0.5) will result in a new color with saturation of 0% since 50% saturation is subtracted from the original value of 50%.

use approx::assert_relative_eq;
use palette::{Hsv, Saturate};

let a = Hsv::new(0.0, 0.5, 1.0);

assert_relative_eq!(a.saturate(0.5).saturation, 0.75);
assert_relative_eq!(a.desaturate_fixed(0.5).saturation, 0.0);

Associated Types

type Scalar: Float

The type of the (de)saturation modifier.

Loading content...

Required methods

fn saturate(&self, factor: Self::Scalar) -> Self

Scale the color towards the maximum saturation by factor, a value ranging from 0.0 to 1.0.

use approx::assert_relative_eq;
use palette::{Hsl, Saturate};

let color = Hsl::new(0.0, 0.5, 0.5);
assert_relative_eq!(color.saturate(0.5).saturation, 0.75);

fn saturate_fixed(&self, amount: Self::Scalar) -> Self

Increase the saturation by amount, a value ranging from 0.0 to 1.0.

use approx::assert_relative_eq;
use palette::{Hsl, Saturate};

let color = Hsl::new(0.0, 0.4, 0.5);
assert_relative_eq!(color.saturate_fixed(0.2).saturation, 0.6);

Loading content...

Provided methods

fn desaturate(&self, factor: Self::Scalar) -> Self

Scale the color towards the minimum saturation by factor, a value ranging from 0.0 to 1.0.

use approx::assert_relative_eq;
use palette::{Hsv, Saturate};

let color = Hsv::new(0.0, 0.5, 0.5);
assert_relative_eq!(color.desaturate(0.5).saturation, 0.25);

fn desaturate_fixed(&self, amount: Self::Scalar) -> Self

Increase the saturation by amount, a value ranging from 0.0 to 1.0.

use approx::assert_relative_eq;
use palette::{Hsv, Saturate};

let color = Hsv::new(0.0, 0.4, 0.5);
assert_relative_eq!(color.desaturate_fixed(0.2).saturation, 0.2);

Loading content...

Implementors

impl<C: Saturate> Saturate for Alpha<C, C::Scalar>

type Scalar = C::Scalar

fn saturate(&self, factor: C::Scalar) -> Alpha<C, C::Scalar>

fn saturate_fixed(&self, amount: C::Scalar) -> Alpha<C, C::Scalar>

impl<S, T> Saturate for Hsl<S, T> where
    T: FloatComponent,
    S: RgbStandard, 

type Scalar = T

fn saturate(&self, factor: T) -> Hsl<S, T>

fn saturate_fixed(&self, amount: T) -> Hsl<S, T>

impl<S, T> Saturate for Hsv<S, T> where
    T: FloatComponent,
    S: RgbStandard, 

type Scalar = T

fn saturate(&self, factor: T) -> Hsv<S, T>

fn saturate_fixed(&self, amount: T) -> Hsv<S, T>

impl<Wp, T> Saturate for Hsluv<Wp, T> where
    T: FloatComponent,
    Wp: WhitePoint, 

type Scalar = T

fn saturate(&self, factor: T) -> Hsluv<Wp, T>

fn saturate_fixed(&self, amount: T) -> Hsluv<Wp, T>

impl<Wp, T> Saturate for Lch<Wp, T> where
    T: FloatComponent,
    Wp: WhitePoint, 

type Scalar = T

fn saturate(&self, factor: T) -> Lch<Wp, T>

fn saturate_fixed(&self, amount: T) -> Lch<Wp, T>

impl<Wp, T> Saturate for Lchuv<Wp, T> where
    T: FloatComponent,
    Wp: WhitePoint, 

type Scalar = T

fn saturate(&self, factor: T) -> Lchuv<Wp, T>

fn saturate_fixed(&self, amount: T) -> Lchuv<Wp, T>

Loading content...