Struct pix::rgb::Rgb

pub struct Rgb {}

RGB additive color model.

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

Methods

impl Rgb

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

Get the red component.

Example: RGB Red

use pix::chan::Ch32;
use pix::rgb::{Rgb, Rgb32};

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

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 RGB Red

use pix::chan::Ch32;
use pix::rgb::{Rgb, Rgb32};

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

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

Get the green component.

Example: RGB Green

use pix::chan::Ch16;
use pix::rgb::{Rgb, Rgb16};

let p = Rgb16::new(0x2000, 0x1234, 0x8000);
assert_eq!(Rgb::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 RGB Green

use pix::chan::Ch16;
use pix::rgb::{Rgb, Rgb16};

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

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

Get the blue component.

Example: RGB Blue

use pix::chan::Ch8;
use pix::rgb::{Rgb, Rgb8};

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

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 RGB Blue

use pix::chan::Ch8;
use pix::rgb::{Rgb, Rgb8};

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

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

Get channel-wise difference

pub fn within_threshold<P: Pixel>(p: P, rhs: P) -> bool where
    P: Pixel<Model = Self>, 

Check if all Channels are within threshold

Trait Implementations

impl Clone for Rgb

fn clone(&self) -> Rgb

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColorModel for Rgb

const CIRCULAR: Range<usize>

Range of circular channel numbers

const LINEAR: Range<usize>

Range of linear channel numbers

const ALPHA: usize

Alpha channel number

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

impl Copy for Rgb

impl Debug for Rgb

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

Formats the value using the given formatter.

impl Default for Rgb

fn default() -> Rgb

Returns the "default value" for a type.

impl PartialEq<Rgb> for Rgb

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl StructuralPartialEq for Rgb