red-colors 0.1.0

data/lib/colors/helper.rb

@@ -0,0 +1,17 @@
+module Colors
+  module Helper
+    private def check_type(obj, type, name)
+      return obj if obj.instance_of?(type)
+      check_fail TypeError, "#{name} must be a #{type}, but #{obj.class} is given"
+    end
+
+    private def check_range(value, range, name)
+      return value if range.cover?(value)
+      check_fail ArgumentError, "#{name} must be in #{range}, but #{value} is given"
+    end
+
+    private def check_fail(exc_class, message)
+      raise exc_class, message, caller(2)
+    end
+  end
+end

data/lib/colors/hsl.rb

@@ -0,0 +1,128 @@
+module Colors
+  class HSL < AbstractColor
+    include Helper
+
+    def initialize(h, s, l)
+      @h, @s, @l = canonicalize(h, s, l)
+    end
+
+    attr_reader :h, :s, :l
+
+    def components
+      [h, s, l]
+    end
+
+    alias hsl_components components
+
+    def h=(h)
+      @h = Rational(h) % 360
+    end
+
+    def s=(s)
+      @s = if s.instance_of?(Integer)
+             check_range(s, 0..255, :s) / 255r
+           else
+             Rational(check_range(s, 0..1, :s))
+           end
+    end
+
+    def l=(l)
+      @l = if l.instance_of?(Integer)
+             check_range(l, 0..255, :l) / 255r
+           else
+             Rational(check_range(l, 0..1, :l))
+           end
+    end
+
+    alias hue h
+    alias saturation s
+    alias lightness l
+
+    alias hue= h=
+    alias saturation= s=
+    alias lightness= l=
+
+    def ==(other)
+      case other
+      when HSLA
+        other == self
+      when HSL
+        h == other.h && s == other.s && l == other.l
+      else
+        super
+      end
+    end
+
+    def desaturate(factor)
+      HSL.new(h, s*factor, l)
+    end
+
+    def to_hsl
+      self
+    end
+
+    def to_hsla(alpha: 1.0)
+      alpha = canonicalize_component(alpha, :alpha)
+      HSLA.new(h, s, l, alpha)
+    end
+
+    def to_rgb
+      RGB.new(*rgb_components)
+    end
+
+    def to_rgba(alpha: 1.0)
+      alpha = canonicalize_component(alpha, :alpha)
+      RGBA.new(*rgb_components, alpha)
+    end
+
+    def rgb_components
+      t2 = if l <= 0.5r
+             l * (s + 1r)
+           else
+             l + s - l * s
+           end
+      t1 = l * 2r - t2
+      hh = h/60r
+      r = hue_to_rgb(t1, t2, hh + 2)
+      g = hue_to_rgb(t1, t2, hh)
+      b = hue_to_rgb(t1, t2, hh - 2)
+      [r, g, b]
+    end
+
+    private def hue_to_rgb(t1, t2, h)
+      h += 6r if h < 0
+      h -= 6r if h >= 6
+      if h < 1
+        (t2 - t1) * h + t1
+      elsif h < 3
+        t2
+      elsif h < 4
+        (t2 - t1) * (4r - h) + t1
+      else
+        t1
+      end
+    end
+
+    private def canonicalize(h, s, l)
+      if [s, l].map(&:class) == [Integer, Integer]
+        canonicalize_from_integer(h, s, l)
+      else
+        [
+          Rational(h) % 360,
+          canonicalize_component_to_rational(s, :s),
+          canonicalize_component_to_rational(l, :l)
+        ]
+      end
+    end
+
+    private def canonicalize_from_integer(h, s, l)
+      check_type(s, Integer, :s)
+      check_type(l, Integer, :l)
+      [
+        Rational(h) % 360,
+        canonicalize_component_from_integer(s, :s),
+        canonicalize_component_from_integer(l, :l)
+      ]
+    end
+  end
+end

data/lib/colors/hsla.rb

@@ -0,0 +1,81 @@
+module Colors
+  class HSLA < HSL
+    def initialize(h, s, l, a)
+      @h, @s, @l, @a = canonicalize(h, s, l, a)
+    end
+
+    include AlphaComponent
+
+    def components
+      [h, s, l, a]
+    end
+
+    alias hsla_components components
+
+    def ==(other)
+      case other
+      when HSLA
+        h == other.h && s == other.s && l == other.l && a == other.a
+      when HSL
+        h == other.h && s == other.s && l == other.l && a == 1r
+      else
+        super
+      end
+    end
+
+    def desaturate(factor)
+      HSLA.new(h, s*factor, l, a)
+    end
+
+    def to_hsla
+      self
+    end
+
+    def to_rgba
+      RGBA.new(*rgb_components, a)
+    end
+
+    def to_hsl
+      if a == 1r
+        super
+      else
+        raise NotImplementedError,
+              "Unable to convert non-opaque HSLA to HSL"
+      end
+    end
+
+    def to_rgb
+      if a == 1r
+        super
+      else
+        raise NotImplementedError,
+              "Unable to convert non-opaque HSLA to RGB"
+      end
+    end
+
+    private def canonicalize(h, s, l, a)
+      if [s, l, a].map(&:class) == [Integer, Integer, Integer]
+        canonicalize_from_integer(h, s, l, a)
+      else
+        [
+          Rational(h) % 360,
+          canonicalize_component_to_rational(s, :s),
+          canonicalize_component_to_rational(l, :l),
+          canonicalize_component_to_rational(a, :a)
+        ]
+      end
+    end
+
+    private def canonicalize_from_integer(h, s, l, a)
+      check_type(s, Integer, :s)
+      check_type(l, Integer, :l)
+      check_type(a, Integer, :a)
+      [
+        Rational(h) % 360,
+        canonicalize_component_from_integer(s, :s),
+        canonicalize_component_from_integer(l, :l),
+        canonicalize_component_from_integer(a, :a)
+      ]
+    end
+  end
+end

data/lib/colors/husl.rb

@@ -0,0 +1,144 @@
+require "numo/narray"
+
+module Colors
+  # Human-friendly alternative to HSL color space.
+  # The definition of HUSL is provided in <http://www.hsluv.org>.
+  class HUSL < HSL
+    DEG2RAD = 0.01745329251994329577r  # 2 * pi / 360
+
+    def self.from_rgb(r, g, b)
+      c = XYZ.from_rgb(r, g, b)
+      l, u, v = c.luv_components(WHITE_POINT_D65)
+      l, c, h = convert_luv_to_lch(l, u, v)
+      h, s, l = convert_lch_to_husl(l, c, h)
+      new(h, s.to_r.clamp(0r, 1r), l.to_r.clamp(0r, 1r))
+    end
+
+    private_class_method def self.convert_luv_to_lch(l, u, v)
+      c = Math.sqrt(u*u + v*v).to_r
+
+      if c < 1e-8
+        h = 0r
+      else
+        h = Math.atan2(v, u).to_r * 180/Math::PI.to_r
+        h += 360r if h < 0
+      end
+
+      [l, c, h]
+    end
+
+    private_class_method def self.convert_lch_to_husl(l, c, h)
+      if l > 99.9999999 || l < 1e-8
+        s = 0r
+      else
+        mx = max_chroma(l, h)
+        s = c / mx * 100r
+      end
+
+      h = 0r if c < 1e-8
+
+      [h, s/100r, l/100r]
+    end
+
+    def ==(other)
+      case other
+      when HUSL
+        h == other.h && s == other.s && l == other.l
+      else
+        other == self
+      end
+    end
+
+    def desaturate(factor)
+      to_rgb.desaturate(factor).to_husl
+    end
+
+    def to_husl
+      self
+    end
+
+    def to_rgb
+      RGB.new(*rgb_components)
+    end
+
+    def rgb_components
+      l, u, v = convert_lch_to_luv(*lch_components)
+      x, y, z = convert_luv_to_xyz(l, u, v)
+      XYZ.new(x, y, z).rgb_components
+    end
+
+    def lch_components
+      l = self.l * 100r
+      s = self.s * 100r
+
+      if l > 99.9999999 || l < 1e-8
+        c = 0r
+      else
+        mx = self.class.max_chroma(l, h)
+        c = mx / 100r * s
+      end
+
+      h = s < 1e-8 ? 0r : self.h
+
+      [l, c, h]
+    end
+
+    private def convert_lch_to_luv(l, c, h)
+      h_rad = h * DEG2RAD
+      u = Math.cos(h_rad).to_r * c
+      v = Math.sin(h_rad).to_r * c
+      [l, u, v]
+    end
+
+    private def convert_luv_to_xyz(l, u, v)
+      return [0r, 0r, 0r] if l <= 1e-8
+
+      wp_u, wp_v = WHITE_POINT_D65.uv_values
+      var_u = u / (13 * l) + wp_u
+      var_v = v / (13 * l) + wp_v
+      y = if l < 8
+            l / XYZ::KAPPA
+          else
+            ((l + 16r) / 116r)**3
+          end
+      x = -(9 * y * var_u) / ((var_u - 4) * var_v - var_u * var_v)
+      z = (9 * y - (15 * var_v * y) - (var_v * x)) / (3 * var_v)
+      [x, y, z]
+    end
+
+    def self.max_chroma(l, h)
+      h_rad = h * DEG2RAD
+      sin_h = Math.sin(h_rad).to_r
+      cos_h = Math.cos(h_rad).to_r
+
+      result = Float::INFINITY
+      get_bounds(l).each do |line|
+        len = line[1] / (sin_h - line[0] * cos_h)
+        result = len if 0 <= len && len < result
+      end
+      result
+    end
+
+    def self.get_bounds(l)
+      sub1 = (l + 16)**3 / 1560896r
+      sub2 = sub1 > XYZ::EPSILON ? sub1 : l/XYZ::KAPPA
+
+      bounds = Array.new(6) { [0r, 0r] }
+      0.upto(2) do |ch|
+        m1 = XYZ2RGB[ch, 0].to_r
+        m2 = XYZ2RGB[ch, 1].to_r
+        m3 = XYZ2RGB[ch, 2].to_r
+
+        [0, 1].each do |t|
+          top1 = (284517r * m1 - 94839r * m3) * sub2
+          top2 = (838422r * m3 + 769860r * m2 + 731718r * m1) * l * sub2 - 769860r * t * l
+          bottom = (632260r * m3 - 126452r * m2) * sub2 + 126452r * t
+
+          bounds[ch*2 + t][0] = top1 / bottom
+          bounds[ch*2 + t][1] = top2 / bottom
+        end
+      end
+      bounds
+    end
+  end
+end

data/lib/colors/named_colors.rb

@@ -0,0 +1,114 @@
+require_relative 'color_data'
+
+module Colors
+  module NamedColors
+    class Mapping
+      def initialize
+        @mapping = {}
+        @cache = {}
+      end
+
+      attr_reader :cache
+
+      def [](name)
+        if NamedColors.nth_color?(name)
+          cycle = ColorData::DEFAULT_COLOR_CYCLE
+          name = cycle[name[1..-1].to_i % cycle.length]
+        end
+        if cache.has_key?(name)
+          cache[name]
+        else
+          cache[name] = lookup_no_color_cycle(name)
+        end
+      end
+
+      private def lookup_no_color_cycle(color)
+        orig_color = color
+        case color
+        when /\Anone\z/i
+          return RGBA.new(0, 0, 0, 0)
+        when String
+          # nothing to do
+        when Symbol
+          color = color.to_s
+        else
+          color = color.to_str
+        end
+        color = @mapping.fetch(color, color)
+        case color
+        when /\A#\h+\z/
+          case color.length - 1
+          when 3, 6
+            RGB.parse(color)
+          when 4, 8
+            RGBA.parse(color)
+          else
+            raise RuntimeError,
+                  "[BUG] Invalid hex string form #{color.inspect} for #{name.inspect}"
+          end
+        when Array
+          case color.length
+          when 3
+            RGB.new(*color)
+          when 4
+            RGBA.new(*color)
+          else
+            raise RuntimeError,
+                  "[BUG] Invalid number of color components #{color} for #{name.inspect}"
+          end
+        else
+          color
+        end
+      end
+
+      def []=(name, value)
+        @mapping[name] = value
+      ensure
+        cache.clear
+      end
+
+      def delete(name)
+        @mapping.delete(name)
+      ensure
+        cache.clear
+      end
+
+      def update(other)
+        @mapping.update(other)
+      ensure
+        cache.clear
+      end
+    end
+
+    MAPPING = Mapping.new
+    MAPPING.update(ColorData::XKCD_COLORS)
+    ColorData::XKCD_COLORS.each do |key, value|
+      MAPPING[key.sub("grey", "gray")] = value if key.include? "grey"
+    end
+    MAPPING.update(ColorData::CSS4_COLORS)
+    MAPPING.update(ColorData::TABLEAU_COLORS)
+    ColorData::TABLEAU_COLORS.each do |key, value|
+      MAPPING[key.sub("gray", "grey")] = value if key.include? "gray"
+    end
+    MAPPING.update(ColorData::BASE_COLORS)
+
+    def self.[](name)
+      MAPPING[name]
+    end
+
+    # Return whether `name` is an item in the color cycle.
+    def self.nth_color?(name)
+      case name
+      when String
+        # do nothing
+      when Symbol
+        name = name.to_s
+      else
+        name = name.to_str
+      end
+      name.match?(/\AC\d+\z/)
+    rescue NoMethodError, TypeError
+      false
+    end
+  end
+end