Struct pix::oklab::Oklab

pub struct Oklab {}

Oklab color model

The components are L, a, b and optional alpha.

Implementations

impl Oklab

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

Get the L component (perceived lightness).

Example: Oklab L

use pix::chan::Ch32;
use pix::oklab::{Oklab, Oklab32};

let p = Oklab32::new(0.25, 0.5, 1.0);
assert_eq!(Oklab::l(p), Ch32::new(0.25));

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

Get a mutable reference to the L component.

Example: Modify Oklab L

use pix::chan::Ch32;
use pix::oklab::{Oklab, Oklab32};

let mut p = Oklab32::new(0.25, 0.5, 1.0);
*Oklab::l_mut(&mut p) = Ch32::new(0.75);
assert_eq!(Oklab::l(p), Ch32::new(0.75));

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

Get the a component (green/red).

Example: Oklab a

use pix::chan::Ch16;
use pix::oklab::{Oklab, Oklab16};

let p = Oklab16::new(0x2000, 0x1234, 0x8000);
assert_eq!(Oklab::a(p), Ch16::new(0x1234));

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

Get a mutable reference to the a component.

Example: Modify Oklab a

use pix::chan::Ch16;
use pix::oklab::{Oklab, Oklab16};

let mut p = Oklab16::new(0x2000, 0x1234, 0x8000);
*Oklab::a_mut(&mut p) = 0x4321.into();
assert_eq!(Oklab::a(p), Ch16::new(0x4321));

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

Get the b component (blue/yellow).

Example: Oklab b

use pix::chan::Ch8;
use pix::oklab::{Oklab, Oklab8};

let p = Oklab8::new(0x93, 0x80, 0xA0);
assert_eq!(Oklab::b(p), Ch8::new(0xA0));

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

Get a mutable reference to the b component.

Example: Modify Oklab b

use pix::chan::Ch8;
use pix::oklab::{Oklab, Oklab8};

let mut p = Oklab8::new(0x88, 0x77, 0x66);
*Oklab::b_mut(&mut p) = 0x55.into();
assert_eq!(Oklab::b(p), Ch8::new(0x55));

Trait Implementations

impl Clone for Oklab

fn clone(&self) -> Oklab

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ColorModel for Oklab

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 Oklab

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

Formats the value using the given formatter.

impl Default for Oklab

fn default() -> Oklab

Returns the “default value” for a type.

impl PartialEq<Oklab> for Oklab

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

impl Eq for Oklab

impl StructuralEq for Oklab

impl StructuralPartialEq for Oklab