@texel/color 1.0.0

package/test/test.js

@@ -0,0 +1,321 @@
+import test from "tape";
+import Color from "colorjs.io";
+import arrayAlmostEqual from "./almost-equal.js";
+import {
+  floatToByte,
+  hexToRGB,
+  isRGBInGamut,
+  RGBtoHex,
+  linear_sRGB_to_LMS_M,
+  LMS_to_linear_sRGB_M,
+  LMS_to_XYZ_M,
+  XYZ_to_linear_sRGB_M,
+  XYZ_to_LMS_M,
+  convert,
+  OKLab,
+  OKLCH,
+  sRGB,
+  sRGBLinear,
+  XYZ,
+  OKLab_from,
+  OKLab_to,
+  transform,
+  OKHSL,
+  sRGBGamut,
+  OKHSV,
+  serialize,
+  gamutMapOKLCH,
+  degToRad,
+  OKHSLToOKLab,
+  OKHSVToOKLab,
+  OKLabToOKHSL,
+  OKLabToOKHSV,
+  XYZD65ToD50,
+  XYZD50ToD65,
+  XYZD50,
+  ProPhotoRGB,
+  ProPhotoRGBLinear,
+  findCuspOKLCH,
+  LMS_to_OKLab_M,
+  DisplayP3,
+  A98RGB,
+  A98RGBLinear,
+  XYZ_to_linear_A98RGB_M,
+  DisplayP3Gamut,
+} from "../src/index.js";
+
+test("should convert XYZ in different whitepoints", async (t) => {
+  const oklab = [0.56, 0.03, -0.1];
+  const xyz_d65_input = new Color("oklab", oklab).to("xyz").coords;
+  const xyz_d50_output = new Color("xyz", xyz_d65_input).to("xyz-d50").coords;
+
+  let tmp = [0, 0, 0];
+  const out = XYZD65ToD50(xyz_d65_input, tmp);
+  t.equal(tmp, out);
+  t.deepEqual(out, xyz_d50_output);
+
+  tmp = [0, 0, 0];
+  const out2 = XYZD50ToD65(xyz_d50_output, tmp);
+  t.deepEqual(out2, xyz_d65_input);
+  t.equal(out2, tmp);
+
+  t.deepEqual(convert(xyz_d50_output, XYZD50, XYZ), xyz_d65_input);
+  t.deepEqual(convert(xyz_d65_input, XYZ, XYZD50), xyz_d50_output);
+});
+
+test("should convert", async (t) => {
+  const oklab = [0.56, 0.03, -0.1];
+  const rgbExpected = new Color("oklab", oklab)
+    .to("srgb")
+    .coords.map((n) => floatToByte(n));
+
+  const lrgb = OKLab_to(oklab, LMS_to_linear_sRGB_M);
+  const rgb = convert(lrgb, sRGBLinear, sRGB).map((f) => floatToByte(f));
+  t.deepEqual(rgb, rgbExpected, "oklab to srgb");
+
+  const inArray = oklab.slice();
+  const outArray = OKLab_to(oklab, LMS_to_linear_sRGB_M, inArray);
+  t.equal(inArray, outArray);
+
+  const oklab2 = OKLab_from(lrgb, linear_sRGB_to_LMS_M);
+  t.equals(arrayAlmostEqual(oklab, oklab2), true, "linear srgb to oklab");
+
+  const xyzExpected = new Color("oklab", oklab).to("xyz").coords;
+  const xyz0 = OKLab_to(oklab, LMS_to_XYZ_M);
+  t.deepEqual(arrayAlmostEqual(xyzExpected, xyz0), true, "OKLab to XYZ");
+
+  const oklabResult = OKLab_from(xyzExpected, XYZ_to_LMS_M);
+  t.deepEqual(arrayAlmostEqual(oklabResult, oklab), true, "XYZ to OKLab");
+
+  const xyzToLSRGBExpected = new Color("xyz", xyzExpected).to(
+    "srgb-linear"
+  ).coords;
+  const xyzToLSRGB = transform(xyzExpected, XYZ_to_linear_sRGB_M);
+  t.deepEqual(
+    arrayAlmostEqual(xyzToLSRGB, xyzToLSRGBExpected),
+    true,
+    "XYZ to sRGB-linear"
+  );
+
+  // XYZ to sRGBLinear
+  const outTest = [0, 0, 0];
+  const outTest2 = convert(xyzExpected, XYZ, sRGBLinear, outTest);
+  t.equal(outTest, outTest2, "returns out vec3");
+  t.deepEqual(outTest, xyzToLSRGB);
+
+  t.deepEqual(
+    convert(xyzExpected, XYZ, sRGB),
+    sRGB.fromBase(xyzToLSRGB),
+    "XYZ to sRGB"
+  );
+
+  const sRGBL_from_XYZ = new Color("xyz", xyzExpected).to("srgb-linear").coords;
+
+  t.ok(
+    arrayAlmostEqual(convert(xyzExpected, XYZ, sRGBLinear), sRGBL_from_XYZ),
+    true,
+    "XYZ to sRGBLinear"
+  );
+
+  // from https://bottosson.github.io/posts/oklab/
+  const knownPairsXYZToOKLab = [
+    [
+      [0.95, 1, 1.089],
+      [1, 0, 0],
+    ],
+    [
+      [1, 0, 0],
+      [0.45, 1.236, -0.019],
+    ],
+    [
+      [0, 1, 0],
+      [0.922, -0.671, 0.263],
+    ],
+    [
+      [0, 0, 1],
+      [0.153, -1.415, -0.449],
+    ],
+  ];
+
+  for (let [xyz, oklabExpected] of knownPairsXYZToOKLab) {
+    const oklabRet = convert(xyz, XYZ, OKLab).map((n) => {
+      n = roundToNDecimals(n, 3);
+      if (n === -0) n = 0;
+      return n;
+    });
+    t.deepEqual(oklabRet, oklabExpected);
+  }
+
+  const oklch = [0.5, -0.36, 90];
+  t.deepEqual(
+    convert(oklch, OKLCH, OKLab),
+    new Color("oklch", oklch).to("oklab").coords,
+    "handle negative chroma"
+  );
+  t.equal(
+    arrayAlmostEqual(
+      convert(oklch, OKLCH, sRGB),
+      new Color("oklch", oklch).to("srgb").coords
+    ),
+    true
+  );
+});
+
+test("should convert to okhsl", async (t) => {
+  const okhsl = [30, 0.5, 0.5];
+  const oklab = OKHSLToOKLab(okhsl, sRGBGamut);
+  const expectedLABfromOKHSL = [
+    0.568838198942395, 0.08553885335853362, 0.049385880012721296,
+  ];
+  t.deepEqual(oklab, expectedLABfromOKHSL);
+  const okhslOut = OKLabToOKHSL(expectedLABfromOKHSL, sRGBGamut);
+  t.deepEqual(okhslOut, okhsl);
+
+  const okhsv = okhsl.slice();
+  const expectedLABfromOKHSV = [
+    0.45178419415172344, 0.0658295198906634, 0.03800669102949832,
+  ];
+  t.deepEqual(OKHSVToOKLab(okhsv, sRGBGamut), expectedLABfromOKHSV);
+  t.deepEqual(
+    arrayAlmostEqual(OKLabToOKHSV(expectedLABfromOKHSV, sRGBGamut), okhsv),
+    true
+  );
+
+  t.deepEqual(convert(okhsl, OKHSL, OKLab), expectedLABfromOKHSL);
+  t.deepEqual(convert(okhsv, OKHSV, OKLab), expectedLABfromOKHSV);
+  t.deepEqual(
+    arrayAlmostEqual(convert(expectedLABfromOKHSV, OKLab, OKHSV), okhsv),
+    true
+  );
+  t.deepEqual(
+    arrayAlmostEqual(convert(expectedLABfromOKHSL, OKLab, OKHSL), okhsl),
+    true
+  );
+});
+
+test("should find cusp", async (t) => {
+  const H = 30;
+  const hueAngle = degToRad(H);
+
+  const aNorm = Math.cos(hueAngle);
+  const bNorm = Math.sin(hueAngle);
+  const out2 = [0, 0];
+  const cusp = findCuspOKLCH(aNorm, bNorm, sRGBGamut, out2);
+  const hue30sRGBCusp = [0.6322837041534408, 0.2535829789121266];
+
+  t.equal(out2, cusp);
+  t.deepEqual(cusp, hue30sRGBCusp);
+
+  const cuspP3 = findCuspOKLCH(aNorm, bNorm, DisplayP3Gamut, out2);
+  const hue30P3Cusp = [0.6542359095783624, 0.2931937837912358];
+  t.equal(out2, cuspP3);
+  t.deepEqual(cuspP3, hue30P3Cusp);
+
+  const l2 = 0.7;
+  const c2 = 0.3;
+  const newLCH = [l2, c2, H];
+  const mapped = gamutMapOKLCH(newLCH, sRGBGamut, OKLCH);
+  t.deepEqual(mapped, [0.679529110489262, 0.2093088779230169, 30]);
+});
+
+test("should gamut map", async (t) => {
+  const oklch = [0.9, 0.4, 30];
+  const rgb = convert(oklch, OKLCH, sRGB);
+  t.equals(isRGBInGamut(rgb, 0), false);
+});
+
+test("should serialize", async (t) => {
+  t.deepEqual(serialize([0, 0.5, 1], sRGB), "rgb(0, 128, 255)");
+  t.deepEqual(serialize([0, 0.5, 1], sRGBLinear), "color(srgb-linear 0 0.5 1)");
+  t.deepEqual(serialize([1, 0, 0], OKLCH, sRGB), "rgb(255, 255, 255)");
+  t.deepEqual(serialize([1, 0, 0], OKLCH), "oklch(1 0 0)");
+});
+
+test("utils", async (t) => {
+  t.deepEqual(RGBtoHex([0, 0.5, 1]), "#0080ff");
+  t.deepEqual(hexToRGB("#0080ff"), [0, 0.5019607843137255, 1]);
+  const tmp = [0, 0, 0];
+  hexToRGB("#0080ff", tmp);
+  t.deepEqual(tmp, [0, 0.5019607843137255, 1]);
+});
+
+test("should convert D65 based to D50 based color spaces", async (t) => {
+  const rgbin = [0.25, 0.5, 1];
+  const xyzD65Input = new Color("srgb", rgbin).to("xyz-d65").coords;
+  const xyzD50Input = XYZD65ToD50(xyzD65Input);
+
+  const prophotoFromXYZD65_expected = new Color("xyz-d65", xyzD65Input).to(
+    "prophoto-linear"
+  ).coords;
+
+  const ret = convert(xyzD65Input, XYZ, ProPhotoRGBLinear);
+  t.deepEqual(ret, prophotoFromXYZD65_expected);
+
+  const xyzD65 = convert(prophotoFromXYZD65_expected, ProPhotoRGBLinear, XYZ);
+  t.deepEqual(arrayAlmostEqual(xyzD65, xyzD65Input), true);
+
+  const prophoto2 = convert(rgbin, sRGB, ProPhotoRGBLinear);
+  const prophotoExpected = new Color("srgb", rgbin).to(
+    "prophoto-linear"
+  ).coords;
+  t.deepEqual(arrayAlmostEqual(prophoto2, prophotoExpected), true);
+
+  const oklabIn = new Color("srgb", rgbin).to("oklab").coords;
+  const oklabToProphoto = new Color("oklab", oklabIn).to(
+    "prophoto-linear"
+  ).coords;
+  t.deepEqual(
+    arrayAlmostEqual(
+      convert(oklabIn, OKLab, ProPhotoRGBLinear),
+      oklabToProphoto
+    ),
+    true
+  );
+
+  const oklabIn2 = [1, 1, 1];
+  const oklabToProphoto2 = new Color("oklab", oklabIn2).to("prophoto").coords;
+
+  t.deepEqual(
+    arrayAlmostEqual(convert(oklabIn2, OKLab, ProPhotoRGB), oklabToProphoto2),
+    true
+  );
+});
+
+test("should handle problematic coords", async (t) => {
+  const in0 = [0.95, 1, 1.089];
+  const out0 = convert(in0, XYZ, OKLab);
+  const expected0lab = new Color("xyz", in0).to("oklab").coords;
+  t.deepEqual(arrayAlmostEqual(out0, expected0lab), true);
+  const inP3 = [0, 0, 1];
+  const outXYZ = convert(inP3, DisplayP3, XYZ);
+  t.deepEqual(
+    arrayAlmostEqual(outXYZ, new Color("p3", inP3).to("xyz").coords),
+    true
+  );
+  const outA98 = convert(outXYZ, XYZ, A98RGBLinear);
+  t.deepEqual(
+    arrayAlmostEqual(
+      outA98,
+      new Color("xyz", outXYZ).to("a98rgb-linear").coords
+    ),
+    true
+  );
+
+  // Failing test here, but it appears Colorjs does not match the latest
+  // CSS spec (working draft with rational form). Please open a PR/issue if you
+  // think you could help, but unless I'm mistaken it seems to be an upstream issue
+  const tolerance = 0.0000001;
+  t.deepEqual(
+    arrayAlmostEqual(
+      convert(inP3, DisplayP3, A98RGB),
+      new Color("p3", inP3).to("a98rgb").coords,
+      tolerance
+    ),
+    true
+  );
+});
+
+function roundToNDecimals(value, digits) {
+  var tenToN = 10 ** digits;
+  return Math.round(value * tenToN) / tenToN;
+}

package/tools/calc_oklab_matrices.py

@@ -0,0 +1,233 @@
+"""
+Calculate `oklab` matrices.
+
+Björn Ottosson, in his original calculations, used a different white point than
+what CSS and most other people use. In the CSS repository, he commented on
+how to calculate the M1 matrix using the exact same white point as CSS. He
+provided the initial matrix used in this calculation, which we will call M0.
+https://github.com/w3c/csswg-drafts/issues/6642#issuecomment-945714988.
+This M0 matrix is used to create a precise matrix to convert XYZ to LMS using
+the D65 white point as specified by CSS. Both ColorAide and CSS use the D65
+chromaticity coordinates of `(0.31270, 0.32900)` which is documented and used
+for sRGB as the standard. There are likely implementations unaware that the
+they should, or even how to adapt the Oklab M1 matrix to their white point
+as this is not documented in the author's Oklab blog post, but is buried in a
+CSS repository discussion.
+
+Additionally, the documented M2 matrix is specified as 32 bit values, and the
+inverse is calculated directly from the this 32 bit matrix. The forward and
+reverse transform is calculated to perfectly convert 32 bit values, but when
+translating 64 bit values, the transform adds a lot of noise after about 7 - 8
+digits (the precision of 32 bit floats). This is particularly problematic for
+achromatic colors in Oklab and OkLCh and can cause chroma not to resolve to zero.
+
+To provide an M2 matrix that works better for 64 bit, we take the inverse M2,
+which provides a perfect transforms to white from Oklab `[1, 0, 0]` in 32 bit
+floating point. We process the matrix as float 32 bit values and emit them as 64
+bit double values, ~17 digit double accuracy. We then calculate the forward
+matrix. This gives us a transform in 64 bit that drives chroma extremely close
+to zero for 64 bit doubles and maintains the same 32 bit precision of up to about
+7 digits, the 32 bit accuracy limit (~7.22).
+
+To demonstrate that our 64 bit converted matrices work as we claim and does not
+alter the intent of the values, we can observe by comparing the documented matrices
+(adjusting for our white point).
+
+Below we demonstrate by first using the documented 32 bit M2 matrix (adjusting the
+M1 for our white point). This is what most implementations do, though some may not
+properly correct the M1 matrix for their white point. Notice how the lightness for
+white is only accurate up to about 7 digits making the expected value of 1 not very
+accurate. Also notice that a and b do not resolve as close to 0. The a value is
+pretty good, but the b value is substantially worse. Also notice the first 7 digits
+(the 32 bit precision) for red, green, and blue as they will be used for comparison.
+
+```
+>>> from coloraide.everything import ColorAll as Color
+>>> import numpy as np
+>>> Color('white').convert('oklab')[:]
+[0.9999999935000001, -1.6653345369377348e-16, 3.729999997759137e-08, 1.0]
+>>> [np.float32(c) for c in Color('red').convert('oklab', norm=False)[:]]
+[0.6279554, 0.22486307, 0.1258463, 1.0]
+>>> [np.float32(c) for c in Color('green').convert('oklab', norm=False)[:]]
+[0.51975185, -0.14030233, 0.107675895, 1.0]
+>>> [np.float32(c) for c in Color('blue').convert('oklab', norm=False)[:]]
+[0.4520137, -0.03245697, -0.31152815, 1.0]
+```
+
+When we use our 64 bit adjusted M2 matrix, we now get a precise 1 for lightness
+when converting white and get zero or nearly zero for a and b. When comparing the
+first 7 digits to the previous example we get the same values. Anything after
+~7 digits is not guaranteed to be the same.
+
+```
+>>> from coloraide.everything import ColorAll as Color
+>>> import numpy as np
+>>> Color('white').convert('oklab')[:]
+[1.0, -5.551115123125783e-17, 0.0, 1.0]
+>>> [np.float32(c) for c in Color('red').convert('oklab', norm=False)[:]]
+[0.6279554, 0.22486307, 0.12584628, 1.0]
+>>> [np.float32(c) for c in Color('green').convert('oklab', norm=False)[:]]
+[0.51975185, -0.14030233, 0.10767588, 1.0]
+>>> [np.float32(c) for c in Color('blue').convert('oklab', norm=False)[:]]
+[0.45201373, -0.032456975, -0.31152818, 1.0]
+```
+
+Okhsl is completely calculated using 32 bit floats as that is how the author
+provided the algorithm, but we can see that when we calculate the new coefficients,
+using our M1 and 64 bit adjusted M2 matrices, that we preserve the 32 precision.
+Anything after ~7 digits is just noise due to the differences in 32 bit and 64 bit.
+
+Comparing to the actual values returned using the author's code in his Okhsl and Okhsv
+color pickers:
+
+```
+// Okhsl
+> var value = srgb_to_okhsl(255, 255, 255); value[0] *= 360; value
+[89.87556309590242, 0.5582831888483675, 0.9999999923961898]
+> var value = srgb_to_okhsl(255, 0, 0); value[0] *= 360; value
+[29.23388519234263, 1.0000000001433997, 0.5680846525040862]
+> var value = srgb_to_okhsl(0, 255, 0); value[0] *= 360; value
+[142.49533888780996, 0.9999999700728788, 0.8445289645307816]
+> var value = srgb_to_okhsl(0, 0, 255); value[0] *= 360; value
+[264.052020638055, 0.9999999948631134, 0.3665653394260194]
+
+// Okhsv
+> var value = srgb_to_okhsv(255, 255, 255); value[0] *= 360; value
+[89.87556309590242, 1.0347523928230576e-7, 1.000000027003774]
+> var value = srgb_to_okhsv(255, 0, 0); value[0] *= 360; value
+[29.23388519234263, 0.9995219692256989, 1.0000000001685625]
+> var value = srgb_to_okhsv(0, 255, 0); value[0] *= 360; value
+[142.49533888780996, 0.9999997210415695, 0.9999999884428648]
+> var value = srgb_to_okhsv(0, 0, 255); value[0] *= 360; value
+[264.052020638055, 0.9999910912349018, 0.9999999646150918]
+```
+
+And then ours. Ignoring the authors hue and our hue results for white
+and the oddly high chroma for the author's achromatic white in Okhsl
+(both of which are meaningless in an achromatic color), we can see that
+that we match quite well up to ~7 digits.
+
+```
+# Okhsl
+>>> Color('white').convert('okhsl', norm=False)[:]
+[180.0, 0.0, 1.0, 1.0]
+>>> Color('#ff0000').convert('okhsl', norm=False)[:]
+[29.233880279627876, 1.0000001765854427, 0.5680846563197033, 1.0]
+>>> Color('#00ff00').convert('okhsl', norm=False)[:]
+[142.4953450414438, 1.0000000000000009, 0.8445289714936317, 1.0]
+>>> [264.05202261637004, 1.0000000005848086, 0.36656533918708145, 1.0]
+[264.05202261637004, 1.0000000005848086, 0.36656533918708145, 1.0]
+# Okhsv
+>>> Color('white').convert('okhsv', norm=False)[:]
+[180.0, 0.0, 1.0, 1.0]
+>>> Color('#ff0000').convert('okhsv', norm=False)[:]
+[29.233880279627876, 1.0000004019360378, 0.9999999999999994, 1.0]
+>>> Color('#00ff00').convert('okhsv', norm=False)[:]
+[142.4953450414438, 0.9999998662471965, 1.0000000000000004, 1.0]
+>>> Color('#0000ff').convert('okhsv', norm=False)[:]
+[264.05202261637004, 1.000000002300706, 0.9999999999999999, 1.0]
+"""
+import sys
+import os
+import struct
+
+sys.path.insert(0, os.getcwd())
+
+# import tools.calc_xyz_transform as xyzt  # noqa: E402
+from coloraide import util  # noqa: E402
+from coloraide import algebra as alg  # noqa: E402
+
+"""Calculate XYZ conversion matrices."""
+import sys
+import os
+
+sys.path.insert(0, os.getcwd())
+
+xyzt_white_d65 = util.xy_to_xyz((0.31270, 0.32900))
+xyzt_white_d50 = util.xy_to_xyz((0.34570, 0.35850))
+xyzt_white_aces = util.xy_to_xyz((0.32168, 0.33767))
+
+def xyzt_get_matrix(wp, space):
+    """Get the matrices for the specified space."""
+
+    if space == 'srgb':
+        x = [0.64, 0.30, 0.15]
+        y = [0.33, 0.60, 0.06]
+    elif space == 'display-p3':
+        x = [0.68, 0.265, 0.150]
+        y = [0.32, 0.69, 0.060]
+    elif space == 'rec2020':
+        x = [0.708, 0.17, 0.131]
+        y = [0.292, 0.797, 0.046]
+    elif space == 'a98-rgb':
+        x = [0.64, 0.21, 0.15]
+        y = [0.33, 0.71, 0.06]
+    elif space == 'prophoto-rgb':
+        x = [0.7347, 0.1596, 0.0366]
+        y = [0.2653, 0.8404, 0.0001]
+    elif space == 'aces-ap0':
+        x = [0.7347, 0.0, 0.0001]
+        y = [0.2653, 1.0, -0.0770]
+    elif space == 'aces-ap1':
+        x = [0.713, 0.165, 0.128]
+        y = [0.293, 0.830, 0.044]
+    else:
+        raise ValueError
+
+    m = alg.transpose([util.xy_to_xyz(xy) for xy in zip(x, y)])
+    rgb = alg.solve(m, wp)
+    rgb2xyz = alg.multiply(m, rgb)
+    xyz2rgb = alg.inv(rgb2xyz)
+
+    return rgb2xyz, xyz2rgb
+
+float32 = alg.vectorize(lambda value: struct.unpack('f', struct.pack('f', value))[0])
+
+# Calculated using our own `calc_xyz_transform.py`
+RGB_TO_XYZ, XYZ_TO_RGB = xyzt_get_matrix(xyzt_white_d65, 'srgb')
+
+# Matrix provided by the author of Oklab to allow for calculating a precise M1 matrix
+# using any white point.
+M0 = [
+    [0.77849780, 0.34399940, -0.12249720],
+    [0.03303601, 0.93076195, 0.03620204],
+    [0.05092917, 0.27933344, 0.66973739]
+]
+
+# Calculate XYZ to LMS and LMS to XYZ using our white point.
+XYZ_TO_LMS = alg.divide(M0, alg.outer(alg.matmul(M0, xyzt_white_d65), alg.ones(3)))
+XYZD50_TO_LMS = alg.divide(M0, alg.outer(alg.matmul(M0, xyzt_white_d50), alg.ones(3)))
+
+# Calculate the inverse
+LMS_TO_XYZ = alg.inv(XYZ_TO_LMS)
+LMS_TO_XYZD50 = alg.inv(XYZD50_TO_LMS)
+
+# Calculate linear sRGB to LMS (used for Okhsl and Okhsv)
+SRGBL_TO_LMS = alg.matmul(XYZ_TO_LMS, RGB_TO_XYZ)
+LMS_TO_SRGBL = alg.inv(SRGBL_TO_LMS)
+
+# Oklab specifies the following matrix as M1 along with the inverse.
+# ```
+# LMS3_TO_OKLAB = [
+#     [0.2104542553, 0.7936177850, -0.0040720468],
+#     [1.9779984951, -2.4285922050, 0.4505937099],
+#     [0.0259040371, 0.7827717662, -0.8086757660]
+# ]
+# ```
+# But since the matrix is provided in 32 bit, we are not able to get the
+# proper inverse for `[1, 0, 0]` in 64 bit, even if we calculate the a
+# new 64 bit inverse for the above forward transform. What we need is a
+# proper 64 bit forward and reverse transform.
+#
+# In order to adjust for this, we take documented 32 bit inverse matrix which
+# gives us a perfect translation from Oklab `[1, 0, 0]` to LMS of `[1, 1, 1]`
+# and parse the matrix as float 32 and emit it as 64 bit and then take the inverse.
+OKLAB_TO_LMS3 = float32([
+    [1.0, 0.3963377774, 0.2158037573],
+    [1.0, -0.1055613458, -0.0638541728],
+    [1.0, -0.0894841775, -1.2914855480]
+])
+
+# Calculate the inverse
+LMS3_TO_OKLAB = alg.inv(OKLAB_TO_LMS3)
+