Trait image::Pixel

pub trait Pixel: Copy + Clone {
    type Subpixel: Primitive;
    fn channel_count() -> u8;
    fn channels(&self) -> &[Self::Subpixel];
    fn channels_mut(&mut self) -> &mut [Self::Subpixel];
    fn color_model() -> &'static str;
    fn color_type() -> ColorType;
    fn channels4(
        &self
    ) -> (Self::Subpixel, Self::Subpixel, Self::Subpixel, Self::Subpixel);
    fn from_channels(
        a: Self::Subpixel, 
        b: Self::Subpixel, 
        c: Self::Subpixel, 
        d: Self::Subpixel
    ) -> Self;
    fn from_slice(slice: &[Self::Subpixel]) -> &Self;
    fn from_slice_mut(slice: &mut [Self::Subpixel]) -> &mut Self;
    fn to_rgb(&self) -> Rgb<Self::Subpixel>;
    fn to_rgba(&self) -> Rgba<Self::Subpixel>;
    fn to_luma(&self) -> Luma<Self::Subpixel>;
    fn to_luma_alpha(&self) -> LumaA<Self::Subpixel>;
    fn to_bgr(&self) -> Bgr<Self::Subpixel>;
    fn to_bgra(&self) -> Bgra<Self::Subpixel>;
    fn map<F>(&self, f: F) -> Self
    where
        F: FnMut(Self::Subpixel) -> Self::Subpixel;
    fn apply<F>(&mut self, f: F)
    where
        F: FnMut(Self::Subpixel) -> Self::Subpixel;
    fn map_with_alpha<F, G>(&self, f: F, g: G) -> Self
    where
        F: FnMut(Self::Subpixel) -> Self::Subpixel,
        G: FnMut(Self::Subpixel) -> Self::Subpixel;
    fn apply_with_alpha<F, G>(&mut self, f: F, g: G)
    where
        F: FnMut(Self::Subpixel) -> Self::Subpixel,
        G: FnMut(Self::Subpixel) -> Self::Subpixel;
    fn map2<F>(&self, other: &Self, f: F) -> Self
    where
        F: FnMut(Self::Subpixel, Self::Subpixel) -> Self::Subpixel;
    fn apply2<F>(&mut self, other: &Self, f: F)
    where
        F: FnMut(Self::Subpixel, Self::Subpixel) -> Self::Subpixel;
    fn invert(&mut self);
    fn blend(&mut self, other: &Self);
}

A generalized pixel.

A pixel object is usually not used standalone but as a view into an image buffer.

Associated Types

type Subpixel: Primitive

The underlying subpixel type.

Required Methods

fn channel_count() -> u8

Returns the number of channels of this pixel type.

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

Returns the components as a slice.

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

Returns the components as a mutable slice

fn color_model() -> &'static str

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

fn color_type() -> ColorType

Returns the ColorType for this pixel format

fn channels4(
    &self
) -> (Self::Subpixel, Self::Subpixel, Self::Subpixel, Self::Subpixel)

Returns the channels of this pixel as a 4 tuple. If the pixel has less than 4 channels the remainder is filled with the maximum value

TODO deprecate

fn from_channels(
    a: Self::Subpixel,
    b: Self::Subpixel,
    c: Self::Subpixel,
    d: Self::Subpixel
) -> 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.

TODO deprecate

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Returns a view into a slice.

Note: The slice length is not checked on creation. Thus the caller has to ensure that the slice is long enough to present panics if the pixel is used later on.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

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

Returns mutable view into a mutable slice.

Note: The slice length is not checked on creation. Thus the caller has to ensure that the slice is long enough to present panics if the pixel is used later on.

fn to_rgb(&self) -> Rgb<Self::Subpixel>

Convert this pixel to RGB

fn to_rgba(&self) -> Rgba<Self::Subpixel>

Convert this pixel to RGB with an alpha channel

fn to_luma(&self) -> Luma<Self::Subpixel>

Convert this pixel to luma

fn to_luma_alpha(&self) -> LumaA<Self::Subpixel>

Convert this pixel to luma with an alpha channel

fn to_bgr(&self) -> Bgr<Self::Subpixel>

Convert this pixel to BGR

fn to_bgra(&self) -> Bgra<Self::Subpixel>

Convert this pixel to BGR with an alpha channel

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

Apply the function f to each channel of this pixel.

fn apply<F>(&mut self, f: F) where
    F: FnMut(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: FnMut(Self::Subpixel) -> Self::Subpixel,
    G: FnMut(Self::Subpixel) -> Self::Subpixel, 

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

fn apply_with_alpha<F, G>(&mut self, f: F, g: G) where
    F: FnMut(Self::Subpixel) -> Self::Subpixel,
    G: FnMut(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 map2<F>(&self, other: &Self, f: F) -> Self where
    F: FnMut(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: FnMut(Self::Subpixel, Self::Subpixel) -> Self::Subpixel, 

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

fn invert(&mut self)

Invert this pixel

fn blend(&mut self, other: &Self)

Blend the color of a given pixel into ourself, taking into account alpha channels

Implementors

impl<T: Primitive + 'static> Pixel for Bgr<T>

type Subpixel = T

fn channel_count() -> u8

fn color_model() -> &'static str

fn color_type() -> ColorType

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

fn channels4(&self) -> (T, T, T, T)

fn from_channels(a: T, b: T, c: T, d: T) -> Bgr<T>

fn from_slice(slice: &[T]) -> &Bgr<T>

fn from_slice_mut(slice: &mut [T]) -> &mut Bgr<T>

fn to_rgb(&self) -> Rgb<T>

fn to_bgr(&self) -> Bgr<T>

fn to_rgba(&self) -> Rgba<T>

fn to_bgra(&self) -> Bgra<T>

fn to_luma(&self) -> Luma<T>

fn to_luma_alpha(&self) -> LumaA<T>

fn map<F>(&self, f: F) -> Bgr<T> where     F: FnMut(T) -> T,

fn apply<F>(&mut self, f: F) where     F: FnMut(T) -> T,

fn map_with_alpha<F, G>(&self, f: F, g: G) -> Bgr<T> where     F: FnMut(T) -> T,     G: FnMut(T) -> T,

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

fn map2<F>(&self, other: &Self, f: F) -> Bgr<T> where     F: FnMut(T, T) -> T,

fn apply2<F>(&mut self, other: &Bgr<T>, f: F) where     F: FnMut(T, T) -> T,

fn invert(&mut self)

fn blend(&mut self, other: &Bgr<T>)

impl<T: Primitive + 'static> Pixel for Bgra<T>

type Subpixel = T

fn channel_count() -> u8

fn color_model() -> &'static str

fn color_type() -> ColorType

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

fn channels4(&self) -> (T, T, T, T)

fn from_channels(a: T, b: T, c: T, d: T) -> Bgra<T>

fn from_slice(slice: &[T]) -> &Bgra<T>

fn from_slice_mut(slice: &mut [T]) -> &mut Bgra<T>

fn to_rgb(&self) -> Rgb<T>

fn to_bgr(&self) -> Bgr<T>

fn to_rgba(&self) -> Rgba<T>

fn to_bgra(&self) -> Bgra<T>

fn to_luma(&self) -> Luma<T>

fn to_luma_alpha(&self) -> LumaA<T>

fn map<F>(&self, f: F) -> Bgra<T> where     F: FnMut(T) -> T,

fn apply<F>(&mut self, f: F) where     F: FnMut(T) -> T,

fn map_with_alpha<F, G>(&self, f: F, g: G) -> Bgra<T> where     F: FnMut(T) -> T,     G: FnMut(T) -> T,

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

fn map2<F>(&self, other: &Self, f: F) -> Bgra<T> where     F: FnMut(T, T) -> T,

fn apply2<F>(&mut self, other: &Bgra<T>, f: F) where     F: FnMut(T, T) -> T,

fn invert(&mut self)

fn blend(&mut self, other: &Bgra<T>)

impl<T: Primitive + 'static> Pixel for Luma<T>

type Subpixel = T

fn channel_count() -> u8

fn color_model() -> &'static str

fn color_type() -> ColorType

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

fn channels4(&self) -> (T, T, T, T)

fn from_channels(a: T, b: T, c: T, d: T) -> Luma<T>

fn from_slice(slice: &[T]) -> &Luma<T>

fn from_slice_mut(slice: &mut [T]) -> &mut Luma<T>

fn to_rgb(&self) -> Rgb<T>

fn to_bgr(&self) -> Bgr<T>

fn to_rgba(&self) -> Rgba<T>

fn to_bgra(&self) -> Bgra<T>

fn to_luma(&self) -> Luma<T>

fn to_luma_alpha(&self) -> LumaA<T>

fn map<F>(&self, f: F) -> Luma<T> where     F: FnMut(T) -> T,

fn apply<F>(&mut self, f: F) where     F: FnMut(T) -> T,

fn map_with_alpha<F, G>(&self, f: F, g: G) -> Luma<T> where     F: FnMut(T) -> T,     G: FnMut(T) -> T,

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

fn map2<F>(&self, other: &Self, f: F) -> Luma<T> where     F: FnMut(T, T) -> T,

fn apply2<F>(&mut self, other: &Luma<T>, f: F) where     F: FnMut(T, T) -> T,

fn invert(&mut self)

fn blend(&mut self, other: &Luma<T>)

impl<T: Primitive + 'static> Pixel for LumaA<T>

type Subpixel = T

fn channel_count() -> u8

fn color_model() -> &'static str

fn color_type() -> ColorType

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

fn channels4(&self) -> (T, T, T, T)

fn from_channels(a: T, b: T, c: T, d: T) -> LumaA<T>

fn from_slice(slice: &[T]) -> &LumaA<T>

fn from_slice_mut(slice: &mut [T]) -> &mut LumaA<T>

fn to_rgb(&self) -> Rgb<T>

fn to_bgr(&self) -> Bgr<T>

fn to_rgba(&self) -> Rgba<T>

fn to_bgra(&self) -> Bgra<T>

fn to_luma(&self) -> Luma<T>

fn to_luma_alpha(&self) -> LumaA<T>

fn map<F>(&self, f: F) -> LumaA<T> where     F: FnMut(T) -> T,

fn apply<F>(&mut self, f: F) where     F: FnMut(T) -> T,

fn map_with_alpha<F, G>(&self, f: F, g: G) -> LumaA<T> where     F: FnMut(T) -> T,     G: FnMut(T) -> T,

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

fn map2<F>(&self, other: &Self, f: F) -> LumaA<T> where     F: FnMut(T, T) -> T,

fn apply2<F>(&mut self, other: &LumaA<T>, f: F) where     F: FnMut(T, T) -> T,

fn invert(&mut self)

fn blend(&mut self, other: &LumaA<T>)

impl<T: Primitive + 'static> Pixel for Rgb<T>

type Subpixel = T

fn channel_count() -> u8

fn color_model() -> &'static str

fn color_type() -> ColorType

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

fn channels4(&self) -> (T, T, T, T)

fn from_channels(a: T, b: T, c: T, d: T) -> Rgb<T>

fn from_slice(slice: &[T]) -> &Rgb<T>

fn from_slice_mut(slice: &mut [T]) -> &mut Rgb<T>

fn to_rgb(&self) -> Rgb<T>

fn to_bgr(&self) -> Bgr<T>

fn to_rgba(&self) -> Rgba<T>

fn to_bgra(&self) -> Bgra<T>

fn to_luma(&self) -> Luma<T>

fn to_luma_alpha(&self) -> LumaA<T>

fn map<F>(&self, f: F) -> Rgb<T> where     F: FnMut(T) -> T,

fn apply<F>(&mut self, f: F) where     F: FnMut(T) -> T,

fn map_with_alpha<F, G>(&self, f: F, g: G) -> Rgb<T> where     F: FnMut(T) -> T,     G: FnMut(T) -> T,

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

fn map2<F>(&self, other: &Self, f: F) -> Rgb<T> where     F: FnMut(T, T) -> T,

fn apply2<F>(&mut self, other: &Rgb<T>, f: F) where     F: FnMut(T, T) -> T,

fn invert(&mut self)

fn blend(&mut self, other: &Rgb<T>)

impl<T: Primitive + 'static> Pixel for Rgba<T>

type Subpixel = T

fn channel_count() -> u8

fn color_model() -> &'static str

fn color_type() -> ColorType

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

Important traits for &'a [u8]

impl<'a> Read for &'a [u8]impl<'a> Write for &'a mut [u8]

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

fn channels4(&self) -> (T, T, T, T)

fn from_channels(a: T, b: T, c: T, d: T) -> Rgba<T>

fn from_slice(slice: &[T]) -> &Rgba<T>

fn from_slice_mut(slice: &mut [T]) -> &mut Rgba<T>

fn to_rgb(&self) -> Rgb<T>

fn to_bgr(&self) -> Bgr<T>

fn to_rgba(&self) -> Rgba<T>

fn to_bgra(&self) -> Bgra<T>

fn to_luma(&self) -> Luma<T>

fn to_luma_alpha(&self) -> LumaA<T>

fn map<F>(&self, f: F) -> Rgba<T> where     F: FnMut(T) -> T,

fn apply<F>(&mut self, f: F) where     F: FnMut(T) -> T,

fn map_with_alpha<F, G>(&self, f: F, g: G) -> Rgba<T> where     F: FnMut(T) -> T,     G: FnMut(T) -> T,

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

fn map2<F>(&self, other: &Self, f: F) -> Rgba<T> where     F: FnMut(T, T) -> T,

fn apply2<F>(&mut self, other: &Rgba<T>, f: F) where     F: FnMut(T, T) -> T,

fn invert(&mut self)

fn blend(&mut self, other: &Rgba<T>)