red-colors 0.2.0 → 0.4.0

data/lib/colors/colormap_data/seaborn_builtin.rb

@@ -0,0 +1,10 @@
+module Colors
+  module ColormapRegistry
+    register_listed_colormap("rocket")
+    register_listed_colormap("mako")
+    register_listed_colormap("icefire")
+    register_listed_colormap("vlag")
+    register_listed_colormap("flare")
+    register_listed_colormap("crest")
+  end
+end

data/lib/colors/colormap_data.rb

@@ -0,0 +1,44 @@
+require "json"
+require "pathname"
+
+module Colors
+  module ColormapRegistry
+    BUILTIN_COLORMAPS = {}
+    LUT_SIZE = 512
+
+    top_dir = Pathname.new(__dir__).parent.parent
+    @colormaps_dir = top_dir.join("data", "colormaps")
+
+    def self.load_colormap_data(name)
+      path = @colormaps_dir.join("#{name}.json")
+      json = File.read(path)
+      JSON.load(json, nil, symbolize_names: true, create_additions: false)
+    end
+
+    def self.register_listed_colormap(name, data=nil)
+      data = load_colormap_data(name) if data.nil?
+      colors = data.map {|r, g, b| Colors::RGB.new(r, g, b) }
+      BUILTIN_COLORMAPS[name] = ListedColormap.new(colors, name: name)
+    end
+
+    require_relative "colormap_data/matplotlib_builtin.rb"
+    require_relative "colormap_data/seaborn_builtin.rb"
+
+    class << self
+      undef load_colormap_data
+      undef register_listed_colormap
+    end
+
+    # Generate reversed colormaps
+    cmaps_r = BUILTIN_COLORMAPS.each_value.map(&:reversed)
+    cmaps_r.each do |cmap_r|
+      BUILTIN_COLORMAPS[cmap_r.name] = cmap_r
+    end
+
+    BUILTIN_COLORMAPS.freeze
+
+    BUILTIN_COLORMAPS.each do |name, cmap|
+      @registry[name] = cmap
+    end
+  end
+end

data/lib/colors/colormap_registry.rb

@@ -0,0 +1,61 @@
+module Colors
+  module ColormapRegistry
+    @registry = {}
+
+    def self.[](name)
+      return name if name.is_a?(Colormap)
+
+      name = String.try_convert(name)
+      if @registry.key?(name)
+        return @registry[name]
+      else
+        raise ArgumentError, "Unknown colormap name: %p" % name
+      end
+    end
+
+    def self.register(cmap, name: nil, override_builtin: false)
+      case name
+      when String, Symbol
+        name = name.to_s
+      when nil
+        name = cmap.name
+        if name.nil?
+          raise ArgumentError, "`name` cannot be omitted for unnamed colormaps"
+        end
+      else
+        name = String.try_convert(name)
+        if name.nil?
+          raise ArgumentError, "`name` must be convertible to a String by to_str"
+        end
+      end
+
+      if @registry.key?(name)
+        if BUILTIN_COLORMAPS.key?(name)
+          unless override_builtin
+            raise ArgumentError,
+                  "Trying to re-register a builtin colormap: %p" % name
+          end
+        end
+        warn "Trying to re-register the colormap %p which already exists" % name
+      end
+
+      unless cmap.is_a?(Colormap)
+        raise ArgumentError,
+              "Invalid value for registering a colormap (%p for a Colormap)" % cmap
+      end
+
+      @registry[name] = cmap
+    end
+
+    def self.unregister(name)
+      if @registry.key?(name)
+        if BUILTIN_COLORMAPS.key?(name)
+          raise ArgumentError,
+                "Unable to unregister the colormap %p which is a builtin colormap" % name
+        end
+      else
+        @registry.delete(name)
+      end
+    end
+  end
+end

data/lib/colors/convert.rb

@@ -150,6 +150,12 @@ module Colors
       dot_product(RGB2XYZ, srgb_to_linear_srgb(r, g, b))
     end
 
+    def rgb_to_greyscale(r, g, b)
+      r, g, b = srgb_to_linear_srgb(r, g, b)
+      a = RGB2XYZ[1]
+      (a[0]*r + a[1]*g + a[2]*b).clamp(0, 1)
+    end
+
     def rgb_to_xterm256(r, g, b)
       i = closest_xterm256_rgb_index(r)
       j = closest_xterm256_rgb_index(g)

data/lib/colors/css.rb

@@ -0,0 +1,63 @@
+module Colors
+  module CSS
+    # Factory method for generating RGB/RGBA/HSL/HSLA Objects.
+    # Parsing based on spec https://www.w3.org/TR/css-color-3 ; section 4.2
+    def self.parse(css_string)
+      error_message = "must be a string of `rgb(rr,gg,bb)`, `rgba(rr,gg,bb,aa)`, `hsl(hh,ss,ll)`, or `hsla(hh,ss,ll,aa)` form"
+      unless css_string.respond_to?(:to_str)
+        raise ArgumentError, "#{error_message}: #{css_string.inspect}"
+      end
+
+      css_string = css_string.to_str.strip
+
+      matcher = /\A((?:rgb|hsl)a?)\(([^)]+)\)\z/.match(css_string)
+      unless matcher
+        raise ArgumentError, "#{error_message}: #{css_string.inspect}"
+      end
+
+      color_space, args_string = matcher[1..2]
+      args = args_string.strip.split(/\s*,\s*/)
+      has_alpha = color_space.end_with?("a") # rgba/hsla
+      if has_alpha && args.length != 4
+        raise ArgumentError, "Expecting 4 fields for #{color_space}(): #{css_string.inspect}"
+      elsif !has_alpha && args.length != 3
+        raise ArgumentError, "Expecting 3 fields for #{color_space}(): #{css_string.inspect}"
+      end
+
+      case color_space
+      when "rgb", "rgba"
+        rgb, alpha = args[0, 3], args[3]
+        num_percent_vals = rgb.count {|v| v.end_with?("%") }
+        # CSS3 allows RGB values to be specified with all 3 as a percentage "##%"
+        # or all as integer values without '%' sign.
+        if num_percent_vals.zero?
+          # interpret as integer values in range of 0..255
+          r, g, b = rgb.map {|strval| strval.to_i.clamp(0, 255) }
+          # Note, RGBA.new expects all values to be integers or floats.
+          # For this case, we also turn the alpha-value into an int range 0..255
+          # to match the r,g,b values.
+          a = has_alpha && (alpha.to_r.clamp(0r, 1r) * 255).to_i
+        elsif num_percent_vals == 3
+          r, g, b = rgb.map {|strval| (strval.to_r / 100).clamp(0r, 1r) }
+          a = has_alpha && alpha.to_r.clamp(0r, 1r)
+        else
+          raise ArgumentError, "Invalid mix of percent and integer values: #{css_string.inspect}"
+        end
+        return has_alpha ? RGBA.new(r, g, b, a) : RGB.new(r, g, b)
+      when "hsl", "hsla"
+        hue, sat, light, alpha = *args
+        # CSS3 Hue values are an angle, unclear if we should convert to Integer or Rational here.
+        h = hue.to_r
+        s, l = [sat, light].map {|strval| (strval.to_r / 100).clamp(0r, 1r) }
+        if has_alpha
+          a = alpha.to_r.clamp(0r, 1r)
+          return HSLA.new(h, s, l, a)
+        else
+          return HSL.new(h, s, l)
+        end
+      else
+        raise ArgumentError, "Unknown color space: #{css_string.inspect}"
+      end
+    end
+  end
+end

data/lib/colors/helper.rb

@@ -7,7 +7,8 @@ module Colors
 
     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"
+      check_fail ArgumentError,
+                 "#{name} must be in #{range}, but %p is given" % value
     end
 
     private def check_fail(exc_class, message)

data/lib/colors/linear_segmented_colormap.rb

@@ -17,7 +17,7 @@ module Colors
       else
         ary = Array.try_convert(colors)
         if ary.nil?
-          raise ArgumentError, "colors must be convertible to an array"
+          raise ArgumentError, "colors must be convertible to an array: %p for %s" % [colors, name]
         else
           colors = ary
         end
@@ -80,8 +80,6 @@ module Colors
         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
@@ -115,5 +113,23 @@ module Colors
 
       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

@@ -37,5 +37,9 @@ module Colors
       @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/version.rb

@@ -1,3 +1,3 @@
 module Colors
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/colors/xterm256.rb

@@ -42,7 +42,8 @@ module Colors
     def to_grey_level
       if code < 232
         r, g, b = to_rgb_components
-        x, y, z = Convet.rgb_to_xyz(r, g, b)
+        y = Convert.rgb_to_greyscale(r, g, b)
+        canonicalize_component_to_rational(y, :grey)
       else
         grey = 10*(code - 232) + 8
         canonicalize_component_from_integer(grey, :grey)

data/lib/colors.rb

@@ -4,6 +4,7 @@ require_relative "colors/convert"
 require_relative "colors/helper"
 
 require_relative "colors/abstract_color"
+require_relative "colors/css"
 require_relative "colors/hsl"
 require_relative "colors/hsla"
 require_relative "colors/husl"
@@ -19,6 +20,7 @@ require_relative "colors/named_colors"
 require_relative "colors/colormap"
 require_relative "colors/listed_colormap"
 require_relative "colors/linear_segmented_colormap"
+require_relative "colors/colormap_registry"
 
 module Colors
   # ITU-R BT.709 D65 white point
@@ -37,3 +39,5 @@ module Colors
     NamedColors[name]
   end
 end
+
+require_relative "colors/colormap_data"

data/red-colors.gemspec

@@ -27,11 +27,13 @@ Gem::Specification.new do |spec|
     "#{spec.name}.gemspec",
   ]
   spec.files += [".yardopts"]
+  spec.files += Dir.glob("data/colormaps/*.json")
   spec.files += Dir.glob("lib/**/*.rb")
   spec.files += Dir.glob("image/*.*")
   spec.files += Dir.glob("doc/text/*")
   spec.test_files += Dir.glob("test/**/*")
 
+  spec.add_runtime_dependency("json")
   spec.add_runtime_dependency("matrix")
 
   spec.add_development_dependency("bundler")

data/test/run.rb

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
-# TODO
-# $VERBOSE = true
+$VERBOSE = true
 
 require "pathname"
 

data/test/test-css.rb

@@ -0,0 +1,174 @@
+class ColorsCSSParserTest < Test::Unit::TestCase
+  include TestHelper
+
+  sub_test_case("rgb") do
+    test("simple in-range integer values") do
+      ref = Colors::RGB.new(1, 0, 255)
+      css = Colors::CSS.parse("rgb(1,0,255)")
+      assert_near(ref, css)
+    end
+
+    test("clamps out-of-range integer values") do
+      ref = Colors::RGB.new(255, 0, 0)
+      css = Colors::CSS.parse("rgb(   300 ,0,0)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("rgb(   255 , -10,0)")
+      assert_near(ref, css)
+    end
+
+    test("in-range percent values") do
+      ref = Colors::RGB.new(0, 0.55, 1)
+      css = Colors::CSS.parse("rgb(0%,55%,100%)")
+      assert_near(ref, css)
+    end
+
+    test("clamps out-of-range percent values") do
+      ref = Colors::RGB.new(0r, 0r, 1r)
+      css = Colors::CSS.parse("rgb(0%,0%,110%)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("rgb(-10%,0%,100%)")
+      assert_near(ref, css)
+    end
+
+    test("bad input") do
+      assert_raises ArgumentError, "mixed pct/int" do
+        Colors::CSS.parse("rgb(50%,0 ,0)")
+      end
+      assert_raises ArgumentError, "too few args" do
+        Colors::CSS.parse("rgb(50%,0%)")
+      end
+      assert_raises ArgumentError, "too many args" do
+        Colors::CSS.parse("rgb(50%,0%,6%,0)")
+      end
+      assert_raises ArgumentError, "missing comma" do
+        Colors::CSS.parse("rgb(50% 0% 6%)")
+      end
+    end
+  end
+
+  sub_test_case("rgba") do
+    test("integer values, int alpha") do
+      ref = Colors::RGBA.new(1r, 0r, 1r, 1r)
+      css = Colors::CSS.parse("rgba(255,0,255,1)")
+      assert_near(ref, css)
+      ref = Colors::RGBA.new(1r, 0r, 1r, 0r)
+      css = Colors::CSS.parse("rgba(255,0,255,0)")
+      assert_near(ref, css)
+    end
+
+    test("integer values, float alpha") do
+      ref = Colors::RGBA.new(255, 0, 255, 127)
+      css = Colors::CSS.parse("rgba(255,0,255 ,   0.5)")
+      assert_near(ref, css)
+    end
+
+    test("clamp out of range alpha values") do
+      ref = Colors::RGBA.new(1r, 0, 1r, 1r)
+      css = Colors::CSS.parse("rgba(255,0,255,2.0)")
+      assert_near(ref, css)
+      ref = Colors::RGBA.new(1r, 127/255r, 123/255r, 0.0)
+      css = Colors::CSS.parse("rgba(255, 127, 123,-0.1)")
+      assert_near(ref, css)
+    end
+
+    test("percent values, int alpha") do
+      ref = Colors::RGBA.new(1r, 0r, 0.25r, 1r)
+      css = Colors::CSS.parse("rgba(100%,0%,25%,1)")
+      assert_near(ref, css)
+      ref = Colors::RGBA.new(1r, 0.33r, 0.02r, 0r)
+      css = Colors::CSS.parse("rgba(100% , 33%,2%,0)")
+      assert_near(ref, css)
+    end
+
+    test("percent values, float alpha") do
+      ref = Colors::RGBA.new(0.5r, 0, 0.06, 1/2r)
+      css = Colors::CSS.parse("rgba(50%,0%,6% ,0.5)")
+      assert_near(ref, css)
+    end
+
+    test("bad input") do
+      assert_raises ArgumentError, "mixed pct/int" do
+        Colors::CSS.parse("rgba(50%,0,6 ,0.5)")
+      end
+      assert_raises ArgumentError, "too few args" do
+        Colors::CSS.parse("rgba(50%,0%,6%)")
+      end
+      assert_raises ArgumentError, "too many args" do
+        Colors::CSS.parse("rgba(50%,0%,6%,0.5, 0.5)")
+      end
+      assert_raises ArgumentError, "missing comma" do
+        Colors::CSS.parse("rgba(50%,0%,6% 0.5)")
+      end
+    end
+  end
+
+  sub_test_case("hsl") do
+    test("in-range hsl") do
+      ref = Colors::HSL.new(180, 0, 0.5)
+      css = Colors::CSS.parse("hsl( 180, 0% , 50% )")
+      assert_near(ref, css)
+    end
+
+    test("clamps out-of-range integer values") do
+      ref = Colors::HSL.new(180, 0, 0.5)
+      css = Colors::CSS.parse("hsl(-180,0%,50%)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsl(180,-10%,50%)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsl(540,-10%,50%)")
+      assert_near(ref, css)
+      ref = Colors::HSL.new(0, 1.0, 1.0)
+      css = Colors::CSS.parse("hsl(0,100%,100%)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsl(360,100%,100%)")
+      assert_near(ref, css)
+    end
+
+    test("bad input") do
+      assert_raises ArgumentError, "too many args" do
+        css = Colors::CSS.parse("hsl( 180, 0% , 50%, 50% )")
+      end
+      assert_raises ArgumentError, "too few args" do
+        css = Colors::CSS.parse("hsl( 180, 0%)")
+      end
+      assert_raises ArgumentError, "missing comma" do
+        css = Colors::CSS.parse("hsl( 180, 0% 50% )")
+      end
+    end
+  end
+
+  sub_test_case("hsla") do
+    test("in-range hsla") do
+      ref = Colors::HSLA.new(180, 0, 0.5, 1.0)
+      css = Colors::CSS.parse("hsla( 180, 0% , 50%,1.0)")
+      assert_near(ref, css)
+    end
+
+    test("clamps out-of-range integer values") do
+      ref = Colors::HSLA.new(180, 0, 0.5, 0.1)
+      css = Colors::CSS.parse("hsla(-180,0%,50%,0.1)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsla(180,-10%,50%, 0.1)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsla(540,-10%,50%, 0.1)")
+      assert_near(ref, css)
+      ref = Colors::HSLA.new(0, 1.0, 1.0, 0.0)
+      css = Colors::CSS.parse("hsla(0,100%,100%,0.0)")
+      assert_near(ref, css)
+      css = Colors::CSS.parse("hsla(360,100%,100%, 0.0)")
+      assert_near(ref, css)
+    end
+
+    test("bad input") do
+      assert_raises ArgumentError, "too many args" do
+        css = Colors::CSS.parse("hsla( 180, 0% , 50%, 0.0, 0.0 )")
+      end
+      assert_raises ArgumentError, "too few args" do
+        css = Colors::CSS.parse("hsla( 180, 0%, 0.0)")
+      end
+      assert_raises ArgumentError, "missing comma" do
+        css = Colors::CSS.parse("hsla( 180, 0% 50% 0.0 )")
+      end
+    end
+  end
+end

data/test/test-linear-segmented-colormap.rb

@@ -115,5 +115,24 @@ class ColorsLinearSegmentedColormapTest < Test::Unit::TestCase
                    after
                  ])
   end
+
+  def test_reversed
+    cm = Colors::LinearSegmentedColormap.new_from_list("four", [:red, :magenta, :green, :yellow, :blue], n_colors: 5)
+    cm.under_color = :black
+    cm.over_color = :white
+    rev = cm.reversed
+    assert_equal([
+                   "four_r",
+                   cm[[0, 1, 2, 3, 4]],
+                   Colors[:black],
+                   Colors[:white]
+                 ],
+                 [
+                   rev.name,
+                   rev[[4, 3, 2, 1, 0]],
+                   rev.under_color,
+                   rev.over_color
+                 ])
+  end
 end
 

data/test/test-listed-colormap.rb

@@ -112,4 +112,23 @@ class ColorsListedColormapTest < Test::Unit::TestCase
                    after
                  ])
   end
+
+  def test_reversed
+    cm = Colors::ListedColormap.new([:red, :green, :blue], name: "three")
+    cm.under_color = :orange
+    cm.over_color = :yellow
+    rev = cm.reversed
+    assert_equal([
+                   "three_r",
+                   cm[[0, 1, 2]],
+                   Colors[:orange],
+                   Colors[:yellow]
+                 ],
+                 [
+                   rev.name,
+                   rev[[2, 1, 0]],
+                   rev.under_color,
+                   rev.over_color
+                 ])
+  end
 end

data/test/test-xterm256.rb

@@ -44,7 +44,9 @@ class ColorsXterm256Test < Test::Unit::TestCase
     assert { Colors::Xterm256.new(16) != Colors::Xterm256.new(17) }
   end
 
-  data do
+  RGB2GREY = [0.21263900587151035754r, 0.71516867876775592746r, 0.07219231536073371500r]
+
+  data(keep: true) do
     data_set = {}
     # colors 16-231 are a 6x6x6 color cube
     (0...6).each do |r|
@@ -55,7 +57,10 @@ class ColorsXterm256Test < Test::Unit::TestCase
           green = (g > 0) ? 40*g + 55 : g
           blue  = (b > 0) ? 40*b + 55 : b
           label = "Color #{code} is rgb(#{red}, #{green}, #{blue})"
-          data_set[label] = [code, Colors::RGB.new(red, green, blue)]
+          rgb = Colors::RGB.new(red, green, blue)
+          red, green, blue = Colors::Convert.srgb_to_linear_srgb(*rgb.components)
+          grey = RGB2GREY[0]*red + RGB2GREY[1]*green + RGB2GREY[2]*blue
+          data_set[label] = [code, rgb, grey]
         end
       end
     end
@@ -63,14 +68,23 @@ class ColorsXterm256Test < Test::Unit::TestCase
     (0...24).each do |y|
       code = 232 + y
       level = 10*y + 8
+      grey = level/255r
       label = "Color #{code} is gray(#{level})"
-      data_set[label] = [code, Colors::RGB.new(level, level, level)]
+      data_set[label] = [code, Colors::RGB.new(level, level, level), grey]
     end
     data_set
   end
+
   def test_to_rgb(data)
-    code, rgb = data
+    code, rgb, _grey = data
     assert_equal(rgb,
                  Colors::Xterm256.new(code).to_rgb)
   end
+
+  def test_to_grey_level(data)
+    code, _rgb, grey = data
+    assert_in_delta(grey,
+                    Colors::Xterm256.new(code).to_grey_level,
+                    1e-12)
+  end
 end