red-colors 0.1.0

data/lib/colors/rgb.rb

@@ -0,0 +1,145 @@
+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
+      when 3  # rgb
+        r, g, b = hex_string.scan(/\h/).map {|h| h.hex * 17 }
+        new(r, g, b)
+      when 6  # rrggbb
+        r, g, b = hex_string.scan(/\h{2}/).map(&:hex)
+        new(r, g, b)
+      else
+        raise ArgumentError, "Invalid hex string: #{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)
+      @r, @g, @b = canonicalize(r, g, b)
+    end
+
+    attr_reader :r, :g, :b
+
+    def components
+      [r, g, b]
+    end
+
+    alias rgb_components components
+
+    def r=(r)
+      @r = canonicalize_component(r, :r)
+    end
+
+    def g=(g)
+      @g = canonicalize_component(g, :g)
+    end
+
+    def b=(b)
+      @b = canonicalize_component(b, :b)
+    end
+
+    alias red r
+    alias green g
+    alias blue b
+
+    alias red= r=
+    alias green= g=
+    alias blue= b=
+
+    def ==(other)
+      case other
+      when RGBA
+        other == self
+      when RGB
+        r == other.r && g == other.g && b == other.b
+      else
+        super
+      end
+    end
+
+    def desaturate(factor)
+      to_hsl.desaturate(factor).to_rgb
+    end
+
+    def to_hex_string
+      "##{components.map {|c| "%02x" % (255*c).round.to_i }.join('')}"
+    end
+
+    def to_rgb
+      self
+    end
+
+    def to_rgba(alpha: 1.0)
+      alpha = canonicalize_component(alpha, :alpha)
+      RGBA.new(r, g, b, alpha)
+    end
+
+    def to_hsl
+      HSL.new(*hsl_components)
+    end
+
+    def to_hsla(alpha: 1.0)
+      alpha = canonicalize_component(alpha, :alpha)
+      HSLA.new(*hsl_components, alpha)
+    end
+
+    def hsl_components
+      m1, m2 = [r, g, b].minmax
+      c = m2 - m1
+      hh = case
+           when c == 0
+             0r
+           when m2 == r
+             ((g - b) / c) % 6r
+           when m2 == g
+             ((b - r) / c + 2) % 6r
+           when m2 == b
+             ((r - g) / c + 4) % 6r
+           end
+      h = 60r * hh
+      l = 0.5r * m2 + 0.5r * m1
+      s = if l == 1 || l == 0
+            0r
+          else
+            c / (1 - (2*l - 1).abs)
+          end
+      [h, s, l]
+    end
+
+    def to_husl
+      HUSL.from_rgb(r, g, b)
+    end
+
+    def to_xyz
+      XYZ.from_rgb(r, g, b)
+    end
+
+    private def canonicalize(r, g, b)
+      if [r, g, b].map(&:class) == [Integer, Integer, Integer]
+        canonicalize_from_integer(r, g, b)
+      else
+        [
+          canonicalize_component_to_rational(r, :r),
+          canonicalize_component_to_rational(g, :g),
+          canonicalize_component_to_rational(b, :b)
+        ]
+      end
+    end
+
+    private def canonicalize_from_integer(r, g, b)
+      check_type(r, Integer, :r)
+      check_type(g, Integer, :g)
+      check_type(b, Integer, :b)
+      [
+        canonicalize_component_from_integer(r, :r),
+        canonicalize_component_from_integer(g, :g),
+        canonicalize_component_from_integer(b, :b)
+      ]
+    end
+  end
+end

data/lib/colors/rgba.rb

@@ -0,0 +1,101 @@
+module Colors
+  class RGBA < RGB
+    def self.parse(hex_string)
+      case hex_string.to_str.match(/\A#(\h+)\z/) { $1 }.length
+      when 3  # rgb
+        r, g, b = hex_string.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)
+        new(r, g, b, 255)
+      when 4 # rgba
+        r, g, b, a = hex_string.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)
+        new(r, g, b, a)
+      else
+        raise ArgumentError, "Invalid hex string: #{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)
+      @r, @g, @b, @a = canonicalize(r, g, b, a)
+    end
+
+    include AlphaComponent
+
+    def components
+      [r, g, b, a]
+    end
+
+    def ==(other)
+      case other
+      when RGBA
+        r == other.r && g == other.g && b == other.b && a == other.a
+      when RGB
+        r == other.r && g == other.g && b == other.b && a == 1r
+      else
+        super
+      end
+    end
+
+    def desaturate(factor)
+      to_hsla.desaturate(factor).to_rgba
+    end
+
+    def to_rgb
+      if a == 1r
+        RGB.new(r, g, b)
+      else
+        raise NotImplementedError,
+              "Unable to convert non-opaque RGBA to RGB"
+      end
+    end
+
+    def to_rgba
+      self
+    end
+
+    def to_hsl
+      if a == 1r
+        super
+      else
+        raise NotImplementedError,
+              "Unable to convert non-opaque RGBA to RGB"
+      end
+    end
+
+    def to_hsla
+      HSLA.new(*hsl_components, a)
+    end
+
+    private def canonicalize(r, g, b, a)
+      if [r, g, b, a].map(&:class) == [Integer, Integer, Integer, Integer]
+        canonicalize_from_integer(r, g, b, a)
+      else
+        [
+          canonicalize_component_to_rational(r, :r),
+          canonicalize_component_to_rational(g, :g),
+          canonicalize_component_to_rational(b, :b),
+          canonicalize_component_to_rational(a, :a)
+        ]
+      end
+    end
+
+    private def canonicalize_from_integer(r, g, b, a)
+      check_type(r, Integer, :r)
+      check_type(g, Integer, :g)
+      check_type(b, Integer, :b)
+      check_type(a, Integer, :a)
+      [
+        canonicalize_component_from_integer(r, :r),
+        canonicalize_component_from_integer(g, :g),
+        canonicalize_component_from_integer(b, :b),
+        canonicalize_component_from_integer(a, :a)
+      ]
+    end
+  end
+end

data/lib/colors/version.rb

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

data/lib/colors/xyz.rb

@@ -0,0 +1,123 @@
+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
+
+    def initialize(x, y, z)
+      @x, @y, @z = canonicalize(x, y, z)
+    end
+
+    attr_reader :x, :y, :z
+
+    def components
+      [x, y, z]
+    end
+
+    def ==(other)
+      case other
+      when XYZ
+        x == other.x && y == other.y && z == other.z
+      else
+        super
+      end
+    end
+
+    def to_rgb
+      RGB.new(*rgb_components)
+    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)
+      ]
+    end
+
+    def luv_components(wp)
+      yy = y/wp.y
+      uu, vv = uv_values
+      l = if yy <= EPSILON
+            KAPPA * yy
+          else
+            116 * Math.cbrt(yy).to_r - 16
+          end
+      if l <= 1e-8
+        u = v = 0r
+      else
+        wp_u, wp_v = wp.uv_values
+        u = 13*l*(uu - wp_u)
+        v = 13*l*(vv - wp_v)
+      end
+      [l, u, v]
+    end
+
+    def uv_values
+      d = x + 15*y + 3*z
+      return [0r, 0r] if d == 0
+      u = 4*x / d
+      v = 9*y / d
+      [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),
+        Rational(y),
+        Rational(z)
+      ]
+    end
+  end
+end

data/red-colors.gemspec

@@ -0,0 +1,41 @@
+clean_white_space = lambda do |entry|
+  entry.gsub(/(\A\n+|\n+\z)/, '') + "\n"
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "lib"))
+require "colors/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "red-colors"
+  spec.version = Colors::VERSION
+  spec.homepage = "https://github.com/red-data-tools/red-colors"
+  spec.authors = ["Kenta Murata"]
+  spec.email = ["mrkn@mrkn.jp"]
+
+  readme = File.read("README.md")
+  readme.force_encoding("UTF-8")
+  entries = readme.split(/^\#\#\s(.*)$/)
+  clean_white_space.call(entries[entries.index("Description") + 1])
+  description = clean_white_space.call(entries[entries.index("Description") + 1])
+  spec.summary, spec.description, = description.split(/\n\n+/, 3)
+  spec.license = "MIT"
+  spec.files = [
+    "README.md",
+    "LICENSE.txt",
+    "Rakefile",
+    "Gemfile",
+    "#{spec.name}.gemspec",
+  ]
+  spec.files += [".yardopts"]
+  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_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/helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'colors'
+require 'test/unit'
+
+module TestHelper
+  def assert_near(c1, c2, eps=1e-8)
+    assert_equal(c1.class, c2.class)
+    c1.components.zip(c2.components).each do |x1, x2|
+      x1, x2 = [x1, x2].map(&:to_f)
+      assert { (x1 - x2).abs < eps }
+    end
+  end
+end

data/test/run.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# TODO
+# $VERBOSE = true
+
+require "pathname"
+
+base_dir = Pathname(__dir__).parent.expand_path
+
+lib_dir = base_dir + "lib"
+test_dir = base_dir + "test"
+
+$LOAD_PATH.unshift(lib_dir.to_s)
+
+require_relative "helper"
+
+exit(Test::Unit::AutoRunner.run(true, test_dir.to_s))