Struct CieLab 

pub struct CieLab { /* private fields */ }

Implementations

impl CieLab

pub fn new(lab: [f64; 3], xyzn: XYZ) -> CieLab

Creates a new CIE Lab* color from the given Lab* values and reference white.

Arguments

• lab - The Lab* color values as an array of three f64 values.
• white_point - The reference white tristimulus value.

Returns

A new CieLab instance.

pub fn a(&self) -> f64

pub fn b(&self) -> f64

pub fn l(&self) -> f64

pub fn from_rxyz(xyz: RelXYZ) -> CieLab

Creates a new CIE Lab* color from the given XYZ color and reference white.

Arguments

• rxyz - The RelXYZ color to convert.

Returns

A Result containing the CIE Lab* color or an error if the observers do not match.

pub fn rxyz(&self) -> RelXYZ

Converts the CIE L*a*b* color back to XYZ using the reference white.

Returns

The XYZ color corresponding to the CIE L*a*b* values.

pub fn xyz(&self) -> XYZ

Converts the CIE L*a*b* color back to XYZ using the reference white.

Returns

The XYZ color corresponding to the CIE L*a*b* values.

pub fn white_point(&self) -> XYZ

Returns the reference white tristimulus value for this CIE Lab* color.

pub fn set_white_luminance(self, luminance: f64) -> CieLab

Sets the reference white luminance for this CIE Lab* color, in units of cd/m².

Arguments

• luminance - The desired luminance level for the reference white.

Returns

A new CieLab instance with the adjusted luminance.

This adjusts the reference white to the specified illuminance level.

Notes

• This does not change the L*a*b* values directly; it modifies the reference white to scale the white reference luminance.
• Typically the value is set to 100 for normalized white luminance, but more advanced models, such as CIECAM16, may use different luminance levels for perceptual accuracy.

pub fn ciede(&self, other: &Self) -> Result<f64, Error>

Computes the Euclidean ΔE*ab color difference between two CIE L*a*b* colors.

This function measures the straight-line distance in L*a*b* space: ΔE = sqrt((L₁−L₂)² + (a₁−a₂)² + (b₁−b₂)²)

Arguments

• other – The second Lab color to compare against.

Returns

• Ok(de) – The ΔE value if both colors share the same observer and illuminant.

Errors

• CmtError::RequireSameObserver if the two colors use different standard observers.
• CmtError::IlluminantMismatch if they were computed under different illuminants.

Notes

The plain Euclidean ΔE*ab is commonly used but does not always match perceived differences as well as more advanced formulas (e.g., CIEDE2000, or CIECAM16DE).

Example

use colorimetry::{lab::CieLab, xyz::{RelXYZ, XYZ}, observer::Observer, Error};

let xyz1 = XYZ::new([36.0, 70.0, 12.0], Observer::Cie1931);
let xyz2 = XYZ::new([35.0, 71.0, 11.0], Observer::Cie1931);
let lab1 = CieLab::from_rxyz(RelXYZ::with_d65(xyz1));
let lab2 = CieLab::from_rxyz(RelXYZ::with_d65(xyz2));
let de = lab1.ciede(&lab2).unwrap();
//  ΔE=6.57

pub fn ciede2000(&self, other: &Self) -> Result<f64, Error>

Computes the CIEDE2000 ΔE color difference between two CIE Lab* colors.

This is a more advanced formula that accounts for perceptual non-uniformities in the Lab* space.

Arguments

• other – The second Lab color to compare against.

Returns

• Ok(de) – The ΔE value if both colors share the same observer and illuminant.

Errors

• CmtError::RequireSameObserver if the two colors use different standard observers.
• CmtError::RequiresSameIlluminant if they were computed under different illuminants.

Notes

CIEDE2000 is generally preferred over the plain Euclidean ΔE*ab for color difference calculations, as it better matches human perception of color differences.

Example

use colorimetry::{observer::Observer::Cie1931, lab::CieLab, Error};

// Sharma et al. (2005) test case 25
let xyz_d65 = Cie1931.xyz_d65();
let lab1 = CieLab::new([60.2574, -34.0099, 36.2677], xyz_d65);
let lab2 = CieLab::new([60.4626, -34.1751, 39.4387], xyz_d65);
let de = lab1.ciede2000(&lab2).unwrap();
approx::assert_abs_diff_eq!(de, 1.2644, epsilon = 1E-4);

pub fn to_array(&self) -> [f64; 3]

Returns the CIE Lab* color values as an array of three f64 values.

Returns

An array containing the L*, a*, and b* values of the color.

pub fn is_valid(&self) -> bool

Validates the CIE Lab* color values.

Returns

true if the L*, a*, and b* values are within valid ranges and the round-trip conversion to and from XYZ is consistent; false otherwise.

pub fn is_black(&self, epsilon: f64) -> bool

Trait Implementations

impl AbsDiffEq for CieLab

type Epsilon = f64

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl AsRef<[f64; 3]> for CieLab

fn as_ref(&self) -> &[f64; 3]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for CieLab

fn clone(&self) -> CieLab

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CieLab

impl Debug for CieLab

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

Formats the value using the given formatter.

impl PartialEq for CieLab

fn eq(&self, other: &CieLab) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for CieLab