Struct pix::cmy::Cmy

pub struct Cmy {}

CMY subtractive color model.

The components are cyan, magenta, yellow and optional alpha.

Implementations

impl Cmy

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

Get the cyan component.

Example: Get CMY Cyan

use pix::cmy::{Cmy, Cmy8};
use pix::chan::Ch8;

let p = Cmy8::new(0x93, 0x80, 0xA0);
assert_eq!(Cmy::cyan(p), Ch8::new(0x93));

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

Get a mutable reference to the cyan component.

Example: Modify CMY Cyan

use pix::cmy::{Cmy, Cmy8};
use pix::chan::Ch8;

let mut p = Cmy8::new(0x88, 0x77, 0x66);
*Cmy::cyan_mut(&mut p) = 0x55.into();
assert_eq!(Cmy::cyan(p), Ch8::new(0x55));

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

Get the magenta component.

Example: CMY Magenta

use pix::cmy::{Cmy, Cmy16};
use pix::chan::Ch16;

let p = Cmy16::new(0x2000, 0x1234, 0x8000);
assert_eq!(Cmy::magenta(p), Ch16::new(0x1234));

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

Get a mutable reference to the magenta component.

Example: Modify CMY Magenta

use pix::cmy::{Cmy, Cmy16};
use pix::chan::Ch16;

let mut p = Cmy16::new(0x2000, 0x1234, 0x8000);
*Cmy::magenta_mut(&mut p) = 0x4321.into();
assert_eq!(Cmy::magenta(p), Ch16::new(0x4321));

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

Get the yellow component.

Example: CMY Yellow

use pix::cmy::{Cmy, Cmy32};
use pix::chan::Ch32;

let p = Cmy32::new(0.25, 0.5, 1.0);
assert_eq!(Cmy::yellow(p), Ch32::new(1.0));

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

Get a mutable reference to the yellow component.

Example: Modify CMY Yellow

use pix::cmy::{Cmy, Cmy32};
use pix::chan::Ch32;

let mut p = Cmy32::new(0.25, 0.5, 1.0);
*Cmy::yellow_mut(&mut p) = Ch32::new(0.75);
assert_eq!(Cmy::yellow(p), Ch32::new(0.75));

Trait Implementations

impl Clone for Cmy

fn clone(&self) -> Cmy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColorModel for Cmy

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 Cmy

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

Formats the value using the given formatter.

impl Default for Cmy

fn default() -> Cmy

Returns the “default value” for a type.

impl PartialEq<Cmy> for Cmy

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

impl Eq for Cmy

impl StructuralEq for Cmy

impl StructuralPartialEq for Cmy