Struct image_buffer::color::Lab

#[repr(C)]
pub struct Lab<T: Primitive>(_);

CIE L*a*b*.

Methods

impl<T: Primitive> Lab<T>

fn new(array: [T; 3]) -> Self

Trait Implementations

impl<T: PartialEq + Primitive> PartialEq for Lab<T>

fn eq(&self, __arg_0: &Lab<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Lab<T>) -> bool

This method tests for !=.

impl<T: Eq + Primitive> Eq for Lab<T>

impl<T: Clone + Primitive> Clone for Lab<T>

fn clone(&self) -> Lab<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Primitive> Debug for Lab<T>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Copy + Primitive> Copy for Lab<T>

impl<T: Hash + Primitive> Hash for Lab<T>

fn hash<__HT: Hasher>(&self, __arg_0: &mut __HT)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T: Primitive> AsRef<[T; 3]> for Lab<T>

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

Performs the conversion.

impl<T: Primitive> AsMut<[T; 3]> for Lab<T>

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

Performs the conversion.

impl<T: Primitive> Color for Lab<T>

type Subpixel = T

The underlying subpixel type.

type Storage = [T; 3]

fn channel_count() -> usize

Returns the number of channels of this pixel type.

fn channels(&self) -> &[T; 3]

Returns the components as a slice.

fn channels_mut(&mut self) -> &mut [T; 3]

Returns the components as a mutable slice

fn from_channels(other: [T; 3]) -> Lab<T>

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 [T]) -> &'a Lab<T>

Returns a view into a slice.

fn from_slice_mut<'a>(slice: &'a mut [T]) -> &'a mut Lab<T>

Returns mutable view into a mutable slice.

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

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<T: Primitive> Index<usize> for Lab<T>

type Output = T

The returned type after indexing

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

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

impl<T: Primitive> IndexMut<usize> for Lab<T>

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

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

impl<T: Primitive, V: ColorMathOps<Lab<T>>> Add<V> for Lab<T>

type Output = Self

The resulting type after applying the + operator

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

The method for the + operator

impl<T: Primitive> AddAssign for Lab<T>

fn add_assign(&mut self, rhs: Self)

The method for the += operator

impl<T: Primitive, V: ColorMathOps<Lab<T>>> Sub<V> for Lab<T>

type Output = Self

The resulting type after applying the - operator

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

The method for the - operator

impl<T: Primitive> SubAssign for Lab<T>

fn sub_assign(&mut self, rhs: Self)

The method for the -= operator

impl<T: Primitive, V: ColorMathOps<Lab<T>>> Div<V> for Lab<T>

type Output = Self

The resulting type after applying the / operator

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

The method for the / operator

impl<T: Primitive> DivAssign for Lab<T>

fn div_assign(&mut self, rhs: Self)

The method for the /= operator

impl<T: Primitive, V: ColorMathOps<Lab<T>>> Mul<V> for Lab<T>

type Output = Self

The resulting type after applying the * operator

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

The method for the * operator

impl<T: Primitive> MulAssign for Lab<T>

fn mul_assign(&mut self, rhs: Self)

The method for the *= operator

impl<T: Primitive> From<Alpha4<Lab<T>>> for Lab<T>

fn from(other: Alpha4<Lab<T>>) -> Self

Performs the conversion.