tor-browser

convert.rs (29743B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */

//! Color conversion algorithms.
//!
//! Algorithms, matrices and constants are from the [color-4] specification,
//! unless otherwise specified:
//!
//! https://drafts.csswg.org/css-color-4/#color-conversion-code
//!
//! NOTE: Matrices has to be transposed from the examples in the spec for use
//! with the `euclid` library.

use crate::color::ColorComponents;
use crate::values::normalize;

type Transform = euclid::default::Transform3D<f32>;
type Vector = euclid::default::Vector3D<f32>;

/// Normalize hue into [0, 360).
#[inline]
pub fn normalize_hue(hue: f32) -> f32 {
   hue - 360. * (hue / 360.).floor()
}

/// Calculate the hue from RGB components and return it along with the min and
/// max RGB values.
#[inline]
fn rgb_to_hue_min_max(red: f32, green: f32, blue: f32) -> (f32, f32, f32) {
   let max = red.max(green).max(blue);
   let min = red.min(green).min(blue);

   let delta = max - min;

   let hue = if delta != 0.0 {
       60.0 * if max == red {
           (green - blue) / delta + if green < blue { 6.0 } else { 0.0 }
       } else if max == green {
           (blue - red) / delta + 2.0
       } else {
           (red - green) / delta + 4.0
       }
   } else {
       f32::NAN
   };

   (hue, min, max)
}

/// Convert from HSL notation to RGB notation.
/// https://drafts.csswg.org/css-color-4/#hsl-to-rgb
#[inline]
pub fn hsl_to_rgb(from: &ColorComponents) -> ColorComponents {
   fn hue_to_rgb(t1: f32, t2: f32, hue: f32) -> f32 {
       let hue = normalize_hue(hue);

       if hue * 6.0 < 360.0 {
           t1 + (t2 - t1) * hue / 60.0
       } else if hue * 2.0 < 360.0 {
           t2
       } else if hue * 3.0 < 720.0 {
           t1 + (t2 - t1) * (240.0 - hue) / 60.0
       } else {
           t1
       }
   }

   // Convert missing components to 0.0.
   let ColorComponents(hue, saturation, lightness) = from.map(normalize);
   let saturation = saturation / 100.0;
   let lightness = lightness / 100.0;

   let t2 = if lightness <= 0.5 {
       lightness * (saturation + 1.0)
   } else {
       lightness + saturation - lightness * saturation
   };
   let t1 = lightness * 2.0 - t2;

   ColorComponents(
       hue_to_rgb(t1, t2, hue + 120.0),
       hue_to_rgb(t1, t2, hue),
       hue_to_rgb(t1, t2, hue - 120.0),
   )
}

/// Convert from RGB notation to HSL notation.
/// https://drafts.csswg.org/css-color-4/#rgb-to-hsl
pub fn rgb_to_hsl(from: &ColorComponents) -> ColorComponents {
   let ColorComponents(red, green, blue) = *from;

   let (hue, min, max) = rgb_to_hue_min_max(red, green, blue);

   let lightness = (min + max) / 2.0;
   let delta = max - min;

   let saturation = if delta != 0.0 {
       if lightness == 0.0 || lightness == 1.0 {
           0.0
       } else {
           (max - lightness) / lightness.min(1.0 - lightness)
       }
   } else {
       0.0
   };

   ColorComponents(hue, saturation * 100.0, lightness * 100.0)
}

/// Convert from HWB notation to RGB notation.
/// https://drafts.csswg.org/css-color-4/#hwb-to-rgb
#[inline]
pub fn hwb_to_rgb(from: &ColorComponents) -> ColorComponents {
   // Convert missing components to 0.0.
   let ColorComponents(hue, whiteness, blackness) = from.map(normalize);

   let whiteness = whiteness / 100.0;
   let blackness = blackness / 100.0;

   if whiteness + blackness >= 1.0 {
       let gray = whiteness / (whiteness + blackness);
       return ColorComponents(gray, gray, gray);
   }

   let x = 1.0 - whiteness - blackness;
   hsl_to_rgb(&ColorComponents(hue, 100.0, 50.0)).map(|v| v * x + whiteness)
}

/// Convert from RGB notation to HWB notation.
/// https://drafts.csswg.org/css-color-4/#rgb-to-hwb
#[inline]
pub fn rgb_to_hwb(from: &ColorComponents) -> ColorComponents {
   let ColorComponents(red, green, blue) = *from;

   let (hue, min, max) = rgb_to_hue_min_max(red, green, blue);

   let whiteness = min;
   let blackness = 1.0 - max;

   ColorComponents(hue, whiteness * 100.0, blackness * 100.0)
}

/// Calculate an epsilon for a specified range.
#[inline]
pub fn epsilon_for_range(min: f32, max: f32) -> f32 {
   (max - min) / 1.0e5
}

/// Convert from the rectangular orthogonal to the cylindrical polar coordinate
/// system. This is used to convert (ok)lab to (ok)lch.
/// <https://drafts.csswg.org/css-color-4/#lab-to-lch>
#[inline]
pub fn orthogonal_to_polar(from: &ColorComponents, e: f32) -> ColorComponents {
   let ColorComponents(lightness, a, b) = *from;

   let chroma = (a * a + b * b).sqrt();

   let hue = if a.abs() < e && b.abs() < e {
       // For extremely small values of a and b ... the reported hue angle
       // swinging about wildly and being essentially random ... this means
       // the hue is powerless, and treated as missing when converted into LCH
       // or Oklch.
       f32::NAN
   } else if chroma.abs() < e {
       // Very small chroma values make the hue component powerless.
       f32::NAN
   } else {
       normalize_hue(b.atan2(a).to_degrees())
   };

   ColorComponents(lightness, chroma, hue)
}

/// Convert from the cylindrical polar to the rectangular orthogonal coordinate
/// system. This is used to convert (ok)lch to (ok)lab.
/// <https://drafts.csswg.org/css-color-4/#lch-to-lab>
#[inline]
pub fn polar_to_orthogonal(from: &ColorComponents) -> ColorComponents {
   let ColorComponents(lightness, chroma, hue) = *from;

   // A missing hue component results in an achromatic color.
   if hue.is_nan() {
       return ColorComponents(lightness, 0.0, 0.0);
   }

   let hue = hue.to_radians();
   let a = chroma * hue.cos();
   let b = chroma * hue.sin();

   ColorComponents(lightness, a, b)
}

#[inline]
fn transform(from: &ColorComponents, mat: &Transform) -> ColorComponents {
   let result = mat.transform_vector3d(Vector::new(from.0, from.1, from.2));
   ColorComponents(result.x, result.y, result.z)
}

fn xyz_d65_to_xyz_d50(from: &ColorComponents) -> ColorComponents {
   #[rustfmt::skip]
   const MAT: Transform = Transform::new(
        1.0479298208405488,    0.029627815688159344, -0.009243058152591178, 0.0,
        0.022946793341019088,  0.990434484573249,     0.015055144896577895, 0.0,
       -0.05019222954313557,  -0.01707382502938514,   0.7518742899580008,   0.0,
        0.0,                   0.0,                   0.0,                  1.0,
   );

   transform(from, &MAT)
}

fn xyz_d50_to_xyz_d65(from: &ColorComponents) -> ColorComponents {
   #[rustfmt::skip]
   const MAT: Transform = Transform::new(
        0.9554734527042182,   -0.028369706963208136,  0.012314001688319899, 0.0,
       -0.023098536874261423,  1.0099954580058226,   -0.020507696433477912, 0.0,
        0.0632593086610217,    0.021041398966943008,  1.3303659366080753,   0.0,
        0.0,                   0.0,                   0.0,                  1.0,
   );

   transform(from, &MAT)
}

/// A reference white that is used during color conversion.
pub enum WhitePoint {
   /// D50 white reference.
   D50,
   /// D65 white reference.
   D65,
}

impl WhitePoint {
   const fn values(&self) -> ColorComponents {
       // <https://drafts.csswg.org/css-color-4/#color-conversion-code>
       match self {
           // [0.3457 / 0.3585, 1.00000, (1.0 - 0.3457 - 0.3585) / 0.3585]
           WhitePoint::D50 => ColorComponents(0.9642956764295677, 1.0, 0.8251046025104602),
           // [0.3127 / 0.3290, 1.00000, (1.0 - 0.3127 - 0.3290) / 0.3290]
           WhitePoint::D65 => ColorComponents(0.9504559270516716, 1.0, 1.0890577507598784),
       }
   }
}

fn convert_white_point(from: WhitePoint, to: WhitePoint, components: &mut ColorComponents) {
   match (from, to) {
       (WhitePoint::D50, WhitePoint::D65) => *components = xyz_d50_to_xyz_d65(components),
       (WhitePoint::D65, WhitePoint::D50) => *components = xyz_d65_to_xyz_d50(components),
       _ => {},
   }
}

/// A trait that allows conversion of color spaces to and from XYZ coordinate
/// space with a specified white point.
///
/// Allows following the specified method of converting between color spaces:
/// - Convert to values to sRGB linear light.
/// - Convert to XYZ coordinate space.
/// - Adjust white point to target white point.
/// - Convert to sRGB linear light in target color space.
/// - Convert to sRGB gamma encoded in target color space.
///
/// https://drafts.csswg.org/css-color-4/#color-conversion
pub trait ColorSpaceConversion {
   /// The white point that the implementer is represented in.
   const WHITE_POINT: WhitePoint;

   /// Convert the components from sRGB gamma encoded values to sRGB linear
   /// light values.
   fn to_linear_light(from: &ColorComponents) -> ColorComponents;

   /// Convert the components from sRGB linear light values to XYZ coordinate
   /// space.
   fn to_xyz(from: &ColorComponents) -> ColorComponents;

   /// Convert the components from XYZ coordinate space to sRGB linear light
   /// values.
   fn from_xyz(from: &ColorComponents) -> ColorComponents;

   /// Convert the components from sRGB linear light values to sRGB gamma
   /// encoded values.
   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents;
}

/// Convert the color components from the specified color space to XYZ and
/// return the components and the white point they are in.
pub fn to_xyz<From: ColorSpaceConversion>(from: &ColorComponents) -> (ColorComponents, WhitePoint) {
   // Convert the color components where in-gamut values are in the range
   // [0 - 1] to linear light (un-companded) form.
   let result = From::to_linear_light(from);

   // Convert the color components from the source color space to XYZ.
   (From::to_xyz(&result), From::WHITE_POINT)
}

/// Convert the color components from XYZ at the given white point to the
/// specified color space.
pub fn from_xyz<To: ColorSpaceConversion>(
   from: &ColorComponents,
   white_point: WhitePoint,
) -> ColorComponents {
   let mut xyz = from.clone();

   // Convert the white point if needed.
   convert_white_point(white_point, To::WHITE_POINT, &mut xyz);

   // Convert the color from XYZ to the target color space.
   let result = To::from_xyz(&xyz);

   // Convert the color components of linear-light values in the range
   // [0 - 1] to a gamma corrected form.
   To::to_gamma_encoded(&result)
}

/// The sRGB color space.
/// https://drafts.csswg.org/css-color-4/#predefined-sRGB
pub struct Srgb;

impl Srgb {
   #[rustfmt::skip]
   const TO_XYZ: Transform = Transform::new(
       0.4123907992659595,  0.21263900587151036, 0.01933081871559185, 0.0,
       0.35758433938387796, 0.7151686787677559,  0.11919477979462599, 0.0,
       0.1804807884018343,  0.07219231536073371, 0.9505321522496606,  0.0,
       0.0,                 0.0,                 0.0,                 1.0,
   );

   #[rustfmt::skip]
   const FROM_XYZ: Transform = Transform::new(
        3.2409699419045213, -0.9692436362808798,  0.05563007969699361, 0.0,
       -1.5373831775700935,  1.8759675015077206, -0.20397695888897657, 0.0,
       -0.4986107602930033,  0.04155505740717561, 1.0569715142428786,  0.0,
        0.0,                 0.0,                 0.0,                 1.0,
   );
}

impl ColorSpaceConversion for Srgb {
   const WHITE_POINT: WhitePoint = WhitePoint::D65;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       from.clone().map(|value| {
           let abs = value.abs();

           if abs < 0.04045 {
               value / 12.92
           } else {
               value.signum() * ((abs + 0.055) / 1.055).powf(2.4)
           }
       })
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       transform(from, &Self::TO_XYZ)
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       transform(from, &Self::FROM_XYZ)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       from.clone().map(|value| {
           let abs = value.abs();

           if abs > 0.0031308 {
               value.signum() * (1.055 * abs.powf(1.0 / 2.4) - 0.055)
           } else {
               12.92 * value
           }
       })
   }
}

/// Color specified with hue, saturation and lightness components.
pub struct Hsl;

impl ColorSpaceConversion for Hsl {
   const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       Srgb::to_linear_light(&hsl_to_rgb(from))
   }

   #[inline]
   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       Srgb::to_xyz(from)
   }

   #[inline]
   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       Srgb::from_xyz(from)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       rgb_to_hsl(&Srgb::to_gamma_encoded(from))
   }
}

/// Color specified with hue, whiteness and blackness components.
pub struct Hwb;

impl ColorSpaceConversion for Hwb {
   const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       Srgb::to_linear_light(&hwb_to_rgb(from))
   }

   #[inline]
   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       Srgb::to_xyz(from)
   }

   #[inline]
   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       Srgb::from_xyz(from)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       rgb_to_hwb(&Srgb::to_gamma_encoded(from))
   }
}

/// The same as sRGB color space, except the transfer function is linear light.
/// https://drafts.csswg.org/css-color-4/#predefined-sRGB-linear
pub struct SrgbLinear;

impl ColorSpaceConversion for SrgbLinear {
   const WHITE_POINT: WhitePoint = Srgb::WHITE_POINT;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       // Already in linear light form.
       from.clone()
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       Srgb::to_xyz(from)
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       Srgb::from_xyz(from)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       // Stay in linear light form.
       from.clone()
   }
}

/// The Display-P3 color space.
/// https://drafts.csswg.org/css-color-4/#predefined-display-p3
pub struct DisplayP3;

impl DisplayP3 {
   #[rustfmt::skip]
   const TO_XYZ: Transform = Transform::new(
       0.48657094864821626, 0.22897456406974884, 0.0,                  0.0,
       0.26566769316909294, 0.6917385218365062,  0.045113381858902575, 0.0,
       0.1982172852343625,  0.079286914093745,   1.0439443689009757,   0.0,
       0.0,                 0.0,                 0.0,                  1.0,
   );

   #[rustfmt::skip]
   const FROM_XYZ: Transform = Transform::new(
        2.4934969119414245,  -0.829488969561575,    0.035845830243784335, 0.0,
       -0.9313836179191236,   1.7626640603183468,  -0.07617238926804171,  0.0,
       -0.40271078445071684,  0.02362468584194359,  0.9568845240076873,   0.0,
        0.0,                  0.0,                  0.0,                  1.0,
   );
}

impl ColorSpaceConversion for DisplayP3 {
   const WHITE_POINT: WhitePoint = WhitePoint::D65;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       Srgb::to_linear_light(from)
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       transform(from, &Self::TO_XYZ)
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       transform(from, &Self::FROM_XYZ)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       Srgb::to_gamma_encoded(from)
   }
}

/// The Display-P3-linear color space. This is basically display-p3 without gamma encoding.
pub struct DisplayP3Linear;
impl ColorSpaceConversion for DisplayP3Linear {
   const WHITE_POINT: WhitePoint = DisplayP3::WHITE_POINT;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       *from
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       DisplayP3::to_xyz(from)
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       DisplayP3::from_xyz(from)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       *from
   }
}

/// The a98-rgb color space.
/// https://drafts.csswg.org/css-color-4/#predefined-a98-rgb
pub struct A98Rgb;

impl A98Rgb {
   #[rustfmt::skip]
   const TO_XYZ: Transform = Transform::new(
       0.5766690429101308,  0.29734497525053616, 0.027031361386412378, 0.0,
       0.18555823790654627, 0.627363566255466,   0.07068885253582714,  0.0,
       0.18822864623499472, 0.07529145849399789, 0.9913375368376389,   0.0,
       0.0,                 0.0,                 0.0,                  1.0,
   );

   #[rustfmt::skip]
   const FROM_XYZ: Transform = Transform::new(
        2.041587903810746,  -0.9692436362808798,   0.013444280632031024, 0.0,
       -0.5650069742788596,  1.8759675015077206,  -0.11836239223101824,  0.0,
       -0.3447313507783295,  0.04155505740717561,  1.0151749943912054,   0.0,
        0.0,                 0.0,                  0.0,                  1.0,
   );
}

impl ColorSpaceConversion for A98Rgb {
   const WHITE_POINT: WhitePoint = WhitePoint::D65;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       from.clone().map(|v| v.signum() * v.abs().powf(2.19921875))
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       transform(from, &Self::TO_XYZ)
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       transform(from, &Self::FROM_XYZ)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       from.clone()
           .map(|v| v.signum() * v.abs().powf(0.4547069271758437))
   }
}

/// The ProPhoto RGB color space.
/// https://drafts.csswg.org/css-color-4/#predefined-prophoto-rgb
pub struct ProphotoRgb;

impl ProphotoRgb {
   #[rustfmt::skip]
   const TO_XYZ: Transform = Transform::new(
       0.7977604896723027,  0.2880711282292934,     0.0,                0.0,
       0.13518583717574031, 0.7118432178101014,     0.0,                0.0,
       0.0313493495815248,  0.00008565396060525902, 0.8251046025104601, 0.0,
       0.0,                 0.0,                    0.0,                1.0,
   );

   #[rustfmt::skip]
   const FROM_XYZ: Transform = Transform::new(
        1.3457989731028281,  -0.5446224939028347,  0.0,                0.0,
       -0.25558010007997534,  1.5082327413132781,  0.0,                0.0,
       -0.05110628506753401,  0.02053603239147973, 1.2119675456389454, 0.0,
        0.0,                  0.0,                 0.0,                1.0,
   );
}

impl ColorSpaceConversion for ProphotoRgb {
   const WHITE_POINT: WhitePoint = WhitePoint::D50;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       from.clone().map(|value| {
           const ET2: f32 = 16.0 / 512.0;

           let abs = value.abs();

           if abs <= ET2 {
               value / 16.0
           } else {
               value.signum() * abs.powf(1.8)
           }
       })
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       transform(from, &Self::TO_XYZ)
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       transform(from, &Self::FROM_XYZ)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       const ET: f32 = 1.0 / 512.0;

       from.clone().map(|v| {
           let abs = v.abs();
           if abs >= ET {
               v.signum() * abs.powf(1.0 / 1.8)
           } else {
               16.0 * v
           }
       })
   }
}

/// The Rec.2020 color space.
/// https://drafts.csswg.org/css-color-4/#predefined-rec2020
pub struct Rec2020;

impl Rec2020 {
   const ALPHA: f32 = 1.09929682680944;
   const BETA: f32 = 0.018053968510807;

   #[rustfmt::skip]
   const TO_XYZ: Transform = Transform::new(
       0.6369580483012913,  0.26270021201126703,  0.0,                  0.0,
       0.14461690358620838, 0.677998071518871,    0.028072693049087508, 0.0,
       0.16888097516417205, 0.059301716469861945, 1.0609850577107909,   0.0,
       0.0,                 0.0,                  0.0,                  1.0,
   );

   #[rustfmt::skip]
   const FROM_XYZ: Transform = Transform::new(
        1.7166511879712676, -0.666684351832489,    0.017639857445310915, 0.0,
       -0.3556707837763924,  1.616481236634939,   -0.042770613257808655, 0.0,
       -0.2533662813736598,  0.01576854581391113,  0.942103121235474,    0.0,
        0.0,                 0.0,                  0.0,                  1.0,
   );
}

impl ColorSpaceConversion for Rec2020 {
   const WHITE_POINT: WhitePoint = WhitePoint::D65;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       from.clone().map(|value| {
           let abs = value.abs();

           if abs < Self::BETA * 4.5 {
               value / 4.5
           } else {
               value.signum() * ((abs + Self::ALPHA - 1.0) / Self::ALPHA).powf(1.0 / 0.45)
           }
       })
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       transform(from, &Self::TO_XYZ)
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       transform(from, &Self::FROM_XYZ)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       from.clone().map(|v| {
           let abs = v.abs();

           if abs > Self::BETA {
               v.signum() * (Self::ALPHA * abs.powf(0.45) - (Self::ALPHA - 1.0))
           } else {
               4.5 * v
           }
       })
   }
}

/// A color in the XYZ coordinate space with a D50 white reference.
/// https://drafts.csswg.org/css-color-4/#predefined-xyz
pub struct XyzD50;

impl ColorSpaceConversion for XyzD50 {
   const WHITE_POINT: WhitePoint = WhitePoint::D50;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       from.clone()
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       from.clone()
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       from.clone()
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       from.clone()
   }
}

/// A color in the XYZ coordinate space with a D65 white reference.
/// https://drafts.csswg.org/css-color-4/#predefined-xyz
pub struct XyzD65;

impl ColorSpaceConversion for XyzD65 {
   const WHITE_POINT: WhitePoint = WhitePoint::D65;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       from.clone()
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       from.clone()
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       from.clone()
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       from.clone()
   }
}

/// The Lab color space.
/// https://drafts.csswg.org/css-color-4/#specifying-lab-lch
pub struct Lab;

impl Lab {
   const KAPPA: f32 = 24389.0 / 27.0;
   const EPSILON: f32 = 216.0 / 24389.0;
}

impl ColorSpaceConversion for Lab {
   const WHITE_POINT: WhitePoint = WhitePoint::D50;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       // No need for conversion.
       from.clone()
   }

   /// Convert a CIELAB color to XYZ as specified in [1] and [2].
   ///
   /// [1]: https://drafts.csswg.org/css-color/#lab-to-predefined
   /// [2]: https://drafts.csswg.org/css-color/#color-conversion-code
   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       let ColorComponents(lightness, a, b) = *from;

       let f1 = (lightness + 16.0) / 116.0;
       let f0 = f1 + a / 500.0;
       let f2 = f1 - b / 200.0;

       let f0_cubed = f0 * f0 * f0;
       let x = if f0_cubed > Self::EPSILON {
           f0_cubed
       } else {
           (116.0 * f0 - 16.0) / Self::KAPPA
       };

       let y = if lightness > Self::KAPPA * Self::EPSILON {
           let v = (lightness + 16.0) / 116.0;
           v * v * v
       } else {
           lightness / Self::KAPPA
       };

       let f2_cubed = f2 * f2 * f2;
       let z = if f2_cubed > Self::EPSILON {
           f2_cubed
       } else {
           (116.0 * f2 - 16.0) / Self::KAPPA
       };

       ColorComponents(x, y, z) * Self::WHITE_POINT.values()
   }

   /// Convert an XYZ color to LAB as specified in [1] and [2].
   ///
   /// [1]: https://drafts.csswg.org/css-color/#rgb-to-lab
   /// [2]: https://drafts.csswg.org/css-color/#color-conversion-code
   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       let adapted = *from / Self::WHITE_POINT.values();

       // 4. Convert D50-adapted XYZ to Lab.
       let ColorComponents(f0, f1, f2) = adapted.map(|v| {
           if v > Self::EPSILON {
               v.cbrt()
           } else {
               (Self::KAPPA * v + 16.0) / 116.0
           }
       });

       let lightness = 116.0 * f1 - 16.0;
       let a = 500.0 * (f0 - f1);
       let b = 200.0 * (f1 - f2);

       ColorComponents(lightness, a, b)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       // No need for conversion.
       from.clone()
   }
}

/// The Lch color space.
/// https://drafts.csswg.org/css-color-4/#specifying-lab-lch
pub struct Lch;

impl ColorSpaceConversion for Lch {
   const WHITE_POINT: WhitePoint = Lab::WHITE_POINT;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       // No need for conversion.
       from.clone()
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       // Convert LCH to Lab first.
       let lab = polar_to_orthogonal(from);

       // Then convert the Lab to XYZ.
       Lab::to_xyz(&lab)
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       // First convert the XYZ to LAB.
       let lab = Lab::from_xyz(&from);

       // Then convert the Lab to LCH.
       orthogonal_to_polar(&lab, epsilon_for_range(0.0, 100.0))
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       // No need for conversion.
       from.clone()
   }
}

/// The Oklab color space.
/// https://drafts.csswg.org/css-color-4/#specifying-oklab-oklch
pub struct Oklab;

impl Oklab {
   #[rustfmt::skip]
   const XYZ_TO_LMS: Transform = Transform::new(
        0.8190224432164319,  0.0329836671980271,  0.048177199566046255, 0.0,
        0.3619062562801221,  0.9292868468965546,  0.26423952494422764,  0.0,
       -0.12887378261216414, 0.03614466816999844, 0.6335478258136937,   0.0,
        0.0,                 0.0,                 0.0,                  1.0,
   );

   #[rustfmt::skip]
   const LMS_TO_OKLAB: Transform = Transform::new(
        0.2104542553,  1.9779984951,  0.0259040371, 0.0,
        0.7936177850, -2.4285922050,  0.7827717662, 0.0,
       -0.0040720468,  0.4505937099, -0.8086757660, 0.0,
        0.0,           0.0,           0.0,          1.0,
   );

   #[rustfmt::skip]
   const LMS_TO_XYZ: Transform = Transform::new(
        1.2268798733741557,  -0.04057576262431372, -0.07637294974672142, 0.0,
       -0.5578149965554813,   1.1122868293970594,  -0.4214933239627914,  0.0,
        0.28139105017721583, -0.07171106666151701,  1.5869240244272418,  0.0,
        0.0,                  0.0,                  0.0,                 1.0,
   );

   #[rustfmt::skip]
   const OKLAB_TO_LMS: Transform = Transform::new(
       0.99999999845051981432,  1.0000000088817607767,    1.0000000546724109177,   0.0,
       0.39633779217376785678, -0.1055613423236563494,   -0.089484182094965759684, 0.0,
       0.21580375806075880339, -0.063854174771705903402, -1.2914855378640917399,   0.0,
       0.0,                     0.0,                      0.0,                     1.0,
   );
}

impl ColorSpaceConversion for Oklab {
   const WHITE_POINT: WhitePoint = WhitePoint::D65;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       // No need for conversion.
       from.clone()
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       let lms = transform(&from, &Self::OKLAB_TO_LMS);
       let lms = lms.map(|v| v * v * v);
       transform(&lms, &Self::LMS_TO_XYZ)
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       let lms = transform(&from, &Self::XYZ_TO_LMS);
       let lms = lms.map(|v| v.cbrt());
       transform(&lms, &Self::LMS_TO_OKLAB)
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       // No need for conversion.
       from.clone()
   }
}

/// The Oklch color space.
/// https://drafts.csswg.org/css-color-4/#specifying-oklab-oklch
pub struct Oklch;

impl ColorSpaceConversion for Oklch {
   const WHITE_POINT: WhitePoint = Oklab::WHITE_POINT;

   fn to_linear_light(from: &ColorComponents) -> ColorComponents {
       // No need for conversion.
       from.clone()
   }

   fn to_xyz(from: &ColorComponents) -> ColorComponents {
       // First convert OkLCH to Oklab.
       let oklab = polar_to_orthogonal(from);

       // Then convert Oklab to XYZ.
       Oklab::to_xyz(&oklab)
   }

   fn from_xyz(from: &ColorComponents) -> ColorComponents {
       // First convert XYZ to Oklab.
       let lab = Oklab::from_xyz(&from);

       // Then convert Oklab to OkLCH.
       orthogonal_to_polar(&lab, epsilon_for_range(0.0, 1.0))
   }

   fn to_gamma_encoded(from: &ColorComponents) -> ColorComponents {
       // No need for conversion.
       from.clone()
   }
}