red-colors 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f5bd8e883bdf940ae77ece7135e3667a5d953534fda4780e344fd9413b59fa7
-  data.tar.gz: c275f21b6223f399f50b4265b32d652753d9a6d5297d1bdff1597aa9c2956371
+  metadata.gz: 161a952cf581167db1ac2391f1a4f80c83affbc838efdfc7c525587c0c1c8cdb
+  data.tar.gz: b0aa23b1537ded3aa6484eaffd646877da5c53b784a721d7a324c94788ecb842
 SHA512:
-  metadata.gz: a1dbc251a4dda958ada6163601b876ab7572f6aa2a71bb84e728f6b1bd180ef90a6937ef5db3ca3724951be8a329f2abc655f162d8849a4f2868be9d78eb4c73
-  data.tar.gz: b0d5952ff67aa28147f85105ea7d89f59a526cfa856d5ab1b6826eec35f50d60dde5a69d1f28b1c73720b4edcd8eff948c656880feda2e1e943f7decbc9c0859
+  metadata.gz: e244463b3bd3137808915397688141c67d99298290484c91f94be576b1821f94ad6ce9181a5518ce8d77faddb9a37dbaa0f6c462d1009e7d7bfa6a887fa678fd
+  data.tar.gz: 802cef85dc8c270094812522afffe5571833a2b044145132902939edb5bf118a740a36d07b40583ccfd3ab0f94ec97ccc5f9b8891f00a63b348bfe4519d7dda5

data/lib/colors.rb

@@ -1,3 +1,4 @@
+require_relative "colors/utils"
 require_relative "colors/alpha_component"
 require_relative "colors/convert"
 require_relative "colors/helper"
@@ -15,6 +16,10 @@ require_relative "colors/xyz"
 require_relative "colors/color_data"
 require_relative "colors/named_colors"
 
+require_relative "colors/colormap"
+require_relative "colors/listed_colormap"
+require_relative "colors/linear_segmented_colormap"
+
 module Colors
   # ITU-R BT.709 D65 white point
   # See https://en.wikipedia.org/wiki/Rec._709 for details

data/lib/colors/abstract_color.rb

@@ -4,6 +4,10 @@ module Colors
       unsupported __method__
     end
 
+    def inspect
+      "#{self.class.name}(#{components.join(", ")})"
+    end
+
     private def unsupported(name)
       raise NotImplementedError, "#{name} is unsupported in #{self.class}", caller(2)
     end

data/lib/colors/colormap.rb

@@ -0,0 +1,131 @@
+module Colors
+  class Colormap
+    def initialize(name, n_colors)
+      @name = name
+      @n_colors = n_colors.to_int
+      @bad_color = RGBA.new(0r, 0r, 0r, 0r)
+      @under_color = nil
+      @over_color = nil
+      @under_index = self.n_colors
+      @over_index = self.n_colors + 1
+      @bad_index = self.n_colors + 2
+      @initialized = false
+    end
+
+    attr_reader :name, :n_colors
+
+    def [](x)
+      init_colormap unless @initialized
+
+      xs = Array(x)
+      scalar_p = (xs.length == 1) && xs[0] == x
+
+      if all_ratio?(xs)
+        xs.map! do |v|
+          v *= self.n_colors
+          v = -1 if v < 0
+          v = self.n_colors - 1 if v == self.n_colors
+          v.clamp(-1, self.n_colors).to_i
+        end
+      end
+      ys = xs.map do |v|
+        v = case
+            when v >= self.n_colors
+              @over_index
+            when v < 0
+              @under_index
+            else
+              v
+            end
+        @lookup_table[v]
+      end
+
+      if scalar_p
+        ys[0]
+      else
+        ys
+      end
+    end
+
+    def over_color
+      init_colormap unless @initialized
+      @lookup_table[@over_index]
+    end
+
+    def over_color=(color)
+      @over_color = color
+      update_extreme_colors if @initialized
+    end
+
+    def under_color
+      init_colormap unless @initialized
+      @lookup_table[@under_index]
+    end
+
+    def under_color=(color)
+      @under_color = color
+      update_extreme_colors if @initialized
+    end
+
+    PNG_WIDTH = 512
+    PNG_HEIGHT = 64
+
+    def to_png
+      require "chunky_png"
+      png = ChunkyPNG::Image.new(PNG_WIDTH, PNG_HEIGHT, ChunkyPNG::Color::TRANSPARENT)
+      x = Utils.linspace(0, 1, PNG_WIDTH)
+      (0 ... PNG_WIDTH).each do |i|
+        color = self[x[i].to_f]
+        png_color = ChunkyPNG::Color.rgba(*color.components.map{|v| (v*255).to_i })
+        png.line(i, 0, i, PNG_HEIGHT-1, png_color)
+      end
+      png.to_blob
+    end
+
+    def to_html
+      require "base64"
+      png_blob = to_png
+      png_base64 = Base64.encode64(png_blob)
+      html = %Q[<div style="vertical-align: middle;">] +
+             %Q[<strong>#{self.name}</strong> ] +
+             %Q[</div>] +
+             %Q[<div class="cmap"><img alt="#{self.name} colormap" ] +
+             %Q[title="#{self.name}" style="border: 1px solid #555;" ] +
+             %Q[src="data:image/png;base64,#{png_base64}"></div>] +
+             %Q[<div style="vertical-align: middle; ] +
+             %Q[max-width: #{PNG_WIDTH + 2}px; ] +
+             %Q[display: flex; justify-content: space-between;">] +
+             %Q[<div style="float: left;">] +
+             %Q[#{html_color_block(under_color)} under</div>] +
+             # TODO: bad_color support
+             # %Q[<div style="margin: 0 auto; display: inline-block;">] +
+             # %Q[bad #{html_color_block(bad_color)}</div>] +
+             %Q[<div style="float: right;">] +
+             %Q[over #{html_color_block(over_color)}</div>]
+      ["text/html", html]
+    end
+
+    private def html_color_block(color)
+      hex_color = color.to_hex_string
+      html = %Q[<div title="#{hex_color}" style="display: inline-block; ] +
+             %Q[width: 1em; height: 1em; margin: 0; vertical-align: middle; ] +
+             %Q[border: 1px solid #555; background-color: #{hex_color};">] +
+             %Q[</div>]
+      html
+    end
+
+    private def init_colormap
+      raise NotImplementedError
+    end
+
+    private def all_ratio?(ary)
+      ary.all? {|x| x.is_a?(Float) || x.is_a?(Rational) }
+    end
+
+    private def update_extreme_colors
+      @lookup_table[@under_index] = Utils.make_color(@under_color || @lookup_table[0]).to_rgba
+      @lookup_table[@over_index] = Utils.make_color(@over_color || @lookup_table[self.n_colors - 1]).to_rgba
+      @lookup_table[@bad_index] = Utils.make_color(@bad_color).to_rgba
+    end
+  end
+end

data/lib/colors/linear_segmented_colormap.rb

@@ -0,0 +1,119 @@
+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"
+        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
+  end
+end

data/lib/colors/listed_colormap.rb

@@ -0,0 +1,41 @@
+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
+  end
+end

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.3"
+  VERSION = "0.2.0"
 end

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

@@ -0,0 +1,119 @@
+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
+end
+

data/test/test-listed-colormap.rb

@@ -0,0 +1,115 @@
+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
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-colors
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Kenta Murata
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-10 00:00:00.000000000 Z
+date: 2021-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: matrix
@@ -110,14 +110,18 @@ files:
 - lib/colors/abstract_color.rb
 - lib/colors/alpha_component.rb
 - lib/colors/color_data.rb
+- lib/colors/colormap.rb
 - lib/colors/convert.rb
 - lib/colors/helper.rb
 - lib/colors/hsl.rb
 - lib/colors/hsla.rb
 - lib/colors/husl.rb
+- lib/colors/linear_segmented_colormap.rb
+- lib/colors/listed_colormap.rb
 - lib/colors/named_colors.rb
 - lib/colors/rgb.rb
 - lib/colors/rgba.rb
+- lib/colors/utils.rb
 - lib/colors/version.rb
 - lib/colors/xterm256.rb
 - lib/colors/xyy.rb
@@ -128,6 +132,8 @@ files:
 - test/test-hsl.rb
 - test/test-hsla.rb
 - test/test-husl.rb
+- test/test-linear-segmented-colormap.rb
+- test/test-listed-colormap.rb
 - test/test-named-color.rb
 - test/test-rgb.rb
 - test/test-rgba.rb
@@ -163,6 +169,8 @@ test_files:
 - test/test-hsl.rb
 - test/test-hsla.rb
 - test/test-husl.rb
+- test/test-linear-segmented-colormap.rb
+- test/test-listed-colormap.rb
 - test/test-named-color.rb
 - test/test-rgb.rb
 - test/test-rgba.rb