Struct Pix2 

pub struct Pix2<C, M, A, G>
where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma,
{ /* private fields */ }

Pixel with two channels in its color model.

Implementations

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::gray::Graya8;

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

Trait Implementations

impl<C, M, A, G> Clone for Pix2<C, M, A, G>

where C: Channel + Clone, M: ColorModel + Clone, A: Alpha + Clone, G: Gamma + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C, M, A, G> Debug for Pix2<C, M, A, G>

where C: Channel + Debug, M: ColorModel + Debug, A: Alpha + Debug, G: Gamma + Debug,

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

Formats the value using the given formatter.

impl<C, M, A, G> Default for Pix2<C, M, A, G>

where C: Channel + Default, M: ColorModel + Default, A: Alpha + Default, G: Gamma + Default,

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

Returns the “default value” for a type.

impl<C, M, A, G> PartialEq for Pix2<C, M, A, G>

where C: Channel + PartialEq, M: ColorModel + PartialEq, A: Alpha + PartialEq, G: Gamma + PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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 copy_color(dst: &mut [Self], clr: &Self)

Copy a color to a pixel slice

fn copy_slice(dst: &mut [Self], src: &[Self])

Copy a slice to another

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

where Self: Pixel<Alpha = Premultiplied, Gamma = Linear>, O: Blend,

Composite a color with a pixel slice

fn composite_matte<M, O>(dst: &mut [Self], src: &[M], clr: &Self, op: O)

where Self: Pixel<Alpha = Premultiplied, Gamma = Linear>, M: Pixel<Chan = Self::Chan, Model = Matte, Gamma = Linear>, O: Blend,

Composite matte with color to destination pixel slice

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

where Self: Pixel<Alpha = Premultiplied, Gamma = Linear>, O: Blend,

Composite two slices of pixels

fn composite_channels<O>(&mut self, src: &Self, op: O)

where Self: Pixel<Alpha = Premultiplied, Gamma = Linear>, O: Blend,

Composite the channels of two pixels

fn composite_channels_alpha<O>(&mut self, src: &Self, op: O, alpha: &Self::Chan)

where Self: Pixel<Alpha = Premultiplied, Gamma = Linear>, O: Blend,

Composite the channels of two pixels with alpha

impl<C, M, A, G> Copy for Pix2<C, M, A, G>

where C: Channel + Copy, M: ColorModel + Copy, A: Alpha + Copy, G: Gamma + Copy,

impl<C, M, A, G> Eq for Pix2<C, M, A, G>

where C: Channel + Eq, M: ColorModel + Eq, A: Alpha + Eq, G: Gamma + Eq,

impl<C, M, A, G> StructuralPartialEq for Pix2<C, M, A, G>

where C: Channel, M: ColorModel, A: Alpha, G: Gamma,