[][src]Struct amethyst_rendy::palette::Alpha

#[repr(C)]pub struct Alpha<C, T> {
    pub color: C,
    pub alpha: T,
}

An alpha component wrapper for colors.

Fields

color: C

The color.

alpha: T

The transparency component. 0.0 is fully transparent and 1.0 is fully opaque.

Implementations

impl<T, A> Alpha<Hsl<Srgb, T>, A> where
    A: Component,
    T: Component + Float
[src]

Hsla implementations.

pub fn new<H>(
    hue: H,
    saturation: T,
    lightness: T,
    alpha: A
) -> Alpha<Hsl<Srgb, T>, A> where
    H: Into<RgbHue<T>>, 
[src]

HSL and transparency for linear sRGB.

impl<S, T, A> Alpha<Hsl<S, T>, A> where
    A: Component,
    S: RgbSpace,
    T: Component + Float
[src]

Hsla implementations.

pub fn with_wp<H>(
    hue: H,
    saturation: T,
    lightness: T,
    alpha: A
) -> Alpha<Hsl<S, T>, A> where
    H: Into<RgbHue<T>>, 
[src]

Linear HSL and transparency.

pub fn into_components(self) -> (RgbHue<T>, T, T, A)[src]

Convert to a (hue, saturation, lightness, alpha) tuple.

pub fn from_components<H>((H, T, T, A)) -> Alpha<Hsl<S, T>, A> where
    H: Into<RgbHue<T>>, 
[src]

Convert from a (hue, saturation, lightness, alpha) tuple.

impl<T, A> Alpha<Hsv<Srgb, T>, A> where
    A: Component,
    T: Component + Float
[src]

Hsva implementations.

pub fn new<H>(
    hue: H,
    saturation: T,
    value: T,
    alpha: A
) -> Alpha<Hsv<Srgb, T>, A> where
    H: Into<RgbHue<T>>, 
[src]

HSV and transparency for linear sRGB.

impl<S, T, A> Alpha<Hsv<S, T>, A> where
    A: Component,
    S: RgbSpace,
    T: Component + Float
[src]

Hsva implementations.

pub fn with_wp<H>(
    hue: H,
    saturation: T,
    value: T,
    alpha: A
) -> Alpha<Hsv<S, T>, A> where
    H: Into<RgbHue<T>>, 
[src]

Linear HSV and transparency.

pub fn into_components(self) -> (RgbHue<T>, T, T, A)[src]

Convert to a (hue, saturation, value, alpha) tuple.

pub fn from_components<H>((H, T, T, A)) -> Alpha<Hsv<S, T>, A> where
    H: Into<RgbHue<T>>, 
[src]

Convert from a (hue, saturation, value, alpha) tuple.

impl<T, A> Alpha<Hwb<Srgb, T>, A> where
    A: Component,
    T: Component + Float
[src]

Hwba implementations.

pub fn new<H>(
    hue: H,
    whiteness: T,
    blackness: T,
    alpha: A
) -> Alpha<Hwb<Srgb, T>, A> where
    H: Into<RgbHue<T>>, 
[src]

HWB and transparency for linear sRGB.

impl<S, T, A> Alpha<Hwb<S, T>, A> where
    A: Component,
    S: RgbSpace,
    T: Component + Float
[src]

Hwba implementations.

pub fn with_wp<H>(
    hue: H,
    whiteness: T,
    blackness: T,
    alpha: A
) -> Alpha<Hwb<S, T>, A> where
    H: Into<RgbHue<T>>, 
[src]

Linear HWB and transparency.

pub fn into_components(self) -> (RgbHue<T>, T, T, A)[src]

Convert to a (hue, whiteness, blackness, alpha) tuple.

pub fn from_components<H>((H, T, T, A)) -> Alpha<Hwb<S, T>, A> where
    H: Into<RgbHue<T>>, 
[src]

Convert from a (hue, whiteness, blackness, alpha) tuple.

impl<T, A> Alpha<Lab<D65, T>, A> where
    A: Component,
    T: Component + Float
[src]

Laba implementations.

pub fn new(l: T, a: T, b: T, alpha: A) -> Alpha<Lab<D65, T>, A>[src]

CIE L*a*b* and transparency and white point D65.

impl<Wp, T, A> Alpha<Lab<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

Laba implementations.

pub fn with_wp(l: T, a: T, b: T, alpha: A) -> Alpha<Lab<Wp, T>, A>[src]

CIE L*a*b* and transparency.

pub fn into_components(self) -> (T, T, T, A)[src]

Convert to a (L\*, a\*, b\*, alpha) tuple.

pub fn from_components((T, T, T, A)) -> Alpha<Lab<Wp, T>, A>[src]

Convert from a (L\*, a\*, b\*, alpha) tuple.

impl<T, A> Alpha<Lch<D65, T>, A> where
    A: Component,
    T: Component + Float
[src]

Lcha implementations.

pub fn new<H>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Lch<D65, T>, A> where
    H: Into<LabHue<T>>, 
[src]

CIE L*C*h° and transparency with white point D65.

impl<Wp, T, A> Alpha<Lch<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

Lcha implementations.

pub fn with_wp<H>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Lch<Wp, T>, A> where
    H: Into<LabHue<T>>, 
[src]

CIE L*C*h° and transparency.

pub fn into_components(self) -> (T, T, LabHue<T>, A)[src]

Convert to a (L\*, C\*, h°, alpha) tuple.

pub fn from_components<H>((T, T, H, A)) -> Alpha<Lch<Wp, T>, A> where
    H: Into<LabHue<T>>, 
[src]

Convert from a (L\*, C\*, h°, alpha) tuple.

impl<S, T, A> Alpha<Luma<S, T>, A> where
    A: Component,
    S: LumaStandard,
    T: Component
[src]

Lumaa implementations.

pub fn new(luma: T, alpha: A) -> Alpha<Luma<S, T>, A>[src]

Create a luminance color with transparency.

pub fn into_format<U, B>(self) -> Alpha<Luma<S, U>, B> where
    B: Component,
    U: Component
[src]

Convert into another component type.

pub fn from_format<U, B>(color: Alpha<Luma<S, U>, B>) -> Alpha<Luma<S, T>, A> where
    B: Component,
    U: Component
[src]

Convert from another component type.

pub fn into_components(self) -> (T, A)[src]

Convert to a (luma, alpha) tuple.

pub fn from_components((T, A)) -> Alpha<Luma<S, T>, A>[src]

Convert from a (luma, alpha) tuple.

impl<S, T, A> Alpha<Luma<S, T>, A> where
    A: Component,
    S: LumaStandard,
    T: Component + Float
[src]

Lumaa implementations.

pub fn into_linear(
    self
) -> Alpha<Luma<Linear<<S as LumaStandard>::WhitePoint>, T>, A>
[src]

Convert the color to linear luminance with transparency.

pub fn from_linear(
    color: Alpha<Luma<Linear<<S as LumaStandard>::WhitePoint>, T>, A>
) -> Alpha<Luma<S, T>, A>
[src]

Convert linear luminance to nonlinear luminance with transparency.

pub fn into_encoding<St>(self) -> Alpha<Luma<St, T>, A> where
    St: LumaStandard<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

Convert the color to a different encoding with transparency.

pub fn from_encoding<St>(color: Alpha<Luma<St, T>, A>) -> Alpha<Luma<S, T>, A> where
    St: LumaStandard<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

Convert luminance from a different encoding with transparency.

impl<S, T, A> Alpha<Rgb<S, T>, A> where
    A: Component,
    S: RgbStandard,
    T: Component
[src]

Rgba implementations.

pub fn new(red: T, green: T, blue: T, alpha: A) -> Alpha<Rgb<S, T>, A>[src]

Nonlinear RGB.

pub fn into_format<U, B>(self) -> Alpha<Rgb<S, U>, B> where
    B: Component,
    U: Component
[src]

Convert into another component type.

pub fn from_format<U, B>(color: Alpha<Rgb<S, U>, B>) -> Alpha<Rgb<S, T>, A> where
    B: Component,
    U: Component
[src]

Convert from another component type.

pub fn into_components(self) -> (T, T, T, A)[src]

Convert to a (red, green, blue, alpha) tuple.

pub fn from_components((T, T, T, A)) -> Alpha<Rgb<S, T>, A>[src]

Convert from a (red, green, blue, alpha) tuple.

impl<S, T, A> Alpha<Rgb<S, T>, A> where
    A: Component,
    S: RgbStandard,
    T: Component + Float
[src]

Rgba implementations.

pub fn into_linear(self) -> Alpha<Rgb<Linear<<S as RgbStandard>::Space>, T>, A>[src]

Convert the color to linear RGB with transparency.

pub fn from_linear(
    color: Alpha<Rgb<Linear<<S as RgbStandard>::Space>, T>, A>
) -> Alpha<Rgb<S, T>, A>
[src]

Convert linear RGB to nonlinear RGB with transparency.

pub fn into_encoding<St>(self) -> Alpha<Rgb<St, T>, A> where
    St: RgbStandard<Space = <S as RgbStandard>::Space>, 
[src]

Convert the color to a different encoding with transparency.

pub fn from_encoding<St>(color: Alpha<Rgb<St, T>, A>) -> Alpha<Rgb<S, T>, A> where
    St: RgbStandard<Space = <S as RgbStandard>::Space>, 
[src]

Convert RGB from a different encoding with transparency.

impl<T, A> Alpha<Xyz<D65, T>, A> where
    A: Component,
    T: Component + Float
[src]

Xyza implementations.

pub fn new(x: T, y: T, luma: T, alpha: A) -> Alpha<Xyz<D65, T>, A>[src]

CIE Yxy and transparency with white point D65.

impl<Wp, T, A> Alpha<Xyz<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

Xyza implementations.

pub fn with_wp(x: T, y: T, z: T, alpha: A) -> Alpha<Xyz<Wp, T>, A>[src]

CIE XYZ and transparency.

pub fn into_components(self) -> (T, T, T, A)[src]

Convert to a (X, Y, Z, alpha) tuple.

pub fn from_components((T, T, T, A)) -> Alpha<Xyz<Wp, T>, A>[src]

Convert from a (X, Y, Z, alpha) tuple.

impl<T, A> Alpha<Yxy<D65, T>, A> where
    A: Component,
    T: Component + Float
[src]

Yxya implementations.

pub fn new(x: T, y: T, luma: T, alpha: A) -> Alpha<Yxy<D65, T>, A>[src]

CIE Yxy and transparency with white point D65.

impl<Wp, T, A> Alpha<Yxy<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

Yxya implementations.

pub fn with_wp(x: T, y: T, luma: T, alpha: A) -> Alpha<Yxy<Wp, T>, A>[src]

CIE Yxy and transparency.

pub fn into_components(self) -> (T, T, T, A)[src]

Convert to a (x, y, luma), a.k.a. (x, y, Y) tuple.

pub fn from_components((T, T, T, A)) -> Alpha<Yxy<Wp, T>, A>[src]

Convert from a (x, y, luma), a.k.a. (x, y, Y) tuple.

impl<T> Alpha<Color<Srgb, T>, T> where
    T: Component + Float
[src]

Colora implementations.

pub fn linear_y(luma: T, alpha: T) -> Alpha<Color<Srgb, T>, T>[src]

Linear luminance.

pub fn linear_rgb(
    red: T,
    green: T,
    blue: T,
    alpha: T
) -> Alpha<Color<Srgb, T>, T>
[src]

Linear RGB.

pub fn xyz(x: T, y: T, z: T, alpha: T) -> Alpha<Color<Srgb, T>, T>[src]

CIE XYZ.

pub fn yxy(x: T, y: T, luma: T, alpha: T) -> Alpha<Color<Srgb, T>, T>[src]

CIE Yxy.

pub fn lab(l: T, a: T, b: T, alpha: T) -> Alpha<Color<Srgb, T>, T>[src]

CIE L*a*b*.

pub fn lch(
    l: T,
    chroma: T,
    hue: LabHue<T>,
    alpha: T
) -> Alpha<Color<Srgb, T>, T>
[src]

CIE L*C*h°.

pub fn hsv(
    hue: RgbHue<T>,
    saturation: T,
    value: T,
    alpha: T
) -> Alpha<Color<Srgb, T>, T>
[src]

Linear HSV.

pub fn hsl(
    hue: RgbHue<T>,
    saturation: T,
    lightness: T,
    alpha: T
) -> Alpha<Color<Srgb, T>, T>
[src]

Linear HSL.

pub fn hwb(
    hue: RgbHue<T>,
    whiteness: T,
    balckness: T,
    alpha: T
) -> Alpha<Color<Srgb, T>, T>
[src]

Linear HWB.

Trait Implementations

impl<C, T> Add<Alpha<C, T>> for Alpha<C, T> where
    C: Add<C>,
    T: Float
[src]

type Output = Alpha<<C as Add<C>>::Output, <T as Add<T>>::Output>

The resulting type after applying the + operator.

impl<T, C> Add<T> for Alpha<C, T> where
    C: Add<T>,
    T: Clone + Add<T>, 
[src]

type Output = Alpha<<C as Add<T>>::Output, <T as Add<T>>::Output>

The resulting type after applying the + operator.

impl<C, T> ApproxEq for Alpha<C, T> where
    C: ApproxEq<Epsilon = <T as ApproxEq>::Epsilon>,
    T: ApproxEq,
    <T as ApproxEq>::Epsilon: Clone
[src]

type Epsilon = <T as ApproxEq>::Epsilon

Used for specifying relative comparisons.

impl<C, T, P> AsMut<P> for Alpha<C, T> where
    C: Pixel<T>,
    P: RawPixel<T> + ?Sized
[src]

impl AsRef<Alpha<Rgb<Srgb, f32>, f32>> for AmbientColor[src]

impl<C, T, P> AsRef<P> for Alpha<C, T> where
    C: Pixel<T>,
    P: RawPixel<T> + ?Sized
[src]

impl<C, T> Blend for Alpha<C, T> where
    C: Blend,
    T: Float,
    <C as Blend>::Color: ComponentWise,
    Alpha<C, T>: Into<Alpha<<C as Blend>::Color, T>>,
    Alpha<C, T>: From<Alpha<<C as Blend>::Color, T>>,
    <<C as Blend>::Color as ComponentWise>::Scalar == T, 
[src]

type Color = <C as Blend>::Color

The core color type. Typically Self for color types without alpha.

impl<C, T> Clone for Alpha<C, T> where
    C: Clone,
    T: Clone
[src]

impl<C, T> ComponentWise for Alpha<C, T> where
    C: ComponentWise<Scalar = T>,
    T: Clone
[src]

type Scalar = T

The scalar type for color components.

impl<C, T> Copy for Alpha<C, T> where
    C: Copy,
    T: Copy
[src]

impl<C, T> Debug for Alpha<C, T> where
    C: Debug,
    T: Debug
[src]

impl<C, T> Default for Alpha<C, T> where
    C: Default,
    T: Component
[src]

impl<C, T> Deref for Alpha<C, T>[src]

type Target = C

The resulting type after dereferencing.

impl<C, T> DerefMut for Alpha<C, T>[src]

impl<'de, C, T> Deserialize<'de> for Alpha<C, T> where
    C: Deserialize<'de>,
    T: Deserialize<'de>, 
[src]

impl<C, T> Div<Alpha<C, T>> for Alpha<C, T> where
    C: Div<C>,
    T: Float
[src]

type Output = Alpha<<C as Div<C>>::Output, <T as Div<T>>::Output>

The resulting type after applying the / operator.

impl<T, C> Div<T> for Alpha<C, T> where
    C: Div<T>,
    T: Clone + Div<T>, 
[src]

type Output = Alpha<<C as Div<T>>::Output, <T as Div<T>>::Output>

The resulting type after applying the / operator.

impl<S, T, H, A> From<(H, T, T, A)> for Alpha<Hsv<S, T>, A> where
    A: Component,
    H: Into<RgbHue<T>>,
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T, H, A> From<(H, T, T, A)> for Alpha<Hsl<S, T>, A> where
    A: Component,
    H: Into<RgbHue<T>>,
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T, H, A> From<(H, T, T, A)> for Alpha<Hwb<S, T>, A> where
    A: Component,
    H: Into<RgbHue<T>>,
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T, A> From<(T, A)> for Alpha<Luma<S, T>, A> where
    A: Component,
    S: LumaStandard,
    T: Component
[src]

impl<Wp, T, H, A> From<(T, T, H, A)> for Alpha<Lch<Wp, T>, A> where
    A: Component,
    H: Into<LabHue<T>>,
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Lab<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Xyz<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<S, T, A> From<(T, T, T, A)> for Alpha<Rgb<S, T>, A> where
    A: Component,
    S: RgbStandard,
    T: Component
[src]

impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Yxy<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<C, T> From<Alpha<C, T>> for PreAlpha<C, T> where
    C: ComponentWise<Scalar = T>,
    T: Float
[src]

impl<S, T> From<Alpha<Color<<S as RgbStandard>::Space, T>, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Color<<S as RgbStandard>::Space, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Color<S, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Color<S, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Color<S, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Color<S, T>, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Color<S, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Color<S, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T, _S> From<Alpha<Color<_S, T>, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Color<_S, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Color<_S, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Color<_S, T>, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Color<_S, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Color<_S, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Color<_S, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Color<_S, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Color<_S, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Color<_S, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T> From<Alpha<Hsl<<S as RgbStandard>::Space, T>, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsl<<S as RgbStandard>::Space, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsl<S, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsl<S, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Hsl<S, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsl<S, T>, T>> for Alpha<Color<S, T>, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Hsl<S, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsl<S, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsl<S, T>, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T, _S> From<Alpha<Hsl<_S, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Hsl<_S, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsl<_S, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsl<_S, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsl<_S, T>, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Hsl<_S, T>, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsl<_S, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsl<_S, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsl<_S, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsl<_S, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T> From<Alpha<Hsv<<S as RgbStandard>::Space, T>, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsv<<S as RgbStandard>::Space, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsv<S, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsv<S, T>, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsv<S, T>, T>> for Alpha<Color<S, T>, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Hsv<S, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsv<S, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Hsv<S, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hsv<S, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T, _S> From<Alpha<Hsv<_S, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsv<_S, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsv<_S, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsv<_S, T>, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Hsv<_S, T>, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsv<_S, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsv<_S, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsv<_S, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Hsv<_S, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Hsv<_S, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T> From<Alpha<Hwb<<S as RgbStandard>::Space, T>, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hwb<<S as RgbStandard>::Space, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hwb<S, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hwb<S, T>, T>> for Alpha<Color<S, T>, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Hwb<S, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hwb<S, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hwb<S, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Hwb<S, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Hwb<S, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T, _S> From<Alpha<Hwb<_S, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hwb<_S, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hwb<_S, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hwb<_S, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Hwb<_S, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Hwb<_S, T>, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Hwb<_S, T>, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Hwb<_S, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hwb<_S, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Hwb<_S, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T> From<Alpha<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lab<<S as LumaStandard>::WhitePoint, T>, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lab<<S as LumaStandard>::WhitePoint, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Color<S, T>, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<S, T> From<Alpha<Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lch<<S as LumaStandard>::WhitePoint, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lch<<S as LumaStandard>::WhitePoint, T>, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Color<S, T>, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<S, T> From<Alpha<Luma<Linear<<S as RgbSpace>::WhitePoint>, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Luma<Linear<<S as RgbSpace>::WhitePoint>, T>, T>> for Alpha<Color<S, T>, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T, B> From<Alpha<Luma<S, T>, T>> for Pixel<Rg, B, Srgb> where
    B: ChannelSize,
    S: LumaStandard<WhitePoint = D65>,
    T: Component,
    Srgb: ChannelRepr<B>,
    <Srgb as ChannelRepr<B>>::Repr: Component

impl<S, T, B> From<Alpha<Luma<S, T>, T>> for Pixel<Rg, B, Unorm> where
    B: ChannelSize,
    S: LumaStandard<WhitePoint = D65>,
    T: Component,
    Unorm: ChannelRepr<B>,
    <Unorm as ChannelRepr<B>>::Repr: Component

impl<S, T, B> From<Alpha<Luma<S, T>, T>> for Pixel<Rg, B, Float> where
    B: ChannelSize,
    S: LumaStandard<WhitePoint = D65>,
    T: Component,
    Float: ChannelRepr<B>,
    <Float as ChannelRepr<B>>::Repr: Component

impl<Wp, T, _S> From<Alpha<Luma<_S, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Luma<_S, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Luma<_S, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <<S as RgbStandard>::Space as RgbSpace>::WhitePoint>, 
[src]

impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Luma<_S, T>, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Luma<_S, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Luma<_S, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>, 
[src]

impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>, 
[src]

impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <<S as RgbStandard>::Space as RgbSpace>::WhitePoint>, 
[src]

impl<S, T, _S> From<Alpha<Luma<_S, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Alpha<Luma<_S, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Alpha<Luma<_S, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<S, T> From<Alpha<Rgb<Linear<S>, T>, T>> for Alpha<Color<S, T>, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Rgb<Linear<S>, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T, B> From<Alpha<Rgb<S, T>, T>> for Pixel<Rgba, B, Unorm> where
    B: ChannelSize,
    S: RgbStandard<Space = Srgb>,
    T: Component,
    Unorm: ChannelRepr<B>,
    <Unorm as ChannelRepr<B>>::Repr: Component

impl<S, T, B> From<Alpha<Rgb<S, T>, T>> for Pixel<Rgba, B, Srgb> where
    B: ChannelSize,
    S: RgbStandard<Space = Srgb>,
    T: Component,
    Srgb: ChannelRepr<B>,
    <Srgb as ChannelRepr<B>>::Repr: Component

impl<S, T, B> From<Alpha<Rgb<S, T>, T>> for Pixel<Rgba, B, Float> where
    B: ChannelSize,
    S: RgbStandard<Space = Srgb>,
    T: Component,
    Float: ChannelRepr<B>,
    <Float as ChannelRepr<B>>::Repr: Component

impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<Wp, T, _S> From<Alpha<Rgb<_S, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<Wp, T, _S> From<Alpha<Rgb<_S, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<Wp, T, _S> From<Alpha<Rgb<_S, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<Wp, T, _S> From<Alpha<Rgb<_S, T>, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<Wp, T, _S> From<Alpha<Rgb<_S, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == <S as LumaStandard>::WhitePoint
[src]

impl<Wp, T, _S> From<Alpha<Rgb<_S, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float,
    _S: RgbStandard<Space = <S as RgbStandard>::Space>, 
[src]

impl<Wp, T, _S> From<Alpha<Rgb<_S, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<Wp, T, _S> From<Alpha<Rgb<_S, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, _S> From<Alpha<Rgb<_S, T>, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == <S as LumaStandard>::WhitePoint
[src]

impl<S, T> From<Alpha<Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Xyz<<S as LumaStandard>::WhitePoint, T>, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Xyz<<S as LumaStandard>::WhitePoint, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Color<S, T>, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<S, T> From<Alpha<Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Yxy<<S as LumaStandard>::WhitePoint, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Yxy<<S as LumaStandard>::WhitePoint, T>, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Color<S, T>, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[src]

impl<S, T> From<Alpha<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Alpha<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<C, T> From<C> for Alpha<C, T> where
    T: Component
[src]

impl<S, T> From<Color<<S as RgbStandard>::Space, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Color<S, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Color<S, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Color<S, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T, _S> From<Color<_S, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Color<_S, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Color<_S, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Color<_S, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Color<_S, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<S, T> From<Hsl<<S as RgbStandard>::Space, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Hsl<S, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Hsl<S, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T, _S> From<Hsl<_S, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Hsl<_S, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Hsl<_S, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Hsl<_S, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Hsl<_S, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<S, T> From<Hsv<<S as RgbStandard>::Space, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Hsv<S, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Hsv<S, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T, _S> From<Hsv<_S, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Hsv<_S, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Hsv<_S, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Hsv<_S, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Hsv<_S, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T> From<Hwb<<S as RgbStandard>::Space, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Hwb<S, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Hwb<S, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T, _S> From<Hwb<_S, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Hwb<_S, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Hwb<_S, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbSpace<WhitePoint = <S as LumaStandard>::WhitePoint>, 
[src]

impl<Wp, T, _S> From<Hwb<_S, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Hwb<_S, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<S, T> From<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Lab<<S as LumaStandard>::WhitePoint, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Lab<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Lab<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Lab<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Lab<Wp, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Lab<Wp, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Lab<Wp, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<S, T> From<Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Lch<<S as LumaStandard>::WhitePoint, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Lch<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Lch<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Lch<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Lch<Wp, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Lch<Wp, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Lch<Wp, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T, _S> From<Luma<_S, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Luma<_S, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Luma<_S, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<Wp, T, _S> From<Luma<_S, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[src]

impl<S, T, _S> From<Luma<_S, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <<S as RgbStandard>::Space as RgbSpace>::WhitePoint>, 
[src]

impl<S, T, _S> From<Luma<_S, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>, 
[src]

impl<S, T, _S> From<Luma<_S, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>, 
[src]

impl<S, T, _S> From<Luma<_S, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as RgbSpace>::WhitePoint>, 
[src]

impl<C, T> From<PreAlpha<C, T>> for Alpha<C, T> where
    C: ComponentWise<Scalar = T>,
    T: Float
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<Wp, T, _S> From<Rgb<_S, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == Wp, 
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float,
    _S: RgbStandard,
    <_S as RgbStandard>::Space: RgbSpace,
    <<_S as RgbStandard>::Space as RgbSpace>::WhitePoint == <S as LumaStandard>::WhitePoint
[src]

impl<S, T, _S> From<Rgb<_S, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[src]

impl<S, T> From<Xyz<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Xyz<<S as LumaStandard>::WhitePoint, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Xyz<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Xyz<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Xyz<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Xyz<Wp, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Xyz<Wp, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Xyz<Wp, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<S, T> From<Yxy<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[src]

impl<S, T> From<Yxy<<S as LumaStandard>::WhitePoint, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    T: Component + Float
[src]

impl<S, T> From<Yxy<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Yxy<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T> From<Yxy<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Yxy<Wp, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Yxy<Wp, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Yxy<Wp, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<C, T> GetHue for Alpha<C, T> where
    C: GetHue
[src]

type Hue = <C as GetHue>::Hue

The kind of hue unit this color space uses. Read more

impl<C, T> Hue for Alpha<C, T> where
    C: Hue,
    T: Clone
[src]

impl<S, T, A> Into<(RgbHue<T>, T, T, A)> for Alpha<Hwb<S, T>, A> where
    A: Component,
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T, A> Into<(RgbHue<T>, T, T, A)> for Alpha<Hsl<S, T>, A> where
    A: Component,
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T, A> Into<(RgbHue<T>, T, T, A)> for Alpha<Hsv<S, T>, A> where
    A: Component,
    S: RgbSpace,
    T: Component + Float
[src]

impl<S, T, A> Into<(T, A)> for Alpha<Luma<S, T>, A> where
    A: Component,
    S: LumaStandard,
    T: Component
[src]

impl<Wp, T, A> Into<(T, T, LabHue<T>, A)> for Alpha<Lch<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T, A> Into<(T, T, T, A)> for Alpha<Yxy<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T, A> Into<(T, T, T, A)> for Alpha<Xyz<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T, A> Into<(T, T, T, A)> for Alpha<Lab<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<S, T, A> Into<(T, T, T, A)> for Alpha<Rgb<S, T>, A> where
    A: Component,
    S: RgbStandard,
    T: Component
[src]

impl<C, T> Limited for Alpha<C, T> where
    C: Limited,
    T: Component
[src]

impl<C, T> LowerHex for Alpha<C, T> where
    C: LowerHex,
    T: LowerHex
[src]

impl<C> Mix for Alpha<C, <C as Mix>::Scalar> where
    C: Mix
[src]

type Scalar = <C as Mix>::Scalar

The type of the mixing factor.

impl<C, T> Mul<Alpha<C, T>> for Alpha<C, T> where
    C: Mul<C>,
    T: Float
[src]

type Output = Alpha<<C as Mul<C>>::Output, <T as Mul<T>>::Output>

The resulting type after applying the * operator.

impl<T, C> Mul<T> for Alpha<C, T> where
    C: Mul<T>,
    T: Clone + Mul<T>, 
[src]

type Output = Alpha<<C as Mul<T>>::Output, <T as Mul<T>>::Output>

The resulting type after applying the * operator.

impl<C, T> PartialEq<Alpha<C, T>> for Alpha<C, T> where
    C: PartialEq<C>,
    T: PartialEq<T>, 
[src]

impl<T, C> Pixel<T> for Alpha<C, T> where
    C: Pixel<T>, 
[src]

impl<C> Saturate for Alpha<C, <C as Saturate>::Scalar> where
    C: Saturate
[src]

type Scalar = <C as Saturate>::Scalar

The type of the (de)saturation factor.

impl<C, T> Serialize for Alpha<C, T> where
    C: Serialize,
    T: Serialize
[src]

impl<C> Shade for Alpha<C, <C as Shade>::Scalar> where
    C: Shade
[src]

type Scalar = <C as Shade>::Scalar

The type of the lighten/darken amount.

impl<C, T> StructuralPartialEq for Alpha<C, T>[src]

impl<C, T> Sub<Alpha<C, T>> for Alpha<C, T> where
    C: Sub<C>,
    T: Float
[src]

type Output = Alpha<<C as Sub<C>>::Output, <T as Sub<T>>::Output>

The resulting type after applying the - operator.

impl<T, C> Sub<T> for Alpha<C, T> where
    C: Sub<T>,
    T: Clone + Sub<T>, 
[src]

type Output = Alpha<<C as Sub<T>>::Output, <T as Sub<T>>::Output>

The resulting type after applying the - operator.

impl<C, T> UpperHex for Alpha<C, T> where
    C: UpperHex,
    T: UpperHex
[src]

Auto Trait Implementations

impl<C, T> RefUnwindSafe for Alpha<C, T> where
    C: RefUnwindSafe,
    T: RefUnwindSafe

impl<C, T> Send for Alpha<C, T> where
    C: Send,
    T: Send

impl<C, T> Sync for Alpha<C, T> where
    C: Sync,
    T: Sync

impl<C, T> Unpin for Alpha<C, T> where
    C: Unpin,
    T: Unpin

impl<C, T> UnwindSafe for Alpha<C, T> where
    C: UnwindSafe,
    T: UnwindSafe

Blanket Implementations

impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S where
    D: AdaptFrom<S, Swp, Dwp, T>,
    Dwp: WhitePoint,
    Swp: WhitePoint,
    T: Component + Float
[src]