Struct pix::hwb::Hwb

pub struct Hwb {}

HWB color model.

The components are hue, whiteness, blackness and optional alpha.

Implementations

impl Hwb

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

Get the hue component.

Hue is divided into 6 equal intervals arranged into a circle of degrees:

• 0: Red
• 60: Yellow
• 120: Green
• 180: Cyan
• 240: Blue
• 300: Magenta

The degrees are mapped from Channel::MIN (0) to Channel::MAX (360)

Example: HWB Hue

use pix::chan::Ch32;
use pix::hwb::{Hwb, Hwb32};

let p = Hwb32::new(0.25, 0.5, 1.0);
assert_eq!(Hwb::hue(p), Ch32::new(0.25));

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

Get a mutable reference to the hue component.

Example: Modify HWB Hue

use pix::chan::{Ch32, Channel};
use pix::hwb::{Hwb, Hwb32};

let mut p = Hwb32::new(0.75, 0.5, 0.5);
let mut h = Hwb::hue_mut(&mut p);
*h = h.wrapping_add(0.5.into());
assert_eq!(Hwb::hue(p), Ch32::new(0.25));

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

Get the whiteness component.

This is the amount of whiteness mixed in with a “pure” hue.

Example: HWB Whiteness

use pix::chan::Ch16;
use pix::hwb::{Hwb, Hwb16};

let p = Hwb16::new(0x2000, 0x2345, 0x5432);
assert_eq!(Hwb::whiteness(p), Ch16::new(0x2345));

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

Get a mutable reference to the whiteness component.

Example: Modify HWB Whiteness

use pix::chan::Ch16;
use pix::hwb::{Hwb, Hwb16};

let mut p = Hwb16::new(0x2000, 0x1234, 0x8000);
*Hwb::whiteness_mut(&mut p) = Ch16::new(0x4321);
assert_eq!(Hwb::whiteness(p), Ch16::new(0x4321));

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

Get the blackness component.

This is the amount of blackness mixed in with a “pure” hue.

Example: HWB Blackness

use pix::chan::Ch8;
use pix::hwb::{Hwb, Hwb8};

let p = Hwb8::new(0x43, 0x22, 0x19);
assert_eq!(Hwb::blackness(p), Ch8::new(0x19));

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

Get a mutable reference to the blackness component.

Example: Modify HWB Blackness

use pix::chan::Ch8;
use pix::hwb::{Hwb, Hwb8};

let mut p = Hwb8::new(0x93, 0x80, 0xA0);
*Hwb::blackness_mut(&mut p) = Ch8::new(0xBB);
assert_eq!(Hwb::blackness(p), Ch8::new(0xBB));

Trait Implementations

impl Clone for Hwb

fn clone(&self) -> Hwb

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColorModel for Hwb

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 Hwb

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

Formats the value using the given formatter.

impl Default for Hwb

fn default() -> Hwb

Returns the “default value” for a type.

impl PartialEq<Hwb> for Hwb

fn eq(&self, other: &Hwb) -> 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 Hwb

impl Eq for Hwb

impl StructuralEq for Hwb

impl StructuralPartialEq for Hwb