[][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.

Methods

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> Default for Alpha<C, T> where
    C: Default,
    T: Component
[src]

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

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

fn as_raw<P>(&self) -> &P where
    P: RawPixel<T> + ?Sized
[src]

Cast as a reference to raw color components.

fn as_raw_mut<P>(&mut self) -> &mut P where
    P: RawPixel<T> + ?Sized
[src]

Cast as a mutable reference to raw color components.

fn into_raw<P>(self) -> P where
    P: RawPixelSized<T>, 
[src]

Convert from raw color components.

fn from_raw<P>(pixel: &P) -> &Self where
    P: RawPixel<T> + ?Sized
[src]

Cast from a reference to raw color components.

fn from_raw_mut<P>(pixel: &mut P) -> &mut Self where
    P: RawPixel<T> + ?Sized
[src]

Cast from a mutable reference to raw color components.

Important traits for &'_ [u8]
fn from_raw_slice(slice: &[T]) -> &[Self][src]

Cast a slice of raw color components to a slice of colors. Read more

Important traits for &'_ [u8]
fn from_raw_slice_mut(slice: &mut [T]) -> &mut [Self][src]

Cast a mutable slice of raw color components to a mutable slice of colors. Read more

Important traits for &'_ [u8]
fn into_raw_slice(slice: &[Self]) -> &[T][src]

Cast a slice of colors to a slice of raw color components. Read more

Important traits for &'_ [u8]
fn into_raw_slice_mut(slice: &mut [Self]) -> &mut [T][src]

Cast a mutable slice of colors to a mutable slice of raw color components. Read more

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

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl<'de, C, T> Deserialize<'de> for Alpha<C, T> where
    C: Deserialize<'de>,
    T: Deserialize<'de>, 
[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.

fn blend<F>(self, destination: Self, blend_function: F) -> Self where
    F: BlendFunction<Self::Color>, 
[src]

Blend self, as the source color, with destination, using blend_function. Anything that implements BlendFunction is acceptable, including functions and closures. Read more

fn over(self, other: Self) -> Self[src]

Place self over other. This is the good old common alpha composition equation. Read more

fn inside(self, other: Self) -> Self[src]

Results in the parts of self that overlaps the visible parts of other. Read more

fn outside(self, other: Self) -> Self[src]

Results in the parts of self that lies outside the visible parts of other. Read more

fn atop(self, other: Self) -> Self[src]

Place self over only the visible parts of other.

fn xor(self, other: Self) -> Self[src]

Results in either self or other, where they do not overlap.

fn plus(self, other: Self) -> Self[src]

Add self and other. This uses the alpha component to regulate the effect, so it's not just plain component wise addition. Read more

fn multiply(self, other: Self) -> Self[src]

Multiply self with other. This uses the alpha component to regulate the effect, so it's not just plain component wise multiplication. Read more

fn screen(self, other: Self) -> Self[src]

Make a color which is at least as light as self or other.

fn overlay(self, other: Self) -> Self[src]

Multiply self or other if other is dark, or screen them if other is light. This results in an S curve. Read more

fn darken(self, other: Self) -> Self[src]

Return the darkest parts of self and other.

fn lighten(self, other: Self) -> Self[src]

Return the lightest parts of self and other.

fn dodge(self, other: Self) -> Self[src]

Lighten other to reflect self. Results in other if self is black. Read more

fn burn(self, other: Self) -> Self[src]

Darken other to reflect self. Results in other if self is white. Read more

fn hard_light(self, other: Self) -> Self[src]

Multiply self or other if other is dark, or screen them if self is light. This is similar to overlay, but depends on self instead of other. Read more

fn soft_light(self, other: Self) -> Self[src]

Lighten other if self is light, or darken other as if it's burned if self is dark. The effect is increased if the components of self is further from 0.5. Read more

fn difference(self, other: Self) -> Self[src]

Return the absolute difference between self and other. It's basically abs(self - other), but regulated by the alpha component. Read more

fn exclusion(self, other: Self) -> Self[src]

Similar to difference, but appears to result in a lower contrast. other is inverted if self is white, and preserved if self is black. Read more

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

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: Add<T> + Clone
[src]

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

The resulting type after applying the + operator.

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

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

impl<C, T> UpperHex for Alpha<C, T> where
    C: UpperHex,
    T: UpperHex
[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.

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

Decrease the saturation by factor.

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

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

The resulting type after applying the - operator.

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> Mul<T> for Alpha<C, T> where
    C: Mul<T>,
    T: Mul<T> + Clone
[src]

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

The resulting type after applying the * operator.

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<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<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<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<(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<(RgbHue<T>, T, T, A)> for Alpha<Hwb<S, T>, A> where
    A: Component,
    S: RgbSpace,
    T: Component + Float
[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<S, T, A> Into<(T, T, T, A)> for Alpha<Rgb<S, T>, A> where
    A: Component,
    S: RgbStandard,
    T: Component
[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<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<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: Div<T> + Clone
[src]

type Output = Alpha<<C as Div<T>>::Output, <T as Div<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.

fn relative_ne(
    &self,
    other: &Self,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool
[src]

The inverse of ApproxEq::relative_eq.

fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool[src]

The inverse of ApproxEq::ulps_eq.

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

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

impl<C, T> LowerHex for Alpha<C, T> where
    C: LowerHex,
    T: LowerHex
[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<Lab<Wp, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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, _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<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<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<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<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<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[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> From<Lab<<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<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<Hwb<<S as RgbStandard>::Space, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    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<Hwb<<S as RgbStandard>::Space, T>, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    T: Component + Float
[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<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, _S> From<Alpha<Hsv<_S, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[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<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<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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 RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[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<Hsl<_S, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[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<Hsv<S, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: 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<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<Rgb<_S, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[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<S, T> From<Alpha<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    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<Color<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<Hsl<S, T>, 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<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<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<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<Hsl<_S, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[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<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<S, T> From<Alpha<Hsl<S, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Lch<Wp, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<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, _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<Color<_S, T>, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[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<Hsv<<S as RgbStandard>::Space, T>> for Alpha<Rgb<S, T>, T> where
    S: RgbStandard,
    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<Alpha<Xyz<<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 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 Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[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<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, _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<Wp, T> From<Lab<Wp, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<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<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<Color<S, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[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> From<Alpha<Yxy<Wp, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<Yxy<<S as RgbSpace>::WhitePoint, 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<Hwb<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<S, T> From<Alpha<Hwb<S, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<S, T> From<Yxy<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[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> From<Lch<Wp, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[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> 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<Color<S, T>, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[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<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<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<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, _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> From<Lch<Wp, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<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<Hwb<_S, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[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<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Alpha<Xyz<Wp, T>, T> where
    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> From<Yxy<Wp, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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, 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> From<Alpha<Hwb<S, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[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<Hsv<_S, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T> From<Alpha<Lch<Wp, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<Lch<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[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> From<Lch<<S as RgbSpace>::WhitePoint, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[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> From<Alpha<Hwb<S, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float
[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<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[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<Wp, T> From<Xyz<Wp, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<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<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<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + 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<S, T> From<Lch<<S as LumaStandard>::WhitePoint, T>> for Alpha<Luma<S, T>, T> where
    S: LumaStandard,
    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<C, T> From<C> for Alpha<C, T> where
    T: Component
[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<Luma<_S, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: LumaStandard<WhitePoint = Wp>, 
[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<Color<S, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[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<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<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<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<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, 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<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> From<Xyz<Wp, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<Alpha<Lch<<S as LumaStandard>::WhitePoint, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    T: Component + Float
[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<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> 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, 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> 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, _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<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<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<Lab<<S as LumaStandard>::WhitePoint, T>, T>> for Luma<S, T> where
    S: LumaStandard,
    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> From<Lab<Wp, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<Hsv<<S as RgbStandard>::Space, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    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<Hsl<S, T>, T>> for Hsl<S, T> where
    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<S, T> From<Alpha<Hwb<S, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[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<Hwb<S, T>> for Alpha<Hsv<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, _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<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<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> From<Alpha<Lch<Wp, T>, T>> for Lch<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<S, T> From<Alpha<Lab<<S as RgbSpace>::WhitePoint, T>, T>> for Hwb<S, 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<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<Color<_S, T>> for Alpha<Lab<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[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, _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<Hsl<_S, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<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<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<Hsl<<S as RgbStandard>::Space, 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, _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<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<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<Hsv<_S, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[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<Wp, T> From<Yxy<Wp, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<S, T> From<Hwb<S, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[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<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, _S> From<Rgb<_S, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[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<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<Hsl<S, T>, T>> for Hwb<S, 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, A> From<(T, T, T, A)> for Alpha<Xyz<Wp, T>, A> where
    A: Component,
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<Wp, T> From<Yxy<Wp, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<Lab<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[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> From<Alpha<Yxy<<S as RgbSpace>::WhitePoint, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: 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<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<S, T> From<Alpha<Hwb<S, T>, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[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<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<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<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<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<Color<S, T>, 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<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, _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<Rgb<_S, T>> for Alpha<Hwb<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[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> From<Alpha<Lch<<<S as RgbStandard>::Space as RgbSpace>::WhitePoint, T>, T>> for Rgb<S, T> where
    S: RgbStandard,
    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<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<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: 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<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Lch<Wp, 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<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, _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<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<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> From<Alpha<Yxy<Wp, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<S, T> From<Alpha<Hsv<S, T>, T>> for Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float
[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<Alpha<Lch<<S as RgbSpace>::WhitePoint, T>, T>> for Alpha<Hsl<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[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> From<Alpha<Hsv<S, T>, T>> for Color<S, T> where
    S: RgbSpace,
    T: Float + Component
[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, _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<Color<_S, T>, T>> for Lab<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[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<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: 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<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<S, T> From<Hsl<S, 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<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float
[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<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<Alpha<Luma<_S, T>, T>> for Hsv<S, 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 Hwb<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: LumaStandard<WhitePoint = <S as RgbSpace>::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<Hsl<S, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[src]

impl<Wp, T> From<Alpha<Yxy<Wp, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<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, _S> From<Rgb<_S, T>> for Alpha<Hsv<S, T>, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[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> From<Alpha<Xyz<Wp, T>, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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, _S> From<Alpha<Rgb<_S, T>, T>> for Hsl<S, T> where
    S: RgbSpace,
    T: Component + Float,
    _S: RgbStandard<Space = S>, 
[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<Hwb<S, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[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, _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<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<S, T> From<Alpha<Rgb<Linear<S>, T>, T>> for Alpha<Color<S, T>, T> where
    S: RgbSpace,
    T: Float + Component
[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<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<Hsv<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<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 Rgb<S, T> where
    S: RgbStandard,
    T: Component + Float
[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, _S> From<Hsv<_S, T>> for Alpha<Xyz<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint,
    _S: RgbSpace<WhitePoint = Wp>, 
[src]

impl<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Xyz<Wp, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<C, T> From<Alpha<C, T>> for PreAlpha<C, T> where
    C: ComponentWise<Scalar = T>,
    T: Float
[src]

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<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<Wp, T> From<Alpha<Lab<Wp, T>, T>> for Alpha<Lch<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[src]

impl<S, T> From<Alpha<Color<S, T>, T>> for Hsv<S, T> where
    S: RgbSpace,
    T: Component + Float
[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<Wp, T> From<Xyz<Wp, T>> for Alpha<Yxy<Wp, T>, T> where
    T: Component + Float,
    Wp: WhitePoint
[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<Xyz<<S as RgbSpace>::WhitePoint, T>, T>> for Hsv<S, 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<Wp, T> From<Alpha<Xyz<Wp, T>, T>> for Yxy<Wp, T> where
    T: Component + Float,
    Wp: 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<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<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.

fn darken(&self, amount: Self::Scalar) -> Self[src]

Darken the color by amount.

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

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

type Target = C

The resulting type after dereferencing.

impl<C, T> Serialize for Alpha<C, T> where
    C: Serialize,
    T: Serialize
[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> 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> Hue for Alpha<C, T> where
    C: Hue,
    T: Clone
[src]

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
[src]

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
[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
[src]

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
[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
[src]

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
[src]

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

Auto Trait Implementations

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

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

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

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

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

Blanket Implementations

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

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]

fn adapt_into(self) -> D[src]

Convert the source color to the destination color using the bradford method by default Read more

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

impl<T> SetParameter for T[src]

fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where
    T: Parameter<Self>, 
[src]

Sets value as a parameter of self.

impl<T> MemoryUsage for T where
    T: Deref + Debug,
    <T as Deref>::Target: MemoryUsage
[src]

impl<T> Supports<T> for T[src]

impl<T> Erased for T[src]

impl<T> Serialize for T where
    T: Serialize + ?Sized
[src]

impl<T> Scalar for T where
    T: Copy + PartialEq<T> + Any + Debug
[src]

fn is<T>() -> bool where
    T: Scalar
[src]

Tests if Self the same as the type T Read more

impl<T> Same<T> for T[src]

type Output = T

Should always be Self

impl<SS, SP> SupersetOf<SS> for SP where
    SS: SubsetOf<SP>, 
[src]

impl<T> Resource for T where
    T: Any + Send + Sync
[src]

impl<T> Any for T where
    T: Any
[src]

impl<T> TryDefault for T where
    T: Default
[src]

fn unwrap_default() -> Self[src]

Calls try_default and panics on an error case.

impl<T> Event for T where
    T: Send + Sync + 'static, 
[src]

impl<T> Clone for T where
    T: Clone
[src]

impl<T> Config for T where
    T: Deserialize<'a> + Serialize + Default
[src]