abachrome-float 0.1.6

data/lib/abachrome/converters/lrgb_to_oklab.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Abachrome::Converters::LrgbToOklab - Linear RGB to OKLAB color space converter
+#
+# This converter transforms colors from the linear RGB (LRGB) color space to the OKLAB color space
+# using the standard OKLAB transformation matrices. The conversion process applies a series of
+# matrix transformations and non-linear operations to accurately map linear RGB coordinates to
+# the perceptually uniform OKLAB color space.
+#
+# Key features:
+# - Implements the official OKLAB transformation algorithm with high-precision matrices
+# - Converts linear RGB values through intermediate LMS color space representation
+# - Applies cube root 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 linear RGB source data
+#
+# The OKLAB color space provides better perceptual uniformity compared to traditional RGB spaces,
+# making it ideal for color manipulation operations like blending, lightness adjustments, and
+# gamut mapping where human visual perception accuracy is important.
+
+module Abachrome
+  module Converters
+    class LrgbToOklab < Abachrome::Converters::Base
+      # Converts a color from linear RGB (LRGB) color space to OKLAB color space.
+      #
+      # This conversion applies a matrix transformation to the linear RGB values,
+      # followed by a non-linear transformation, then another matrix transformation
+      # to produce OKLAB coordinates.
+      #
+      # @param rgb_color [Abachrome::Color] A color in linear RGB (LRGB) color space
+      # @raise [ArgumentError] If the provided color is not in LRGB color space
+      # @return [Abachrome::Color] The converted color in OKLAB color space with the same alpha value as the input
+      def self.convert(rgb_color)
+        raise_unless rgb_color, :lrgb
+
+        r, g, b = rgb_color.coordinates.map { |_| _.to_f }
+
+        l = (AD("0.41222147079999993") * r) + (AD("0.5363325363") * g) + (AD("0.0514459929") * b)
+        m = (AD("0.2119034981999999") * r) + (AD("0.680699545099999") * g) + (AD("0.1073969566") * b)
+        s = (AD("0.08830246189999998") * r) + (AD("0.2817188376") * g) + (AD("0.6299787005000002") * b)
+
+        l_ = l.to_f**Rational(1, 3)
+        m_ = m.to_f**Rational(1, 3)
+        s_ = s.to_f**Rational(1, 3)
+
+        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], rgb_color.alpha)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/lrgb_to_srgb.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Abachrome::Converters::LrgbToSrgb - Linear RGB to sRGB color space converter
+#
+# This converter transforms colors from the linear RGB (LRGB) color space to the standard RGB (sRGB) color space by applying gamma correction. The conversion process applies the sRGB transfer function which uses different formulas for small and large values to match the non-linear response characteristics of typical display devices.
+#
+# Key features:
+# - Implements the standard sRGB gamma correction algorithm with precise threshold handling
+# - Converts linear RGB values to gamma-corrected sRGB values for proper display representation
+# - Applies different transformation functions based on value magnitude (linear vs power function)
+# - Maintains alpha channel transparency values during conversion
+# - Uses AbcDecimal arithmetic for precise color science calculations
+# - Validates input color space to ensure proper linear RGB source data
+#
+# The sRGB color space is the standard RGB color space for web content and most consumer displays, providing gamma correction that better matches human visual perception and display device characteristics compared to linear RGB values.
+
+module Abachrome
+  module Converters
+    class LrgbToSrgb < Abachrome::Converters::Base
+      # Converts a color from linear RGB to sRGB color space.
+      #
+      # @param lrgb_color [Abachrome::Color] The color in linear RGB color space to convert
+      # @return [Abachrome::Color] A new Color object in sRGB color space with the converted coordinates
+      # @raise [TypeError] If the provided color is not in linear RGB color space
+      def self.convert(lrgb_color)
+        raise_unless lrgb_color, :lrgb
+        r, g, b = lrgb_color.coordinates.map { |c| to_srgb(c.to_f) }
+
+        output_coords = [r, g, b]
+
+        Color.new(
+          ColorSpace.find(:srgb),
+          output_coords,
+          lrgb_color.alpha
+        )
+      end
+
+      # Converts a linear RGB value to standard RGB color space (sRGB) value.
+      #
+      # This method implements the standard linearization function used in the sRGB color space.
+      # For small values (≤ 0.0031308), a simple linear transformation is applied.
+      # For larger values, a power function with gamma correction is used.
+      #
+      # @param v [AbcDecimal] The linear RGB value to convert
+      # @return [AbcDecimal] The corresponding sRGB value, preserving the sign of the input
+      def self.to_srgb(v)
+        v_abs = v.abs
+        v_sign = v.negative? ? -1 : 1
+        if v_abs <= AD("0.0031308")
+          v * AD("12.92")
+        else
+          v_sign * ((AD("1.055") * (v_abs**Rational(1.0, 2.4))) - AD("0.055"))
+        end
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/lrgb_to_xyz.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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 { |_| _.to_f }
+
+        # 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
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/oklab_to_lms.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+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 { |_| _.to_f }
+
+        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 = l_.to_f**3
+        m_lms = m_.to_f**3
+        s_lms = s_.to_f**3
+
+        Color.new(ColorSpace.find(:lms), [l_lms, m_lms, s_lms], oklab_color.alpha)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/oklab_to_lrgb.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# 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 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 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 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 (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
+      # the same alpha as the input color
+      def self.convert(oklab_color)
+        raise_unless oklab_color, :oklab
+
+        l_ok, a_ok, b_ok = oklab_color.coordinates.map { |_| _.to_f }
+
+        # Step 1: OKLAB to L'M'S' (cone responses, non-linear)
+        # These are the M_lms_prime_from_oklab matrix operations.
+        l_prime = l_ok + (AD("0.39633779217376785678".to_f * a_ok) + (AD("0.21580375806075880339") * b_ok))
+        m_prime = l_ok - (a_ok * AD("0.1055613423236563494".to_f) - (b_ok * AD("0.063854174771705903402"))) # NOTE: original OklabToLms had + (b * AD("-0.063..."))
+        s_prime = l_ok - (a_ok * AD("0.089484182094965759684".to_f) - (b_ok * AD("1.2914855378640917399"))) # NOTE: original OklabToLms had + (b * AD("-1.291..."))
+
+        # Step 2: L'M'S' to LMS (cubing)
+        l_lms = l_prime**3
+        m_lms = m_prime**3
+        s_lms = s_prime**3
+
+        # 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 }
+
+        Color.new(ColorSpace.find(:lrgb), output_coords, oklab_color.alpha)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/oklab_to_oklch.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Abachrome::Converters::OklabToOklch - OKLAB to OKLCH color space converter
+#
+# This converter transforms colors from the OKLAB color space to the OKLCH color space
+# using cylindrical coordinate conversion. The transformation converts the rectangular
+# coordinates (L, a, b) to cylindrical coordinates (L, C, h) where lightness remains
+# unchanged, chroma is calculated as the Euclidean distance in the a-b plane, and hue
+# is calculated as the angle in the a-b plane expressed in degrees.
+#
+# Key features:
+# - Converts OKLAB rectangular coordinates to OKLCH cylindrical coordinates
+# - Preserves lightness component unchanged during conversion
+# - Calculates chroma as sqrt(a² + b²) for colorfulness representation
+# - Computes hue angle using atan2 function and normalizes to 0-360 degree range
+# - 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 OKLCH color space provides an intuitive interface for color manipulation through
+# its cylindrical coordinate system, making it ideal for hue adjustments, saturation
+# modifications, and other color operations that benefit from polar coordinates.
+
+module Abachrome
+  module Converters
+    class OklabToOklch < Abachrome::Converters::Base
+      # Converts a color from OKLAB color space to OKLCH color space.
+      # The method performs a mathematical transformation from the rectangular
+      # coordinates (L, a, b) to cylindrical coordinates (L, C, h), where:
+      # - L (lightness) remains the same
+      # - C (chroma) is calculated as the Euclidean distance from the origin in the a-b plane
+      # - h (hue) is calculated as the angle in the a-b plane
+      #
+      # @param oklab_color [Abachrome::Color] A color in the OKLAB color space
+      # @raise [ArgumentError] If the provided color is not in OKLAB color space
+      # @return [Abachrome::Color] The equivalent color in OKLCH color space with the same alpha value
+      def self.convert(oklab_color)
+        raise_unless oklab_color, :oklab
+
+        l, a, b = oklab_color.coordinates.map { |_| _.to_f }
+
+        c = ((a * a) + (b * b)).sqrt
+        h = (AbcDecimal.atan2(b, a) * 180) / Math::PI
+        h += 360 if h.negative?
+
+        Color.new(
+          ColorSpace.find(:oklch),
+          [l, c, h],
+          oklab_color.alpha
+        )
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/oklab_to_srgb.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Abachrome::Converters::OklabToSrgb - OKLAB to sRGB color space converter
+#
+# This converter transforms colors from the OKLAB color space to the standard RGB (sRGB) color space
+# through a two-step conversion process. The transformation first converts OKLAB coordinates to
+# linear RGB as an intermediate step, then applies gamma correction to produce the final sRGB
+# values suitable for display on standard monitors and web applications.
+#
+# Key features:
+# - Two-stage conversion pipeline: OKLAB → Linear RGB → sRGB
+# - Leverages existing OklabToLrgb and LrgbToSrgb converters for modular transformation
+# - Maintains alpha channel transparency values during conversion
+# - Applies proper gamma correction for display-ready color values
+# - Uses AbcDecimal arithmetic for precise color science calculations
+# - Validates input color space to ensure proper OKLAB source data
+#
+# The sRGB color space is the standard RGB color space for web content and most consumer
+# displays, providing gamma-corrected values that properly represent colors on typical
+# display devices while maintaining compatibility with web standards and digital media formats.
+
+module Abachrome
+  module Converters
+    class OklabToSrgb < Abachrome::Converters::Base
+      # Converts a color from the Oklab color space to the sRGB color space.
+      # This conversion is performed in two steps:
+      # 1. First converts from Oklab to linear RGB
+      # 2. Then converts from linear RGB to sRGB
+      #
+      # @param oklab_color [Color] A color in the Oklab color space
+      # @raise [ArgumentError] If the provided color is not in the Oklab color space
+      # @return [Color] The converted color in the sRGB color space
+      def self.convert(oklab_color)
+        raise_unless oklab_color, :oklab
+
+        # First convert Oklab to linear RGB
+        lrgb_color = OklabToLrgb.convert(oklab_color)
+
+        # Then use the LrgbToSrgb converter to go from linear RGB to sRGB
+        LrgbToSrgb.convert(lrgb_color)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/oklch_to_lrgb.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# 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.
+# 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:
+# - 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
+      def self.convert(oklch_color)
+        raise_unless oklch_color, :oklch
+
+        l_oklch, c_oklch, h_oklch = oklch_color.coordinates.map { |_| _.to_f }
+        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
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/oklch_to_oklab.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Abachrome::Converters::OklchToOklab - OKLCH to OKLAB color space converter
+#
+# This converter transforms colors from the OKLCH color space to the OKLAB color space
+# using cylindrical to rectangular coordinate conversion. The transformation converts the
+# cylindrical coordinates (L, C, h) to rectangular coordinates (L, a, b) where lightness
+# remains unchanged, and the a and b components are calculated from chroma and hue using
+# trigonometric functions (cosine and sine respectively).
+#
+# Key features:
+# - Converts OKLCH cylindrical coordinates to OKLAB rectangular coordinates
+# - Preserves lightness component unchanged during conversion
+# - Calculates a component as chroma × cos(hue) for green-red axis positioning
+# - Calculates b component as chroma × sin(hue) for blue-yellow axis positioning
+# - Converts hue angle from degrees to radians for trigonometric calculations
+# - 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 OKLAB color space provides the foundation for further conversions to other color
+# spaces and serves as an intermediate step in the color transformation pipeline when
+# working with OKLCH color manipulations that need to be converted to display-ready formats.
+
+module Abachrome
+  module Converters
+    class OklchToOklab < Abachrome::Converters::Base
+      # Converts a color from OKLCH color space to OKLAB color space.
+      #
+      # @param oklch_color [Abachrome::Color] The color in OKLCH format to convert
+      # @return [Abachrome::Color] The converted color in OKLAB format
+      # @raise [StandardError] If the provided color is not in OKLCH color space
+      def self.convert(oklch_color)
+        raise_unless oklch_color, :oklch
+
+        l, c, h = oklch_color.coordinates.map { |_| _.to_f }
+
+        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),
+          [l, a, b],
+          oklch_color.alpha
+        )
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/oklch_to_srgb.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Abachrome::Converters::OklchToSrgb - OKLCH to sRGB color space converter
+#
+# This converter transforms colors from the OKLCH color space to the standard RGB (sRGB) 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 sRGB
+# transformation pipeline to produce the final gamma-corrected sRGB values.
+#
+# Key features:
+# - Two-stage conversion pipeline: OKLCH → OKLAB → sRGB
+# - Leverages existing OklchToOklab and OklabToSrgb converters for modular transformation
+# - Converts cylindrical coordinates (lightness, chroma, hue) to display-ready RGB values
+# - Maintains alpha channel transparency values during conversion
+# - Applies proper gamma correction for display on standard monitors and web applications
+# - Uses AbcDecimal arithmetic for precise color science calculations
+# - Validates input color space to ensure proper OKLCH source data
+#
+# The sRGB color space is the standard RGB color space for web content and most consumer
+# displays, providing gamma-corrected values that properly represent colors on typical
+# display devices while maintaining compatibility with web standards and digital media formats.
+
+require_relative "oklch_to_oklab"
+require_relative "oklab_to_srgb"
+
+module Abachrome
+  module Converters
+    class OklchToSrgb < Abachrome::Converters::Base
+      # Converts a color from OKLCH color space to sRGB color space.
+      # This is done by first converting from OKLCH to OKLAB,
+      # then from OKLAB to sRGB.
+      #
+      # @param oklch_color [Abachrome::Color] Color in OKLCH color space
+      # @return [Abachrome::Color] The converted color in sRGB color space
+      def self.convert(oklch_color)
+        # Convert OKLCh to OKLab first
+        oklab_color = OklchToOklab.convert(oklch_color)
+
+        # Then convert OKLab to sRGB
+        OklabToSrgb.convert(oklab_color)
+      end
+    end
+  end
+end
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.

data/lib/abachrome/converters/oklch_to_xyz.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+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| coord.to_f }
+        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 .to_f 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
+
+# Copyright (c) 2025 Durable Programming, LLC. All rights reserved.