abachrome 0.1.1 → 0.1.3

data/lib/abachrome/color_space.rb

@@ -168,4 +168,16 @@ module Abachrome
     s.white_point = :D65
     s.color_model = :oklch
   end
+
+  ColorSpace.register(:xyz) do |s|
+    s.coordinates = %i[x y z]
+    s.white_point = :D65
+    s.color_model = :xyz
+  end
+
+  ColorSpace.register(:lms) do |s|
+    s.coordinates = %i[l m s]
+    s.white_point = :D65
+    s.color_model = :lms
+  end
 end

data/lib/abachrome/converter.rb

@@ -110,4 +110,4 @@ module Abachrome
 
   # Auto-register all converters
   Converter.register_all_converters
-end
+end

data/lib/abachrome/converters/lms_to_lrgb.rb

@@ -0,0 +1,36 @@
+module Abachrome
+  module Converters
+    class LmsToLrgb < Abachrome::Converters::Base
+      # Converts a color from LMS color space to linear RGB color space.
+      # 
+      # This method implements the final part of the OKLAB to linear RGB transformation,
+      # converting LMS (Long, Medium, Short) coordinates to linear RGB coordinates
+      # using the standard transformation matrix. The LMS color space represents
+      # the response of the three types of cone cells in the human eye.
+      # 
+      # @param lms_color [Abachrome::Color] The color in LMS color space
+      # @raise [ArgumentError] If the input color is not in LMS color space
+      # @return [Abachrome::Color] The resulting color in linear RGB color space with
+      # the same alpha as the input color
+      def self.convert(lms_color)
+        raise_unless lms_color, :lms
+
+        l, m, s = lms_color.coordinates.map { |_| AbcDecimal(_) }
+
+        r = (l * AD("4.07674166134799")) +
+            (m * AD("-3.307711590408193")) +
+            (s * AD("0.230969928729428"))
+        g = (l * AD("-1.2684380040921763")) +
+            (m * AD("2.6097574006633715")) +
+            (s * AD("-0.3413193963102197"))
+        b = (l * AD("-0.004196086541837188")) +
+            (m * AD("-0.7034186144594493")) +
+            (s * AD("1.7076147009309444"))
+
+        output_coords = [r, g, b].map { |it| [it, 0].max }
+
+        Color.new(ColorSpace.find(:lrgb), output_coords, lms_color.alpha)
+      end
+    end
+  end
+end

data/lib/abachrome/converters/lms_to_srgb.rb

@@ -0,0 +1,23 @@
+module Abachrome
+  module Converters
+    class LmsToSrgb < Abachrome::Converters::Base
+      # Converts a color from LMS color space to sRGB color space.
+      # 
+      # This method implements a two-step conversion process:
+      # 1. First converts from LMS to linear RGB using the standard transformation matrix
+      # 2. Then converts from linear RGB to sRGB by applying gamma correction
+      # 
+      # @param lms_color [Abachrome::Color] The color in LMS color space
+      # @raise [ArgumentError] If the input color is not in LMS color space
+      # @return [Abachrome::Color] The resulting color in sRGB color space with
+      # the same alpha as the input color
+      def self.convert(lms_color)
+        # First convert LMS to linear RGB
+        lrgb_color = LmsToLrgb.convert(lms_color)
+        
+        # Then convert linear RGB to sRGB
+        LrgbToSrgb.convert(lrgb_color)
+      end
+    end
+  end
+end

data/lib/abachrome/converters/lms_to_xyz.rb

@@ -0,0 +1,30 @@
+module Abachrome
+  module Converters
+    class LmsToXyz < Abachrome::Converters::Base
+      # Converts a color from LMS color space to XYZ color space.
+      # 
+      # This method implements the LMS to XYZ transformation using the standard
+      # transformation matrix. The LMS color space represents the response of
+      # the three types of cone cells in the human eye (Long, Medium, Short),
+      # while XYZ is the CIE 1931 color space that forms the basis for most
+      # other color space definitions.
+      # 
+      # @param lms_color [Abachrome::Color] The color in LMS color space
+      # @raise [ArgumentError] If the input color is not in LMS color space
+      # @return [Abachrome::Color] The resulting color in XYZ color space with
+      # the same alpha as the input color
+      def self.convert(lms_color)
+        raise_unless lms_color, :lms
+
+        l, m, s = lms_color.coordinates.map { |_| AbcDecimal(_) }
+
+        # LMS to XYZ transformation matrix
+        x = (l * AD("1.86006661")) - (m * AD("1.12948190")) + (s * AD("0.21989740"))
+        y = (l * AD("0.36122292")) + (m * AD("0.63881308")) - (s * AD("0.00000000"))
+        z = (l * AD("0.00000000")) - (m * AD("0.00000000")) + (s * AD("1.08906362"))
+
+        Color.new(ColorSpace.find(:xyz), [x, y, z], lms_color.alpha)
+      end
+    end
+  end
+end

data/lib/abachrome/converters/lrgb_to_xyz.rb

@@ -0,0 +1,29 @@
+module Abachrome
+  module Converters
+    class LrgbToXyz < Abachrome::Converters::Base
+      # Converts a color from linear RGB color space to XYZ color space.
+      # 
+      # This method implements the linear RGB to XYZ transformation using the standard
+      # transformation matrix for the sRGB color space with D65 white point. The XYZ
+      # color space is the CIE 1931 color space that forms the basis for most other
+      # color space definitions and serves as a device-independent reference.
+      # 
+      # @param lrgb_color [Abachrome::Color] The color in linear RGB color space
+      # @raise [ArgumentError] If the input color is not in linear RGB color space
+      # @return [Abachrome::Color] The resulting color in XYZ color space with
+      # the same alpha as the input color
+      def self.convert(lrgb_color)
+        raise_unless lrgb_color, :lrgb
+
+        r, g, b = lrgb_color.coordinates.map { |_| AbcDecimal(_) }
+
+        # Linear RGB to XYZ transformation matrix (sRGB/D65)
+        x = (r * AD("0.4124564")) + (g * AD("0.3575761")) + (b * AD("0.1804375"))
+        y = (r * AD("0.2126729")) + (g * AD("0.7151522")) + (b * AD("0.0721750"))
+        z = (r * AD("0.0193339")) + (g * AD("0.1191920")) + (b * AD("0.9503041"))
+
+        Color.new(ColorSpace.find(:xyz), [x, y, z], lrgb_color.alpha)
+      end
+    end
+  end
+end

data/lib/abachrome/converters/oklab_to_lms.rb

@@ -0,0 +1,41 @@
+module Abachrome
+  module Converters
+    class OklabToLms < Abachrome::Converters::Base
+      # Converts a color from OKLAB color space to LMS color space.
+      # 
+      # This method implements the first part of the OKLAB to linear RGB transformation,
+      # converting OKLAB coordinates to the intermediate LMS (Long, Medium, Short) color space
+      # which represents the response of the three types of cone cells in the human eye.
+      # 
+      # @param oklab_color [Abachrome::Color] The color in OKLAB color space
+      # @raise [ArgumentError] If the input color is not in OKLAB color space
+      # @return [Abachrome::Color] The resulting color in LMS color space with
+      # the same alpha as the input color
+      def self.convert(oklab_color)
+        raise_unless oklab_color, :oklab
+
+        l, a, b = oklab_color.coordinates.map { |_| AbcDecimal(_) }
+
+        l_ = AbcDecimal((l ) +
+                        (AD("0.39633779217376785678") * a) +
+                        (AD("0.21580375806075880339") * b))
+
+        m_ = AbcDecimal((l) -
+                        (a * AD("-0.1055613423236563494")) +
+                        (b * AD("-0.063854174771705903402")))
+        
+        s_ = AbcDecimal((l) -
+                        (a * AD("-0.089484182094965759684")) +
+                        (b * AD("-1.2914855378640917399")))
+
+        # Apply cubic operation to convert from L'M'S' to LMS
+        l_lms = AbcDecimal(l_)**3
+        m_lms = AbcDecimal(m_)**3
+        s_lms = AbcDecimal(s_)**3
+
+        Color.new(ColorSpace.find(:lms), [l_lms, m_lms, s_lms], oklab_color.alpha)
+      end
+    end
+  end
+end
+

data/lib/abachrome/converters/oklab_to_lrgb.rb

@@ -1,36 +1,32 @@
 # Abachrome::Converters::OklabToLrgb - OKLAB to Linear RGB color space converter
 #
 # This converter transforms colors from the OKLAB color space to the linear RGB (LRGB) color space
-# using the standard OKLAB inverse transformation matrices. The conversion process applies a series of
-# matrix transformations and cubic operations to accurately map OKLAB coordinates back to the
-# linear RGB color space, which represents colors with a linear relationship to light intensity.
+# using the standard OKLAB transformation matrices. The conversion process first transforms
+# OKLAB coordinates to the intermediate LMS (Long, Medium, Short) color space, then applies
+# another matrix transformation to convert LMS coordinates to linear RGB coordinates.
 #
 # Key features:
-# - Implements the official OKLAB to linear RGB inverse transformation algorithm with high-precision matrices
-# - Converts OKLAB values through intermediate L'M'S' and LMS color space representations
-# - Applies cubic operations to reverse the perceptual uniformity transformations
-# - Clamps negative RGB values to zero to ensure valid linear RGB output
+# - Implements the official OKLAB inverse transformation algorithm with high-precision matrices
+# - Converts OKLAB coordinates through intermediate LMS color space representation
+# - Applies cubic transformation for perceptual uniformity in the OKLAB space
 # - Maintains alpha channel transparency values during conversion
 # - Uses AbcDecimal arithmetic for precise color science calculations
 # - Validates input color space to ensure proper OKLAB source data
 #
-# The linear RGB color space provides the foundation for further conversions to display-ready
-# color spaces like sRGB, making this converter essential for the color transformation pipeline
-# when working with perceptually uniform OKLAB color manipulations.
+# The linear RGB color space provides a linear relationship between stored numeric values and
+# actual light intensity, making it essential for accurate color calculations and serving as
+# an intermediate color space for many color transformations, particularly when converting
+# between different color models or preparing colors for display on standard monitors.
 
 module Abachrome
   module Converters
     class OklabToLrgb < Abachrome::Converters::Base
-      # Converts a color from OKLAB color space to linear RGB color space.
-      # 
-      # The method implements the OKLAB to linear RGB transformation matrix based on
-      # standard color science algorithms. It first confirms the input is in OKLAB
-      # space, then applies the transformation through several steps:
-      # 1. Converts OKLAB coordinates to intermediate L'M'S' values
-      # 2. Applies a cubic operation to get LMS values
-      # 3. Transforms LMS to linear RGB
-      # 4. Clamps negative values to zero
-      # 
+      # Converts a color from OKLAB color space to linear RGB (LRGB) color space.
+      #
+      # This method performs a two-step conversion:
+      # 1. OKLAB to LMS (cone response space)
+      # 2. LMS to LRGB (linear RGB)
+      #
       # @param oklab_color [Abachrome::Color] The color in OKLAB color space
       # @raise [ArgumentError] If the input color is not in OKLAB color space
       # @return [Abachrome::Color] The resulting color in linear RGB color space with
@@ -38,37 +34,36 @@ module Abachrome
       def self.convert(oklab_color)
         raise_unless oklab_color, :oklab
 
-        l, a, b = oklab_color.coordinates.map { |_| AbcDecimal(_) }
+        l_ok, a_ok, b_ok = oklab_color.coordinates.map { |_| AbcDecimal(_) }
 
-        l_ = AbcDecimal((l * AD("0.99999999845051981432")) +
-                        (AD("0.39633779217376785678") * a) +
-                        (AD("0.21580375806075880339") * b))
+        # Step 1: OKLAB to L'M'S' (cone responses, non-linear)
+        # These are the M_lms_prime_from_oklab matrix operations.
+        l_prime = AbcDecimal(l_ok + (AD("0.39633779217376785678") * a_ok) + (AD("0.21580375806075880339") * b_ok))
+        m_prime = AbcDecimal(l_ok - (a_ok * AD("0.1055613423236563494")) - (b_ok * AD("0.063854174771705903402"))) # Note: original OklabToLms had + (b * AD("-0.063..."))
+        s_prime = AbcDecimal(l_ok - (a_ok * AD("0.089484182094965759684")) - (b_ok * AD("1.2914855378640917399"))) # Note: original OklabToLms had + (b * AD("-1.291..."))
 
-        m_ = AbcDecimal((l * AD("1.0000000088817607767")) -
-                        (a * AD("0.1055613423236563494")) -
-                        (b * AD("0.063854174771705903402")))
-        s_ = AbcDecimal((l * AD("1.000000054672410917")) -
-                        (a * AD("0.089484182094965759684")) -
-                        (b * AD("1.2914855378640917399")))
 
-        l = AbcDecimal(l_)**3
-        m = AbcDecimal(m_)**3
-        s = AbcDecimal(s_)**3
+        # Step 2: L'M'S' to LMS (cubing)
+        l_lms = l_prime**3
+        m_lms = m_prime**3
+        s_lms = s_prime**3
 
-        r =  (l * AD("4.07674166134799")) -
-             (m * AD("3.307711590408193")) +
-             (s * AD("0.230969928729428"))
-        g =  (l * AD("-1.2684380040921763")) +
-             (m * AD("2.6097574006633715")) -
-             (s * AD("0.3413193963102197"))
-        b =  (l * AD("-0.004196086541837188")) -
-             (m * AD("0.7034186144594493")) +
-             (s * AD("1.7076147009309444"))
+        # Step 3: LMS to LRGB
+        # Using matrix M_lrgb_from_lms (OKLAB specific)
+        r_lrgb = (l_lms * AD("4.07674166134799"))   + (m_lms * AD("-3.307711590408193")) + (s_lms * AD("0.230969928729428"))
+        g_lrgb = (l_lms * AD("-1.2684380040921763")) + (m_lms * AD("2.6097574006633715")) + (s_lms * AD("-0.3413193963102197"))
+        b_lrgb = (l_lms * AD("-0.004196086541837188"))+ (m_lms * AD("-0.7034186144594493")) + (s_lms * AD("1.7076147009309444"))
+
+        # Clamp LRGB values to be non-negative (as done in LmsToLrgb.rb)
+        # It's also common to clamp to [0, 1] range after conversion from a wider gamut space
+        # For LRGB, often just ensuring non-negative is done, and further clamping happens
+        # when converting to sRGB or other display spaces.
+        # Here, we'll ensure non-negative as per LmsToLrgb.
+        output_coords = [r_lrgb, g_lrgb, b_lrgb].map { |it| [it, AD(0)].max }
 
-        output_coords = [r, g, b].map { |it| [it, 0].max }
 
         Color.new(ColorSpace.find(:lrgb), output_coords, oklab_color.alpha)
       end
     end
   end
-end
+end

data/lib/abachrome/converters/oklch_to_lrgb.rb

@@ -1,38 +1,75 @@
 # Abachrome::Converters::OklchToLrgb - OKLCH to Linear RGB color space converter
 #
-# This converter transforms colors from the OKLCH color space to the linear RGB (LRGB) color space
-# through a two-step conversion process. The transformation first converts OKLCH cylindrical
-# coordinates to OKLAB rectangular coordinates, then applies the standard OKLAB to linear RGB
-# transformation matrices to produce the final linear RGB values.
+# This converter transforms colors from the OKLCH color space to the linear RGB (LRGB) color space.
+# The conversion is performed by first transforming OKLCH's cylindrical coordinates (Lightness, Chroma, Hue)
+# into OKLAB's rectangular coordinates (L, a, b).
+# Then, these OKLAB coordinates are converted to LRGB. This second part involves transforming
+# OKLAB to an intermediate non-linear cone response space (L'M'S'), then to a linear
+# cone response space (LMS), and finally from LMS to LRGB using appropriate matrices.
+# All these steps are combined into a single direct conversion method.
 #
 # Key features:
-# - Two-stage conversion pipeline: OKLCH → OKLAB → Linear RGB
-# - Leverages existing OklchToOklab and OklabToLrgb converters for modular transformation
-# - Converts cylindrical coordinates (lightness, chroma, hue) to linear light intensity values
-# - Maintains alpha channel transparency values during conversion
-# - Uses AbcDecimal arithmetic for precise color science calculations
-# - Validates input color space to ensure proper OKLCH source data
-#
-# The linear RGB color space provides the foundation for further conversions to display-ready
-# color spaces like sRGB, making this converter essential for the color transformation pipeline
-# when working with OKLCH color manipulations that need to be rendered on standard displays.
-
-require_relative "oklab_to_lrgb"
-require_relative "oklch_to_oklab"
+# - Direct conversion from OKLCH to LRGB.
+# - Combines cylindrical to rectangular conversion (OKLCH to OKLAB)
+#   with the OKLAB to LRGB transformation pipeline (OKLAB -> L'M'S' -> LMS -> LRGB).
+# - Uses AbcDecimal arithmetic for precise color science calculations.
+# - Maintains alpha channel transparency values during conversion.
+# - Validates input color space to ensure proper OKLCH source data.
 
 module Abachrome
   module Converters
     class OklchToLrgb < Abachrome::Converters::Base
-      # Converts a color from OKLCH color space to linear RGB color space.
-      # This is a two-step conversion process that first converts from OKLCH to OKLAB,
-      # then from OKLAB to linear RGB.
-      # 
-      # @param oklch_color [Abachrome::Color] A color in the OKLCH color space
-      # @return [Abachrome::Color] The resulting color in linear RGB color space
       def self.convert(oklch_color)
-        oklab_color = OklchToOklab.convert(oklch_color)
-        OklabToLrgb.convert(oklab_color)
+        raise_unless oklch_color, :oklch
+
+        l_oklch, c_oklch, h_oklch = oklch_color.coordinates.map { |_| AbcDecimal(_) }
+        alpha = oklch_color.alpha
+
+        # Step 1: OKLCH to OKLAB
+        # l_oklab is the same as l_oklch
+        l_oklab = l_oklch
+
+        # Convert hue from degrees to radians
+        # h_oklch is AbcDecimal, Math::PI is Float. AD(Math::PI) makes it AbcDecimal.
+        # Division by AD("180") ensures AbcDecimal arithmetic.
+        h_rad = (h_oklch * AD(Math::PI)) / AD("180")
+
+        # Calculate a_oklab and b_oklab
+        # Math.cos/sin take a float; .value of AbcDecimal is BigDecimal.
+        # AD(Math.cos/sin(big_decimal_value)) wraps the result back to AbcDecimal.
+        a_oklab = c_oklch * AD(Math.cos(h_rad.value))
+        b_oklab = c_oklch * AD(Math.sin(h_rad.value))
+
+        # Step 2: OKLAB to L'M'S' (cone responses, non-linear)
+        # Constants from the inverse of M2 matrix (OKLAB to L'M'S')
+        # l_oklab, a_oklab, b_oklab are already AbcDecimal.
+        l_prime = l_oklab + (AD("0.39633779217376785678") * a_oklab) + (AD("0.21580375806075880339") * b_oklab)
+        m_prime = l_oklab - (AD("0.1055613423236563494") * a_oklab) - (AD("0.063854174771705903402") * b_oklab)
+        s_prime = l_oklab - (AD("0.089484182094965759684") * a_oklab) - (AD("1.2914855378640917399") * b_oklab)
+
+        # Step 3: L'M'S' to LMS (cubing to linearize cone responses)
+        l_lms = l_prime**3
+        m_lms = m_prime**3
+        s_lms = s_prime**3
+
+        # Step 4: LMS to LRGB
+        # Using matrix M_lrgb_from_lms (OKLAB specific)
+        r_lrgb = (l_lms * AD("4.07674166134799"))   + (m_lms * AD("-3.307711590408193")) + (s_lms * AD("0.230969928729428"))
+        g_lrgb = (l_lms * AD("-1.2684380040921763")) + (m_lms * AD("2.6097574006633715")) + (s_lms * AD("-0.3413193963102197"))
+        b_lrgb = (l_lms * AD("-0.004196086541837188"))+ (m_lms * AD("-0.7034186144594493")) + (s_lms * AD("1.7076147009309444"))
+
+        # Clamp LRGB values to be non-negative.
+        # LRGB values can be outside [0,1] but should be >= 0.
+        # Further clamping to [0,1] typically occurs when converting to display-referred spaces like sRGB.
+        zero_ad = AD("0")
+        output_coords = [
+          [r_lrgb, zero_ad].max,
+          [g_lrgb, zero_ad].max,
+          [b_lrgb, zero_ad].max
+        ]
+
+        Color.new(ColorSpace.find(:lrgb), output_coords, alpha)
       end
     end
   end
-end
+end

data/lib/abachrome/converters/oklch_to_oklab.rb

@@ -33,9 +33,9 @@ module Abachrome
 
         l, c, h = oklch_color.coordinates.map { |_| AbcDecimal(_) }
 
-        h_rad = h * Rational(Math::PI, 180)
-        a = c * Math.cos(h_rad.value)
-        b = c * Math.sin(h_rad.value)
+        h_rad = (h * Math::PI)/ AD(180)
+        a = c * AD(Math.cos(h_rad.value))
+        b = c * AD(Math.sin(h_rad.value))
 
         Color.new(
           ColorSpace.find(:oklab),
@@ -45,4 +45,4 @@ module Abachrome
       end
     end
   end
-end
+end

data/lib/abachrome/converters/oklch_to_xyz.rb

@@ -0,0 +1,66 @@
+module Abachrome
+  module Converters
+    class OklchToXyz < Abachrome::Converters::Base
+      def self.convert(oklch_color)
+        raise_unless oklch_color, :oklch
+
+        l_oklch, c_oklch, h_oklch = oklch_color.coordinates.map { |coord| AbcDecimal(coord) }
+        alpha = oklch_color.alpha
+
+        # Step 1: OKLCH to OKLAB
+        # (l_oklab, a_oklab, b_oklab)
+        l_oklab = l_oklch
+        # h_rad = (h_oklch * Math::PI) / AD(180) # h_oklch is AbcDecimal, Math::PI is Float. Coercion happens.
+        # More explicit for Math::PI:
+        h_rad = (h_oklch * AD(Math::PI.to_s)) / AD(180)
+
+        # Standard Math.cos/sin expect float. h_rad is AbcDecimal.
+        # .to_f is needed for conversion from AbcDecimal/BigDecimal to Float.
+        cos_h_rad = AD(Math.cos(h_rad.to_f))
+        sin_h_rad = AD(Math.sin(h_rad.to_f))
+
+        a_oklab = c_oklch * cos_h_rad
+        b_oklab = c_oklch * sin_h_rad
+
+        # Step 2: OKLAB to L'M'S' (cone responses, non-linear)
+        # (l_prime, m_prime, s_prime)
+        # These are the M_lms_prime_from_oklab matrix operations.
+        # The AbcDecimal() wrapper on the whole sum (as in OklabToLms.rb) is not strictly necessary
+        # if l_oklab, a_oklab, b_oklab are already AbcDecimal, as AbcDecimal ops return AbcDecimal.
+        l_prime = l_oklab + (AD("0.39633779217376785678") * a_oklab) + (AD("0.21580375806075880339") * b_oklab)
+        m_prime = l_oklab - (a_oklab * AD("-0.1055613423236563494")) + (b_oklab * AD("-0.063854174771705903402"))
+        s_prime = l_oklab - (a_oklab * AD("-0.089484182094965759684")) + (b_oklab * AD("-1.2914855378640917399"))
+
+        # Step 3: L'M'S' to LMS (cubing)
+        # (l_lms, m_lms, s_lms)
+        l_lms = l_prime**3
+        m_lms = m_prime**3
+        s_lms = s_prime**3
+
+        # Step 4: LMS to LRGB
+        # (r_lrgb, g_lrgb, b_lrgb)
+        # Using matrix M_lrgb_from_lms (OKLAB specific)
+        r_lrgb = (l_lms * AD("4.07674166134799"))   + (m_lms * AD("-3.307711590408193")) + (s_lms * AD("0.230969928729428"))
+        g_lrgb = (l_lms * AD("-1.2684380040921763")) + (m_lms * AD("2.6097574006633715")) + (s_lms * AD("-0.3413193963102197"))
+        b_lrgb = (l_lms * AD("-0.004196086541837188"))+ (m_lms * AD("-0.7034186144594493")) + (s_lms * AD("1.7076147009309444"))
+
+        # Clamp LRGB values to be non-negative (as done in LmsToLrgb.rb)
+        # Using the pattern [AbcDecimal, Integer].max which relies on AbcDecimal's <=> coercion.
+        # AD(0) is AbcDecimal zero.
+        zero_ad = AD(0)
+        r_lrgb_clamped = [r_lrgb, zero_ad].max
+        g_lrgb_clamped = [g_lrgb, zero_ad].max
+        b_lrgb_clamped = [b_lrgb, zero_ad].max
+        
+        # Step 5: LRGB to XYZ
+        # (x_xyz, y_xyz, z_xyz)
+        # Using matrix M_xyz_from_lrgb (sRGB D65)
+        x_xyz = (r_lrgb_clamped * AD("0.4124564")) + (g_lrgb_clamped * AD("0.3575761")) + (b_lrgb_clamped * AD("0.1804375"))
+        y_xyz = (r_lrgb_clamped * AD("0.2126729")) + (g_lrgb_clamped * AD("0.7151522")) + (b_lrgb_clamped * AD("0.0721750"))
+        z_xyz = (r_lrgb_clamped * AD("0.0193339")) + (g_lrgb_clamped * AD("0.1191920")) + (b_lrgb_clamped * AD("0.9503041"))
+
+        Color.new(ColorSpace.find(:xyz), [x_xyz, y_xyz, z_xyz], alpha)
+      end
+    end
+  end
+end

data/lib/abachrome/converters/xyz_to_lms.rb

@@ -0,0 +1,30 @@
+module Abachrome
+  module Converters
+    class XyzToLms < Abachrome::Converters::Base
+      # Converts a color from XYZ color space to LMS color space.
+      # 
+      # This method implements the XYZ to LMS transformation using the standard
+      # transformation matrix. The LMS color space represents the response of
+      # the three types of cone cells in the human eye (Long, Medium, Short),
+      # while XYZ is the CIE 1931 color space that forms the basis for most
+      # other color space definitions.
+      # 
+      # @param xyz_color [Abachrome::Color] The color in XYZ color space
+      # @raise [ArgumentError] If the input color is not in XYZ color space
+      # @return [Abachrome::Color] The resulting color in LMS color space with
+      # the same alpha as the input color
+      def self.convert(xyz_color)
+        raise_unless xyz_color, :xyz
+
+        x, y, z = xyz_color.coordinates.map { |_| AbcDecimal(_) }
+
+        # XYZ to LMS transformation matrix
+        l = (x * AD("0.8189330101")) + (y * AD("0.3618667424")) - (z * AD("0.1288597137"))
+        m = (x * AD("0.0329845436")) + (y * AD("0.9293118715")) + (z * AD("0.0361456387"))
+        s = (x * AD("0.0482003018")) + (y * AD("0.2643662691")) + (z * AD("0.6338517070"))
+
+        Color.new(ColorSpace.find(:lms), [l, m, s], xyz_color.alpha)
+      end
+    end
+  end
+end

data/lib/abachrome/converters/xyz_to_oklab.rb

@@ -0,0 +1,38 @@
+module Abachrome
+  module Converters
+    class XyzToOklab < Abachrome::Converters::Base
+      # Converts a color from XYZ color space to OKLAB color space.
+      # 
+      # This method implements the XYZ to OKLAB transformation by first
+      # converting XYZ coordinates to the intermediate LMS (Long, Medium, Short)
+      # color space, then applying the LMS to OKLAB transformation matrix.
+      # 
+      # @param xyz_color [Abachrome::Color] The color in XYZ color space
+      # @raise [ArgumentError] If the input color is not in XYZ color space
+      # @return [Abachrome::Color] The resulting color in OKLAB color space with
+      # the same alpha as the input color
+      def self.convert(xyz_color)
+        raise_unless xyz_color, :xyz
+
+        x, y, z = xyz_color.coordinates.map { |_| AbcDecimal(_) }
+
+        # XYZ to LMS transformation matrix
+        l = (x * AD("0.8189330101")) + (y * AD("0.3618667424")) - (z * AD("0.1288597137"))
+        m = (x * AD("0.0329845436")) + (y * AD("0.9293118715")) + (z * AD("0.0361456387"))
+        s = (x * AD("0.0482003018")) + (y * AD("0.2643662691")) + (z * AD("0.6338517070"))
+
+        # Apply cube root transformation
+        l_ = AbcDecimal(l)**Rational(1, 3)
+        m_ = AbcDecimal(m)**Rational(1, 3)
+        s_ = AbcDecimal(s)**Rational(1, 3)
+
+        # LMS to OKLAB transformation matrix
+        lightness = (AD("0.2104542553") * l_) + (AD("0.793617785") * m_) - (AD("0.0040720468") * s_)
+        a         = (AD("1.9779984951") * l_) - (AD("2.4285922050") * m_) + (AD("0.4505937099") * s_)
+        b         = (AD("0.0259040371") * l_) + (AD("0.7827717662") * m_) - (AD("0.8086757660") * s_)
+
+        Color.new(ColorSpace.find(:oklab), [lightness, a, b], xyz_color.alpha)
+      end
+    end
+  end
+end