red-colors 0.1.0 → 0.3.0

data/lib/colors/linear_segmented_colormap.rb

@@ -0,0 +1,137 @@
+module Colors
+  class LinearSegmentedColormap < Colormap
+    def initialize(name, segmented_data, n_colors: 256, gamma: 1.0)
+      super(name, n_colors)
+
+      @monochrome = false
+      @segmented_data = segmented_data
+      @gamma = gamma
+    end
+
+    attr_reader :segmented_data, :gamma
+
+    def self.new_from_list(name, colors, n_colors: 256, gamma: 1.0)
+      case colors
+      when Enumerable
+        colors = colors.to_a
+      else
+        ary = Array.try_convert(colors)
+        if ary.nil?
+          raise ArgumentError, "colors must be convertible to an array: %p for %s" % [colors, name]
+        else
+          colors = ary
+        end
+      end
+
+      case colors[0]
+      when Array
+        unless colors.all? {|a| a.length == 2 }
+          raise ArgumentError, "colors array has invalid items" 
+        end
+        vals, colors = colors.transpose
+      else
+        vals = Utils.linspace(0r, 1r, colors.length)
+      end
+
+      r, g, b, a = colors.map { |c|
+        Utils.make_color(c).to_rgba.components
+      }.transpose
+
+      segmented_data = {
+        red:   [vals, r, r].transpose,
+        green: [vals, g, g].transpose,
+        blue:  [vals, b, b].transpose,
+        alpha: [vals, a, a].transpose
+      }
+
+      new(name, segmented_data, n_colors: n_colors, gamma: gamma)
+    end
+
+    def gamma=(val)
+      @gamma = val
+      @initialized = false
+    end
+
+    private def init_colormap
+      red = create_lookup_table(self.n_colors, @segmented_data[:red], @gamma)
+      green = create_lookup_table(self.n_colors, @segmented_data[:green], @gamma)
+      blue = create_lookup_table(self.n_colors, @segmented_data[:blue], @gamma)
+      alpha = if @segmented_data.key?(:alpha)
+                create_lookup_table(self.n_colors, @segmented_data[:alpha], @gamma)
+              end
+      @lookup_table = Array.new(self.n_colors) do |i|
+        Colors::RGBA.new(red[i], green[i], blue[i], alpha ? alpha[i] : 1r)
+      end
+      @initialized = true
+      update_extreme_colors
+    end
+
+    private def create_lookup_table(n, data, gamma=1.0)
+      if data.respond_to?(:call)
+        xind = Utils.linspace(0r, 1r, n).map {|x| x ** gamma }
+        lut = xind.map {|i| data.(i).clamp(0, 1).to_f }
+        return lut
+      end
+
+      ary = Array.try_convert(data)
+      if ary.nil?
+        raise ArgumentError, "data must be convertible to an array"
+      elsif ary.any? {|sub| sub.length != 3 }
+        raise ArgumentError, "data array must consist of 3-length arrays"
+      end
+
+      shape = [ary.length, 3]
+
+      x, y0, y1 = ary.transpose
+
+      if x[0] != 0.0 || x[-1] != 1.0
+        raise ArgumentError,
+              "data mapping points must start with x=0 and end with x=1"
+      end
+
+      unless x.each_cons(2).all? {|a, b| a < b }
+        raise ArgumentError,
+              "data mapping points must have x in increasing order"
+      end
+
+      if n == 1
+        # Use the `y = f(x=1)` value for a 1-element lookup table
+        lut = [y0[-1]]
+      else
+        x.map! {|v| v.to_f * (n - 1) }
+        xind = Utils.linspace(0r, 1r, n).map {|i| (n - 1) * i ** gamma }
+        ind = (0 ... n).map {|i| x.find_index {|v| xind[i] < v } }[1 ... -1]
+
+        distance = ind.map.with_index do |i, j|
+          (xind[j+1] - x[i - 1]) / (x[i] - x[i - 1])
+        end
+
+        lut = [
+          y1[0],
+          *ind.map.with_index {|i, j| distance[j] * (y0[i] - y1[i - 1]) + y1[i - 1] },
+          y0[-1]
+        ]
+      end
+
+      return lut.map {|v| v.clamp(0, 1).to_f }
+    end
+
+    private def make_reverse_colormap(name)
+      segmented_data_r = self.segmented_data.map { |key, data|
+        data_r = if data.respond_to?(:call)
+                   make_inverse_func(data)
+                 else
+                   data.reverse_each.map do |x, y0, y1|
+                     [1r - x, y1, y0]
+                   end
+                 end
+        [key, data_r]
+      }.to_h
+      LinearSegmentedColormap.new(name, segmented_data_r, n_colors: self.n_colors, gamma: self.gamma)
+    end
+
+    private def make_inverse_func(f)
+      ->(x) { f(1 - x) }
+    end
+  end
+end

data/lib/colors/listed_colormap.rb

@@ -0,0 +1,45 @@
+module Colors
+  class ListedColormap < Colormap
+    def initialize(colors, name: :from_list, n_colors: nil)
+      @monochrome = false
+      if n_colors.nil?
+        @colors = Array.try_convert(colors)
+        n_colors = @colors.length
+      else
+        case colors
+        when String, Symbol
+          @colors = Array.new(n_colors) { colors }
+          @monochrome = true
+        when Enumerable
+          @colors = colors.cycle.take(n_colors)
+          @monochrome = @colors.all? {|x| x == @colors[0] }
+        else
+          begin
+            gray = Float(colors)
+          rescue TypeError, ArgumentError
+            raise ArgumentError,
+                  "invalid value for `colors` (%p)" % colors
+          else
+            @colors = Array.new(n_colors) { gray }
+          end
+          @monochrome = true
+        end
+      end
+      @colors.freeze
+
+      super(name, n_colors)
+    end
+
+    attr_reader :colors
+
+    private def init_colormap
+      @lookup_table = self.colors.map {|color| Utils.make_color(color).to_rgba }
+      @initialized = true
+      update_extreme_colors
+    end
+
+    private def make_reverse_colormap(name)
+      ListedColormap.new(self.colors.reverse, name: name, n_colors: self.n_colors)
+    end
+  end
+end

data/lib/colors/named_colors.rb

@@ -1,5 +1,3 @@
-require_relative 'color_data'
-
 module Colors
   module NamedColors
     class Mapping
@@ -8,33 +6,26 @@ module Colors
         @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
+        @cache[name] ||= lookup_no_color_cycle(name)
       end
 
-      private def lookup_no_color_cycle(color)
-        orig_color = color
-        case color
+      private def lookup_no_color_cycle(name)
+        case name
         when /\Anone\z/i
           return RGBA.new(0, 0, 0, 0)
         when String
           # nothing to do
         when Symbol
-          color = color.to_s
+          name = name.to_s
         else
-          color = color.to_str
+          name = name.to_str
         end
-        color = @mapping.fetch(color, color)
+        color = @mapping.fetch(name, name)
         case color
         when /\A#\h+\z/
           case color.length - 1
@@ -64,19 +55,19 @@ module Colors
       def []=(name, value)
         @mapping[name] = value
       ensure
-        cache.clear
+        @cache.clear
       end
 
       def delete(name)
         @mapping.delete(name)
       ensure
-        cache.clear
+        @cache.clear
       end
 
       def update(other)
         @mapping.update(other)
       ensure
-        cache.clear
+        @cache.clear
       end
     end
 
@@ -104,11 +95,10 @@ module Colors
       when Symbol
         name = name.to_s
       else
+        return false unless name.respond_to?(:to_str)
         name = name.to_str
       end
       name.match?(/\AC\d+\z/)
-    rescue NoMethodError, TypeError
-      false
     end
   end
 end

data/lib/colors/rgb.rb

@@ -1,22 +1,25 @@
-require_relative 'helper'
-
 module Colors
   class RGB < AbstractColor
     include Helper
 
     def self.parse(hex_string)
-      case hex_string.to_str.match(/\A#(\h+)\z/) { $1 }.length
+      error_message = "must be a hexadecimal string of `#rrggbb` or `#rgb` form"
+      unless hex_string.respond_to?(:to_str)
+        raise ArgumentError, "#{error_message}: #{hex_string.inspect}"
+      end
+
+      hex_string = hex_string.to_str
+      hexes = hex_string.match(/\A#(\h+)\z/) { $1 }
+      case hexes&.length
       when 3  # rgb
-        r, g, b = hex_string.scan(/\h/).map {|h| h.hex * 17 }
+        r, g, b = hexes.scan(/\h/).map {|h| h.hex * 17 }
         new(r, g, b)
       when 6  # rrggbb
-        r, g, b = hex_string.scan(/\h{2}/).map(&:hex)
+        r, g, b = hexes.scan(/\h{2}/).map(&:hex)
         new(r, g, b)
       else
-        raise ArgumentError, "Invalid hex string: #{hex_string.inspect}"
+        raise ArgumentError, "#{error_message}: #{hex_string.inspect}"
       end
-    rescue NoMethodError
-      raise ArgumentError, "hex_string must be a hexadecimal string of `#rrggbb` or `#rgb` form"
     end
 
     def initialize(r, g, b)
@@ -112,11 +115,18 @@ module Colors
     end
 
     def to_husl
-      HUSL.from_rgb(r, g, b)
+      c = RGB.new(r, g, b).to_xyz
+      l, u, v = c.luv_components(WHITE_POINT_D65)
+      h, s, l = Convert.luv_to_husl(l, u, v)
+      HUSL.new(h, s.clamp(0r, 1r).to_r, l.clamp(0r, 1r).to_r)
     end
 
     def to_xyz
-      XYZ.from_rgb(r, g, b)
+      XYZ.new(*Convert.rgb_to_xyz(r, g, b))
+    end
+
+    def to_xterm256
+      Xterm256.new(*Convert.rgb_to_xterm256(r, g, b))
     end
 
     private def canonicalize(r, g, b)

data/lib/colors/rgba.rb

@@ -1,24 +1,30 @@
 module Colors
   class RGBA < RGB
     def self.parse(hex_string)
-      case hex_string.to_str.match(/\A#(\h+)\z/) { $1 }.length
+      error_message = "must be a hexadecimal string of " +
+                      "`#rrggbbaa`, `#rgba`, `#rrggbb` or `#rgb` form"
+      unless hex_string.respond_to?(:to_str)
+        raise ArgumentError, "#{error_message}: #{hex_string.inspect}"
+      end
+
+      hex_string = hex_string.to_str
+      hexes = hex_string.match(/\A#(\h+)\z/) { $1 }
+      case hexes&.length
       when 3  # rgb
-        r, g, b = hex_string.scan(/\h/).map {|h| h.hex * 17 }
+        r, g, b = hexes.scan(/\h/).map {|h| h.hex * 17 }
         new(r, g, b, 255)
       when 6  # rrggbb
-        r, g, b = hex_string.scan(/\h{2}/).map(&:hex)
+        r, g, b = hexes.scan(/\h{2}/).map(&:hex)
         new(r, g, b, 255)
       when 4 # rgba
-        r, g, b, a = hex_string.scan(/\h/).map {|h| h.hex * 17 }
+        r, g, b, a = hexes.scan(/\h/).map {|h| h.hex * 17 }
         new(r, g, b, a)
       when 8 # rrggbbaa
-        r, g, b, a = hex_string.scan(/\h{2}/).map(&:hex)
+        r, g, b, a = hexes.scan(/\h{2}/).map(&:hex)
         new(r, g, b, a)
       else
-        raise ArgumentError, "Invalid hex string: #{hex_string.inspect}"
+        raise ArgumentError, "#{error_message}: #{hex_string.inspect}"
       end
-    rescue NoMethodError
-      raise ArgumentError, "hex_string must be a hexadecimal string of `#rrggbb` or `#rgb` form"
     end
 
     def initialize(r, g, b, a)

data/lib/colors/utils.rb

@@ -0,0 +1,18 @@
+module Colors
+  module Utils
+    module_function def linspace(x0, x1, n)
+      Array.new(n) { |i|
+        x0 + i*(x1 - x0)/(n-1r)
+      }
+    end
+
+    module_function def make_color(value)
+      case value
+      when Colors::AbstractColor
+        value
+      else
+        Colors[value]
+      end
+    end
+  end
+end

data/lib/colors/version.rb

@@ -1,3 +1,3 @@
 module Colors
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/colors/xterm256.rb

@@ -0,0 +1,56 @@
+module Colors
+  class Xterm256 < AbstractColor
+    include Helper
+
+    def initialize(code)
+      unless 16 <= code && code <= 255
+        raise ArgumentError, "code should be in 16..255, but #{code} is given"
+      end
+      @code = code
+    end
+
+    attr_reader :code
+
+    def ==(other)
+      case other
+      when Xterm256
+        code == other.code
+      else
+        super
+      end
+    end
+
+    def to_rgb_components
+      if code < 232
+        x = code - 16
+        x, b = x.divmod(6)
+        r, g = x.divmod(6)
+        r = 40*r + 55 if r > 0
+        g = 40*g + 55 if g > 0
+        b = 40*b + 55 if b > 0
+        [
+          canonicalize_component_from_integer(r, :r),
+          canonicalize_component_from_integer(g, :r),
+          canonicalize_component_from_integer(b, :r)
+        ]
+      else
+        grey = to_grey_level
+        [grey, grey, grey]
+      end
+    end
+
+    def to_grey_level
+      if code < 232
+        r, g, b = to_rgb_components
+        x, y, z = Convet.rgb_to_xyz(r, g, b)
+      else
+        grey = 10*(code - 232) + 8
+        canonicalize_component_from_integer(grey, :grey)
+      end
+    end
+
+    def to_rgb
+      RGB.new(*to_rgb_components)
+    end
+  end
+end

data/lib/colors/xyy.rb

@@ -0,0 +1,48 @@
+module Colors
+  class XYY < AbstractColor
+    include Helper
+
+    def initialize(x, y, large_y)
+      @x, @y, @large_y = canonicalize(x, y, large_y)
+    end
+
+    attr_reader :x, :y, :large_y
+
+    def components
+      [x, y, large_y]
+    end
+
+    def ==(other)
+      case other
+      when XYY
+        x == other.x && y == other.y && large_y == other.large_y
+      else
+        super
+      end
+    end
+
+    def to_rgb
+      to_xyz.to_rgb
+    end
+
+    def rgb_components
+      to_xyz.rgb_components
+    end
+
+    def luv_components(wp)
+      to_xyz.luv_components(wp)
+    end
+
+    def to_xyz
+      XYZ.new(*Convert.xyy_to_xyz(*components))
+    end
+
+    private def canonicalize(x, y, large_y)
+      [
+        Rational(x),
+        Rational(y),
+        Rational(large_y)
+      ]
+    end
+  end
+end