Struct image_buffer::color::Alpha4

pub struct Alpha4<C: Color>(_);

Color with an associated alpha value.

Methods

impl<C: Color> Alpha4<C>

fn new(array: [C::Subpixel; 4]) -> Self

Trait Implementations

impl<C: Copy + Color> Copy for Alpha4<C> where
    C::Subpixel: Copy, 

impl<C: Clone + Color> Clone for Alpha4<C> where
    C::Subpixel: Clone, 

fn clone(&self) -> Alpha4<C>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Color> AsRef<<Alpha4<C> as Color>::Storage> for Alpha4<C>

fn as_ref(&self) -> &Self::Storage

Performs the conversion.

impl<C: Color> AsMut<<Alpha4<C> as Color>::Storage> for Alpha4<C>

fn as_mut(&mut self) -> &mut Self::Storage

Performs the conversion.

impl<C: Color> Color for Alpha4<C>

type Subpixel = C::Subpixel

The underlying subpixel type.

type Storage = [C::Subpixel; 4]

fn channel_count() -> usize

Returns the number of channels of this pixel type.

fn channels(&self) -> &[Self::Subpixel; 4]

Returns the components as a slice.

fn channels_mut(&mut self) -> &mut [Self::Subpixel; 4]

Returns the components as a mutable slice

fn from_channels(other: [Self::Subpixel; 4]) -> Self

Construct a pixel from the 4 channels a, b, c and d. If the pixel does not contain 4 channels the extra are ignored.

fn from_slice<'a>(slice: &'a [Self::Subpixel]) -> &'a Self

Returns a view into a slice.

fn from_slice_mut<'a>(slice: &'a mut [Self::Subpixel]) -> &'a mut Self

Returns mutable view into a mutable slice.

fn apply_with_alpha<F, G>(&mut self, f: F, g: G) where
    F: Fn(Self::Subpixel) -> Self::Subpixel,
    G: Fn(Self::Subpixel) -> Self::Subpixel, 

Apply the function f to each channel except the alpha channel. Apply the function g to the alpha channel. Works in-place.

fn color_model() -> &'static str

Returns a string that can help to interprete the meaning each channel See gimp babl.

fn map<F>(&self, f: F) -> Self where
    F: Fn(Self::Subpixel) -> Self::Subpixel, 

Apply the function f to each channel of this pixel.

fn apply<F>(&mut self, f: F) where
    F: Fn(Self::Subpixel) -> Self::Subpixel, 

Apply the function f to each channel of this pixel.

fn map_with_alpha<F, G>(&self, f: F, g: G) -> Self where
    F: Fn(Self::Subpixel) -> Self::Subpixel,
    G: Fn(Self::Subpixel) -> Self::Subpixel, 

Apply the function f to each channel except the alpha channel. Apply the function g to the alpha channel.

fn map2<F>(&self, other: &Self, f: F) -> Self where
    F: Fn(Self::Subpixel, Self::Subpixel) -> Self::Subpixel, 

Apply the function f to each channel of this pixel and other pairwise.

fn apply2<F>(&mut self, other: &Self, f: F) where
    F: Fn(Self::Subpixel, Self::Subpixel) -> Self::Subpixel, 

Apply the function f to each channel of this pixel and other pairwise. Works in-place.

impl<C: Color> Index<usize> for Alpha4<C>

type Output = C::Subpixel

The returned type after indexing

fn index<'a>(&'a self, _index: usize) -> &'a C::Subpixel

The method for the indexing (container[index]) operation

impl<C: Color> IndexMut<usize> for Alpha4<C>

fn index_mut<'a>(&'a mut self, _index: usize) -> &'a mut C::Subpixel

The method for the mutable indexing (container[index]) operation

impl<C: Color, T: ColorMathOps<Alpha4<C>>> Add<T> for Alpha4<C>

type Output = Self

The resulting type after applying the + operator

fn add(self, rhs: T) -> Self::Output

The method for the + operator

impl<C: Color> AddAssign for Alpha4<C>

fn add_assign(&mut self, rhs: Self)

The method for the += operator

impl<C: Color> Sub for Alpha4<C>

type Output = Self

The resulting type after applying the - operator

fn sub(self, rhs: Self) -> Self::Output

The method for the - operator

impl<C: Color> SubAssign for Alpha4<C>

fn sub_assign(&mut self, rhs: Self)

The method for the -= operator

impl<C: Color> Div for Alpha4<C>

type Output = Self

The resulting type after applying the / operator

fn div(self, rhs: Self) -> Self::Output

The method for the / operator

impl<C: Color> DivAssign for Alpha4<C>

fn div_assign(&mut self, rhs: Self)

The method for the /= operator

impl<C: Color> Mul for Alpha4<C>

type Output = Self

The resulting type after applying the * operator

fn mul(self, rhs: Self) -> Self::Output

The method for the * operator

impl<C: Color> MulAssign for Alpha4<C>

fn mul_assign(&mut self, rhs: Self)

The method for the *= operator

impl<C: Color> From<C> for Alpha4<C> where
    C::Subpixel: ChannelMax, 

fn from(other: C) -> Self

Performs the conversion.