Struct pix::rgb::Rgb

pub struct Rgb {}

RGB additive color model.

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

Implementations

impl Rgb

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

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>(p: &mut P) -> &mut P::Chanwhere P: Pixel<Model = Self> + Pixel,

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>(p: P) -> P::Chanwhere P: Pixel<Model = Self> + Pixel,

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>(p: &mut P) -> &mut P::Chanwhere P: Pixel<Model = Self> + Pixel,

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>(p: P) -> P::Chanwhere P: Pixel<Model = Self> + Pixel,

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>(p: &mut P) -> &mut P::Chanwhere P: Pixel<Model = Self> + Pixel,

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>(p: P, rhs: P) -> Pwhere P: Pixel<Model = Self> + Pixel,

Get channel-wise difference

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

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

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>) -> Pwhere P: Pixel<Model = Self>,

Convert from red, green, blue and alpha components

const CIRCULAR: Range<usize> = _

Range of circular channel numbers

const LINEAR: Range<usize> = _

Range of linear channel numbers

const ALPHA: usize = 3usize

Alpha channel number

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 ==.

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

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

impl Copy for Rgb

impl Eq for Rgb

impl StructuralEq for Rgb

impl StructuralPartialEq for Rgb