Trait palette::Mix

pub trait Mix {
    type Scalar: Float;
    fn mix(&self, other: &Self, factor: Self::Scalar) -> Self;
}

A trait for linear color interpolation.

use palette::{LinSrgb, Mix};

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

assert_eq!(a.mix(&b, 0.0), a);
assert_eq!(a.mix(&b, 0.5), LinSrgb::new(0.5, 0.5, 0.5));
assert_eq!(a.mix(&b, 1.0), b);

Associated Types

type Scalar: Float

The type of the mixing factor.

Loading content...

Required methods

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

Mix the color with an other color, by factor.

factor sould be between 0.0 and 1.0, where 0.0 will result in the same color as self and 1.0 will result in the same color as other.

Loading content...

Implementors

impl<C: Mix> Mix for PreAlpha<C, C::Scalar>

type Scalar = C::Scalar

fn mix(
    &self,
    other: &PreAlpha<C, C::Scalar>,
    factor: C::Scalar
) -> PreAlpha<C, C::Scalar>

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

type Scalar = C::Scalar

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

impl<S, T> Mix for Luma<S, T> where
    T: Component + Float,
    S: LumaStandard<TransferFn = LinearFn>, 

type Scalar = T

fn mix(&self, other: &Luma<S, T>, factor: T) -> Luma<S, T>

impl<S, T> Mix for Rgb<S, T> where
    S: RgbStandard<TransferFn = LinearFn>,
    T: Component + Float, 

type Scalar = T

fn mix(&self, other: &Rgb<S, T>, factor: T) -> Rgb<S, T>

impl<S, T> Mix for Hsl<S, T> where
    T: Component + Float,
    S: RgbSpace, 

type Scalar = T

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

impl<S, T> Mix for Hsv<S, T> where
    T: Component + Float,
    S: RgbSpace, 

type Scalar = T

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

impl<S, T> Mix for Hwb<S, T> where
    T: Component + Float,
    S: RgbSpace, 

type Scalar = T

fn mix(&self, other: &Hwb<S, T>, factor: T) -> Hwb<S, T>

impl<Wp, T> Mix for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint, 

type Scalar = T

fn mix(&self, other: &Lab<Wp, T>, factor: T) -> Lab<Wp, T>

impl<Wp, T> Mix for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint, 

type Scalar = T

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

impl<Wp, T> Mix for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint, 

type Scalar = T

fn mix(&self, other: &Xyz<Wp, T>, factor: T) -> Xyz<Wp, T>

impl<Wp, T> Mix for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint, 

type Scalar = T

fn mix(&self, other: &Yxy<Wp, T>, factor: T) -> Yxy<Wp, T>

Loading content...