decolmor 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4394b870f83f01ebe74db59131475d1d9a72bd32d307e36b775f903fbfe95b67
-  data.tar.gz: e9aad1484b539e938e666de21bd5eb1a630118646b3391da4d40d95a473ea766
+  metadata.gz: 9bad9f3f292018ddb773baabedc9fd9d7cd6da14d7932dae3768640124ec8c0a
+  data.tar.gz: 1846c3b81edf98d162ce5c3ac8be9a48475f60d35c4ca57c83ae0c3590fd79c1
 SHA512:
-  metadata.gz: 939483bfc049fefab624f9ed62e10b081684ce020a3b0d96189036eb20747386f9693c831221684eb1403eeb0af899e29382459798fd3bbbebdbf232f8976aec
-  data.tar.gz: 606d35831d04dea98b8405e176240d2cf4ceedd9f7684170b0c972fc9b7db97964ab2c5080de897d3308b900fd5d0b9aeaafb1f8ce5ad899147f320796d6a45a
+  metadata.gz: a3bb07b37d6f970dd81c29cd4aca46f01d8eb6131cd2f2516f43b8e618ef18d4c65ea72c5a26c51f1c0b7ee6b1f63df3f21931fc886610100eb8815eac2e4119
+  data.tar.gz: a3984305b33fd84a30ef1faee7129bcb4da307ee702830f69cf1873f9c0557e6dceee25238d054d42e16deba276e24d1d9293cf9ed6a7b92546ef2a10da079ef

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.3.0 (September 27, 2021)
+
+  * Added support HSI <==> RGB  
+  > _RGB => HSI when rounding 1 ~2k RGB colors will be slightly different, 2 will fix this_
+  * Added methods for HEX <==> HSL/HSV/HSB/HSI/CMYK
+  * Fixed incorrect conversion to RGB when HUE == 360  
+    it was about the methods:
+    * hsl_to_rgb_alt
+    * hsv_to_rgb_alt  
+    and new:
+    * hsi_to_rgb
+
 ## 1.2.0 (September 21, 2021)
 
   * `.hex_to_rgb` now support a returnable alpha in range `0..255`  

data/NEWS.md

@@ -1,5 +1,10 @@
 # News
 
+## 1.3.0 (September 27, 2021)
+
+  * added support HSI <==> RGB
+  * added methods for HEX <==> HSL/HSV/HSB/HSI/CMYK
+
 ## 1.2.0 (September 21, 2021)
 
   * `.hex_to_rgb` now support a returnable alpha in range `0..255`  

data/README.md

@@ -4,11 +4,11 @@
 [![badge-codecov][badge-codecov]][codecov]
 [![badge-license][badge-license]][license]
 
-Gem for converting color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK  
+Gem for converting color spaces from/to: HEX/RGB/HSL/HSV/HSB/HSI/CMYK  
 The Alpha channel (transparency) is supported.  
 There is also a simple RGB generator.  
 
-[News][news] | [Recent releases][releases] | [Changelog][changelog] | [Wiki][wiki]
+[News][news] . [Recent releases][releases] . [Changelog][changelog] . [Wiki][wiki]
 
 ## Install
 Add the following line to Gemfile:
@@ -50,9 +50,10 @@ Gem methods will be available as class methods.
 
 See [WIKI](https://github.com/ChildrenofkoRn/decolmor/wiki/Examples) for more examples.
 
-## Rounding for HSL/HSV/HSB/CMYK
-By default, rounding 1 is used to convert to HSL/HSV/HSB/CMYK.  
-This is enough to loselessly convert RGB -> HSL/HSV/HSB/CMYK -> RGB:
+## Rounding for HSL/HSV/HSB/HSI/CMYK
+By default, rounding 1 is used to convert to HSL/HSV/HSB/HSI/CMYK.  
+This is enough to loselessly convert RGB -> HSL/HSV/HSB/HSI/CMYK -> RGB:
+ * _for HSI this is not quite true ~2k (of 16.6M) RGB colors will be slightly different, rounding 2 fixes this._
 ```ruby
     rgb = [224, 23, 131]  
     hsl = Decolmor.rgb_to_hsl(rgb)  # => [327.8, 81.4, 48.4]
@@ -75,7 +76,7 @@ You can also specify rounding as a second argument when calling the method:
 In this case, the global rounding will be ignored.
 If you need to get integers, use 0.
 
-## HEX to RGB(A)
+## HEX to
  - with & without prefix `#`
  - short HEX are supported (including Alpha)
  - can be set rounding for the Alpha channel
@@ -97,11 +98,16 @@ You can also set rounding for Alpha channel as a second argument:
 ```ruby
     Decolmor.hex_to_rgb('#19988BB8', 2)  # => [25, 152, 139, 0.72]
 ```
-This only works for converting HEX to RGBA.  
-In other cases (conversions between RGB/HSL/HSV/HSB/CMYK) Alpha channel remains unchanged.
+This only works for converting from HEX.  
+In other cases (conversions between RGB/HSL/HSV/HSB/HSI/CMYK) Alpha channel remains unchanged.
 
-## HSV or HSB
-HSB is an alternative name for HSV, it is the same thing.  
+## HSL, HSI, HSV or HSB
+**HSL**, **HSI**, **HSV** - are three _different_ color spaces.  
+They have only one common parameter **HUE**.    
+**S** - **Suturation**, despite the same name, is _different_ in all three spaces,  
+like the last component: **Lightness** / **Intensity** / **Value** (**Brightness**).
+
+**HSB** is an alternative name for **HSV**, it is the same thing.  
 However, for convenience, aliasing methods are made for HSB from HSV.
 ```ruby
     rgb = [255, 109, 55]  
@@ -119,7 +125,7 @@ or
 - hsv_to_rgb_alt
 - hsb_to_rgb_alt
 
-The results of the two implementations are identical, but the alternative versions (postfix `_alt`) are ~1.35X slower.
+The results of the two implementations are identical, but the alternative versions (postfix `_alt`) are slightly slower.
 
 ## Attention for CMYK !
 Unfortunately, there is no simple formula for linear RGB to/from CMYK conversion.  
@@ -127,7 +133,7 @@ This implementation is a simplified/dirty/simulation.
 CMYK is used for printing and the correct conversion will be non-linear, based on the color profile for the particular printing device.  
 Therefore, the CMYK conversion results will not match Adobe products.  
 **BUT:**  
-Conversion from/to HEX/RGB/HSL/HSV/HSB is simple and is described by formulas.  
+Conversion from/to HEX/RGB/HSL/HSV/HSB/HSI is simple and is described by formulas.  
 Read more: https://en.wikipedia.org/wiki/HSL_and_HSV  
 The results when rounded to an integer will be the same as when using graphics editors, such as CorelDRAW or Adobe Photoshop.
 
@@ -139,14 +145,16 @@ The results when rounded to an integer will be the same as when using graphics e
    - rgb_to_hex
   - Simple generator RGB, you can set any channel(s)
     - new_rgb
- - RGB(A) to HSL/HSV/HSB
+ - RGB(A) to HSL/HSV/HSB/HSI
    - rgb_to_hsl
    - rgb_to_hsv
    - rgb_to_hsb
- - HSL/HSV/HSB to RGB(A)
+   - rgb_to_hsi
+ - HSL/HSV/HSB/HSI to RGB(A)
    - hsl_to_rgb
    - hsv_to_rgb
    - hsb_to_rgb
+   - hsi_to_rgb
  - Alternative implementation HSL/HSV/HSB to RGB(A) (a little slower)
    - hsl_to_rgb_alt
    - hsv_to_rgb_alt
@@ -159,6 +167,18 @@ The results when rounded to an integer will be the same as when using graphics e
  - RGB(A) <==> CMYK
    - rgb_to_cmyk
    - cmyk_to_rgb
+ - HEX => HSL/HSV/HSB/HSI/CMYK
+   - hex_to_hsl
+   - hex_to_hsv
+   - hex_to_hsb
+   - hex_to_hsi
+   - hex_to_cmyk
+ - HSL/HSV/HSB/HSI/CMYK => HEX 
+   - hsl_to_hex
+   - hsv_to_hex
+   - hsb_to_hex
+   - hsi_to_hex
+   - cmyk_to_hex
 
 ## License
 MIT License  
@@ -167,8 +187,8 @@ Copyright (c) 2021 ChildrenofkoRn
 
 
 
-  [gem]: https://badge.fury.io/rb/decolmor "gem version"
-  [badge-gem]: https://badge.fury.io/rb/decolmor.svg "gem version"
+  [gem]: https://rubygems.org/gems/decolmor "gem version"
+  [badge-gem]: https://img.shields.io/gem/v/decolmor?color=bri&label=gem%20version&logo=ruby&logoColor=f01f7a "gem version"
   [codecov]: https://codecov.io/gh/ChildrenofkoRn/decolmor "codecov"
   [badge-codecov]: https://codecov.io/gh/ChildrenofkoRn/decolmor/branch/main/graph/badge.svg?token=5P4OQUXC3N "codecov"
   [github-workflow]: https://github.com/ChildrenofkoRn/decolmor/actions/workflows/build.yml "build"

data/decolmor.gemspec

@@ -4,8 +4,8 @@ Gem::Specification.new do |spec|
   spec.name          = 'decolmor'
   spec.version       = Decolmor::VERSION
   spec.licenses      = ['MIT']
-  spec.summary       = "Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK"
-  spec.description   = "Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK.\n" \
+  spec.summary       = "Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/HSI/CMYK"
+  spec.description   = "Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/HSI/CMYK.\n" \
                        "The Alpha channel (transparency) is supported.\n" \
                        "There is also a simple RGB generator."
   spec.authors       = ["ChildrenofkoRn"]

data/lib/decolmor/main.rb

@@ -148,8 +148,8 @@ module Decolmor
       lightness /= 100
 
       # calculation chroma & intermediate values
+      hue = (hue % 360) / 60
       chroma = (1 - (2 * lightness - 1).abs) * saturation
-      hue /= 60
       x = chroma * (1 - (hue % 2 - 1).abs)
       point = get_rgb_point(hue, chroma, x)
 
@@ -166,8 +166,8 @@ module Decolmor
       value /= 100
 
       # calculation chroma & intermediate values
+      hue = (hue % 360) / 60
       chroma = value * saturation
-      hue /= 60
       x = chroma * (1 - (hue % 2 - 1).abs)
       point = get_rgb_point(hue, chroma, x)
 
@@ -179,6 +179,56 @@ module Decolmor
 
     alias_method :hsb_to_rgb_alt, :hsv_to_rgb_alt
 
+    #========= RGB <==> HSI ================================================
+
+    def rgb_to_hsi(rgb_arr, rounding = hsx_round)
+      # scaling RGB values into range 0..1
+      rgb = rgb_arr[0..2].map { |color| color / 255.to_f }
+      alpha = rgb_arr[3]
+
+      # calculation HSI values
+      hue = get_hue(*rgb)
+      intensity = rgb.sum / 3
+      saturation = intensity.zero? ? 0 : 1 - rgb.min / intensity
+
+      # scaling values to fill 0..100 interval
+      saturation *= 100
+      intensity *= 100
+
+      # rounding, drop Alpha if not set (nil)
+      hsi = [hue, saturation, intensity].map { |x| x.round(rounding) }
+      alpha.nil? ? hsi : hsi + [alpha]
+    end
+
+    def hsi_to_rgb(hsi_arr)
+      hue, saturation, intensity, alpha = hsi_arr.map(&:to_f)
+      # scaling values into range 0..1
+      saturation /= 100
+      intensity /= 100
+
+      # calculation chroma & intermediate values
+      #
+      # as 360/60 does not get_rgb_point in any of the ranges 0...1 or 5...6
+      # so in the method we use (hue % 360)
+      # at the same time solving if hue is not in the 0..360 range
+      hue = (hue % 360) / 60
+      z = 1 - (hue % 2 - 1).abs
+      chroma = (3 * intensity * saturation) / (1 + z)
+      x = chroma * z
+      point = get_rgb_point(hue, chroma, x)
+
+      # calculation rgb
+      m = intensity * (1 - saturation)
+      rgb = point.map { |channel|  channel + m }
+
+      # checking rgb on overrange 0..1
+      rgb = fix_overrange_rgb(rgb)
+      # scaling into range 0..255 & rounding
+      rgb.map! { |channel|  (channel * 255).round }
+
+      alpha.nil? ? rgb : rgb + [alpha]
+    end
+
     #========= HSL <==> HSV (HSB) ==========================================
 
     def hsl_to_hsv(hsl_arr, rounding = hsx_round)
@@ -246,9 +296,55 @@ module Decolmor
       cmyk_arr.size == 5 ? rgb + [cmyk_arr.last] : rgb
     end
 
+    #========= HEX <==> HSL/HSV/HSB/HSI ========================================
+
+    def hex_to_hsl(hex, rounding = hsx_round, alpha_255: false)
+      rgb = hex_to_rgb(hex, alpha_255: alpha_255)
+      rgb_to_hsl(rgb, rounding)
+    end
+
+    def hsl_to_hex(hsl_arr, alpha_255: false)
+      rgb = hsl_to_rgb(hsl_arr)
+      rgb_to_hex(rgb, alpha_255: alpha_255)
+    end
+
+    def hex_to_hsv(hex, rounding = hsx_round, alpha_255: false)
+      rgb = hex_to_rgb(hex, alpha_255: alpha_255)
+      rgb_to_hsv(rgb, rounding)
+    end
+
+    def hsv_to_hex(hsv_arr, alpha_255: false)
+      rgb = hsv_to_rgb(hsv_arr)
+      rgb_to_hex(rgb, alpha_255: alpha_255)
+    end
+
+    alias_method :hex_to_hsb, :hex_to_hsv
+    alias_method :hsb_to_hex, :hsv_to_hex
+
+    def hex_to_hsi(hex, rounding = hsx_round, alpha_255: false)
+      rgb = hex_to_rgb(hex, alpha_255: alpha_255)
+      rgb_to_hsi(rgb, rounding)
+    end
+
+    def hsi_to_hex(hsi_arr, alpha_255: false)
+      rgb = hsi_to_rgb(hsi_arr)
+      rgb_to_hex(rgb, alpha_255: alpha_255)
+    end
+
+    def hex_to_cmyk(hex, rounding = hsx_round, alpha_255: false)
+      rgb = hex_to_rgb(hex, alpha_255: alpha_255)
+      rgb_to_cmyk(rgb, rounding)
+    end
+
+    def cmyk_to_hex(cmyk_arr, alpha_255: false)
+      rgb = cmyk_to_rgb(cmyk_arr)
+      rgb_to_hex(rgb, alpha_255: alpha_255)
+    end
+
+
     private
 
-    #========= helper methods for RGB to HSL/HSB/HSV =======================
+    #========= helper methods ==============================================
 
     # find greatest and smallest channel values and chroma from RGB
     def get_min_max_chroma(red, green, blue)
@@ -293,9 +389,21 @@ module Decolmor
       when 3...4 then [0, x, chroma]
       when 4...5 then [x, 0, chroma]
       when 5...6 then [chroma, 0, x]
-      else [0, 0, 0]
+      # HUE will never leave the 0..359 range because we use (hue % 360)
+      # else [0, 0, 0]
       end
     end
+
+    # checking rgb on overrange 0..1
+    def fix_overrange_rgb(rgb)
+      max = rgb.max
+      # so we keep HUE
+      # if we had just used clipping [[value, 255].min, 0].max
+      # we would have changed HUE
+      #
+      # Thx to Rotem & Giacomo Catenazzi from stackoverflow
+      max > 1 ? rgb.map { |channel|  channel / max } : rgb
+    end
   end
 
   extend ClassMethods

data/lib/decolmor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Decolmor
-  VERSION = '1.2.0'
+  VERSION = '1.3.0'
 end

data/spec/decolmor_spec.rb

@@ -19,7 +19,7 @@ RSpec.describe Decolmor do
       Decolmor.hsx_round = 1
     end
 
-    let(:colors) { FactoryBot.build(:colors_map, round: 2) }
+    let(:colors) { FactoryBot.build(:colors, round: 2) }
 
     it ".hsx_round by default 1" do
       expect( Decolmor.hsx_round ).to eq 1
@@ -32,7 +32,7 @@ RSpec.describe Decolmor do
 
   context 'HEX <==> RGB(A)' do
     describe ".hex_to_rgb" do
-      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:colors) { FactoryBot.build(:colors) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HEX w prefix # to RGB" do
@@ -96,7 +96,7 @@ RSpec.describe Decolmor do
     end
 
     describe ".rgb_to_hex" do
-      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:colors) { FactoryBot.build(:colors) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "RGB converts to HEX" do
@@ -127,7 +127,7 @@ RSpec.describe Decolmor do
     end
   end
 
-  
+
   context 'simple generator RGB, you can set any channel(s)' do
     describe ".new_rgb" do
       it "generate RGB with values into range 0..255" do
@@ -152,7 +152,7 @@ RSpec.describe Decolmor do
 
   context 'RGB(A) to HSL/HSV/HSB' do
     describe ".rgb_to_hsl" do
-      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:colors) { FactoryBot.build(:colors) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "RGB converts to HSL" do
@@ -188,9 +188,9 @@ RSpec.describe Decolmor do
     end
 
     describe ".rgb_to_hsv" do
-      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:colors) { FactoryBot.build(:colors) }
       let(:alphas) { FactoryBot.build(:alpha) }
-      let(:colors_round_2) { FactoryBot.build(:colors_map, round: 2) }
+      let(:colors_round_2) { FactoryBot.build(:colors, round: 2) }
 
       it "RGB converts to HSV" do
         colors.each_pair do |hex, values|
@@ -231,7 +231,7 @@ RSpec.describe Decolmor do
 
   context 'HSL/HSV/HSB to RGB(A)' do
     describe ".hsl_to_rgb" do
-      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:colors) { FactoryBot.build(:colors) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSL converts to RGB" do
@@ -250,7 +250,7 @@ RSpec.describe Decolmor do
     end
 
     describe ".hsv_to_rgb" do
-      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:colors) { FactoryBot.build(:colors) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSV converts to RGB" do
@@ -278,7 +278,7 @@ RSpec.describe Decolmor do
 
   context 'Alternative implementation HSL/HSV/HSB to RGB(A)' do
     describe ".hsl_to_rgb_alt" do
-      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:colors) { FactoryBot.build(:colors) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSL converts to RGB" do
@@ -295,17 +295,22 @@ RSpec.describe Decolmor do
         end
       end
 
-      it "if hue not a range member 0..360 return identical RGB values (colorless)" do
-        colors.each_pair do |hex, values|
-          hsl = values[:hsl]
-          hsl[0] += 360
-          expect( Decolmor.hsl_to_rgb_alt(hsl).uniq.size ).to eq 1
-        end
+      it "if hue == 360 we get valid values" do
+        rgb_int = [123, 1, 2]
+        # the resulting value from hsi with rounding 0 to an integer (hue will be 360)
+        # as 360/60 does not get_rgb_point in any of the ranges 0...1 or 5...6
+        # so in the method we use (hue % 360)
+        # at the same time solving if hue is not in the 0..360 range
+        # the fact that rgb_int and rgb_out differ is normal,
+        # because with integer HSL values its impossible to losslessly convert back to RGB
+        rgb_out = [121, 1, 1]
+        hsv = Decolmor.rgb_to_hsl(rgb_int, 0)
+        expect( Decolmor.hsl_to_rgb_alt(hsv) ).to eq rgb_out
       end
     end
 
     describe ".hsv_to_rgb_alt" do
-      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:colors) { FactoryBot.build(:colors) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSV converts to RGB" do
@@ -322,12 +327,17 @@ RSpec.describe Decolmor do
         end
       end
 
-      it "if hue not a range member 0..360 return identical RGB values (colorless)" do
-        colors.each_pair do |_hex, values|
-          hsl = values[:hsl]
-          hsl[0] -= 360
-          expect( Decolmor.hsl_to_rgb_alt(hsl).uniq.size ).to eq 1
-        end
+      it "if hue == 360 we get valid values" do
+        rgb_int = [128, 7, 8]
+        # the resulting value from hsi with rounding 0 to an integer (hue will be 360)
+        # as 360/60 does not get_rgb_point in any of the ranges 0...1 or 5...6
+        # so in the method we use (hue % 360)
+        # at the same time solving if hue is not in the 0..360 range
+        # the fact that rgb_int and rgb_out differ is normal,
+        # because with integer HSV values its impossible to losslessly convert back to RGB
+        rgb_out = [128, 6, 6]
+        hsv = Decolmor.rgb_to_hsv(rgb_int, 0)
+        expect( Decolmor.hsv_to_rgb_alt(hsv) ).to eq rgb_out
       end
     end
 
@@ -339,10 +349,79 @@ RSpec.describe Decolmor do
   end
 
 
+  context 'RGB <==> HSI' do
+    describe ".rgb_to_hsi" do
+      let(:colors) { FactoryBot.build(:colors) }
+      let(:alphas) { FactoryBot.build(:alpha) }
+      let(:colors_r3) { FactoryBot.build(:colors, round: 3) }
+
+      it "RGB converts to hsi" do
+        colors.each_pair do |hex, values|
+          expect( Decolmor.rgb_to_hsi(values[:rgb]) ).to eq values[:hsi]
+        end
+      end
+
+      it "alpha channel pass to hsi unchanged" do
+        color = colors.keys.sample
+        alphas.each_pair do |_hex_alpha, alpha|
+          rgba = colors[color][:rgb] + [alpha[:rgb]]
+          expect( Decolmor.rgb_to_hsi(rgba).last ).to eq alpha[:rgb]
+        end
+      end
+
+      it "you can set rounding for resulting hsi values (default = 1)" do
+        colors_r3.each_pair do |hex, values|
+          expect( Decolmor.rgb_to_hsi(values[:rgb], 3) ).to eq values[:hsi]
+        end
+      end
+
+      it "setting rounding doesn't affect alpha channel" do
+        color = colors.keys.sample
+        alphas.each_pair do |_hex_alpha, alpha|
+          rgba = colors[color][:rgb] + [alpha[:rgb]]
+          expect( Decolmor.rgb_to_hsi(rgba, 0).last ).to eq alpha[:rgb]
+        end
+      end
+    end
+
+    describe ".hsi_to_rgb" do
+      let(:colors) { FactoryBot.build(:colors) }
+      let(:alphas) { FactoryBot.build(:alpha) }
+
+      it "hsi converts to RGB" do
+        colors.each_pair do |_hex, values|
+          expect( Decolmor.hsi_to_rgb(values[:hsi]) ).to eq values[:rgb]
+        end
+      end
+
+      it "alpha channel pass to RGB unchanged" do
+        color = colors.keys.sample
+        alphas.each_pair do |_hex_alpha, values|
+          hsia = colors[color][:hsi] + [values[:rgb]]
+          expect( Decolmor.hsi_to_rgb(hsia).last ).to eq values[:rgb]
+        end
+      end
+
+      it "if hue == 360 we get valid values" do
+        rgb_int = [255, 11, 13]
+        # the resulting value from hsi with rounding 0 to an integer (hue will be 360)
+        # as 360/60 does not get_rgb_point in any of the ranges 0...1 or 5...6
+        # so in the method we use (hue % 360)
+        # at the same time solving if hue is not in the 0..360 range
+        # the fact that rgb_int and rgb_out differ is normal,
+        # because with integer HSI values its impossible to losslessly convert back to RGB
+        rgb_out = [253, 11, 11]
+        hsi = Decolmor.rgb_to_hsi(rgb_int, 0)
+        expect( Decolmor.hsi_to_rgb(hsi) ).to eq rgb_out
+      end
+    end
+  end
+
+
   context 'HSL <==> HSV (HSB)' do
     describe ".hsl_to_hsv" do
       # as for lossless conversion need to use float value with 2 decimal places
-      let(:colors) { FactoryBot.build(:colors_map, round: 2) }
+      let(:colors) { FactoryBot.build(:colors, round: 2) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSL converts to HSV" do
@@ -383,7 +462,7 @@ RSpec.describe Decolmor do
 
     describe ".hsv_to_hsl" do
       # as for lossless conversion need to use float value with 2 decimal places
-      let(:colors) { FactoryBot.build(:colors_map, round: 2) }
+      let(:colors) { FactoryBot.build(:colors, round: 2) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "HSV converts to HSL" do
@@ -426,7 +505,7 @@ RSpec.describe Decolmor do
 
   context 'RGB(A) <==> CMYK' do
     describe ".rgb_to_cmyk" do
-      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:colors) { FactoryBot.build(:colors) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "RGB converts to CMYK" do
@@ -461,7 +540,7 @@ RSpec.describe Decolmor do
     end
 
     describe ".cmyk_to_rgb" do
-      let(:colors) { FactoryBot.build(:colors_map) }
+      let(:colors) { FactoryBot.build(:colors) }
       let(:alphas) { FactoryBot.build(:alpha) }
 
       it "CMYK converts to RGB" do
@@ -480,4 +559,163 @@ RSpec.describe Decolmor do
     end
   end
 
+
+  context 'HEX <==> HSL/HSV/HSB/HSI/CMYK' do
+    describe ".hex_to_hsl" do
+      let(:color) { FactoryBot.build(:colors, :one) }
+
+      it "call hex_to_rgb & rgb_to_hsl" do
+        hex, values = *color.first
+        expect(Decolmor).to receive(:hex_to_rgb).with(hex, {alpha_255: false}).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hsl).with(values[:rgb], Decolmor.hsx_round)
+        Decolmor.hex_to_hsl(hex)
+      end
+
+      it "w additional args (rounding, alpha_255) call hex_to_rgb & rgb_to_hsl" do
+        hex, values = *color.first
+        expect(Decolmor).to receive(:hex_to_rgb).with(hex, {alpha_255: true}).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hsl).with(values[:rgb], 2)
+        Decolmor.hex_to_hsl(hex, 2, alpha_255: true)
+      end
+    end
+
+    describe ".hsl_to_hex" do
+      let(:color) { FactoryBot.build(:colors, :one) }
+
+      it "call hsl_to_rgb & rgb_to_hex" do
+        values = color.first.last
+        expect(Decolmor).to receive(:hsl_to_rgb).with(values[:hsl]).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hex).with(values[:rgb], {alpha_255: false})
+        Decolmor.hsl_to_hex(values[:hsl])
+      end
+
+      it "w additional args (rounding, alpha_255) call hsl_to_rgb & rgb_to_hex" do
+        _hex, values = color.first
+        expect(Decolmor).to receive(:hsl_to_rgb).with(values[:hsl]).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hex).with(values[:rgb], {alpha_255: true})
+        Decolmor.hsl_to_hex(values[:hsl], alpha_255: true)
+      end
+    end
+
+    describe ".hex_to_hsv" do
+      let(:color) { FactoryBot.build(:colors, :one) }
+
+      it "call hex_to_rgb & rgb_to_hsv" do
+        hex, values = *color.first
+        expect(Decolmor).to receive(:hex_to_rgb).with(hex, {alpha_255: false}).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hsv).with(values[:rgb], Decolmor.hsx_round)
+        Decolmor.hex_to_hsv(hex)
+      end
+
+      it "w additional args (rounding, alpha_255) call hex_to_rgb & rgb_to_hsv" do
+        hex, values = *color.first
+        expect(Decolmor).to receive(:hex_to_rgb).with(hex, {alpha_255: true}).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hsv).with(values[:rgb], 2)
+        Decolmor.hex_to_hsv(hex, 2, alpha_255: true)
+      end
+    end
+
+    describe ".hsv_to_hex" do
+      let(:color) { FactoryBot.build(:colors, :one) }
+
+      it "call hsv_to_rgb & rgb_to_hex" do
+        values = color.first.last
+        expect(Decolmor).to receive(:hsv_to_rgb).with(values[:hsv]).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hex).with(values[:rgb], {alpha_255: false})
+        Decolmor.hsv_to_hex(values[:hsv])
+      end
+
+      it "w additional args (rounding, alpha_255) call hsv_to_rgb & rgb_to_hex" do
+        values = color.first.last
+        expect(Decolmor).to receive(:hsv_to_rgb).with(values[:hsv]).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hex).with(values[:rgb], {alpha_255: true})
+        Decolmor.hsv_to_hex(values[:hsv], alpha_255: true)
+      end
+    end
+
+    describe ".hex_to_hsb" do
+      it "alias .rgb_to_hsv" do
+        expect( Decolmor.method(:hex_to_hsb ).original_name).to eq(:hex_to_hsv)
+      end
+    end
+
+    describe ".hsb_to_hex" do
+      it "alias .rgb_to_hsv" do
+        expect( Decolmor.method(:hsb_to_hex ).original_name).to eq(:hsv_to_hex)
+      end
+    end
+
+    describe ".hex_to_hsi" do
+      let(:color) { FactoryBot.build(:colors, :one) }
+
+      it "call hex_to_rgb & rgb_to_hsi" do
+        hex, values = *color.first
+        expect(Decolmor).to receive(:hex_to_rgb).with(hex, {alpha_255: false}).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hsi).with(values[:rgb], Decolmor.hsx_round)
+        Decolmor.hex_to_hsi(hex)
+      end
+
+      it "w additional args (rounding, alpha_255) call hex_to_rgb & rgb_to_hsi" do
+        hex, values = *color.first
+        expect(Decolmor).to receive(:hex_to_rgb).with(hex, {alpha_255: true}).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hsi).with(values[:rgb], 2)
+        Decolmor.hex_to_hsi(hex, 2, alpha_255: true)
+      end
+    end
+
+    describe ".hsi_to_hex" do
+      let(:color) { FactoryBot.build(:colors, :one) }
+
+      it "call hsi_to_rgb & rgb_to_hex" do
+        values = color.first.last
+        expect(Decolmor).to receive(:hsi_to_rgb).with(values[:hsi]).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hex).with(values[:rgb], {alpha_255: false})
+        Decolmor.hsi_to_hex(values[:hsi])
+      end
+
+      it "w additional args (rounding, alpha_255) call hsi_to_rgb & rgb_to_hex" do
+        values = color.first.last
+        expect(Decolmor).to receive(:hsi_to_rgb).with(values[:hsi]).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hex).with(values[:rgb], {alpha_255: true})
+        Decolmor.hsi_to_hex(values[:hsi], alpha_255: true)
+      end
+    end
+
+    describe ".hex_to_cmyk" do
+      let(:color) { FactoryBot.build(:colors, :one) }
+
+      it "call hex_to_rgb & rgb_to_cmyk" do
+        hex, values = *color.first
+        expect(Decolmor).to receive(:hex_to_rgb).with(hex, {alpha_255: false}).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_cmyk).with(values[:rgb], Decolmor.hsx_round)
+        Decolmor.hex_to_cmyk(hex)
+      end
+
+      it "w additional args (rounding, alpha_255) call hex_to_rgb & rgb_to_cmyk" do
+        hex, values = *color.first
+        expect(Decolmor).to receive(:hex_to_rgb).with(hex, {alpha_255: true}).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_cmyk).with(values[:rgb], 2)
+        Decolmor.hex_to_cmyk(hex, 2, alpha_255: true)
+      end
+    end
+
+    describe ".cmyk_to_hex" do
+      let(:color) { FactoryBot.build(:colors, :one) }
+
+      it "call cmyk_to_rgb & rgb_to_hex" do
+        values = color.first.last
+        expect(Decolmor).to receive(:cmyk_to_rgb).with(values[:cmyk]).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hex).with(values[:rgb], {alpha_255: false})
+        Decolmor.cmyk_to_hex(values[:cmyk])
+      end
+
+      it "w additional args (rounding, alpha_255) call cmyk_to_rgb & rgb_to_hex" do
+        values = color.first.last
+        expect(Decolmor).to receive(:cmyk_to_rgb).with(values[:cmyk]).and_return(values[:rgb])
+        expect(Decolmor).to receive(:rgb_to_hex).with(values[:rgb], {alpha_255: true})
+        Decolmor.cmyk_to_hex(values[:cmyk], alpha_255: true)
+      end
+    end
+  end
+
 end

data/spec/factories/colors.rb

@@ -1,78 +1,105 @@
 FactoryBot.define do
-  factory :colors_map, class: Hash do
+
+  factory :colors, class: Hash do
     skip_create
 
     colors_map = {
       # black
       "#000000" => {rgb:  [  0,   0,   0],                            hsl: [  0.000,   0.000,   0.000],
-                    cmyk: [  0.000,   0.000,   0.000, 100.000],       hsv: [  0.000,   0.000,   0.000],},
+                    cmyk: [  0.000,   0.000,   0.000, 100.000],       hsv: [  0.000,   0.000,   0.000],
+                                                                      hsi: [  0.000,   0.000,   0.000]},
       # white
       "#FFFFFF" => {rgb:  [255, 255, 255],                            hsl: [  0.000,   0.000, 100.000],
-                    cmyk: [  0.000,   0.000,   0.000,   0.000],       hsv: [  0.000,   0.000, 100.000],},
+                    cmyk: [  0.000,   0.000,   0.000,   0.000],       hsv: [  0.000,   0.000, 100.000],
+                                                                      hsi: [  0.000,   0.000, 100.000]},
       # red
       "#FF0000" => {rgb:  [255,   0,   0],                            hsl: [  0.000, 100.000,  50.000],
-                    cmyk: [  0.000, 100.000, 100.000,   0.000],       hsv: [  0.000, 100.000, 100.000],},
+                    cmyk: [  0.000, 100.000, 100.000,   0.000],       hsv: [  0.000, 100.000, 100.000],
+                                                                      hsi: [  0.000, 100.000,  33.333]},
       # lime
       "#00FF00" => {rgb:  [  0, 255,   0],                            hsl: [120.000, 100.000,  50.000],
-                    cmyk: [100.000,   0.000, 100.000,   0.000],       hsv: [120.000, 100.000, 100.000],},
+                    cmyk: [100.000,   0.000, 100.000,   0.000],       hsv: [120.000, 100.000, 100.000],
+                                                                      hsi: [120.000, 100.000,  33.333]},
       # blue
       "#0000FF" => {rgb:  [  0,   0, 255],                            hsl: [240.000, 100.000,  50.000],
-                    cmyk: [100.000, 100.000,   0.000,   0.000],       hsv: [240.000, 100.000, 100.000],},
+                    cmyk: [100.000, 100.000,   0.000,   0.000],       hsv: [240.000, 100.000, 100.000],
+                                                                      hsi: [240.000, 100.000,  33.333]},
       # yellow
       "#FFFF00" => {rgb:  [255, 255,   0],                            hsl: [ 60.000, 100.000,  50.000],
-                    cmyk: [  0.000,   0.000, 100.000,   0.000],       hsv: [ 60.000, 100.000, 100.000],},
+                    cmyk: [  0.000,   0.000, 100.000,   0.000],       hsv: [ 60.000, 100.000, 100.000],
+                                                                      hsi: [ 60.000, 100.000,  66.667]},
       # cyan / aqua
       "#00FFFF" => {rgb:  [  0, 255, 255],                            hsl: [180.000, 100.000,  50.000],
-                    cmyk: [100.000,   0.000,   0.000,   0.000],       hsv: [180.000, 100.000, 100.000],},
+                    cmyk: [100.000,   0.000,   0.000,   0.000],       hsv: [180.000, 100.000, 100.000],
+                                                                      hsi: [180.000, 100.000,  66.667]},
       # magenta / fuchsia
       "#FF00FF" => {rgb:  [255,   0, 255],                            hsl: [300.000, 100.000,  50.000],
-                    cmyk: [  0.000, 100.000,   0.000,   0.000],       hsv: [300.000, 100.000, 100.000],},
+                    cmyk: [  0.000, 100.000,   0.000,   0.000],       hsv: [300.000, 100.000, 100.000],
+                                                                      hsi: [300.000, 100.000,  66.667]},
       # silver
       "#C0C0C0" => {rgb:  [192, 192, 192],                            hsl: [  0.000,   0.000,  75.294],
-                    cmyk: [  0.000,   0.000,   0.000,  24.706],       hsv: [  0.000,   0.000,  75.294],},
+                    cmyk: [  0.000,   0.000,   0.000,  24.706],       hsv: [  0.000,   0.000,  75.294],
+                                                                      hsi: [  0.000,   0.000,  75.294]},
       # gray
       "#808080" => {rgb:  [128, 128, 128],                            hsl: [  0.000,   0.000,  50.196],
-                    cmyk: [  0.000,   0.000,   0.000,  49.804],       hsv: [  0.000,   0.000,  50.196],},
+                    cmyk: [  0.000,   0.000,   0.000,  49.804],       hsv: [  0.000,   0.000,  50.196],
+                                                                      hsi: [  0.000,   0.000,  50.196]},
       # maroon
       "#800000" => {rgb:  [128,   0,   0],                            hsl: [  0.000, 100.000,  25.098],
-                    cmyk: [  0.000, 100.000, 100.000,  49.804],       hsv: [  0.000, 100.000,  50.196],},
+                    cmyk: [  0.000, 100.000, 100.000,  49.804],       hsv: [  0.000, 100.000,  50.196],
+                                                                      hsi: [  0.000, 100.000,  16.732]},
       # olive
       "#808000" => {rgb:  [128, 128,   0],                            hsl: [ 60.000, 100.000,  25.098],
-                    cmyk: [  0.000,   0.000, 100.000,  49.804],       hsv: [ 60.000, 100.000,  50.196],},
+                    cmyk: [  0.000,   0.000, 100.000,  49.804],       hsv: [ 60.000, 100.000,  50.196],
+                                                                      hsi: [ 60.000, 100.000,  33.464]},
       # green
       "#008000" => {rgb:  [  0, 128,   0],                            hsl: [120.000, 100.000,  25.098],
-                    cmyk: [100.000,   0.000, 100.000,  49.804],       hsv: [120.000, 100.000,  50.196],},
+                    cmyk: [100.000,   0.000, 100.000,  49.804],       hsv: [120.000, 100.000,  50.196],
+                                                                      hsi: [120.000, 100.000,  16.732]},
       # purple
       "#800080" => {rgb:  [128,   0, 128],                            hsl: [300.000, 100.000,  25.098],
-                    cmyk: [  0.000, 100.000,   0.000,  49.804],       hsv: [300.000, 100.000,  50.196],},
+                    cmyk: [  0.000, 100.000,   0.000,  49.804],       hsv: [300.000, 100.000,  50.196],
+                                                                      hsi: [300.000, 100.000,  33.464]},
       # teal
       "#008080" => {rgb:  [  0, 128, 128],                            hsl: [180.000, 100.000,  25.098],
-                    cmyk: [100.000,   0.000,   0.000,  49.804],       hsv: [180.000, 100.000,  50.196],},
+                    cmyk: [100.000,   0.000,   0.000,  49.804],       hsv: [180.000, 100.000,  50.196],
+                                                                      hsi: [180.000, 100.000,  33.464]},
       # navy
       "#000080" => {rgb:  [  0,   0, 128],                            hsl: [240.000, 100.000,  25.098],
-                    cmyk: [100.000, 100.000,   0.000,  49.804],       hsv: [240.000, 100.000,  50.196],},
+                    cmyk: [100.000, 100.000,   0.000,  49.804],       hsv: [240.000, 100.000,  50.196],
+                                                                      hsi: [240.000, 100.000,  16.732]},
 
       # some random colors
       "#E01783" => {rgb:  [224,  23, 131],                            hsl: [327.761,  81.377,  48.431],
-                    cmyk: [  0.000,  89.732,  41.518,  12.157],       hsv: [327.761,  89.732,  87.843],},
+                    cmyk: [  0.000,  89.732,  41.518,  12.157],       hsv: [327.761,  89.732,  87.843],
+                                                                      hsi: [327.761,  81.746,  49.412]},
 
       "#1D8056" => {rgb:  [ 29, 128,  86],                            hsl: [154.545,  63.057,  30.784],
-                    cmyk: [ 77.344,   0.000,  32.812,  49.804],       hsv: [154.545,  77.344,  50.196],},
+                    cmyk: [ 77.344,   0.000,  32.812,  49.804],       hsv: [154.545,  77.344,  50.196],
+                                                                      hsi: [154.545,  64.198,  31.765]},
 
       "#229765" => {rgb:  [ 34, 151, 101],                            hsl: [154.359,  63.243,  36.275],
-                    cmyk: [ 77.483,   0.000,  33.113,  40.784],       hsv: [154.359,  77.483,  59.216],},
+                    cmyk: [ 77.483,   0.000,  33.113,  40.784],       hsv: [154.359,  77.483,  59.216],
+                                                                      hsi: [154.359,  64.336,  37.386]},
 
       "#239393" => {rgb:  [ 35, 147, 147],                            hsl: [180.000,  61.538,  35.686],
-                    cmyk: [ 76.190,   0.000,   0.000,  42.353],       hsv: [180.000,  76.190,  57.647],},
+                    cmyk: [ 76.190,   0.000,   0.000,  42.353],       hsv: [180.000,  76.190,  57.647],
+                                                                      hsi: [180.000,  68.085,  43.007]},
     }
 
     transient do
       round { 1 }
     end
 
-    initialize_with  do
-      colors_map.transform_values do |value|
-        value.transform_values { |arr| arr.map { |num| num.round(round)} }
+    trait :one do
+      initialize_with { colors_map.to_a.sample(1).to_h }
+    end
+
+    initialize_with { colors_map }
+
+    after(:build) do |colors, evaluator|
+      colors.transform_values! do |value|
+        value.transform_values! { |arr| arr.map { |num| num.round(evaluator.round)} }
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: decolmor
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - ChildrenofkoRn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-21 00:00:00.000000000 Z
+date: 2021-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -93,7 +93,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '7.0'
 description: |-
-  Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK.
+  Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/HSI/CMYK.
   The Alpha channel (transparency) is supported.
   There is also a simple RGB generator.
 email: Rick-ROR@ya.ru
@@ -146,7 +146,7 @@ requirements: []
 rubygems_version: 3.2.27
 signing_key: 
 specification_version: 4
-summary: 'Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/CMYK'
+summary: 'Converter color spaces from/to: HEX/RGB/HSL/HSV/HSB/HSI/CMYK'
 test_files:
 - spec/decolmor_spec.rb
 - spec/factories/alpha.rb