color_converters 0.1.2 → 0.1.4

data/lib/color_converters/converters/xyz_converter.rb

@@ -1,127 +1,110 @@
-module ColorConverters
-  class XyzConverter < BaseConverter
-    def self.matches?(color_input)
-      return false unless color_input.is_a?(Hash)
-
-      color_input.keys - [:x, :y, :z] == []
-    end
-
-    def self.bounds
-      { x: [0.0, 95.047], y: [0.0, 100.0], z: [0.0, 108.883] }
-    end
-
-    private
-
-    def validate_input(color_input)
-      bounds = XyzConverter.bounds
-      color_input[:x].to_f.between?(*bounds[:x]) && color_input[:y].to_f.between?(*bounds[:y]) && color_input[:z].to_f.between?(*bounds[:z])
-    end
-
-    def input_to_rgba(color_input)
-      r, g, b = xyz_to_rgb(color_input)
-
-      { r: r.round(IMPORT_DP), g: g.round(IMPORT_DP), b: b.round(IMPORT_DP), a: 1.0 }
-    end
-
-    def xyz_to_rgb(xyz_hash)
-      # Convert XYZ (typically with Y=100 for white) to normalized XYZ (Y=1 for white).
-      # The transformation matrix expects X, Y, Z values in the 0-1 range.
-      x = xyz_hash[:x].to_f / 100.0
-      y = xyz_hash[:y].to_f / 100.0
-      z = xyz_hash[:z].to_f / 100.0
-
-      # Convert normalized XYZ to Linear sRGB values.
-      # This uses the inverse sRGB matrix for D65 illuminant.
-      # The resulting rr, gg, bb values are linear (gamma-uncorrected) and in the 0-1 range.
-      rr = (x * 3.2404542) + (y * -1.5371385) + (z * -0.4985314)
-      gg = (x * -0.9692660) + (y * 1.8760108) + (z * 0.0415560)
-      bb = (x * 0.0556434) + (y * -0.2040259) + (z * 1.0572252)
-
-      # Apply sRGB Companding (gamma correction) to convert from Linear RGB to non-linear sRGB.
-      # This is defined by the sRGB specification (IEC 61966-2-1).
-      # The exponent for the non-linear segment is 1/2.4 (approximately 0.41666...).
-      r, g, b = [rr, gg, bb].map do
-        if _1 <= 0.0031308
-          # Linear portion of the sRGB curve
-          _1 * 12.92
-        else
-          # Non-linear (gamma-corrected) portion of the sRGB curve
-          # The sRGB specification uses an exponent of 1/2.4.
-          #
-          (1.055 * (_1**(1.0 / 2.4))) - 0.055
-
-          # IMPORTANT NUMERICAL NOTE:
-          # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
-          # the inverse power function for val**2.4 yields a result that deviates from the value expected by widely-used color science libraries (like Bruce Lindbloom's).
-          #
-          # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
-          # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
-          #
-          # Choose 1/2.4 for strict adherence to the standard's definition (knowing your results may slightly deviate from common calculators),
-          # or choose 1/2.5 to ensure your calculated linear RGB values (and thus CIELAB) match authoritative external tools on this system.
-          #
-          # (1.055 * (_1**(1.0 / 2.5))) - 0.055
-        end
-      end
-
-      # Scale the 0-1 sRGB value to the 0-255 range for 8-bit color components.
-      r *= 255.0
-      g *= 255.0
-      b *= 255.0
-
-      # Clamping RGB values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
-      r = r.clamp(0.0..255.0)
-      g = g.clamp(0.0..255.0)
-      b = b.clamp(0.0..255.0)
-
-      [r, g, b]
-    end
-
-    # http://www.brucelindbloom.com/index.html?Eqn_RGB_to_XYZ.html
-    def self.rgb_to_xyz(rgb_array_frac)
-      r, g, b = rgb_array_frac
-
-      # Inverse sRGB companding. Linearizes RGB channels with respect to energy.
-      rr, gg, bb = [r, g, b].map do
-        if _1 <= 0.04045
-          _1 / 12.92
-        else
-          # sRGB Inverse Companding (Non-linear to Linear RGB)
-          # The sRGB specification (IEC 61966-2-1) defines the exponent as 2.4.
-          #
-          (((_1 + 0.055) / 1.055)**2.4)
-
-          # IMPORTANT NUMERICAL NOTE:
-          # On this specific system (and confirmed by Wolfram Alpha for direct calculation),
-          # the power function for val**2.4 yields a result that deviates from the value expected by widely-used color science libraries (like Bruce Lindbloom's).
-          #
-          # To compensate for this numerical discrepancy and ensure the final CIELAB values match standard online calculators and specifications,
-          # an empirically determined exponent of 2.5 has been found to produce the correct linearized sRGB values on this environment.
-          #
-          # Choose 2.4 for strict adherence to the standard's definition (knowing your results may slightly deviate from common calculators),
-          # or choose 2.5 to ensure your calculated linear RGB values (and thus CIELAB) match authoritative external tools on this system.
-          #
-          # ((_1 + 0.055) / 1.055)**2.5
-        end
-      end
-
-      # Convert using the RGB/XYZ matrix at:
-      # http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html#WSMatrices
-      x = (rr * 0.4124564) + (gg * 0.3575761) + (bb * 0.1804375)
-      y = (rr * 0.2126729) + (gg * 0.7151522) + (bb * 0.0721750)
-      z = (rr * 0.0193339) + (gg * 0.1191920) + (bb * 0.9503041)
-
-      # Now, scale X, Y, Z so that Y for D65 white would be 100.
-      x *= 100.0
-      y *= 100.0
-      z *= 100.0
-
-      # Clamping XYZ values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
-      x = x.clamp(0.0..95.047)
-      y = y.clamp(0.0..100.0)
-      z = z.clamp(0.0..108.883)
-
-      [x, y, z]
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class XyzConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:x, :y, :z] == []
+    end
+
+    def self.d65
+      { x: 95.047, y: 100.0, z: 108.883 }
+    end
+
+    def self.bounds
+      { x: [0.0, 100.0], y: [0.0, 100.0], z: [0.0, 110.0] }
+    end
+
+    private
+
+    def validate_input(colour_input)
+      XyzConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      r, g, b = XyzConverter.xyz_to_rgb(colour_input)
+
+      [r, g, b, 1.0]
+    end
+
+    def self.xyz_to_rgb(xyz_hash)
+      # [0, 100]
+      x = xyz_hash[:x].to_d
+      y = xyz_hash[:y].to_d
+      z = xyz_hash[:z].to_d
+
+      # Convert XYZ (typically with Y=100 for white) to normalized XYZ (Y=1 for white).
+      # The transformation matrix expects X, Y, Z values in the 0-1 range.
+      x /= 100.0.to_d
+      y /= 100.0.to_d
+      z /= 100.0.to_d
+
+      # Convert normalized XYZ to Linear sRGB values using sRGB's own white, D65 (no chromatic adaptation)
+      # https://www.w3.org/TR/css-color-4/#color-conversion-code
+      conversion_matrix = ::Matrix[
+        [BigDecimal('3.2409699419045213'), BigDecimal('-1.5373831775700935'), BigDecimal('-0.4986107602930033')],
+        [BigDecimal('-0.9692436362808798'), BigDecimal('1.8759675015077206'), BigDecimal('0.04155505740717561')],
+        [BigDecimal('0.05563007969699361'), BigDecimal('-0.20397695888897657'), BigDecimal('1.0569715142428786')]
+      ]
+
+      rr, gg, bb = (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
+
+      # [0, 1]
+      RgbConverter.lrgb_to_rgb([rr, gg, bb])
+    end
+
+    # http://www.brucelindbloom.com/index.html?Eqn_RGB_to_XYZ.html
+    def self.rgb_to_xyz(rgb_array_frac)
+      rr, gg, bb = RgbConverter.rgb_to_lrgb(rgb_array_frac)
+
+      # Convert using the RGB/XYZ matrix and sRGB's own white, D65 (no chromatic adaptation)
+      # https://www.w3.org/TR/css-color-4/#color-conversion-code
+      conversion_matrix = ::Matrix[
+        [BigDecimal('0.4123907992659595'), BigDecimal('0.35758433938387796'), BigDecimal('0.1804807884018343')],
+        [BigDecimal('0.21263900587151036'), BigDecimal('0.7151686787677559'), BigDecimal('0.07219231536073371')],
+        [BigDecimal('0.01933081871559185'), BigDecimal('0.11919477979462599'), BigDecimal('0.9505321522496606')]
+      ]
+
+      x, y, z = (conversion_matrix * ::Matrix.column_vector([rr, gg, bb])).to_a.flatten
+
+      # Now, scale X, Y, Z so that Y for D65 white would be 100.
+      x *= 100.0
+      y *= 100.0
+      z *= 100.0
+
+      # Clamping XYZ values to prevent out-of-gamut issues and numerical errors and ensures these values stay within the valid and expected range.
+      # x = x.clamp(0.0..95.047)
+      # y = y.clamp(0.0..100.0)
+      # z = z.clamp(0.0..108.883)
+
+      [x, y, z]
+    end
+
+    def self.d50_to_d65(xyz_array)
+      x, y, z = xyz_array
+
+      conversion_matrix = ::Matrix[
+        [BigDecimal('0.955473421488075'), BigDecimal('-0.02309845494876471'), BigDecimal('0.06325924320057072')],
+        [BigDecimal('-0.0283697093338637'), BigDecimal('1.0099953980813041'), BigDecimal('0.021041441191917323')],
+        [BigDecimal('0.012314014864481998'), BigDecimal('-0.020507649298898964'), BigDecimal('1.330365926242124')]
+      ]
+
+      (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
+    end
+
+    def self.d65_to_d50(xyz_array)
+      x, y, z = xyz_array
+
+      conversion_matrix = ::Matrix[
+        [BigDecimal('1.0479297925449969'), BigDecimal('0.022946870601609652'), BigDecimal('-0.05019226628920524')],
+        [BigDecimal('0.02962780877005599'), BigDecimal('0.9904344267538799'), BigDecimal('-0.017073799063418826')],
+        [BigDecimal('-0.009243040646204504'), BigDecimal('0.015055191490298152'), BigDecimal('0.7518742814281371')]
+      ]
+
+      (conversion_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
+    end
+  end
+end

data/lib/color_converters/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ColorConverters
-  VERSION = '0.1.2'
+  VERSION = '0.1.4'
 end

data/lib/color_converters.rb

@@ -1,28 +1,31 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-require 'color_converters/version'
-
-require 'color_converters/color'
-require 'color_converters/base_converter'
-
-require 'color_converters/converters/rgb_converter'
-require 'color_converters/converters/rgb_string_converter'
-require 'color_converters/converters/hex_converter'
-require 'color_converters/converters/hsl_converter'
-require 'color_converters/converters/hsl_string_converter'
-require 'color_converters/converters/hsv_converter'
-require 'color_converters/converters/cmyk_converter'
-require 'color_converters/converters/xyz_converter'
-require 'color_converters/converters/cielab_converter'
-require 'color_converters/converters/cielch_converter'
-
-require 'color_converters/converters/name_converter'
-require 'color_converters/converters/null_converter'
-
-module ColorConverters
-  class Error < StandardError; end
-  class InvalidColorError < Error; end
-  # Your code goes here...
-end
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require 'color_converters/version'
+
+require 'color_converters/color'
+require 'color_converters/base_converter'
+
+# Converters
+require 'color_converters/converters/rgb_converter'
+require 'color_converters/converters/rgb_string_converter'
+require 'color_converters/converters/hex_converter'
+require 'color_converters/converters/hsl_converter'
+require 'color_converters/converters/hsl_string_converter'
+require 'color_converters/converters/hsv_converter'
+require 'color_converters/converters/cmyk_converter'
+require 'color_converters/converters/xyz_converter'
+require 'color_converters/converters/cielab_converter'
+require 'color_converters/converters/cielch_converter'
+require 'color_converters/converters/oklab_converter'
+require 'color_converters/converters/oklch_converter'
+
+require 'color_converters/converters/name_converter'
+require 'color_converters/converters/null_converter'
+
+module ColorConverters
+  class Error < StandardError; end
+  class InvalidColorError < Error; end
+  # Your code goes here...
+end

metadata

@@ -1,28 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: color_converters
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Louis Davis
 bindir: bin
 cert_chain: []
-date: 2025-06-26 00:00:00.000000000 Z
+date: 2025-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.3
+- !ruby/object:Gem::Dependency
+  name: color_swatch_collection
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 8.0.2
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 8.0.2
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: matrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Convert colors to hex/rgb/hsv/cmyk/hsl/xyz/cielab/oklch
 email:
 - LouisWilliamDavis@gmail.com
@@ -44,6 +72,8 @@ files:
 - lib/color_converters/converters/hsv_converter.rb
 - lib/color_converters/converters/name_converter.rb
 - lib/color_converters/converters/null_converter.rb
+- lib/color_converters/converters/oklab_converter.rb
+- lib/color_converters/converters/oklch_converter.rb
 - lib/color_converters/converters/rgb_converter.rb
 - lib/color_converters/converters/rgb_string_converter.rb
 - lib/color_converters/converters/xyz_converter.rb