huespace 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6422aedbcf443c23efb849ff2543a1872f120a82d2e68d7a8fc34b0ee4f518f3
+  data.tar.gz: 2353233ed144e5283f833b8e9c7512999a1655c70881d6bac7d13f8ce33743ea
+SHA512:
+  metadata.gz: 50c80164bc380eea51cd27f0798930988334333e327da22abcc639b1711d2eeb89cf40e1033f1da2fcaa90ea01341b9fc0f7e587e54175332c02d34a401a9053
+  data.tar.gz: 726acd864d746d4d64176f07f8ead52ac69c2d647fab10340803e095ba42ab917ac807e3c4d869d735d8acc337375efb57f81416f3f31b10a6c4c6061faf7c47

data/lib/huespace/median_cut.rb

@@ -0,0 +1,80 @@
+module Huespace
+    class MedianCut
+        SplitInfo = Struct.new(:range, :group_index, :color_index, keyword_init: true)
+        
+        def self.process(colors, count, hist)
+            colors = colors.uniq # Remove duplicate colors
+            groups = [colors]
+            limit = [count, colors.size].min
+            
+            loop do
+                break if groups.size >= limit
+
+                split_info = determine_split(groups)
+                group1, group2 = split_group(groups[split_info.group_index], split_info)
+                groups.delete_at(split_info.group_index) # Remove group that we split by
+                groups << group1 unless group1.empty?
+                groups << group2 unless group2.empty?
+            end
+            
+            palette = []
+            groups.sort_by! { |group| -calc_sort_score(group, hist) }
+            groups.each do |group|
+                palette << average_color(group)
+            end
+    
+            palette[0...count]
+        end
+    
+        private
+    
+        def self.determine_split(groups)
+            stats = []
+    
+            groups.each_with_index do |group, index|
+                reds = group.map { |el| el[0] }
+                greens = group.map { |el| el[1] }
+                blues = group.map { |el| el[2] }
+    
+                ranges = []
+                ranges << SplitInfo.new(group_index: index, range: reds.max - reds.min, color_index: 0)
+                ranges << SplitInfo.new(group_index: index, range: greens.max - greens.min, color_index: 1)
+                ranges << SplitInfo.new(group_index: index, range: blues.max - blues.min, color_index: 2)
+    
+                stats << ranges.max_by(&:range)
+            end
+    
+            stats.max_by(&:range)
+        end
+    
+        def self.split_group(group, split_info)
+            colors = group.sort_by { |pixel| pixel[split_info.color_index] }
+    
+            median_index = colors.size / 2
+    
+            group1 = colors[0..(median_index - 1)]
+            group2 = colors[median_index..-1]
+    
+            [group1, group2]
+        end
+
+        # Score for sorting colors by dominance
+        # For each group we calculate the sum of how many of each pixel from the group was in the original image
+        def self.calc_sort_score(group, hist)
+            score = 0
+            group.each do |pixel|
+                score += hist[Huespace.get_pixel_index(pixel)]
+            end
+
+            score
+        end
+    
+        def self.average_color(colors)
+            average_r = colors.map { |pixel| pixel[0]}.sum() / colors.size()
+            average_g = colors.map { |pixel| pixel[1]}.sum() / colors.size()
+            average_b = colors.map { |pixel| pixel[2]}.sum() / colors.size()
+    
+            [average_r, average_g, average_b]
+        end
+    end
+end

data/lib/huespace.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Huespace
+  require "mini_magick"
+  require "huespace/median_cut.rb"
+
+  # Returns a palette of representative colors
+  def Huespace.get_palette(image_source, n_colors)
+    pixels = Huespace.load_image(image_source)
+    
+    sampled_pixels, hist = Huespace.sample_pixels(pixels)
+    Huespace::MedianCut.process(sampled_pixels, n_colors, hist)
+  end
+
+  # Returns most colorful color
+  # This is achieved by sorting the palette using the following formula:
+  # (max + min) * (max - min)) / max
+  # max and min represent one of the rgb values
+  # More about this here: http://changingminds.org/explanations/perception/visual/colourfulness.htm
+  def Huespace.get_most_colorful_color(image_source)
+    colors = Huespace.get_palette(image_source, 6)
+
+    return colors.sort_by { |color| ((color.max + color.min) * (color.max - color.min)) / color.max }.last()
+  end
+
+  # Returns the dominant color
+  def Huespace.get_dominant_color(image_source)
+    colors = Huespace.get_palette(image_source, 5)
+
+    return colors[0]
+  end
+
+  private
+    def Huespace.load_image(image_source)
+      begin
+        image = MiniMagick::Image.open(image_source)
+      rescue TypeError
+        # Extract from stream
+        image = MiniMagick::Image.read(image_source) # 
+      rescue StandardError => e
+        raise "Invalid URL!"
+      end
+
+      image.get_pixels.flatten(1)
+    end
+
+    # Quality determines the step between chosen pixels
+    # Higher number = Lower quality
+    def Huespace.sample_pixels(pixels, quality=10)
+      sampled_pixels = [];
+      hist = Hash.new(0)
+
+      (0..pixels.length - 1).step(quality).each do |i|
+          sampled_pixels << pixels[i] unless (pixels[i][0] > 250 && pixels[i][1] > 250 && pixels[i][2] > 250) # Skip white pixels
+          hist[get_pixel_index(pixels[i])] += 1
+      end
+
+      [sampled_pixels, hist]
+    end
+
+    # Determines the index for the histogram
+    def Huespace.get_pixel_index(pixel)
+      return pixel[0] << 10 + pixel[1] << 5 + pixel[2]
+    end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: huespace
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Dino Tognon, Ivan Božić
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.11.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: "Huespace can extract a color palette from local images, url-s or images
+  as byte-streams. \n                      Besides palettes, it can also extract the
+  most dominant color and the most colorful color!"
+email: dino.tognon@arsfutura.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/huespace.rb
+- lib/huespace/median_cut.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Extract a color palette from any image
+test_files: []