color_converters 0.1.4 → 0.1.5

data/lib/color_converters/converters/hsv_converter.rb

@@ -1,60 +1,64 @@
-# frozen_string_literal: true
-
-module ColorConverters
-  class HsvConverter < BaseConverter
-    def self.matches?(colour_input)
-      return false unless colour_input.is_a?(Hash)
-
-      colour_input.keys - [:h, :s, :v] == [] || colour_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(colour_input)
-      HsvConverter.bounds.collect do |key, range|
-        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].blank? || colour_input[key].to_f.between?(*range)
-      end.compact
-    end
-
-    def input_to_rgba(colour_input)
-      h = colour_input[:h].to_f
-      s = colour_input[:s].to_f
-      v = (colour_input[:v] || colour_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
-        [v, t, p, 1.0]
-      when 1
-        [q, v, p, 1.0]
-      when 2
-        [p, v, t, 1.0]
-      when 3
-        [p, q, v, 1.0]
-      when 4
-        [t, p, v, 1.0]
-      when 5
-        [v, p, q, 1.0]
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class HsvConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:h, :s, :v] == [] || colour_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 clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*HsvConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      HsvConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].blank? || colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      h = colour_input[:h].to_f
+      s = colour_input[:s].to_f
+      v = (colour_input[:v] || colour_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
+        [v, t, p, 1.0]
+      when 1
+        [q, v, p, 1.0]
+      when 2
+        [p, v, t, 1.0]
+      when 3
+        [p, q, v, 1.0]
+      when 4
+        [t, p, v, 1.0]
+      when 5
+        [v, p, q, 1.0]
+      end
+    end
+  end
+end

data/lib/color_converters/converters/name_converter.rb

@@ -1,67 +1,69 @@
-# frozen_string_literal: true
-
-require 'color_swatch_collection'
-
-module ColorConverters
-  class NameConverter < BaseConverter
-    def self.matches?(colour_input)
-      return false unless colour_input.is_a?(String)
-
-      !colour_input.include?('#') && !colour_input.include?('rgb') && !colour_input.include?('hsl')
-    end
-
-    def self.rgb_to_name(rgb_array, fuzzy = false)
-      if fuzzy
-        source_colour = ColorConverters::Color.new({ r: rgb_array[0], g: rgb_array[1], b: rgb_array[2] })
-
-        collection_colours = []
-
-        ::ColorSwatchCollection.list_collections.each do |collection_name|
-          collection_colours += self.add_colour_distances_to_collection(Object.const_get("::ColorSwatchCollection::#{collection_name.capitalize}").colours, source_colour)
-        end
-
-        collection_colours.min_by { |swatch| swatch[:distance] }.dig(:name)
-      else
-        ::ColorSwatchCollection.get_from_hex(HexConverter.rgb_to_hex(rgb_array)).dig(:name)
-      end
-    end
-
-    private
-
-    def validate_input(colour_input)
-      self.class.match_name_from_palettes(colour_input).present? ? [] : ['name could not be found across colour collections']
-    end
-
-    def input_to_rgba(colour_input)
-      found_colour = self.class.match_name_from_palettes(colour_input)
-
-      raise InvalidColorError unless found_colour.present?
-
-      HexConverter.hex_to_rgba(found_colour)
-    end
-
-    # this is a checking for a direct naming match against the ColorSwatchCollection
-    def self.match_name_from_palettes(colour_name)
-      ::ColorSwatchCollection.get_from_name(colour_name).dig(:hex)
-    end
-
-    def self.add_colour_distances_to_collection(collection_colours, source_colour)
-      collection_colours.map do |swatch|
-        swatch[:distance] = self.distance_between_colours(ColorConverters::Color.new(swatch.dig(:hex)), source_colour)
-      end
-
-      collection_colours
-    end
-
-    def self.distance_between_colours(comparison_colour, source_colour)
-      # https://en.wikipedia.org/wiki/Euclidean_distance#Higher_dimensions
-      # https://www.baeldung.com/cs/compute-similarity-of-colours
-      # TODO: allow the type of matching to be set via config. Use HSL for now as it's far faster than CIELab
-      conversion_1 = comparison_colour.hsl
-      conversion_2 = source_colour.hsl
-
-      keys = conversion_1.keys
-      Math.sqrt((conversion_1[keys[0]] - conversion_2[keys[0]])**2 + (conversion_1[keys[1]] - conversion_2[keys[1]])**2 + (conversion_1[keys[2]] - conversion_2[keys[2]])**2)
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'color_swatch_collection'
+
+module ColorConverters
+  class NameConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(String)
+
+      !colour_input.include?('#') && !colour_input.include?('rgb') && !colour_input.include?('hsl')
+    end
+
+    def self.rgb_to_name(rgb_array, fuzzy = false)
+      if fuzzy
+        source_colour = ColorConverters::Color.new({ r: rgb_array[0], g: rgb_array[1], b: rgb_array[2] })
+
+        collection_colours = []
+
+        ::ColorSwatchCollection.list_collections.each do |collection_name|
+          collection_colours += self.add_colour_distances_to_collection(Object.const_get("::ColorSwatchCollection::#{collection_name.capitalize}").colours, source_colour)
+        end
+
+        collection_colours.min_by { |swatch| swatch[:distance] }.dig(:name)
+      else
+        ::ColorSwatchCollection.get_from_hex(HexConverter.rgb_to_hex(rgb_array)).dig(:name)
+      end
+    end
+
+    private
+
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*CielchConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      self.class.match_name_from_palettes(colour_input).present? ? [] : ['name could not be found across colour collections']
+    end
+
+    def input_to_rgba(colour_input)
+      found_colour = self.class.match_name_from_palettes(colour_input) || ''
+
+      HexConverter.hex_to_rgba(found_colour) if found_colour.present?
+    end
+
+    # this is a checking for a direct naming match against the ColorSwatchCollection
+    def self.match_name_from_palettes(colour_name)
+      ::ColorSwatchCollection.get_from_name(colour_name).dig(:hex)
+    end
+
+    def self.add_colour_distances_to_collection(collection_colours, source_colour)
+      collection_colours.map do |swatch|
+        swatch[:distance] = self.distance_between_colours(ColorConverters::Color.new(swatch.dig(:hex)), source_colour)
+      end
+
+      collection_colours
+    end
+
+    def self.distance_between_colours(comparison_colour, source_colour)
+      # https://en.wikipedia.org/wiki/Euclidean_distance#Higher_dimensions
+      # https://www.baeldung.com/cs/compute-similarity-of-colours
+      # TODO: allow the type of matching to be set via config. Use HSL for now as it's far faster than CIELab
+      conversion_1 = comparison_colour.hsl
+      conversion_2 = source_colour.hsl
+
+      keys = conversion_1.keys
+      Math.sqrt((conversion_1[keys[0]] - conversion_2[keys[0]])**2 + (conversion_1[keys[1]] - conversion_2[keys[1]])**2 + (conversion_1[keys[2]] - conversion_2[keys[2]])**2)
+    end
+  end
+end

data/lib/color_converters/converters/null_converter.rb

@@ -1,19 +1,23 @@
-# frozen_string_literal: true
-
-module ColorConverters
-  class NullConverter < BaseConverter
-    def self.matches?(_colour_input)
-      true
-    end
-
-    private
-
-    def validate_input(_colour_input)
-      ['did not recognise colour input']
-    end
-
-    def input_to_rgba(_colour_input)
-      raise InvalidColorError
-    end
-  end
-end
+# frozen_string_literal: true
+
+module ColorConverters
+  class NullConverter < BaseConverter
+    def self.matches?(_colour_input)
+      true
+    end
+
+    private
+
+    # def clamp_input(colour_input)
+    #   colour_input
+    # end
+
+    def validate_input(_colour_input)
+      ['did not recognise colour input']
+    end
+
+    def input_to_rgba(_colour_input)
+      raise InvalidColorError
+    end
+  end
+end

data/lib/color_converters/converters/oklab_converter.rb

@@ -1,102 +1,106 @@
-# frozen_string_literal: true
-
-module ColorConverters
-  class OklabConverter < 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 == '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(colour_input)
-      OklabConverter.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 = OklabConverter.oklab_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.oklab_to_xyz(colour_input)
-      l = colour_input[:l].to_d
-      a = colour_input[:a].to_d
-      b = colour_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.0.to_d
-      m_lms **= 3.0.to_d
-      s_lms **= 3.0.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
-
-      cube_root = (1.0.to_d / 3.0.to_d)
-      l_lms **= cube_root
-      m_lms **= cube_root
-      s_lms **= cube_root
-
-      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
+# frozen_string_literal: true
+
+module ColorConverters
+  class OklabConverter < 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 == 'ok'
+    end
+
+    def self.bounds
+      { l: [0.0, 100.0], a: [-0.5, 0.5], b: [-0.5, 0.5] }
+    end
+
+    private
+
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*OklabConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      OklabConverter.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 = OklabConverter.oklab_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.oklab_to_xyz(colour_input)
+      l = colour_input[:l].to_d
+      a = colour_input[:a].to_d
+      b = colour_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.0.to_d
+      m_lms **= 3.0.to_d
+      s_lms **= 3.0.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
+
+      cube_root = (1.0.to_d / 3.0.to_d)
+      l_lms **= cube_root
+      m_lms **= cube_root
+      s_lms **= cube_root
+
+      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

@@ -1,61 +1,65 @@
-# frozen_string_literal: true
-
-module ColorConverters
-  class OklchConverter < BaseConverter
-    def self.matches?(colour_input)
-      return false unless colour_input.is_a?(Hash)
-
-      colour_input.keys - [:l, :c, :h, :space] == [] && colour_input[:space].to_s == 'ok'
-    end
-
-    def self.bounds
-      { l: [0.0, 100.0], c: [0.0, 500.0], h: [0.0, 360.0] }
-    end
-
-    private
-
-    def validate_input(colour_input)
-      OklchConverter.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)
-      l, a, b = OklchConverter.oklch_to_oklab(colour_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.oklch_to_oklab(colour_input)
-      l = colour_input[:l].to_d
-      c = colour_input[:c].to_d
-      h = colour_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.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.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
+# frozen_string_literal: true
+
+module ColorConverters
+  class OklchConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:l, :c, :h, :space] == [] && colour_input[:space].to_s == 'ok'
+    end
+
+    def self.bounds
+      { l: [0.0, 100.0], c: [0.0, 500.0], h: [0.0, 360.0] }
+    end
+
+    private
+
+    # def clamp_input(colour_input)
+    #   colour_input.each { |key, value| colour_input[key] = value.clamp(*OklchConverter.bounds[key]) }
+    # end
+
+    def validate_input(colour_input)
+      OklchConverter.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)
+      l, a, b = OklchConverter.oklch_to_oklab(colour_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.oklch_to_oklab(colour_input)
+      l = colour_input[:l].to_d
+      c = colour_input[:c].to_d
+      h = colour_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.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.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