Struct pix::el::Pix3

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

Pixel with three channels in its color model.

Implementations

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

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

Create a three-channel color.

Example

use pix::rgb::Rgb8;

let rgb = Rgb8::new(128, 200, 255);

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug, M: Debug, A: Debug, G: Debug> Debug for Pix3<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 Pix3<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma, 

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

Returns the “default value” for a type.

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

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

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

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

This method tests for !=.

impl<C, M, A, G> Pixel for Pix3<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: Copy, M: Copy, A: Copy, G: Copy> Copy for Pix3<C, M, A, G> where
    C: Channel,
    M: ColorModel,
    A: Alpha,
    G: Gamma, 

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