color_converters 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 41c9c2e35a56c7fcbc75a4b96a923cef9c106c260b2eb567caa958404042466a
+  data.tar.gz: f8ee279b96b83cb0938acc291a58752e495c2a6295227f9d3ad5f88ea33ad280
+SHA512:
+  metadata.gz: f9db0a0eec4f2380b45a21be819e5c698dbdcf73e5fbf064e2f97f90a0debd46e62e6e5fc63a07ea64b0ba1c84e2150dc6475d029a577747376f27d3acbe9fd1
+  data.tar.gz: e1a9aec3fee9cb4a467f6d16b42482088c5af3390dead1574015d1cea5e4bdeff69d314f73c9a60566b0ef6d0d087b696235783029888a5da993a351839761e6

data/README.md

@@ -0,0 +1,152 @@
+# Color Converters
+
+> Give me a color and I'll convert it.
+
+Color Converters is an ruby gem package for use in ruby or other projects that provides conversions for colors to other color spaces.
+Given a color in [Hexadecimal, RGA(A), HSL(A), HSV, HSB, CMYK, XYZ, CIELAB, or OKLCH format](https://github.com/devrieda/color_conversion), it can convert the color to those other spaces.
+
+> Lab and LCH color spaces are special in that the perceived difference between two colors is proportional to their Euclidean distance in color space. This special property, called perceptual uniformity, makes them ideal for accurate visual encoding of data. In contrast, the more familiar RGB and HSL color spaces distort data when used for visualization.
+
+## Converters
+
+Colors can be converted between the following spaces:
+
+- hex
+- rgb(a)
+- hsl(a)
+- hsv/hsb
+- cmyk
+- xyz
+- cielab
+- oklch
+- name
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add color_converters
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install color_converters
+```
+
+## Usage
+
+Initialize a color:
+
+```ruby
+# from hex
+color = Color.new("#3366cc")
+color = Color.new("#36c")
+
+# from rgb(a)
+color = Color.new(r: 51, g: 102, b: 204)
+color = Color.new(r: 51, g: 102, b: 204, a: 0.5)
+
+# from hsl(a)
+color = Color.new(h: 225, s: 73, l: 57)
+color = Color.new(h: 225, s: 73, l: 57, a: 0.5)
+
+# from hsv/hsb
+color = Color.new(h: 220, s: 75, v: 80)
+color = Color.new(h: 220, s: 75, b: 80)
+
+# from cmyk
+color = Color.new(c: 74, m: 58, y: 22, k: 3)
+
+# from xyz
+color = Color.new(x: 16, y: 44, z: 32)
+
+# from cielab
+color = Color.new(l: 16, a: 44, b: 32)
+
+# from oklch
+color = Color.new(l: 16, c: 44, h: 32)
+
+# from textual color
+color = Color.new("blue")
+
+# from a css rgb(a) string
+color = Color.new("rgb(51, 102, 204)")
+color = Color.new("rgba(51, 102, 204, 0.5)")
+
+# from a css hsl(a) string
+color = Color.new("hsl(225, 73%, 57%)")
+color = Color.new("hsl(225, 73%, 57%, 0.5)")
+```
+
+Converters
+
+```ruby
+color = Color.new(r: 70, g: 130, b: 180, a: 0.5)
+
+color.alpha
+=> 0.5
+
+color.rgb
+=> {:r=>70, :g=>130, :b=>180}
+
+color.hsl
+=> {:h=>207, :s=>44, :l=>49}
+
+color.hsv
+=> {:h=>207, :s=>61, :v=>71}
+
+color.hsb
+=> {:h=>207, :s=>61, :b=>71}
+
+color.cmyk
+=> {:c=>61, :m=>28, :y=>0, :k=>29}
+
+color.xyz
+=> {:x=>33, :y=>21, :z=>54}
+
+color.cielab
+=> {:l=>52.47, :a=>-4.08, :b=>-32.19}
+
+color.oklch
+=> {:l=>52.47, :c=>32.45, :h=>262.78}
+
+color.hex
+=> "#4682b4"
+
+color.name
+=> "steelblue"
+```
+
+## Options
+
+### limit_override
+
+By default all values are checked to be within the expected number ranges, i.e.; rgb between 0-255 each.
+This parameter allows you to ignore those ranges and submit any values you want.
+
+```ruby
+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).
+
+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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/louiswdavis/color_converters>. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/louiswdavis/color_converters/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+Forked from original gem by Derek DeVries.
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ColorConverters project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/louiswdavis/color_converters/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/color_converter/base_converter.rb

@@ -0,0 +1,161 @@
+require 'active_support/core_ext/object/blank'
+
+module ColorConverter
+  class BaseConverter
+    IMPORT_DP = 2
+    OUTPUT_DP = 2
+
+    attr_reader :original_value, :rgba
+
+    # keep track of subclasses for factory
+    class << self
+      attr_reader :converters
+    end
+
+    @converters = []
+
+    def self.inherited(subclass)
+      BaseConverter.converters << subclass
+    end
+
+    def self.factory(color)
+      converter = BaseConverter.converters.find { |klass| klass.matches?(color) }
+      converter.new(color) if converter
+    end
+
+    def initialize(color_input, limit_override = false)
+      @original_value = color_input
+
+      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
+    end
+
+    def rgb
+      { r: @rgba[:r].round(OUTPUT_DP), g: @rgba[:g].round(OUTPUT_DP), b: @rgba[:b].round(OUTPUT_DP) }
+    end
+
+    def hex
+      "##{'%02x' % @rgba[:r] + '%02x' % @rgba[:g] + '%02x' % @rgba[:b]}"
+    end
+
+    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) }
+    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) }
+    end
+
+    def hsb
+      hsb_hash = self.hsv
+      hsb_hash[:b] = hsb_hash.delete(:v)
+      hsb_hash
+    end
+
+    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) }
+    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) }
+    end
+
+    def cielab
+      l, a, b = CielabConverter.xyz_to_lab(XyzConverter.rgb_to_xyz(self.rgb_array_frac))
+
+      { l: l.round(OUTPUT_DP), a: a.round(OUTPUT_DP), b: b.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: l.round(OUTPUT_DP), c: c.round(OUTPUT_DP), h: h.round(OUTPUT_DP) }
+    end
+
+    def alpha
+      @rgba[:a]
+    end
+
+    def name
+      NameConverter.rgb_to_name(self.rgb_array_frac)
+    end
+
+    protected
+
+    def rgb_array
+      [@rgba[:r].to_f, @rgba[:g].to_f, @rgba[:b].to_f]
+    end
+
+    def rgb_array_frac
+      [@rgba[:r] / 255.0, @rgba[:g] / 255.0, @rgba[:b] / 255.0]
+    end
+
+    def rgb_min
+      [@r, @g, @b].min
+    end
+
+    def rgb_max
+      [@r, @g, @b].max
+    end
+
+    def rgb_delta
+      self.rgb_max - self.rgb_min
+    end
+
+    def hue
+      h = 0
+
+      case true
+      when self.rgb_max == self.rgb_min
+        h = 0
+      when self.rgb_max == @r
+        h = (@g - @b) / self.rgb_delta
+      when self.rgb_max == @g
+        h = 2 + (@b - @r) / self.rgb_delta
+      when self.rgb_max == @b
+        h = 4 + (@r - @g) / self.rgb_delta
+      end
+
+      h = [h * 60, 360].min
+      h % 360
+    end
+
+    def hsl_saturation
+      s = 0
+
+      case true
+      when self.rgb_max == self.rgb_min
+        s = 0
+      when (self.hsl_lightness / 100.0) <= 0.5
+        s = self.rgb_delta / (self.rgb_max + self.rgb_min)
+      else
+        s = self.rgb_delta / (2.0 - self.rgb_max - self.rgb_min)
+      end
+
+      s * 100
+    end
+
+    def hsl_lightness
+      (self.rgb_min + self.rgb_max) / 2.0 * 100
+    end
+
+    def hsv_saturation
+      self.rgb_max.zero? ? 0 : ((self.rgb_delta / self.rgb_max * 1000) / 10.0)
+    end
+
+    def hsv_value
+      ((self.rgb_max / 255.0) * 1000) / 10.0
+    end
+  end
+end

data/lib/color_converter/color.rb

@@ -0,0 +1,16 @@
+module ColorConverter
+  class Color
+    extend Forwardable
+    def_delegators :@converter, :rgb, :hex, :hsl, :hsv, :hsb, :cmyk, :xyz, :cielab, :oklch, :name, :alpha
+
+    def initialize(color)
+      @converter = BaseConverter.factory(color)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Color)
+
+      rgb == other.rgb && alpha == other.alpha
+    end
+  end
+end

data/lib/color_converter/color_converters/cielab_converter.rb

@@ -0,0 +1,88 @@
+module ColorConverter
+  class CielabConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(Hash)
+
+      color_input.keys - [:l, :a, :b] == []
+    end
+
+    def self.bounds
+      { l: [0.0, 100.0], a: [-128.0, 127.0], b: [-128.0, 127.0] }
+    end
+
+    private
+
+    def validate_input(color_input)
+      bounds = CielabConverter.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)
+      xyz_hash = CielabConverter.lab_to_xyz(color_input)
+      XyzConverter.new(xyz_hash, limit_override: true).rgba
+    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
+
+      yy = (l + 16.0) / 116.0
+      xx = (a / 500.0) + yy
+      zz = yy - (b / 200.0)
+
+      ratio = 6.0 / 29.0
+
+      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)))
+        else
+          _1**3
+        end
+      end
+
+      x *= 95.047
+      y *= 100.0
+      z *= 108.883
+
+      { x: x, y: y, z: z }
+    end
+
+    def self.xyz_to_lab(xyz_array)
+      x, y, z = xyz_array
+
+      # The D65 standard illuminant white point
+      xr = 95.047
+      yr = 100.0
+      zr = 108.883
+
+      # 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
+
+      # And now transform
+      # 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)
+        else
+          (k * _1) + (4.0 / 29.0)
+          # 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, a, b]
+    end
+  end
+end

data/lib/color_converter/color_converters/cmyk_converter.rb

@@ -0,0 +1,56 @@
+module ColorConverter
+  class CmykConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(Hash)
+
+      color_input.keys - [:c, :m, :y, :k] == []
+    end
+
+    def self.bounds
+      { c: [0.0, 100.0], m: [0.0, 100.0], y: [0.0, 100.0], k: [0.0, 100.0] }
+    end
+
+    private
+
+    def validate_input(color_input)
+      bounds = CmykConverter.bounds
+      color_input[:c].to_f.between?(*bounds[:c]) && color_input[:m].to_f.between?(*bounds[:m]) && color_input[:y].to_f.between?(*bounds[:y]) && color_input[:k].to_f.between?(*bounds[:k])
+    end
+
+    def input_to_rgba(color_input)
+      c = color_input[:c].to_f
+      m = color_input[:m].to_f
+      y = color_input[:y].to_f
+      k = color_input[:k].to_f
+
+      c /= 100.0
+      m /= 100.0
+      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: r, g: g, b: b, a: 1.0 }
+    end
+
+    def self.rgb_to_cmyk(rgb_array_frac)
+      r, g, b = rgb_array_frac
+
+      k = (1.0 - [r, g, b].max)
+      k_frac = k == 1.0 ? 1.0 : 1.0 - k
+
+      c = (1.0 - r - k) / k_frac
+      m = (1.0 - g - k) / k_frac
+      y = (1.0 - b - k) / k_frac
+
+      c *= 100
+      m *= 100
+      y *= 100
+      k *= 100
+
+      [c, m, y, k]
+    end
+  end
+end

data/lib/color_converter/color_converters/hex_converter.rb

@@ -0,0 +1,32 @@
+module ColorConverter
+  class HexConverter < BaseConverter
+    def self.matches?(color)
+      return false unless color.is_a?(String)
+
+      color.include?('#') && [4, 7, 9].include?(color.length)
+    end
+
+    private
+
+    def validate_input(color_input)
+      true
+      # color_input[:l].to_f.between?(0.0, 100.0) && color_input[:a].between?(-128.0, 127.0) && color_input[:b].between?(-128.0, 127.0)
+    end
+
+    def input_to_rgba(color_input)
+      color_input = self.normalize_hex(color_input)
+
+      r = color_input[0, 2].hex
+      g = color_input[2, 2].hex
+      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 }
+    end
+
+    def normalize_hex(hex_input)
+      hex_input = hex_input.gsub('#', '')
+      (hex_input.length == 3 ? hex_input[0, 1] * 2 + hex_input[1, 1] * 2 + hex_input[2, 1] * 2 : hex_input).downcase
+    end
+  end
+end

data/lib/color_converter/color_converters/hsl_converter.rb

@@ -0,0 +1,64 @@
+module ColorConverter
+  class HslConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(Hash)
+
+      color_input.keys - [:h, :s, :l] == [] || color_input.keys - [:h, :s, :l, :a] == []
+    end
+
+    def self.bounds
+      { h: [0.0, 360.0], s: [0.0, 100.0], l: [0.0, 100.0] }
+    end
+
+    private
+
+    def validate_input(color_input)
+      bounds = HslConverter.bounds
+      color_input[:h].to_f.between?(*bounds[:h]) && color_input[:s].to_f.between?(*bounds[:s]) && color_input[:l].to_f.between?(*bounds[:l])
+    end
+
+    def input_to_rgba(color_input)
+      h = color_input[:h].to_s.gsub(/[^0-9.]/, '').to_f / 360.0
+      s = color_input[:s].to_s.gsub(/[^0-9.]/, '').to_f / 100.0
+      l = color_input[:l].to_s.gsub(/[^0-9.]/, '').to_f / 100.0
+      a = color_input[:a] ? color_input[:a].to_s.gsub(/[^0-9.]/, '').to_f : 1.0
+
+      return greyscale(l, a) if s.zero?
+
+      t2 = if l < 0.5
+             l * (1 + s)
+           else
+             l + s - l * s
+           end
+
+      t1 = 2 * l - t2
+
+      rgb = [0, 0, 0]
+
+      (0..2).each do |i|
+        t3 = h + 1 / 3.0 * - (i - 1)
+        t3 < 0 && t3 += 1
+        t3 > 1 && t3 -= 1
+
+        val = if 6 * t3 < 1
+                t1 + (t2 - t1) * 6 * t3
+              elsif 2 * t3 < 1
+                t2
+              elsif 3 * t3 < 2
+                t1 + (t2 - t1) * (2 / 3.0 - t3) * 6
+              else
+                t1
+              end
+
+        rgb[i] = (val * 255).round(IMPORT_DP)
+      end
+
+      { r: rgb[0], g: rgb[1], b: rgb[2], a: 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 }
+    end
+  end
+end

data/lib/color_converter/color_converters/hsl_string_converter.rb

@@ -0,0 +1,26 @@
+module ColorConverter
+  class HslStringConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(String)
+
+      color_input.include?('hsl(') || color_input.include?('hsla(')
+    end
+
+    private
+
+    def validate_input(color_input)
+      true
+      # color_input[:l].between?(0.0, 100.0) && color_input[:a].between?(-128.0, 127.0) && color_input[:b].between?(-128.0, 127.0)
+    end
+
+    def input_to_rgba(color_input)
+      matches = color_input.match(/hsla?\(([0-9.,%\s]+)\)/)
+      raise InvalidColorError unless matches
+
+      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
+    end
+  end
+end

data/lib/color_converter/color_converters/hsv_converter.rb

@@ -0,0 +1,58 @@
+module ColorConverter
+  class HsvConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(Hash)
+
+      color_input.keys - [:h, :s, :v] == [] || color_input.keys - [:h, :s, :b] == []
+    end
+
+    def self.bounds
+      { h: [0.0, 360.0], s: [-128.0, 127.0], v: [-128.0, 127.0], b: [-128.0, 127.0] }
+    end
+
+    private
+
+    def validate_input(color_input)
+      bounds = HsvConverter.bounds
+      light = (color_input[:v].present? && color_input[:v].to_f.between?(*bounds[:v])) || (color_input[:b].present? && color_input[:b].to_f.between?(*bounds[:v]))
+      color_input[:h].to_f.between?(*bounds[:h]) && color_input[:s].to_f.between?(*bounds[:s]) && light
+    end
+
+    def input_to_rgba(color_input)
+      h = color_input[:h].to_f
+      s = color_input[:s].to_f
+      v = (color_input[:v] || color_input[:b]).to_f
+
+      h /= 360
+      s /= 100
+      v /= 100
+
+      i = (h * 6).floor
+      f = h * 6 - i
+
+      p = v * (1 - s)
+      q = v * (1 - f * s)
+      t = v * (1 - (1 - f) * s)
+
+      p = (p * 255).round(IMPORT_DP)
+      q = (q * 255).round(IMPORT_DP)
+      t = (t * 255).round(IMPORT_DP)
+      v = (v * 255).round(IMPORT_DP)
+
+      case i % 6
+      when 0
+        { r: v, g: t, b: p, a: 1.0 }
+      when 1
+        { r: q, g: v, b: p, a: 1.0 }
+      when 2
+        { r: p, g: v, b: t, a: 1.0 }
+      when 3
+        { r: p, g: q, b: v, a: 1.0 }
+      when 4
+        { r: t, g: p, b: v, a: 1.0 }
+      when 5
+        { r: v, g: p, b: q, a: 1.0 }
+      end
+    end
+  end
+end

data/lib/color_converter/color_converters/name_converter.rb

@@ -0,0 +1,183 @@
+module ColorConverter
+  class NameConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(String)
+
+      self.color_names.include?(color_input.downcase.to_sym)
+    end
+
+    def self.rgb_to_name(rgb_array_frac)
+      r, g, b = rgb_array_frac
+
+      name = self.color_names.find { |_k, v| v == [r, g, b] }
+      name.present? ? name[0].to_s : nil
+    end
+
+    private
+
+    def validate_input(color_input)
+      true
+      # color_input[:l].between?(0.0, 100.0) && color_input[:a].between?(-128.0, 127.0) && color_input[:b].between?(-128.0, 127.0)
+    end
+
+    def input_to_rgba(color_input)
+      found_colour = self.class.color_names[color_input.downcase.to_sym]
+      raise InvalidColorError unless found_colour.present?
+
+      r, g, b = found_colour
+      { r: r, g: g, b: b, a: 1.0 }
+    end
+
+    def self.color_names
+      {
+        aliceblue: [240, 248, 255],
+        antiquewhite: [250, 235, 215],
+        aqua: [0, 255, 255],
+        aquamarine: [127, 255, 212],
+        azure: [240, 255, 255],
+        beige: [245, 245, 220],
+        bisque: [255, 228, 196],
+        black: [0, 0, 0],
+        blanchedalmond: [255, 235, 205],
+        blue: [0, 0, 255],
+        blueviolet: [138, 43, 226],
+        brown: [165, 42, 42],
+        burlywood: [222, 184, 135],
+        cadetblue: [95, 158, 160],
+        chartreuse: [127, 255, 0],
+        chocolate: [210, 105, 30],
+        coral: [255, 127, 80],
+        cornflowerblue: [100, 149, 237],
+        cornsilk: [255, 248, 220],
+        crimson: [220, 20, 60],
+        cyan: [0, 255, 255],
+        darkblue: [0, 0, 139],
+        darkcyan: [0, 139, 139],
+        darkgoldenrod: [184, 134, 11],
+        darkgray: [169, 169, 169],
+        darkgreen: [0, 100, 0],
+        darkgrey: [169, 169, 169],
+        darkkhaki: [189, 183, 107],
+        darkmagenta: [139, 0, 139],
+        darkolivegreen: [85, 107, 47],
+        darkorange: [255, 140, 0],
+        darkorchid: [153, 50, 204],
+        darkred: [139, 0, 0],
+        darksalmon: [233, 150, 122],
+        darkseagreen: [143, 188, 143],
+        darkslateblue: [72, 61, 139],
+        darkslategray: [47, 79, 79],
+        darkslategrey: [47, 79, 79],
+        darkturquoise: [0, 206, 209],
+        darkviolet: [148, 0, 211],
+        deeppink: [255, 20, 147],
+        deepskyblue: [0, 191, 255],
+        dimgray: [105, 105, 105],
+        dimgrey: [105, 105, 105],
+        dodgerblue: [30, 144, 255],
+        firebrick: [178, 34, 34],
+        floralwhite: [255, 250, 240],
+        forestgreen: [34, 139, 34],
+        fuchsia: [255, 0, 255],
+        gainsboro: [220, 220, 220],
+        ghostwhite: [248, 248, 255],
+        gold: [255, 215, 0],
+        goldenrod: [218, 165, 32],
+        gray: [128, 128, 128],
+        green: [0, 128, 0],
+        greenyellow: [173, 255, 47],
+        grey: [128, 128, 128],
+        honeydew: [240, 255, 240],
+        hotpink: [255, 105, 180],
+        indianred: [205, 92, 92],
+        indigo: [75, 0, 130],
+        ivory: [255, 255, 240],
+        khaki: [240, 230, 140],
+        lavender: [230, 230, 250],
+        lavenderblush: [255, 240, 245],
+        lawngreen: [124, 252, 0],
+        lemonchiffon: [255, 250, 205],
+        lightblue: [173, 216, 230],
+        lightcoral: [240, 128, 128],
+        lightcyan: [224, 255, 255],
+        lightgoldenrodyellow: [250, 250, 210],
+        lightgray: [211, 211, 211],
+        lightgreen: [144, 238, 144],
+        lightgrey: [211, 211, 211],
+        lightpink: [255, 182, 193],
+        lightsalmon: [255, 160, 122],
+        lightseagreen: [32, 178, 170],
+        lightskyblue: [135, 206, 250],
+        lightslategray: [119, 136, 153],
+        lightslategrey: [119, 136, 153],
+        lightsteelblue: [176, 196, 222],
+        lightyellow: [255, 255, 224],
+        lime: [0, 255, 0],
+        limegreen: [50, 205, 50],
+        linen: [250, 240, 230],
+        magenta: [255, 0, 255],
+        maroon: [128, 0, 0],
+        mediumaquamarine: [102, 205, 170],
+        mediumblue: [0, 0, 205],
+        mediumorchid: [186, 85, 211],
+        mediumpurple: [147, 112, 219],
+        mediumseagreen: [60, 179, 113],
+        mediumslateblue: [123, 104, 238],
+        mediumspringgreen: [0, 250, 154],
+        mediumturquoise: [72, 209, 204],
+        mediumvioletred: [199, 21, 133],
+        midnightblue: [25, 25, 112],
+        mintcream: [245, 255, 250],
+        mistyrose: [255, 228, 225],
+        moccasin: [255, 228, 181],
+        navajowhite: [255, 222, 173],
+        navy: [0, 0, 128],
+        oldlace: [253, 245, 230],
+        olive: [128, 128, 0],
+        olivedrab: [107, 142, 35],
+        orange: [255, 165, 0],
+        orangered: [255, 69, 0],
+        orchid: [218, 112, 214],
+        palegoldenrod: [238, 232, 170],
+        palegreen: [152, 251, 152],
+        paleturquoise: [175, 238, 238],
+        palevioletred: [219, 112, 147],
+        papayawhip: [255, 239, 213],
+        peachpuff: [255, 218, 185],
+        peru: [205, 133, 63],
+        pink: [255, 192, 203],
+        plum: [221, 160, 221],
+        powderblue: [176, 224, 230],
+        purple: [128, 0, 128],
+        red: [255, 0, 0],
+        rosybrown: [188, 143, 143],
+        royalblue: [65, 105, 225],
+        saddlebrown: [139, 69, 19],
+        salmon: [250, 128, 114],
+        sandybrown: [244, 164, 96],
+        seagreen: [46, 139, 87],
+        seashell: [255, 245, 238],
+        sienna: [160, 82, 45],
+        silver: [192, 192, 192],
+        skyblue: [135, 206, 235],
+        slateblue: [106, 90, 205],
+        slategray: [112, 128, 144],
+        slategrey: [112, 128, 144],
+        snow: [255, 250, 250],
+        springgreen: [0, 255, 127],
+        steelblue: [70, 130, 180],
+        tan: [210, 180, 140],
+        teal: [0, 128, 128],
+        thistle: [216, 191, 216],
+        tomato: [255, 99, 71],
+        turquoise: [64, 224, 208],
+        violet: [238, 130, 238],
+        wheat: [245, 222, 179],
+        white: [255, 255, 255],
+        whitesmoke: [245, 245, 245],
+        yellow: [255, 255, 0],
+        yellowgreen: [154, 205, 50]
+      }
+    end
+  end
+end

data/lib/color_converter/color_converters/null_converter.rb

@@ -0,0 +1,17 @@
+module ColorConverter
+  class NullConverter < BaseConverter
+    def self.matches?(_color_input)
+      true
+    end
+
+    private
+
+    def validate_input(_color_input)
+      false
+    end
+
+    def input_to_rgba(_color_input)
+      raise InvalidColorError
+    end
+  end
+end

data/lib/color_converter/color_converters/oklch_converter.rb

@@ -0,0 +1,52 @@
+module ColorConverter
+  class OklchConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(Hash)
+
+      color_input.keys - [:l, :c, :h] == []
+    end
+
+    def self.bounds
+      { l: [0.0, 100.0], c: [0.0, 100.0], h: [0.0, 360.0] }
+    end
+
+    private
+
+    def validate_input(color_input)
+      bounds = OklchConverter.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)
+      lab_hash = OklchConverter.lch_to_lab(color_input)
+      xyz_hash = CielabConverter.lab_to_xyz(lab_hash)
+      XyzConverter.new(xyz_hash, limit_override: true).rgba
+    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
+
+      h_rad = h * (Math::PI / 180.0)
+
+      a = c * Math.cos(h_rad)
+      b = c * Math.sin(h_rad)
+
+      { l: l, a: a, b: b }
+    end
+
+    def self.lab_to_lch(lab_array)
+      l, aa, bb = lab_array
+
+      c = ((aa**2) + (bb**2))**0.5
+
+      h_rad = Math.atan2(bb, aa)
+      h = h_rad * (180.0 / Math::PI)
+
+      h %= 360
+
+      [l, c, h]
+    end
+  end
+end

data/lib/color_converter/color_converters/rgb_converter.rb

@@ -0,0 +1,29 @@
+module ColorConverter
+  class RgbConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(Hash)
+
+      color_input.keys - [:r, :g, :b] == [] || color_input.keys - [:r, :g, :b, :a] == []
+    end
+
+    def self.bounds
+      { r: [0.0, 255.0], g: [0.0, 255.0], b: [0.0, 255.0] }
+    end
+
+    private
+
+    def validate_input(color_input)
+      bounds = RgbConverter.bounds
+      color_input[:r].to_f.between?(*bounds[:r]) && color_input[:g].to_f.between?(*bounds[:g]) && color_input[:b].to_f.between?(*bounds[:b])
+    end
+
+    def input_to_rgba(color_input)
+      r = color_input[:r].to_f
+      g = color_input[:g].to_f
+      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) }
+    end
+  end
+end

data/lib/color_converter/color_converters/rgb_string_converter.rb

@@ -0,0 +1,33 @@
+module ColorConverter
+  class RgbStringConverter < BaseConverter
+    def self.matches?(color_input)
+      return false unless color_input.is_a?(String)
+
+      color_input.include?('rgb(') || color_input.include?('rgba(')
+    end
+
+    private
+
+    def validate_input(color_input)
+      true
+      # color_input[:l].between?(0.0, 100.0) && color_input[:a].between?(-128.0, 127.0) && color_input[:b].between?(-128.0, 127.0)
+    end
+
+    def input_to_rgba(color_input)
+      matches = color_input.match(/rgba?\(([0-9.,\s]+)\)/)
+      raise InvalidColorError unless matches
+
+      r, g, b, a = matches[1].split(',').map(&:strip)
+      raise InvalidColorError unless r.present? && g.present? && b.present?
+
+      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, g: g, b: b, a: a }
+    end
+  end
+end

data/lib/color_converter/color_converters/xyz_converter.rb

@@ -0,0 +1,127 @@
+module ColorConverter
+  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

data/lib/color_converter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ColorConverter
+  VERSION = '0.1.0'
+end

data/lib/color_converter.rb

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

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: color_converters
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Louis Davis
+bindir: bin
+cert_chain: []
+date: 2025-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.0.2
+description: Convert colors to hex/rgb/hsv/cmyk/hsl/xyz/cielab/oklch
+email:
+- LouisWilliamDavis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/color_converter.rb
+- lib/color_converter/base_converter.rb
+- lib/color_converter/color.rb
+- lib/color_converter/color_converters/cielab_converter.rb
+- lib/color_converter/color_converters/cmyk_converter.rb
+- lib/color_converter/color_converters/hex_converter.rb
+- lib/color_converter/color_converters/hsl_converter.rb
+- lib/color_converter/color_converters/hsl_string_converter.rb
+- lib/color_converter/color_converters/hsv_converter.rb
+- lib/color_converter/color_converters/name_converter.rb
+- lib/color_converter/color_converters/null_converter.rb
+- lib/color_converter/color_converters/oklch_converter.rb
+- lib/color_converter/color_converters/rgb_converter.rb
+- lib/color_converter/color_converters/rgb_string_converter.rb
+- lib/color_converter/color_converters/xyz_converter.rb
+- lib/color_converter/version.rb
+homepage: https://github.com/louiswdavis/color_converters
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/louiswdavis/color_converters
+  source_code_uri: https://github.com/louiswdavis/color_converters
+  changelog_uri: https://github.com/louiswdavis/color_converters/blob/master/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.3
+specification_version: 4
+summary: Convert colors to hex/rgb/hsv/cmyk/hsl/xyz/cielab/oklch
+test_files: []