color_converters 0.1.2 → 0.1.4

data/lib/color_converters/base_converter.rb

@@ -1,163 +1,184 @@
-require 'active_support/core_ext/object/blank'
-
-module ColorConverters
-  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
-
-      # 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
-    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_cielab(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 cielch
-      l, c, h = CielchConverter.cielab_to_cielch(CielabConverter.xyz_to_cielab(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
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module ColorConverters
+  class BaseConverter
+    IMPORT_DP = 8
+    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(colour)
+      converter = BaseConverter.converters.find { |klass| klass.matches?(colour) }
+      converter&.new(colour)
+    end
+
+    def initialize(colour_input, limit_override = false)
+      @original_value = colour_input
+
+      # self.clamp_input(colour_input) if limit_clamp == true
+
+      validation_errors = self.validate_input(colour_input)
+      if limit_override == false && validation_errors.present?
+        raise InvalidColorError, "Invalid color input: #{validation_errors.join(', ')}" # validation method is defined in each convertor
+      end
+
+      r, g, b, a = self.input_to_rgba(colour_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].to_f.round(OUTPUT_DP), g: @rgba[:g].to_f.round(OUTPUT_DP), b: @rgba[:b].to_f.round(OUTPUT_DP) }
+    end
+
+    def hex
+      HexConverter.rgb_to_hex(self.rgb_array)
+    end
+
+    # not refactored to SubClass methods due to needing so many of the private methods
+    def hsl
+      @r, @g, @b = self.rgb_array_frac
+
+      { 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
+
+    # not refactored to SubClass methods due to needing so many of the private methods
+    def hsv
+      @r, @g, @b = self.rgb_array
+
+      { 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
+      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.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.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_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.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.oklab_to_oklch(OklabConverter.xyz_to_oklab(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 alpha
+      @rgba[:a]
+    end
+
+    def name(fuzzy: false)
+      NameConverter.rgb_to_name(self.rgb_array, fuzzy)
+    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_converters/color.rb

@@ -1,16 +1,18 @@
-module ColorConverters
-  class Color
-    extend Forwardable
-    def_delegators :@converter, :rgb, :hex, :hsl, :hsv, :hsb, :cmyk, :xyz, :cielab, :cielch, :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
+# frozen_string_literal: true
+
+module ColorConverters
+  class Color
+    extend Forwardable
+    def_delegators :@converter, :rgb, :hex, :hsl, :hsv, :hsb, :cmyk, :xyz, :cielab, :cielch, :oklab, :oklch, :name, :alpha
+
+    def initialize(colour)
+      @converter = BaseConverter.factory(colour)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Color)
+
+      rgb == other.rgb && alpha == other.alpha
+    end
+  end
+end

data/lib/color_converters/converters/cielab_converter.rb

@@ -1,88 +1,95 @@
-module ColorConverters
-  class CielabConverter < 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 == 'cie'
-    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.cielab_to_xyz(color_input)
-      XyzConverter.new(xyz_hash, limit_override: true).rgba
-    end
-
-    def self.cielab_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_cielab(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
+# frozen_string_literal: true
+
+module ColorConverters
+  class CielabConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:l, :a, :b, :space] == [] && colour_input[:space].to_s == 'cie'
+    end
+
+    def self.bounds
+      { l: [0.0, 100.0], a: [-128.0, 127.0], b: [-128.0, 127.0] }
+    end
+
+    private
+
+    def validate_input(colour_input)
+      CielabConverter.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)
+      x, y, z = CielabConverter.cielab_to_xyz(colour_input)
+      r, g, b = XyzConverter.xyz_to_rgb({ x: x, y: y, z: z })
+
+      [r, g, b, 1.0]
+    end
+
+    def self.cielab_to_xyz(colour_input)
+      l = colour_input[:l].to_d
+      a = colour_input[:a].to_d
+      b = colour_input[:b].to_d
+
+      yy = (l + 16.0.to_d) / 116.0.to_d
+      xx = (a / 500.0.to_d) + yy
+      zz = yy - (b / 200.0.to_d)
+
+      e = 216.0.to_d / 24_389.0.to_d
+
+      x, y, z = [xx, yy, zz].map do
+        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.to_d
+        end
+      end
+
+      x *= 95.047.to_d
+      y *= 100.0.to_d
+      z *= 108.883.to_d
+
+      [x, y, z]
+    end
+
+    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 }
+
+      xr, yr, zr = wp_rel
+
+      # # 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.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
+      # 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.to_d / 3.0.to_d)
+        else
+          (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.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
+  end
+end