red-colors 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bace2ec96d092df5552c1d8f422bb8c641965bb896d4255842f633d2f0e0238
-  data.tar.gz: d19df3fab59429a3175e2cecb5243b7dce42f3bec54bce55e12a6c26cfebdc61
+  metadata.gz: 3587e5433ccb431efbc46112034d3b9f00d40ad58e8389cb4081bf0bdcb3304f
+  data.tar.gz: 2568105af67abd20c5133a7181194489006eef94cc3c4834d0f3509eaf01c5f9
 SHA512:
-  metadata.gz: 0f1619704538a7cc04ffee56c3eba67c2b0d4bef96f059e253435e93dbf4c1ec52cf76708a1b82e6ac9d09f2d2838610535948f1d82137ca6fa49cafc6180dd6
-  data.tar.gz: 3bd2f146e561b3583a4abc160af383f335b8d35e12d829dc467332eb2d1753ec6e8b7523ae49c8778d1a4bf594e709509d30f6d732582cbf864d1ac72816b13e
+  metadata.gz: d15ae1556244a040ff0822fc739e7dd561d2f29fc9cec04ba68bbc72a1bd6afe097c66fa88f5450bd7f7bce3e89622b34726bdc5e64320255cb6ba71a0c508f7
+  data.tar.gz: aa96cd5773128f79d48993319d920e7325b4db7520429eb211347abfb375688566b083d049e1e679aa81ca05f545682490d70f2b29beaedcbc6ea1c094c45c50

data/README.md

@@ -20,6 +20,7 @@ $ gem install red-colors
 - HSL
 - HSLA
 - HUSL
+- xyY
 - XYZ
 
 ## Usage

data/lib/colors.rb

@@ -1,20 +1,23 @@
-require_relative "colors/helper"
 require_relative "colors/alpha_component"
+require_relative "colors/convert"
+require_relative "colors/helper"
 
 require_relative "colors/abstract_color"
-require_relative "colors/xyz"
-require_relative "colors/rgb"
-require_relative "colors/rgba"
 require_relative "colors/hsl"
 require_relative "colors/hsla"
 require_relative "colors/husl"
+require_relative "colors/rgb"
+require_relative "colors/rgba"
+require_relative "colors/xyy"
+require_relative "colors/xyz"
 
+require_relative "colors/color_data"
 require_relative "colors/named_colors"
 
 module Colors
   # ITU-R BT.709 D65 white point
   # See https://en.wikipedia.org/wiki/Rec._709 for details
-  WHITE_POINT_D65 = Colors::XYZ.from_xyY(0.3127r, 0.3290r, 1r)
+  WHITE_POINT_D65 = Colors::XYY.new(0.3127r, 0.3290r, 1r).to_xyz
 
   def self.desaturate(c, factor)
     case c

data/lib/colors/convert.rb

@@ -0,0 +1,180 @@
+module Colors
+  module Convert
+    module_function
+
+    # Sort alphabetically by FROM name such as degree, LCh, LUV and so on.
+
+    # Utilities
+
+    private def dot_product(matrix, vector)
+      matrix.map do |row|
+        product = 0.0
+        row.zip(vector) do |value1, value2|
+          product += value1 * value2
+        end
+        product
+      end
+    end
+
+    def max_chroma(l, h)
+      h_rad = degree_to_radian(h)
+      sin_h = Math.sin(h_rad).to_r
+      cos_h = Math.cos(h_rad).to_r
+
+      max = Float::INFINITY
+      luminance_bounds(l).each do |line|
+        len = line[1] / (sin_h - line[0] * cos_h)
+        max = len if 0 <= len && len < max
+      end
+      max
+    end
+
+    private def luminance_bounds(l)
+      sub1 = (l + 16)**3 / 1560896r
+      sub2 = sub1 > XYZ::EPSILON ? sub1 : l/XYZ::KAPPA
+
+      bounds = Array.new(6) { [0r, 0r] }
+      0.upto(2) do |ch|
+        m1 = XYZ2RGB[ch][0].to_r
+        m2 = XYZ2RGB[ch][1].to_r
+        m3 = XYZ2RGB[ch][2].to_r
+
+        [0, 1].each do |t|
+          top1 = (284517r * m1 - 94839r * m3) * sub2
+          top2 = (838422r * m3 + 769860r * m2 + 731718r * m1) * l * sub2 - 769860r * t * l
+          bottom = (632260r * m3 - 126452r * m2) * sub2 + 126452r * t
+
+          bounds[ch*2 + t][0] = top1 / bottom
+          bounds[ch*2 + t][1] = top2 / bottom
+        end
+      end
+      bounds
+    end
+
+    # degree -> ???
+
+    DEG2RAD = 0.01745329251994329577r  # 2 * pi / 360
+    def degree_to_radian(d)
+      d * DEG2RAD
+    end
+
+    # LCh -> ???
+
+    def lch_to_husl(l, c, h)
+      if l > 99.9999999 || l < 1e-8
+        s = 0r
+      else
+        mx = max_chroma(l, h)
+        s = c / mx * 100r
+      end
+
+      h = 0r if c < 1e-8
+
+      [h, s/100r, l/100r]
+    end
+
+    def lch_to_luv(l, c, h)
+      h_rad = degree_to_radian(h)
+      u = Math.cos(h_rad).to_r * c
+      v = Math.sin(h_rad).to_r * c
+      [l, u, v]
+    end
+
+    def lch_to_xyz(l, c, h)
+      luv_to_xyz(*lch_to_luv(l, c, h))
+    end
+
+    # linear-sRGB -> ???
+
+    def linear_srgb_to_srgb(r, g, b)
+      [r, g, b].map do |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
+    end
+
+    # Luv -> ???
+
+    def luv_to_husl(l, u, v)
+      lch_to_husl(*luv_to_lch(l, u, v))
+    end
+
+    def luv_to_lch(l, u, v)
+      c = Math.sqrt(u*u + v*v).to_r
+
+      if c < 1e-8
+        h = 0r
+      else
+        h = Math.atan2(v, u).to_r * 180/Math::PI.to_r
+        h += 360r if h < 0
+      end
+
+      [l, c, h]
+    end
+
+    def luv_to_xyz(l, u, v)
+      return [0r, 0r, 0r] if l <= 1e-8
+
+      wp_u, wp_v = WHITE_POINT_D65.uv_values
+      var_u = u / (13 * l) + wp_u
+      var_v = v / (13 * l) + wp_v
+      y = if l < 8
+            l / XYZ::KAPPA
+          else
+            ((l + 16r) / 116r)**3
+          end
+      x = -(9 * y * var_u) / ((var_u - 4) * var_v - var_u * var_v)
+      z = (9 * y - (15 * var_v * y) - (var_v * x)) / (3 * var_v)
+      [x, y, z]
+    end
+
+    # RGB -> ???
+
+    RGB2XYZ = [
+      [  0.41239079926595948129,  0.35758433938387796373,  0.18048078840183428751 ],
+      [  0.21263900587151035754,  0.71516867876775592746,  0.07219231536073371500 ],
+      [  0.01933081871559185069,  0.11919477979462598791,  0.95053215224966058086 ]
+    ]
+
+    def rgb_to_xyz(r, g, b)
+      dot_product(RGB2XYZ, srgb_to_linear_srgb(r, g, b))
+    end
+
+    # sRGB -> ???
+
+    def srgb_to_linear_srgb(r, g, b)
+      [r, g, b].map do |v|
+        if v > 0.04045
+          ((v + 0.055r) / 1.055r) ** 2.4r
+        else
+          v / 12.92r
+        end
+      end
+    end
+
+    # XYZ -> ???
+
+    XYZ2RGB = [
+      [  3.24096994190452134377, -1.53738317757009345794, -0.49861076029300328366 ],
+      [ -0.96924363628087982613,  1.87596750150772066772,  0.04155505740717561247 ],
+      [  0.05563007969699360846, -0.20397695888897656435,  1.05697151424287856072 ]
+    ]
+    def xyz_to_rgb(x, y, z)
+      r, g, b = dot_product(XYZ2RGB, [x, y, z])
+      r, g, b = srgb_to_linear_srgb(r, g, b)
+      [
+        r.clamp(0r, 1r),
+        g.clamp(0r, 1r),
+        b.clamp(0r, 1r)
+      ]
+    end
+  end
+end

data/lib/colors/husl.rb

@@ -1,45 +1,7 @@
-require "numo/narray"
-
 module Colors
   # Human-friendly alternative to HSL color space.
   # The definition of HUSL is provided in <http://www.hsluv.org>.
   class HUSL < HSL
-    DEG2RAD = 0.01745329251994329577r  # 2 * pi / 360
-
-    def self.from_rgb(r, g, b)
-      c = XYZ.from_rgb(r, g, b)
-      l, u, v = c.luv_components(WHITE_POINT_D65)
-      l, c, h = convert_luv_to_lch(l, u, v)
-      h, s, l = convert_lch_to_husl(l, c, h)
-      new(h, s.to_r.clamp(0r, 1r), l.to_r.clamp(0r, 1r))
-    end
-
-    private_class_method def self.convert_luv_to_lch(l, u, v)
-      c = Math.sqrt(u*u + v*v).to_r
-
-      if c < 1e-8
-        h = 0r
-      else
-        h = Math.atan2(v, u).to_r * 180/Math::PI.to_r
-        h += 360r if h < 0
-      end
-
-      [l, c, h]
-    end
-
-    private_class_method def self.convert_lch_to_husl(l, c, h)
-      if l > 99.9999999 || l < 1e-8
-        s = 0r
-      else
-        mx = max_chroma(l, h)
-        s = c / mx * 100r
-      end
-
-      h = 0r if c < 1e-8
-
-      [h, s/100r, l/100r]
-    end
-
     def ==(other)
       case other
       when HUSL
@@ -61,10 +23,13 @@ module Colors
       RGB.new(*rgb_components)
     end
 
+    def to_xyz
+      x, y, z = Convert.lch_to_xyz(*lch_components)
+      XYZ.new(x, y, z)
+    end
+
     def rgb_components
-      l, u, v = convert_lch_to_luv(*lch_components)
-      x, y, z = convert_luv_to_xyz(l, u, v)
-      XYZ.new(x, y, z).rgb_components
+      to_xyz.rgb_components
     end
 
     def lch_components
@@ -74,7 +39,7 @@ module Colors
       if l > 99.9999999 || l < 1e-8
         c = 0r
       else
-        mx = self.class.max_chroma(l, h)
+        mx = Convert.max_chroma(l, h)
         c = mx / 100r * s
       end
 
@@ -82,63 +47,5 @@ module Colors
 
       [l, c, h]
     end
-
-    private def convert_lch_to_luv(l, c, h)
-      h_rad = h * DEG2RAD
-      u = Math.cos(h_rad).to_r * c
-      v = Math.sin(h_rad).to_r * c
-      [l, u, v]
-    end
-
-    private def convert_luv_to_xyz(l, u, v)
-      return [0r, 0r, 0r] if l <= 1e-8
-
-      wp_u, wp_v = WHITE_POINT_D65.uv_values
-      var_u = u / (13 * l) + wp_u
-      var_v = v / (13 * l) + wp_v
-      y = if l < 8
-            l / XYZ::KAPPA
-          else
-            ((l + 16r) / 116r)**3
-          end
-      x = -(9 * y * var_u) / ((var_u - 4) * var_v - var_u * var_v)
-      z = (9 * y - (15 * var_v * y) - (var_v * x)) / (3 * var_v)
-      [x, y, z]
-    end
-
-    def self.max_chroma(l, h)
-      h_rad = h * DEG2RAD
-      sin_h = Math.sin(h_rad).to_r
-      cos_h = Math.cos(h_rad).to_r
-
-      result = Float::INFINITY
-      get_bounds(l).each do |line|
-        len = line[1] / (sin_h - line[0] * cos_h)
-        result = len if 0 <= len && len < result
-      end
-      result
-    end
-
-    def self.get_bounds(l)
-      sub1 = (l + 16)**3 / 1560896r
-      sub2 = sub1 > XYZ::EPSILON ? sub1 : l/XYZ::KAPPA
-
-      bounds = Array.new(6) { [0r, 0r] }
-      0.upto(2) do |ch|
-        m1 = XYZ2RGB[ch, 0].to_r
-        m2 = XYZ2RGB[ch, 1].to_r
-        m3 = XYZ2RGB[ch, 2].to_r
-
-        [0, 1].each do |t|
-          top1 = (284517r * m1 - 94839r * m3) * sub2
-          top2 = (838422r * m3 + 769860r * m2 + 731718r * m1) * l * sub2 - 769860r * t * l
-          bottom = (632260r * m3 - 126452r * m2) * sub2 + 126452r * t
-
-          bounds[ch*2 + t][0] = top1 / bottom
-          bounds[ch*2 + t][1] = top2 / bottom
-        end
-      end
-      bounds
-    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,14 @@ 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.to_r.clamp(0r, 1r), l.to_r.clamp(0r, 1r))
     end
 
     def to_xyz
-      XYZ.from_rgb(r, g, b)
+      XYZ.new(*Convert.rgb_to_xyz(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/version.rb

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

data/lib/colors/xyy.rb

@@ -0,0 +1,50 @@
+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
+      large_x = large_y*x/y
+      large_z = large_y*(1 - x - y)/y
+      XYZ.new(large_x, large_y, large_z)
+    end
+
+    private def canonicalize(x, y, large_y)
+      [
+        Rational(x),
+        Rational(y),
+        Rational(large_y)
+      ]
+    end
+  end
+end

data/lib/colors/xyz.rb

@@ -1,20 +1,4 @@
-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
 
@@ -22,25 +6,6 @@ module Colors
 
     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
@@ -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

@@ -37,5 +37,4 @@ Gem::Specification.new do |spec|
   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,44 +175,17 @@ 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)
   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))
-  end
-
-  test("to_rgb") do
+  test("#to_rgb") do
     # black
     assert_equal(Colors::RGB.new(0, 0, 0),
                  Colors::HUSL.new(0, 0, 0).to_rgb)

data/test/test-rgb.rb

@@ -234,7 +234,7 @@ class ColorsRGBTest < Test::Unit::TestCase
                  Colors::RGB.new(0x33, 0x33, 0x33).to_hex_string)
   end
 
-  test("to_rgb") do
+  test("#to_rgb") do
     black = Colors::RGB.new(0, 0, 0)
     assert_same(black, black.to_rgb)
   end
@@ -291,4 +291,31 @@ class ColorsRGBTest < Test::Unit::TestCase
     assert_equal(Colors::HSL.new(0r, 0r, 1r),
                  Colors::RGB.new(1r, 1r, 1r).to_hsl)
   end
+
+  test("#to_husl") do
+    # black
+    assert_equal(Colors::HUSL.new(0, 0, 0),
+                 Colors::RGB.new(0, 0, 0).to_husl)
+    # red
+    assert_near(Colors::HUSL.new(12.177050630061776r, 1r, 0.5323711559542933r),
+                Colors::RGB.new(1r, 0, 0).to_husl)
+    # yellow
+    assert_near(Colors::HUSL.new(85.87432021817473r, 1r, 0.9713855934179674r),
+                Colors::RGB.new(1r, 1r, 0).to_husl)
+    # green
+    assert_near(Colors::HUSL.new(127.71501294924047r, 1r, 0.8773551910965973r),
+                Colors::RGB.new(0r, 1r, 0).to_husl)
+    # cyan
+    assert_near(Colors::HUSL.new(192.17705063006116r, 1r, 0.9111475231670507r),
+                Colors::RGB.new(0r, 1r, 1r).to_husl)
+    # blue
+    assert_near(Colors::HUSL.new(265.8743202181779r, 1r, 0.3230087290398002r),
+                Colors::RGB.new(0r, 0r, 1r).to_husl)
+    # magenta
+    assert_near(Colors::HUSL.new(307.7150129492436r, 1r, 0.60322731354551294r),
+                Colors::RGB.new(1r, 0r, 1r).to_husl)
+    # white
+    assert_near(Colors::HUSL.new(0r, 0r, 1r),
+                Colors::RGB.new(1r, 1r, 1r).to_husl)
+  end
 end

data/test/test-xyz.rb

@@ -1,7 +1,7 @@
 class ColorsXYZTest < Test::Unit::TestCase
   sub_test_case("#luv_components") do
     test("on ITU-R BT.709 D65 white point") do
-      l, u, v = Colors::XYZ.from_rgb(0r, 0r, 0r).luv_components(Colors::WHITE_POINT_D65)
+      l, u, v = Colors::RGB.new(0r, 0r, 0r).to_xyz.luv_components(Colors::WHITE_POINT_D65)
       assert_in_delta(0, l)
       assert_in_delta(0, u)
       assert_in_delta(0, v)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red-colors
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Kenta Murata
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-16 00:00:00.000000000 Z
+date: 2019-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,20 +80,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: numo-narray
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: ''
 email:
 - mrkn@mrkn.jp
@@ -110,6 +96,7 @@ files:
 - lib/colors/abstract_color.rb
 - lib/colors/alpha_component.rb
 - lib/colors/color_data.rb
+- lib/colors/convert.rb
 - lib/colors/helper.rb
 - lib/colors/hsl.rb
 - lib/colors/hsla.rb
@@ -118,6 +105,7 @@ files:
 - lib/colors/rgb.rb
 - lib/colors/rgba.rb
 - lib/colors/version.rb
+- lib/colors/xyy.rb
 - lib/colors/xyz.rb
 - red-colors.gemspec
 - test/helper.rb
@@ -148,18 +136,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubyforge_project: 
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Red Colors provides a wide array of features for dealing with colors. This
   includes conversion between colorspaces, desaturation, and parsing colors.
 test_files:
-- test/test-named-color.rb
-- test/test-hsl.rb
-- test/test-husl.rb
-- test/test-xyz.rb
 - test/test-hsla.rb
+- test/test-named-color.rb
+- test/test-rgba.rb
 - test/helper.rb
 - test/test-rgb.rb
-- test/test-rgba.rb
 - test/run.rb
+- test/test-hsl.rb
+- test/test-xyz.rb
+- test/test-husl.rb