Struct pix::xyz::Xyz

pub struct Xyz {}

Xyz color model with D65 white point.

The components are X, Y, Z and optional alpha.

Implementations

impl Xyz

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

Get the X component.

Example: Xyz X

use pix::chan::Ch32;
use pix::xyz::{Xyz, Xyz32};

let p = Xyz32::new(0.25, 0.5, 1.0);
assert_eq!(Xyz::x(p), Ch32::new(0.25));

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

Get a mutable reference to the X component.

Example: Modify Xyz X

use pix::chan::Ch32;
use pix::xyz::{Xyz, Xyz32};

let mut p = Xyz32::new(0.25, 0.5, 1.0);
*Xyz::x_mut(&mut p) = Ch32::new(0.75);
assert_eq!(Xyz::x(p), Ch32::new(0.75));

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

Get the Y component.

Example: Xyz Y

use pix::chan::Ch16;
use pix::xyz::{Xyz, Xyz16};

let p = Xyz16::new(0x2000, 0x1234, 0x8000);
assert_eq!(Xyz::y(p), Ch16::new(0x1234));

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

Get a mutable reference to the Y component.

Example: Modify Xyz Y

use pix::chan::Ch16;
use pix::xyz::{Xyz, Xyz16};

let mut p = Xyz16::new(0x2000, 0x1234, 0x8000);
*Xyz::y_mut(&mut p) = 0x4321.into();
assert_eq!(Xyz::y(p), Ch16::new(0x4321));

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

Get the Z component.

Example: Xyz Z

use pix::chan::Ch8;
use pix::xyz::{Xyz, Xyz8};

let p = Xyz8::new(0x93, 0x80, 0xA0);
assert_eq!(Xyz::z(p), Ch8::new(0xA0));

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

Get a mutable reference to the Z component.

Example: Modify Xyz Z

use pix::chan::Ch8;
use pix::xyz::{Xyz, Xyz8};

let mut p = Xyz8::new(0x88, 0x77, 0x66);
*Xyz::z_mut(&mut p) = 0x55.into();
assert_eq!(Xyz::z(p), Ch8::new(0x55));

Trait Implementations

impl Clone for Xyz

fn clone(&self) -> Xyz

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColorModel for Xyz

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 Xyz

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

Formats the value using the given formatter.

impl Default for Xyz

fn default() -> Xyz

Returns the “default value” for a type.

impl PartialEq<Xyz> for Xyz

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

impl Eq for Xyz

impl StructuralEq for Xyz

impl StructuralPartialEq for Xyz