red-colors 0.1.0 → 0.3.0

data/lib/colors/xyz.rb

@@ -1,45 +1,10 @@
-require_relative "helper"
-
-require "numo/narray"
-
 module Colors
-  XYZ2RGB = Numo::DFloat[
-    [  3.24096994190452134377, -1.53738317757009345794, -0.49861076029300328366 ],
-    [ -0.96924363628087982613,  1.87596750150772066772,  0.04155505740717561247 ],
-    [  0.05563007969699360846, -0.20397695888897656435,  1.05697151424287856072 ]
-  ]
-
-  RGB2XYZ = Numo::DFloat[
-    [  0.41239079926595948129,  0.35758433938387796373,  0.18048078840183428751 ],
-    [  0.21263900587151035754,  0.71516867876775592746,  0.07219231536073371500 ],
-    [  0.01933081871559185069,  0.11919477979462598791,  0.95053215224966058086 ]
-  ]
-
   class XYZ < AbstractColor
     include Helper
 
     EPSILON = (6/29r)**3
 
-    KAPPA = (29/3)**3
-
-    def self.from_xyY(x, y, large_y)
-      large_x = large_y*x/y
-      large_z = large_y*(1 - x - y)/y
-      new(large_x, large_y, large_z)
-    end
-
-    def self.from_rgb(r, g, b)
-      c = RGB2XYZ.dot(Numo::DFloat[to_linear(r), to_linear(g), to_linear(b)])
-      new(c[0], c[1], c[2])
-    end
-
-    private_class_method def self.to_linear(v)
-      if v > 0.04045
-        ((v + 0.055r) / 1.055r) ** 2.4r
-      else
-        v / 12.92r
-      end
-    end
+    KAPPA = (29/3r)**3
 
     def initialize(x, y, z)
       @x, @y, @z = canonicalize(x, y, z)
@@ -65,12 +30,7 @@ module Colors
     end
 
     def rgb_components
-      c = XYZ2RGB.dot(Numo::DFloat[x, y, z])
-      [
-        srgb_compand(c[0]).clamp(0r, 1r),
-        srgb_compand(c[1]).clamp(0r, 1r),
-        srgb_compand(c[2]).clamp(0r, 1r)
-      ]
+      Convert.xyz_to_rgb(x, y, z)
     end
 
     def luv_components(wp)
@@ -99,19 +59,6 @@ module Colors
       [u, v]
     end
 
-    private def srgb_compand(v)
-      # the following is an optimization technique for `1.055*v**(1/2.4) - 0.055`.
-      # x^y ~= exp(y*log(x)) ~= exp2(y*log2(y)); the middle form is faster
-      #
-      # See https://github.com/JuliaGraphics/Colors.jl/issues/351#issuecomment-532073196
-      # for more detail benchmark in Julia language.
-      if v <= 0.0031308
-        12.92*v
-      else
-        1.055 * Math.exp(1/2.4 * Math.log(v)) - 0.055
-      end
-    end
-
     private def canonicalize(x, y, z)
       [
         Rational(x),

data/red-colors.gemspec

@@ -27,15 +27,17 @@ 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("matrix")
+
   spec.add_development_dependency("bundler")
   spec.add_development_dependency("rake")
   spec.add_development_dependency("test-unit")
   spec.add_development_dependency("yard")
   spec.add_development_dependency("kramdown")
-  spec.add_development_dependency("numo-narray")
 end

data/test/test-husl.rb

@@ -175,67 +175,59 @@ class ColorsHUSLTest < Test::Unit::TestCase
   end
 
   test("#desaturate") do
-    c = Colors::HUSL.from_rgb(1r, 1r, 0r).desaturate(0.8)
+    c = Colors::RGB.new(1r, 1r, 0r).to_husl.desaturate(0.8)
     assert_instance_of(Colors::HUSL, c)
-    assert_near(Colors::HUSL.new(85.87432021817473r, 0.9838589961976354r, 0.8850923805142681r), c)
+    assert_near(Colors::HUSL.new(85.87432021817473r, 0.9838589961976354r, 0.8850923805142681r), c, 0.01)
   end
 
-  test("to_husl") do
+  test("#to_husl") do
     black = Colors::HUSL.new(0, 0, 0)
     assert_same(black, black.to_hsl)
   end
 
-  test(".from_rgb") do
-    # black
-    assert_equal(Colors::HUSL.new(0, 0, 0),
-                 Colors::HUSL.from_rgb(0, 0, 0))
-    # red
-    assert_near(Colors::HUSL.new(12.177050630061776r, 1r, 0.5323711559542933r),
-                Colors::HUSL.from_rgb(1r, 0, 0))
-    ## yellow
-    assert_near(Colors::HUSL.new(85.87432021817473r, 1r, 0.9713855934179674r),
-                Colors::HUSL.from_rgb(1r, 1r, 0))
-    ## green
-    assert_near(Colors::HUSL.new(127.71501294924047r, 1r, 0.8773551910965973r),
-                Colors::HUSL.from_rgb(0r, 1r, 0))
-    ## cyan
-    assert_near(Colors::HUSL.new(192.17705063006116r, 1r, 0.9111475231670507r),
-                Colors::HUSL.from_rgb(0r, 1r, 1r))
-    ## blue
-    assert_near(Colors::HUSL.new(265.8743202181779r, 1r, 0.3230087290398002r),
-                Colors::HUSL.from_rgb(0r, 0r, 1r))
-    ## magenta
-    assert_near(Colors::HUSL.new(307.7150129492436r, 1r, 0.60322731354551294r),
-                Colors::HUSL.from_rgb(1r, 0r, 1r))
-    ## white
-    assert_near(Colors::HUSL.new(0r, 0r, 1r),
-                Colors::HUSL.from_rgb(1r, 1r, 1r))
+  sub_test_case("basic colors") do
+    colors = [
+      { rgb: "#ff0000", husl: [ 12.16, 1.0, 0.532], name: "red" },
+      { rgb: "#ffff00", husl: [ 85.90, 1.0, 0.971], name: "yellow" },
+      { rgb: "#00ff00", husl: [127.72, 1.0, 0.877], name: "green" },
+      { rgb: "#00ffff", husl: [192.20, 1.0, 0.911], name: "cyan" },
+      { rgb: "#0000ff", husl: [265.87, 1.0, 0.323], name: "blue" },
+      { rgb: "#ff00ff", husl: [307.71, 1.0, 0.603], name: "magenta" },
+    ]
+    data(colors.map {|r| [r[:name], r] }.to_h)
+    def test_husl_to_rgb(data)
+      husl, rgb = data.values_at(:husl, :rgb)
+      assert_equal(rgb,
+                   Colors::HUSL.new(*husl).to_rgb.to_hex_string)
+    end
   end
 
-  test("to_rgb") do
-    # black
-    assert_equal(Colors::RGB.new(0, 0, 0),
-                 Colors::HUSL.new(0, 0, 0).to_rgb)
-    # red
-    assert_near(Colors::RGB.new(1r, 0, 0),
-                Colors::HUSL.new(12.177050630061776r, 1r, 0.5323711559542933r).to_rgb)
-    # yellow
-    assert_near(Colors::RGB.new(1r, 1r, 0),
-                Colors::HUSL.new(85.87432021817473r, 1r, 0.9713855934179674r).to_rgb)
-    # green
-    assert_near(Colors::RGB.new(0r, 1r, 0),
-                Colors::HUSL.new(127.71501294924047r, 1r, 0.8773551910965973r).to_rgb)
-    # cyan
-    assert_near(Colors::RGB.new(0r, 1r, 1r),
-                Colors::HUSL.new(192.17705063006116r, 1r, 0.9111475231670507r).to_rgb)
-    # blue
-    assert_near(Colors::RGB.new(0r, 0r, 1r),
-                Colors::HUSL.new(265.8743202181779r, 1r, 0.3230087290398002r).to_rgb)
-    # magenta
-    assert_near(Colors::RGB.new(1r, 0r, 1r),
-                Colors::HUSL.new(307.7150129492436r, 1r, 0.60322731354551294r).to_rgb)
-    # white
-    assert_near(Colors::RGB.new(1r, 1r, 1r),
-                Colors::HUSL.new(0r, 1r, 1r).to_rgb)
+  sub_test_case("reproducing color conversion in seaborn") do
+    s = 0.9 * 99/100r
+    l = 0.65 * 99/100r
+    palette = [
+      { rgb: "#f77189", husl: [  3.590,            s, l] },
+      { rgb: "#e68332", husl: [ 33.50666666666666, s, l] },
+      { rgb: "#bb9832", husl: [ 63.42333333333333, s, l] },
+      { rgb: "#97a431", husl: [ 93.3400,           s, l] },
+      { rgb: "#50b131", husl: [123.25666666666666, s, l] },
+      { rgb: "#34af84", husl: [153.17333333333332, s, l] },
+      { rgb: "#36ada4", husl: [183.0900,           s, l] },
+      { rgb: "#38aabf", husl: [213.00666666666663, s, l] },
+      { rgb: "#3ba3ec", husl: [242.92333333333332, s, l] },
+      { rgb: "#a48cf4", husl: [272.8400,           s, l] },
+      { rgb: "#e867f4", husl: [302.75666666666666, s, l] }, # TODO: #e866f4 is the best
+      { rgb: "#f668c2", husl: [332.67333333333335, s, l] }
+    ]
+    data(palette.map {|r|
+      name = r[:name] || "husl(#{r[:husl]}) => #{r[:rgb]}"
+      [name, r]
+    }.to_h)
+    def test_husl_to_rgb(data)
+      husl_components, hex_string = data.values_at(:husl, :rgb)
+      husl = Colors::HUSL.new(*husl_components)
+      assert_equal(hex_string,
+                   husl.to_rgb.to_hex_string)
+    end
   end
 end

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

@@ -0,0 +1,138 @@
+class ColorsLinearSegmentedColormapTest < Test::Unit::TestCase
+  include TestHelper
+
+  sub_test_case("#[]") do
+    def setup
+      @cm = Colors::LinearSegmentedColormap.new_from_list(:triple_colors, [:red, :green, :blue], n_colors: 11)
+      @cm.under_color = :black
+      @cm.over_color = :white
+    end
+
+    sub_test_case("with an integer") do
+      data do
+        expected = [
+          Colors::RGBA.new(1r, 0r, 0r, 1r),
+          Colors::RGBA.new(0r, 128/255r, 0r, 1r),
+          Colors::RGBA.new(0r, 0r, 1r, 1r),
+          Colors::RGBA.new(1r, 1r, 1r, 1r),
+          Colors::RGBA.new(0r, 0r, 0r, 1r),
+        ]
+        indices = [0, 5, 10, 11, -1]
+        indices.zip(expected).map { |i, c|
+          ["cmap[#{i}]", {i: i, expected_color: c}]
+        }.to_h
+      end
+      def test_aref(data)
+        i, expected = data.values_at(:i, :expected_color)
+        assert_near(expected, @cm[i])
+      end
+    end
+
+    sub_test_case("with an array of integers") do
+      def test_aref
+        indices = [0, 5, 10, 11, -1]
+        assert_equal(indices.map {|i| @cm[i] },
+                     @cm[indices])
+      end
+    end
+
+    sub_test_case("with a float") do
+      data do
+        expected = [
+          Colors::RGBA.new(0.6r, 0.20078431372549022r, 0.0r, 1r),
+          Colors::RGBA.new(0.19999999999999996r, 0.40156862745098043r, 0.0r, 1r),
+          Colors::RGBA.new(0.0r, 0.4015686274509803r, 0.20000000000000018r, 1r),
+          Colors::RGBA.new(0.0r, 0.20078431372549022r, 0.6r, 1r),
+          Colors::RGBA.new(1r, 1r, 1r, 1r),
+          Colors::RGBA.new(0r, 0r, 0r, 1r),
+        ]
+        indices = [0.2, 0.4, 0.6, 0.8, 1.2, -0.2]
+        indices.zip(expected).map { |i, c|
+          ["cmap[#{i}]", {i: i, expected_color: c}]
+        }.to_h
+      end
+      def test_aref(data)
+        i, expected = data.values_at(:i, :expected_color)
+        assert_near(expected, @cm[i])
+      end
+    end
+
+    sub_test_case("with an array of floats") do
+      def test_aref
+        indices = [0.2, 0.4, 0.6, 0.8, 1.2, -0.2]
+        assert_equal(indices.map {|i| @cm[i] },
+                     @cm[indices])
+      end
+    end
+  end
+
+  def test_over_color
+    cm = Colors::LinearSegmentedColormap.new_from_list(:blue_and_red, [:blue, :red])
+
+    before = cm[[0, 255, 256]]
+    cm.over_color = :black
+    after = cm[[0, 255, 256]]
+
+    assert_equal([
+                   [
+                     Colors::RGBA.new(0r, 0r, 1r, 1r),
+                     Colors::RGBA.new(1r, 0r, 0r, 1r),
+                     Colors::RGBA.new(1r, 0r, 0r, 1r),
+                   ],
+                   [
+                     Colors::RGBA.new(0r, 0r, 1r, 1r),
+                     Colors::RGBA.new(1r, 0r, 0r, 1r),
+                     Colors::RGBA.new(0r, 0r, 0r, 1r),
+                   ]
+                 ],
+                 [
+                   before,
+                   after
+                 ])
+  end
+
+  def test_under_color
+    cm = Colors::LinearSegmentedColormap.new_from_list(:blue_and_red, [:blue, :red])
+
+    before = cm[[0, 255, -1]]
+    cm.under_color = :black
+    after = cm[[0, 255, -1]]
+
+    assert_equal([
+                   [
+                     Colors::RGBA.new(0r, 0r, 1r, 1r),
+                     Colors::RGBA.new(1r, 0r, 0r, 1r),
+                     Colors::RGBA.new(0r, 0r, 1r, 1r),
+                   ],
+                   [
+                     Colors::RGBA.new(0r, 0r, 1r, 1r),
+                     Colors::RGBA.new(1r, 0r, 0r, 1r),
+                     Colors::RGBA.new(0r, 0r, 0r, 1r),
+                   ]
+                 ],
+                 [
+                   before,
+                   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

@@ -0,0 +1,134 @@
+class ColorsListedColormapTest < Test::Unit::TestCase
+  include TestHelper
+
+  sub_test_case("#[]") do
+    def setup
+      @cm = Colors::ListedColormap.new([:red, :green, :blue])
+      @cm.under_color = :black
+      @cm.over_color = :white
+    end
+
+    sub_test_case("with an integer") do
+      def test_aref
+        assert_equal([
+                       Colors::RGBA.new(1r, 0r, 0r, 1r),
+                       Colors::RGBA.new(0r, 128/255r, 0r, 1r),
+                       Colors::RGBA.new(0r, 0r, 1r, 1r),
+                       Colors::RGBA.new(1r, 1r, 1r, 1r),
+                       Colors::RGBA.new(0r, 0r, 0r, 1r),
+                     ],
+                     [
+                       @cm[0],
+                       @cm[1],
+                       @cm[2],
+                       @cm[3],
+                       @cm[-1],
+                     ])
+      end
+    end
+
+    sub_test_case("with an array of integers") do
+      def test_aref
+        indices = [0, 1, 2, 3, -1]
+        assert_equal(indices.map {|i| @cm[i] },
+                     @cm[indices])
+      end
+    end
+
+    sub_test_case("with a float") do
+      def test_aref
+        assert_equal([
+                       Colors::RGBA.new(1r, 0r, 0r, 1r),
+                       Colors::RGBA.new(0r, 128/255r, 0r, 1r),
+                       Colors::RGBA.new(0r, 0r, 1r, 1r),
+                       Colors::RGBA.new(1r, 1r, 1r, 1r),
+                       Colors::RGBA.new(0r, 0r, 0r, 1r),
+                     ],
+                     [
+                       @cm[0.1],
+                       @cm[0.5],
+                       @cm[0.8],
+                       @cm[1.1],
+                       @cm[-0.1]
+                     ])
+      end
+    end
+
+    sub_test_case("with an array of floats") do
+      def test_aref
+        indices = [0.1, 0.5, 0.8, 1.1, -0.1]
+        assert_equal(indices.map {|i| @cm[i] },
+                     @cm[indices])
+      end
+    end
+  end
+
+  def test_over_color
+    cm = Colors::ListedColormap.new([:blue, :red])
+
+    before = cm[[0, 1, 2]]
+    cm.over_color = :black
+    after = cm[[0, 1, 2]]
+
+    assert_equal([
+                   [
+                     Colors::RGBA.new(0r, 0r, 1r, 1r),
+                     Colors::RGBA.new(1r, 0r, 0r, 1r),
+                     Colors::RGBA.new(1r, 0r, 0r, 1r),
+                   ],
+                   [
+                     Colors::RGBA.new(0r, 0r, 1r, 1r),
+                     Colors::RGBA.new(1r, 0r, 0r, 1r),
+                     Colors::RGBA.new(0r, 0r, 0r, 1r),
+                   ]
+                 ],
+                 [
+                   before,
+                   after
+                 ])
+  end
+
+  def test_under_color
+    cm = Colors::ListedColormap.new([:blue, :red])
+
+    before = cm[[0, 1, -1]]
+    cm.under_color = :black
+    after = cm[[0, 1, -1]]
+
+    assert_equal([
+                   [
+                     Colors::RGBA.new(0r, 0r, 1r, 1r),
+                     Colors::RGBA.new(1r, 0r, 0r, 1r),
+                     Colors::RGBA.new(0r, 0r, 1r, 1r),
+                   ],
+                   [
+                     Colors::RGBA.new(0r, 0r, 1r, 1r),
+                     Colors::RGBA.new(1r, 0r, 0r, 1r),
+                     Colors::RGBA.new(0r, 0r, 0r, 1r),
+                   ]
+                 ],
+                 [
+                   before,
+                   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