color_converters 0.1.2 → 0.1.4

data/lib/color_converters/converters/name_converter.rb

@@ -1,183 +1,67 @@
-module ColorConverters
-  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) #
-      # TODO: validate against list of keys?
-      true
-    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
+# 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

data/lib/color_converters/converters/null_converter.rb

@@ -1,17 +1,19 @@
-module ColorConverters
-  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
+# 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

data/lib/color_converters/converters/oklab_converter.rb

@@ -0,0 +1,102 @@
+# 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

data/lib/color_converters/converters/oklch_converter.rb

@@ -0,0 +1,61 @@
+# 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

data/lib/color_converters/converters/rgb_converter.rb

@@ -1,29 +1,109 @@
-module ColorConverters
-  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
+# frozen_string_literal: true
+
+module ColorConverters
+  class RgbConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(Hash)
+
+      colour_input.keys - [:r, :g, :b] == [] || colour_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], a: [0.0, 1.0] }
+    end
+
+    private
+
+    def validate_input(colour_input)
+      RgbConverter.bounds.collect do |key, range|
+        "#{key} must be between #{range[0]} and #{range[1]}" unless colour_input[key].to_f.between?(*range)
+      end.compact
+    end
+
+    def input_to_rgba(colour_input)
+      r = colour_input[:r].to_f
+      g = colour_input[:g].to_f
+      b = colour_input[:b].to_f
+      a = (colour_input[:a] || 1.0).to_f
+
+      [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 colour 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 colour 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 colour 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

@@ -1,32 +1,49 @@
-module ColorConverters
-  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
-    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
+# frozen_string_literal: true
+
+module ColorConverters
+  class RgbStringConverter < BaseConverter
+    def self.matches?(colour_input)
+      return false unless colour_input.is_a?(String)
+
+      colour_input.include?('rgb(') || colour_input.include?('rgba(')
+    end
+
+    def self.bounds
+      RgbConverter.bounds
+    end
+
+    private
+
+    def validate_input(colour_input)
+      keys = colour_input.include?('rgba(') ? [:r, :g, :b, :a] : [:r, :g, :b]
+      colour_input = RgbStringConverter.sanitize_input(colour_input)
+
+      errors = keys.collect do |key|
+        "#{key} must be present" if colour_input[key].blank?
+      end.compact
+
+      return errors if errors.present?
+
+      RgbStringConverter.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)
+      colour_input = RgbStringConverter.sanitize_input(colour_input)
+
+      r = colour_input[:r].to_f
+      g = colour_input[:g].to_f
+      b = colour_input[:b].to_f
+      a = (colour_input[:a] || 1.0).to_f
+
+      [r, g, b, a]
+    end
+
+    def self.sanitize_input(colour_input)
+      matches = colour_input.match(/rgba?\(([0-9.,%\s]+)\)/) || []
+      r, g, b, a = matches[1]&.split(',')&.map(&:strip)
+      { r: r, g: g, b: b, a: a }
+    end
+  end
+end