Struct pix::el::Pix2

#[repr(C)]pub struct Pix2<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma,  { /* fields omitted */ }

Pixel with two channels in its color model.

Methods

impl<C, M, A, G> Pix2<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma, 

pub fn new<H>(one: H, two: H) -> Self where
    C: From<H>, 

Create a two-channel color.

Example

use pix::Graya8;

let translucent_gray = Graya8::new(128, 200);

Trait Implementations

impl<C: Clone, M: Clone, A: Clone, G: Clone> Clone for Pix2<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma, 

fn clone(&self) -> Pix2<C, M, A, G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Copy, M: Copy, A: Copy, G: Copy> Copy for Pix2<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma, 

impl<C: Debug, M: Debug, A: Debug, G: Debug> Debug for Pix2<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma, 

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

Formats the value using the given formatter.

impl<C: Default, M: Default, A: Default, G: Default> Default for Pix2<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma, 

fn default() -> Pix2<C, M, A, G>

Returns the "default value" for a type.

impl<C: PartialEq, M: PartialEq, A: PartialEq, G: PartialEq> PartialEq<Pix2<C, M, A, G>> for Pix2<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma, 

fn eq(&self, other: &Pix2<C, M, A, G>) -> bool

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

fn ne(&self, other: &Pix2<C, M, A, G>) -> bool

This method tests for !=.

impl<C, M, A, G> Pixel for Pix2<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma, 

type Chan = C

Channel type

type Model = M

Color model

type Alpha = A

Alpha mode

type Gamma = G

Gamma mode

fn from_channels(ch: &[C]) -> Self

Make a pixel from a slice of channels.

fn from_bit_depth<P>(p: P) -> Self where
    P: Pixel,
    Self::Chan: From<P::Chan>, 

Convert from a pixel with a different bit depth.

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

Get the channels.

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

Get the channels mutably.

fn one(self) -> Self::Chan

Get the first channel.

fn one_mut(&mut self) -> &mut Self::Chan

Get a mutable reference to the first channel

fn two(self) -> Self::Chan

Get the second channel.

fn two_mut(&mut self) -> &mut Self::Chan

Get a mutable reference to the second channel

fn three(self) -> Self::Chan

Get the third channel.

fn three_mut(&mut self) -> &mut Self::Chan

Get a mutable reference to the third channel

fn four(self) -> Self::Chan

Get the fourth channel.

fn four_mut(&mut self) -> &mut Self::Chan

Get a mutable reference to the fourth channel

fn alpha(self) -> Self::Chan

Get the alpha channel.

fn alpha_mut(&mut self) -> &mut Self::Chan

Get a mutable reference to the alpha channel.

fn convert<D>(self) -> D where
    D: Pixel,
    D::Chan: From<Self::Chan>, 

Convert a pixel to another format

fn to_linear_gamma<C: Channel>(channels: &mut [C])

Convert channels to linear gamma

fn from_linear_gamma(channels: &mut [Self::Chan])

Convert channels from linear gamma

fn composite_color<O>(dst: &mut [Self], clr: &Self, op: O) where
    O: PorterDuff, 

Composite a color with a pixel slice

fn composite_matte<M, O>(dst: &mut [Self], src: &[M], clr: &Self, op: O) where
    M: Pixel<Chan = Self::Chan, Model = Matte, Gamma = Self::Gamma>,
    O: PorterDuff, 

Composite matte with color to destination pixel slice

fn composite_slice<O>(dst: &mut [Self], src: &[Self], op: O) where
    O: PorterDuff, 

Composite two slices of pixels

fn composite_channels<O>(&mut self, src: &Self, _op: O) where
    O: PorterDuff, 

Composite the channels of two pixels

fn composite_channels_matte<O>(
    &mut self,
    alpha: &Self::Chan,
    src: &Self,
    _op: O
) where
    O: PorterDuff, 

Composite the channels of pixels with a matte and color

impl<C, M, A, G> StructuralPartialEq for Pix2<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma,