Struct pix::bgr::Bgr

pub struct Bgr {}

BGR arrangement of RGB color model.

The components are blue, green, red and optional alpha.

Implementations

impl Bgr

pub fn blue<P: Pixel>(p: P) -> P::Chan where
    P: Pixel<Model = Self>, 

Get the blue component.

Example: Get BGR Blue

use pix::bgr::{Bgr, Bgr8};
use pix::chan::Ch8;

let p = Bgr8::new(0x93, 0x80, 0xA0);
assert_eq!(Bgr::blue(p), Ch8::new(0x93));

pub fn blue_mut<P: Pixel>(p: &mut P) -> &mut P::Chan where
    P: Pixel<Model = Self>, 

Get a mutable reference to the blue component.

Example: Modify BGR Blue

use pix::bgr::{Bgr, Bgr8};
use pix::chan::Ch8;

let mut p = Bgr8::new(0x88, 0x77, 0x66);
*Bgr::blue_mut(&mut p) = 0x55.into();
assert_eq!(Bgr::blue(p), Ch8::new(0x55));

pub fn green<P: Pixel>(p: P) -> P::Chan where
    P: Pixel<Model = Self>, 

Get the green component.

Example: BGR Green

use pix::bgr::{Bgr, Bgr16};
use pix::chan::Ch16;

let p = Bgr16::new(0x2000, 0x1234, 0x8000);
assert_eq!(Bgr::green(p), Ch16::new(0x1234));

pub fn green_mut<P: Pixel>(p: &mut P) -> &mut P::Chan where
    P: Pixel<Model = Self>, 

Get a mutable reference to the green component.

Example: Modify BGR Green

use pix::bgr::{Bgr, Bgr16};
use pix::chan::Ch16;

let mut p = Bgr16::new(0x2000, 0x1234, 0x8000);
*Bgr::green_mut(&mut p) = 0x4321.into();
assert_eq!(Bgr::green(p), Ch16::new(0x4321));

pub fn red<P: Pixel>(p: P) -> P::Chan where
    P: Pixel<Model = Self>, 

Get the red component.

Example: BGR Red

use pix::bgr::{Bgr, Bgr32};
use pix::chan::Ch32;

let p = Bgr32::new(0.25, 0.5, 1.0);
assert_eq!(Bgr::red(p), Ch32::new(1.0));

pub fn red_mut<P: Pixel>(p: &mut P) -> &mut P::Chan where
    P: Pixel<Model = Self>, 

Get a mutable reference to the red component.

Example: Modify BGR Red

use pix::bgr::{Bgr, Bgr32};
use pix::chan::Ch32;

let mut p = Bgr32::new(0.25, 0.5, 1.0);
*Bgr::red_mut(&mut p) = Ch32::new(0.75);
assert_eq!(Bgr::red(p), Ch32::new(0.75));

Trait Implementations

impl Clone for Bgr

fn clone(&self) -> Bgr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColorModel for Bgr

fn into_rgba<P>(p: P) -> PixRgba<P> where
    P: Pixel<Model = Self>, 

Convert into red, green, blue and alpha components

fn from_rgba<P>(rgba: PixRgba<P>) -> P where
    P: Pixel<Model = Self>, 

Convert from red, green, blue and alpha components

const CIRCULAR: Range<usize> = 0..0

Range of circular channel numbers

const LINEAR: Range<usize> = 0..3

Range of linear channel numbers

const ALPHA: usize = 3usize

Alpha channel number

impl Debug for Bgr

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

Formats the value using the given formatter.

impl Default for Bgr

fn default() -> Bgr

Returns the “default value” for a type.

impl PartialEq<Bgr> for Bgr

fn eq(&self, other: &Bgr) -> bool

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

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

This method tests for !=.

impl Copy for Bgr

impl StructuralPartialEq for Bgr