color_converters 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c97c6fdaf99305ee413b3648f6c16b8fe9a83124696af3e3e161fae19d71fe19
-  data.tar.gz: b0c6e84ebde615a1b7d044aaa85556e16e1ca9bfa0181232c238b74a1d80d25f
+  metadata.gz: 5cff79bc695fab4e8041206a798421948d03eb04933b77274a802f90a0010999
+  data.tar.gz: 1edc8b8811b32ca6ac4d7b9f8347151ab772fa58d52d90ba4cd8f48ab60d889e
 SHA512:
-  metadata.gz: 1c42e5f3097a878896c29b317856cfd3b9d3458b24ad66c69ac1cf550a50c7bd72e04c135157ef582d8f8ce0408500624f7776339c8949442ea41c1cfec77956
-  data.tar.gz: 8a6310fd2eaa1b323236111ddb96732ad84fca43edfd4e39805afd614499c2afee09b481e81fdcb454187e45637c57770a3e4676c346238641aaf23e686220d4
+  metadata.gz: a5fe55d89679198c41e0e166dbdae882b11f9396d58710b004707358652c6187e53889d88dd21efbeeee99b7738484a7cd3d71f7cc35496445881a9558fa9543
+  data.tar.gz: 507da4fe02639e97285b5df4ed0e6e5e69fd78f793aa8bc772b2702d72e029f227ce50abf2987ac087fe1b050a06562262ed9660ca8395d6833e528412900852

data/README.md

@@ -18,7 +18,9 @@ Colors can be converted between the following spaces:
 - cmyk
 - xyz
 - cielab
-- oklch
+- cielch
+- oklab (not always reliable)
+- oklch (not always reliable)
 - name
 
 ## Installation
@@ -63,10 +65,16 @@ color = ColorConverters::Color.new(c: 74, m: 58, y: 22, k: 3)
 color = ColorConverters::Color.new(x: 16, y: 44, z: 32)
 
 # from cielab
-color = ColorConverters::Color.new(l: 16, a: 44, b: 32)
+color = ColorConverters::Color.new(l: 16, a: 44, b: 32, space: :cie)
+
+# from cielch
+color = ColorConverters::Color.new(l: 16, c: 44, h: 32, space: :cie)
+
+# from oklab
+color = ColorConverters::Color.new(l: 16, a: 44, b: 32, space: :ok)
 
 # from oklch
-color = ColorConverters::Color.new(l: 16, c: 44, h: 32)
+color = ColorConverters::Color.new(l: 16, c: 44, h: 32, space: :ok)
 
 # from textual color
 color = ColorConverters::Color.new("blue")
@@ -109,7 +117,13 @@ color.xyz
 color.cielab
 => {:l=>52.47, :a=>-4.08, :b=>-32.19}
 
-color.oklch
+color.cielch
+=> {:l=>52.47, :c=>32.45, :h=>262.78}
+
+color.oklab # not always accurate
+=> {:l=>52.47, :a=>-4.08, :b=>-32.19}
+
+color.oklch # not always accurate
 => {:l=>52.47, :c=>32.45, :h=>262.78}
 
 color.hex
@@ -121,6 +135,16 @@ color.name
 
 ## Options
 
+### space
+
+As there are certain color spaces that use the same letter keys, there needed to be a way to different between those space.
+The space parameter allows that, with examples in the usage code above
+
+```ruby
+ColorConverters::Color.new(l: 64, a: 28, b: -15, space: :cie)
+ColorConverters::Color.new(l: 64, a: 28, b: -15, space: :ok)
+```
+
 ### limit_override
 
 By default all values are checked to be within the expected number ranges, i.e.; rgb between 0-255 each.
@@ -132,7 +156,7 @@ ColorConverters::Color.new(r: 270, g: 1300, b: 380, a: 0.5, limit_override: true
 
 ## Development
 
-[Converting Colors](https://convertingcolors.com/) can be usef to help verify results. Different calculators use different exponents and standards so there can be discrepency across them (like this calculator for LCH).
+[Converting Colors](https://convertingcolors.com/) and [Colorffy](https://colorffy.com/) can be usef to help verify results. Different calculators use different exponents and standards so there can be discrepency across them (like this calculator for LCH).
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 

data/lib/color_converters/base_converter.rb

@@ -1,4 +1,6 @@
 require 'active_support/core_ext/object/blank'
+require 'bigdecimal'
+require 'bigdecimal/util'
 
 module ColorConverters
   class BaseConverter
@@ -26,15 +28,19 @@ module ColorConverters
     def initialize(color_input, limit_override = false)
       @original_value = color_input
 
+      # self.clamp_input(color_input) if limit_clamp == true
+
       if limit_override == false && !self.validate_input(color_input)
         raise InvalidColorError # validation method is defined in each convertor
       end
 
-      @rgba = self.input_to_rgba(color_input) # conversion method is defined in each convertor
+      r, g, b, a = self.input_to_rgba(color_input) # conversion method is defined in each convertor
+
+      @rgba = { r: r.to_f.round(IMPORT_DP), g: g.to_f.round(IMPORT_DP), b: b.to_f.round(IMPORT_DP), a: a.to_f.round(IMPORT_DP) }
     end
 
     def rgb
-      { r: @rgba[:r].round(OUTPUT_DP), g: @rgba[:g].round(OUTPUT_DP), b: @rgba[:b].round(OUTPUT_DP) }
+      { r: @rgba[:r].to_f.round(OUTPUT_DP), g: @rgba[:g].to_f.round(OUTPUT_DP), b: @rgba[:b].to_f.round(OUTPUT_DP) }
     end
 
     def hex
@@ -44,13 +50,13 @@ module ColorConverters
     def hsl
       @r, @g, @b = self.rgb_array_frac
 
-      { h: self.hue.round(OUTPUT_DP), s: self.hsl_saturation.round(OUTPUT_DP), l: self.hsl_lightness.round(OUTPUT_DP) }
+      { h: self.hue.to_f.round(OUTPUT_DP), s: self.hsl_saturation.to_f.round(OUTPUT_DP), l: self.hsl_lightness.to_f.round(OUTPUT_DP) }
     end
 
     def hsv
       @r, @g, @b = self.rgb_array
 
-      { h: self.hue.round(OUTPUT_DP), s: self.hsv_saturation.round(OUTPUT_DP), v: self.hsv_value.round(OUTPUT_DP) }
+      { h: self.hue.to_f.round(OUTPUT_DP), s: self.hsv_saturation.to_f.round(OUTPUT_DP), v: self.hsv_value.to_f.round(OUTPUT_DP) }
     end
 
     def hsb
@@ -62,25 +68,37 @@ module ColorConverters
     def cmyk
       c, m, y, k = CmykConverter.rgb_to_cmyk(self.rgb_array_frac)
 
-      { c: c.round(OUTPUT_DP), m: m.round(OUTPUT_DP), y: y.round(OUTPUT_DP), k: k.round(OUTPUT_DP) }
+      { c: c.to_f.round(OUTPUT_DP), m: m.to_f.round(OUTPUT_DP), y: y.to_f.round(OUTPUT_DP), k: k.to_f.round(OUTPUT_DP) }
     end
 
     def xyz
       x, y, z = XyzConverter.rgb_to_xyz(self.rgb_array_frac)
 
-      { x: x.round(OUTPUT_DP), y: y.round(OUTPUT_DP), z: z.round(OUTPUT_DP) }
+      { x: x.to_f.round(OUTPUT_DP), y: y.to_f.round(OUTPUT_DP), z: z.to_f.round(OUTPUT_DP) }
     end
 
     def cielab
-      l, a, b = CielabConverter.xyz_to_lab(XyzConverter.rgb_to_xyz(self.rgb_array_frac))
+      l, a, b = CielabConverter.xyz_to_cielab(XyzConverter.rgb_to_xyz(self.rgb_array_frac))
+
+      { l: l.to_f.round(OUTPUT_DP), a: a.to_f.round(OUTPUT_DP), b: b.to_f.round(OUTPUT_DP) }
+    end
+
+    def cielch
+      l, c, h = CielchConverter.cielab_to_cielch(CielabConverter.xyz_to_cielab(XyzConverter.rgb_to_xyz(self.rgb_array_frac)))
+
+      { l: l.to_f.round(OUTPUT_DP), c: c.to_f.round(OUTPUT_DP), h: h.to_f.round(OUTPUT_DP) }
+    end
+
+    def oklab
+      l, a, b = OklabConverter.xyz_to_oklab(XyzConverter.rgb_to_xyz(self.rgb_array_frac))
 
-      { l: l.round(OUTPUT_DP), a: a.round(OUTPUT_DP), b: b.round(OUTPUT_DP) }
+      { l: l.to_f.round(OUTPUT_DP), a: a.to_f.round(OUTPUT_DP), b: b.to_f.round(OUTPUT_DP) }
     end
 
     def oklch
-      l, c, h = OklchConverter.lab_to_lch(CielabConverter.xyz_to_lab(XyzConverter.rgb_to_xyz(self.rgb_array_frac)))
+      l, c, h = OklchConverter.oklab_to_oklch(OklabConverter.xyz_to_oklab(XyzConverter.rgb_to_xyz(self.rgb_array_frac)))
 
-      { l: l.round(OUTPUT_DP), c: c.round(OUTPUT_DP), h: h.round(OUTPUT_DP) }
+      { l: l.to_f.round(OUTPUT_DP), c: c.to_f.round(OUTPUT_DP), h: h.to_f.round(OUTPUT_DP) }
     end
 
     def alpha
@@ -88,7 +106,7 @@ module ColorConverters
     end
 
     def name
-      NameConverter.rgb_to_name(self.rgb_array_frac)
+      NameConverter.rgb_to_name(self.rgb_array)
     end
 
     protected

data/lib/color_converters/color.rb

@@ -1,7 +1,7 @@
 module ColorConverters
   class Color
     extend Forwardable
-    def_delegators :@converter, :rgb, :hex, :hsl, :hsv, :hsb, :cmyk, :xyz, :cielab, :oklch, :name, :alpha
+    def_delegators :@converter, :rgb, :hex, :hsl, :hsv, :hsb, :cmyk, :xyz, :cielab, :cielch, :oklab, :oklch, :name, :alpha
 
     def initialize(color)
       @converter = BaseConverter.factory(color)

data/lib/color_converters/converters/cielab_converter.rb

@@ -3,7 +3,7 @@ module ColorConverters
     def self.matches?(color_input)
       return false unless color_input.is_a?(Hash)
 
-      color_input.keys - [:l, :a, :b] == []
+      color_input.keys - [:l, :a, :b, :space] == [] && color_input[:space].to_s == 'cie'
     end
 
     def self.bounds
@@ -18,69 +18,73 @@ module ColorConverters
     end
 
     def input_to_rgba(color_input)
-      xyz_hash = CielabConverter.lab_to_xyz(color_input)
-      XyzConverter.new(xyz_hash, limit_override: true).rgba
+      x, y, z = CielabConverter.cielab_to_xyz(color_input)
+      r, g, b = XyzConverter.xyz_to_rgb({ x: x, y: y, z: z })
+
+      [r, g, b, 1.0]
     end
 
-    def self.lab_to_xyz(color_input)
-      l = color_input[:l].to_f
-      a = color_input[:a].to_f
-      b = color_input[:b].to_f
+    def self.cielab_to_xyz(color_input)
+      l = color_input[:l].to_d
+      a = color_input[:a].to_d
+      b = color_input[:b].to_d
 
-      yy = (l + 16.0) / 116.0
-      xx = (a / 500.0) + yy
-      zz = yy - (b / 200.0)
+      yy = (l + 16.0.to_d) / 116.0.to_d
+      xx = (a / 500.0.to_d) + yy
+      zz = yy - (b / 200.0.to_d)
 
-      ratio = 6.0 / 29.0
+      e = 216.0.to_d / 24_389.0.to_d
 
       x, y, z = [xx, yy, zz].map do
-        if _1 <= ratio
-          (3.0 * (6.0 / 29.0) * (6.0 / 29.0) * (_1 - (4.0 / 29.0)))
+        if _1**3.to_d <= e
+          (3.0.to_d * (6.0.to_d / 29.0.to_d) * (6.0.to_d / 29.0.to_d) * (_1 - (4.0.to_d / 29.0.to_d)))
         else
-          _1**3
+          _1**3.to_d
         end
       end
 
-      x *= 95.047
-      y *= 100.0
-      z *= 108.883
+      x *= 95.047.to_d
+      y *= 100.0.to_d
+      z *= 108.883.to_d
 
-      { x: x, y: y, z: z }
+      [x, y, z]
     end
 
-    def self.xyz_to_lab(xyz_array)
-      x, y, z = xyz_array
+    def self.xyz_to_cielab(xyz_array)
+      x, y, z = xyz_array.map(&:to_d)
+
+      # https://www.w3.org/TR/css-color-4/#color-conversion-code
+      # # The D50 & D65 standard illuminant white point
+      # wp_rel = [0.3457 / 0.3585, 1.0, (1.0 - 0.3457 - 0.3585) / 0.3585]
+      wp_rel = [0.3127.to_d / 0.3290.to_d, 1.0.to_d, (1.0.to_d - 0.3127.to_d - 0.3290.to_d) / 0.3290.to_d].map { _1 * 100.0.to_d }
 
-      # The D65 standard illuminant white point
-      xr = 95.047
-      yr = 100.0
-      zr = 108.883
+      xr, yr, zr = wp_rel
 
-      # Calculate the ratio of the XYZ values to the reference white.
-      # http://www.brucelindbloom.com/index.html?Equations.html
+      # # Calculate the ratio of the XYZ values to the reference white.
+      # # http://www.brucelindbloom.com/index.html?Equations.html
       rel = [x / xr, y / yr, z / zr]
 
-      e = 216.0 / 24_389.0
-      k = 841.0 / 108.0
+      e = 216.0.to_d / 24_389.0.to_d
+      k = 841.0.to_d / 108.0.to_d
 
       # And now transform
-      # http://en.wikipedia.org/wiki/Lab_color_space#Forward_transformation
+      # http:#en.wikipedia.org/wiki/Lab_color_space#Forward_transformation
       # There is a brief explanation there as far as the nature of the calculations,
       # as well as a much nicer looking modeling of the algebra.
       xx, yy, zz = rel.map do
         if _1 > e
-          _1**(1.0 / 3.0)
+          _1**(1.0.to_d / 3.0.to_d)
         else
-          (k * _1) + (4.0 / 29.0)
+          (k * _1) + (4.0.to_d / 29.0.to_d)
           # The 4/29 here is for when t = 0 (black). 4/29 * 116 = 16, and 16 -
           # 16 = 0, which is the correct value for L* with black.
           # ((1.0/3)*((29.0/6)**2) * t) + (4.0/29)
         end
       end
 
-      l = ((116.0 * yy) - 16.0)
-      a = (500.0 * (xx - yy))
-      b = (200.0 * (yy - zz))
+      l = ((116.0.to_d * yy) - 16.0.to_d)
+      a = (500.0.to_d * (xx - yy))
+      b = (200.0.to_d * (yy - zz))
 
       [l, a, b]
     end

data/lib/color_converters/converters/cielch_converter.rb

@@ -0,0 +1,58 @@
+module ColorConverters
+  class CielchConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(Hash)
+
+      color_input.keys - [:l, :c, :h, :space] == [] && color_input[:space].to_s == 'cie'
+    end
+
+    def self.bounds
+      { l: [0.0, 100.0], c: [0.0, 150.0], h: [0.0, 360.0] }
+    end
+
+    private
+
+    def validate_input(color_input)
+      bounds = CielchConverter.bounds
+      color_input[:l].to_f.between?(*bounds[:l]) && color_input[:c].to_f.between?(*bounds[:c]) && color_input[:h].to_f.between?(*bounds[:h])
+    end
+
+    def input_to_rgba(color_input)
+      l, a, b = CielchConverter.cielch_to_cielab(color_input)
+      x, y, z = CielabConverter.cielab_to_xyz({ l: l, a: a, b: b })
+      r, g, b = XyzConverter.xyz_to_rgb({ x: x, y: y, z: z })
+
+      [r, g, b, 1.0]
+    end
+
+    def self.cielch_to_cielab(color_input)
+      l = color_input[:l].to_d
+      c = color_input[:c].to_d
+      h = color_input[:h].to_d
+
+      h_rad = h * (Math::PI.to_d / 180.0.to_d)
+
+      a = c * Math.cos(h_rad).to_d
+      b = c * Math.sin(h_rad).to_d
+
+      [l, a, b]
+    end
+
+    def self.cielab_to_cielch(lab_array)
+      l, aa, bb = lab_array.map(&:to_d)
+
+      e = 0.0015.to_d; # if chroma is smaller than this, set hue to 0 [https://www.w3.org/TR/css-color-4/#color-conversion-code]
+
+      c = ((aa**2.to_d) + (bb**2.to_d))**0.5.to_d
+
+      h_rad = Math.atan2(bb, aa).to_d
+      h = h_rad * (180.0.to_d / Math::PI.to_d)
+
+      h %= 360
+
+      h = 0 if c < e
+
+      [l, c, h]
+    end
+  end
+end

data/lib/color_converters/converters/cmyk_converter.rb

@@ -28,11 +28,11 @@ module ColorConverters
       y /= 100.0
       k /= 100.0
 
-      r = (255 * (1.0 - [1.0, c * (1.0 - k) + k].min)).round(IMPORT_DP)
-      g = (255 * (1.0 - [1.0, m * (1.0 - k) + k].min)).round(IMPORT_DP)
-      b = (255 * (1.0 - [1.0, y * (1.0 - k) + k].min)).round(IMPORT_DP)
+      r = (255 * (1.0 - [1.0, c * (1.0 - k) + k].min))
+      g = (255 * (1.0 - [1.0, m * (1.0 - k) + k].min))
+      b = (255 * (1.0 - [1.0, y * (1.0 - k) + k].min))
 
-      { r: r, g: g, b: b, a: 1.0 }
+      [r, g, b, 1.0]
     end
 
     def self.rgb_to_cmyk(rgb_array_frac)

data/lib/color_converters/converters/hex_converter.rb

@@ -8,7 +8,7 @@ module ColorConverters
 
     private
 
-    def validate_input(color_input)
+    def validate_input(_color_input)
       # TODO
       true
     end
@@ -21,7 +21,7 @@ module ColorConverters
       b = color_input[4, 2].hex
       a = color_input.length == 8 ? hex[6, 2].hex : 1.0
 
-      { r: r, g: g, b: b, a: a }
+      [r, g, b, a]
     end
 
     def normalize_hex(hex_input)

data/lib/color_converters/converters/hsl_converter.rb

@@ -50,15 +50,16 @@ module ColorConverters
                 t1
               end
 
-        rgb[i] = (val * 255).round(IMPORT_DP)
+        rgb[i] = (val * 255)
       end
 
-      { r: rgb[0], g: rgb[1], b: rgb[2], a: a }
+      [rgb[0], rgb[1], rgb[2], a]
     end
 
     def greyscale(luminosity, alpha)
       rgb_equal_value = (luminosity * 255).round(IMPORT_DP)
-      { r: rgb_equal_value, g: rgb_equal_value, b: rgb_equal_value, a: alpha }
+
+      [rgb_equal_value, rgb_equal_value, rgb_equal_value, alpha]
     end
   end
 end

data/lib/color_converters/converters/hsl_string_converter.rb

@@ -8,7 +8,7 @@ module ColorConverters
 
     private
 
-    def validate_input(color_input)
+    def validate_input(_color_input)
       true
     end
 
@@ -19,7 +19,9 @@ module ColorConverters
       h, s, l, a = matches[1].split(',').map(&:strip)
       raise InvalidColorError unless h.present? && s.present? && l.present?
 
-      HslConverter.new(h: h, s: s, l: l, a: a).rgba
+      rgba = HslConverter.new(h: h, s: s, l: l, a: a).rgba
+
+      [rgba[:r], rgba[:g], rgba[:b], rgba[:a]]
     end
   end
 end

data/lib/color_converters/converters/hsv_converter.rb

@@ -41,17 +41,17 @@ module ColorConverters
 
       case i % 6
       when 0
-        { r: v, g: t, b: p, a: 1.0 }
+        [v, t, p, 1.0]
       when 1
-        { r: q, g: v, b: p, a: 1.0 }
+        [q, v, p, 1.0]
       when 2
-        { r: p, g: v, b: t, a: 1.0 }
+        [p, v, t, 1.0]
       when 3
-        { r: p, g: q, b: v, a: 1.0 }
+        [p, q, v, 1.0]
       when 4
-        { r: t, g: p, b: v, a: 1.0 }
+        [t, p, v, 1.0]
       when 5
-        { r: v, g: p, b: q, a: 1.0 }
+        [v, p, q, 1.0]
       end
     end
   end

data/lib/color_converters/converters/name_converter.rb

@@ -6,16 +6,16 @@ module ColorConverters
       self.color_names.include?(color_input.downcase.to_sym)
     end
 
-    def self.rgb_to_name(rgb_array_frac)
-      r, g, b = rgb_array_frac
+    def self.rgb_to_name(rgb_array)
+      r, g, b = rgb_array
 
-      name = self.color_names.find { |_k, v| v == [r, g, b] }
+      name = self.color_names.find { |_k, v| v == [r.round, g.round, b.round] }
       name.present? ? name[0].to_s : nil
     end
 
     private
 
-    def validate_input(color_input) #
+    def validate_input(_color_input)
       # TODO: validate against list of keys?
       true
     end
@@ -25,9 +25,11 @@ module ColorConverters
       raise InvalidColorError unless found_colour.present?
 
       r, g, b = found_colour
-      { r: r, g: g, b: b, a: 1.0 }
+
+      [r, g, b, 1.0]
     end
 
+    # TODO: use color_namer_ruby gem instead, but that gem also uses this gem
     def self.color_names
       {
         aliceblue: [240, 248, 255],

data/lib/color_converters/converters/oklab_converter.rb

@@ -0,0 +1,98 @@
+module ColorConverters
+  class OklabConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(Hash)
+
+      color_input.keys - [:l, :a, :b, :space] == [] && color_input[:space].to_s == 'ok'
+    end
+
+    def self.bounds
+      { l: [0.0, 100.0], a: [-0.5, 0.5], b: [-0.5, 0.5] }
+    end
+
+    private
+
+    def validate_input(color_input)
+      bounds = OklabConverter.bounds
+      color_input[:l].to_f.between?(*bounds[:l]) && color_input[:a].to_f.between?(*bounds[:a]) && color_input[:b].to_f.between?(*bounds[:b])
+    end
+
+    def input_to_rgba(color_input)
+      x, y, z = OklabConverter.oklab_to_xyz(color_input)
+      r, g, b = XyzConverter.xyz_to_rgb({ x: x, y: y, z: z })
+
+      [r, g, b, 1.0]
+    end
+
+    def self.oklab_to_xyz(color_input)
+      l = color_input[:l].to_d
+      a = color_input[:a].to_d
+      b = color_input[:b].to_d
+
+      # Now, scale l to a decimal
+      l /= 100.0.to_d
+
+      # Convert Oklab (L*a*b*) to LMS'
+      lab_to_lms_matrix = ::Matrix[
+        [1.0000000000000000.to_d, 0.3963377773761749.to_d,  0.2158037573099136.to_d],
+        [1.0000000000000000.to_d, -0.1055613458156586.to_d, -0.0638541728258133.to_d],
+        [1.0000000000000000.to_d, -0.0894841775298119.to_d, -1.2914855480194092.to_d]
+      ]
+
+      l_lms, m_lms, s_lms = (lab_to_lms_matrix * ::Matrix.column_vector([l, a, b])).to_a.flatten
+
+      l_lms **= 3.to_d
+      m_lms **= 3.to_d
+      s_lms **= 3.to_d
+
+      lms_to_xyz_matrix = ::Matrix[
+        [1.2268798758459243.to_d, -0.5578149944602171.to_d, 0.2813910456659647.to_d],
+        [-0.0405757452148008.to_d, 1.1122868032803170.to_d, -0.0717110580655164.to_d],
+        [-0.0763729366746601.to_d, -0.4214933324022432.to_d, 1.5869240198367816.to_d]
+      ]
+
+      x, y, z = (lms_to_xyz_matrix * ::Matrix.column_vector([l_lms, m_lms, s_lms])).to_a.flatten
+
+      x *= 100.0.to_d
+      y *= 100.0.to_d
+      z *= 100.0.to_d
+
+      [x, y, z]
+    end
+
+    def self.xyz_to_oklab(xyz_array)
+      x, y, z = xyz_array.map(&:to_d)
+
+      # The transformation matrix expects normalised X, Y, Z values.
+      x /= 100.0.to_d
+      y /= 100.0.to_d
+      z /= 100.0.to_d
+
+      # Given XYZ relative to D65, convert to OKLab
+      xyz_to_lms_matrix = ::Matrix[
+        [0.8190224379967030.to_d, 0.3619062600528904.to_d, -0.1288737815209879.to_d],
+        [0.0329836539323885.to_d, 0.9292868615863434.to_d, 0.0361446663506424.to_d],
+        [0.0481771893596242.to_d, 0.2642395317527308.to_d, 0.6335478284694309.to_d]
+      ]
+
+      l_lms, m_lms, s_lms = (xyz_to_lms_matrix * ::Matrix.column_vector([x, y, z])).to_a.flatten
+
+      l_lms **= (1.0.to_d / 3.0.to_d)
+      m_lms **= (1.0.to_d / 3.0.to_d)
+      s_lms **= (1.0.to_d / 3.0.to_d)
+
+      lms_to_lab_matrix = ::Matrix[
+        [0.2104542683093140.to_d, 0.7936177747023054.to_d, -0.0040720430116193.to_d],
+        [1.9779985324311684.to_d, -2.4285922420485799.to_d, 0.4505937096174110.to_d],
+        [0.0259040424655478.to_d, 0.7827717124575296.to_d, -0.8086757549230774.to_d]
+      ]
+
+      l_lab, a_lab, b_lab = (lms_to_lab_matrix * ::Matrix.column_vector([l_lms, m_lms, s_lms])).to_a.flatten
+
+      # Now, scale l to a percentage
+      l_lab *= 100.0.to_d
+
+      [l_lab, a_lab, b_lab]
+    end
+  end
+end

data/lib/color_converters/converters/oklch_converter.rb

@@ -3,11 +3,11 @@ module ColorConverters
     def self.matches?(color_input)
       return false unless color_input.is_a?(Hash)
 
-      color_input.keys - [:l, :c, :h] == []
+      color_input.keys - [:l, :c, :h, :space] == [] && color_input[:space].to_s == 'ok'
     end
 
     def self.bounds
-      { l: [0.0, 100.0], c: [0.0, 100.0], h: [0.0, 360.0] }
+      { l: [0.0, 100.0], c: [0.0, 500.0], h: [0.0, 360.0] }
     end
 
     private
@@ -18,34 +18,40 @@ module ColorConverters
     end
 
     def input_to_rgba(color_input)
-      lab_hash = OklchConverter.lch_to_lab(color_input)
-      xyz_hash = CielabConverter.lab_to_xyz(lab_hash)
-      XyzConverter.new(xyz_hash, limit_override: true).rgba
+      l, a, b = OklchConverter.oklch_to_oklab(color_input)
+      x, y, z = OklabConverter.oklab_to_xyz({ l: l, a: a, b: b })
+      r, g, b = XyzConverter.xyz_to_rgb({ x: x, y: y, z: z })
+
+      [r, g, b, 1.0]
     end
 
-    def self.lch_to_lab(color_input)
-      l = color_input[:l].to_f
-      c = color_input[:c].to_f
-      h = color_input[:h].to_f
+    def self.oklch_to_oklab(color_input)
+      l = color_input[:l].to_d
+      c = color_input[:c].to_d
+      h = color_input[:h].to_d
 
-      h_rad = h * (Math::PI / 180.0)
+      h_rad = h * (Math::PI.to_d / 180.0.to_d)
 
-      a = c * Math.cos(h_rad)
-      b = c * Math.sin(h_rad)
+      a = c * Math.cos(h_rad).to_d
+      b = c * Math.sin(h_rad).to_d
 
-      { l: l, a: a, b: b }
+      [l, a, b]
     end
 
-    def self.lab_to_lch(lab_array)
-      l, aa, bb = lab_array
+    def self.oklab_to_oklch(lab_array)
+      l, aa, bb = lab_array.map(&:to_d)
+
+      e = 0.000015.to_d; # if chroma is smaller than this, set hue to 0 similar to CIELch
 
-      c = ((aa**2) + (bb**2))**0.5
+      c = ((aa**2.to_d) + (bb**2.to_d))**0.5.to_d
 
-      h_rad = Math.atan2(bb, aa)
-      h = h_rad * (180.0 / Math::PI)
+      h_rad = Math.atan2(bb, aa).to_d
+      h = h_rad * (180.0.to_d / Math::PI.to_d)
 
       h %= 360
 
+      h = 0 if c < e
+
       [l, c, h]
     end
   end

data/lib/color_converters/converters/rgb_converter.rb

@@ -23,7 +23,84 @@ module ColorConverters
       b = color_input[:b].to_f
       a = (color_input[:a] || 1.0).to_f
 
-      { r: r.round(IMPORT_DP), g: g.round(IMPORT_DP), b: b.round(IMPORT_DP), a: a.round(IMPORT_DP) }
+      [r, g, b, a]
+    end
+
+    def self.rgb_to_lrgb(rgb_array_frac)
+      # [0, 1]
+      r, g, b = rgb_array_frac
+
+      # Inverse sRGB companding. Linearizes RGB channels with respect to energy.
+      # Assumption that r, g, b are always positive
+      rr, gg, bb = [r, g, b].map do
+        if _1.to_d <= 0.04045.to_d
+          _1.to_d / 12.92.to_d
+        else
+          # sRGB Inverse Companding (Non-linear to Linear RGB)
+          # The sRGB specification (IEC 61966-2-1) defines the exponent as 2.4.
+          #
+          (((_1.to_d + 0.055.to_d) / 1.055.to_d)**2.4.to_d)
+
+          # 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
+
+      # [0, 1]
+      [rr, gg, bb]
+    end
+
+    def self.lrgb_to_rgb(lrgb_array)
+      rr, gg, bb = lrgb_array
+
+      # 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...).
+      # Assumption that rr, gg, bb are always positive
+      r, g, b = [rr, gg, bb].map do
+        if _1.to_d <= 0.0031308.to_d
+          # Linear portion of the sRGB curve
+          _1.to_d * 12.92.to_d
+        else
+          # Non-linear (gamma-corrected) portion of the sRGB curve
+          # The sRGB specification uses an exponent of 1/2.4.
+          #
+          (1.055.to_d * (_1.to_d**(1.0.to_d / 2.4.to_d))) - 0.055.to_d
+
+          # 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.to_d
+      g *= 255.0.to_d
+      b *= 255.0.to_d
+
+      # 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
   end
 end

data/lib/color_converters/converters/rgb_string_converter.rb

@@ -8,7 +8,7 @@ module ColorConverters
 
     private
 
-    def validate_input(color_input)
+    def validate_input(_color_input)
       true
     end
 
@@ -21,12 +21,12 @@ module ColorConverters
 
       a ||= 1.0
 
-      r = r.to_f.round(IMPORT_DP)
-      g = g.to_f.round(IMPORT_DP)
-      b = b.to_f.round(IMPORT_DP)
-      a = a.to_f.round(IMPORT_DP)
+      r = r.to_f
+      g = g.to_f
+      b = b.to_f
+      a = a.to_f
 
-      { r: r, g: g, b: b, a: a }
+      [r, g, b, a]
     end
   end
 end

data/lib/color_converters/converters/xyz_converter.rb

@@ -6,8 +6,12 @@ module ColorConverters
       color_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, 95.047], y: [0.0, 100.0], z: [0.0, 108.883] }
+      { x: [0.0, 100.0], y: [0.0, 100.0], z: [0.0, 110.0] }
     end
 
     private
@@ -18,98 +22,50 @@ module ColorConverters
     end
 
     def input_to_rgba(color_input)
-      r, g, b = xyz_to_rgb(color_input)
+      r, g, b = XyzConverter.xyz_to_rgb(color_input)
 
-      { r: r.round(IMPORT_DP), g: g.round(IMPORT_DP), b: b.round(IMPORT_DP), a: 1.0 }
+      [r, g, b, 1.0]
     end
 
-    def xyz_to_rgb(xyz_hash)
+    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 = 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]
+      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)
-      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)
+      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
@@ -117,11 +73,35 @@ module ColorConverters
       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 = 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.1'
+  VERSION = '0.1.3'
 end

data/lib/color_converters.rb

@@ -16,6 +16,8 @@ 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'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: color_converters
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Louis Davis
 bindir: bin
 cert_chain: []
-date: 2025-06-25 00:00:00.000000000 Z
+date: 2025-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 8.0.2
+- !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
@@ -36,6 +50,7 @@ files:
 - lib/color_converters/base_converter.rb
 - lib/color_converters/color.rb
 - lib/color_converters/converters/cielab_converter.rb
+- lib/color_converters/converters/cielch_converter.rb
 - lib/color_converters/converters/cmyk_converter.rb
 - lib/color_converters/converters/hex_converter.rb
 - lib/color_converters/converters/hsl_converter.rb
@@ -43,6 +58,7 @@ 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