coloractor 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c09735acda7beea8d3b3f86be079ce3d3043e0e4
+  data.tar.gz: 9c421a2676a5e1dab33fb13ce68e84c8c2dc18d4
+SHA512:
+  metadata.gz: 7fe619616b81e916ccf6665127b7b790f07e9768f83dbc32ed9f1b8535dc6f00cb5295f64a9f5560549e603857ddd1cbd54e28898a110e61cab854d591d1b057
+  data.tar.gz: 2fd80ac41bba4ccdda997488b49b3da8e1ca39bfd504b08d663ea08a1956594591300178a079b52e5fe491c77a91bf55f0affe5ef9539ec03a1ee6ee7849df78

data/lib/coloractor/palette.rb

@@ -0,0 +1,181 @@
+require 'color' 
+require 'mini_magick'
+
+class Coloractor::Palette
+
+  N_QUANTIZED    = 100
+  MIN_DISTANCE   = 10.0
+  MIN_SATURATION = 0.05
+  MIN_PROMINENCE = 0.01
+  MAX_COLORS     = 5
+
+  def self.build_from_file(filename)
+    image = open_image(filename)
+     
+    unless image_mode_is_rgb?(image)
+      image = convert_image_mode_to_rgb(image)
+    end
+
+    image = trim_image(image)
+    image = resize_image(image)
+    image = reduce_colors_in_image(image, N_QUANTIZED)
+
+    canonical_colors  = { '#FFFFFFFF' => '#FFFFFFFF', '#000000FF' => '#000000FF' }
+    aggregated_colors = { '#FFFFFFFF' => 0, '#000000FF' => 0 }
+    
+    grouped_pixels = get_pixels_from_image(image)
+    pixels_count = grouped_pixels.values.reduce(:+)
+
+    sorted_pixels = grouped_pixels.sort_by{ |color, count| -count }
+    sorted_pixels.each do |(color, count)|
+      if aggregated_colors.include?(color)
+        aggregated_colors[color] += count
+      else
+        closest_color = find_closest_color(color, aggregated_colors)
+      
+        if closest_color && distance(color, closest_color) < MIN_DISTANCE
+          aggregated_colors[closest_color] += count
+          canonical_colors[color]           = closest_color
+        else
+          aggregated_colors[color] = count
+          canonical_colors[color]  = color
+        end
+      end
+    end
+
+    sorted_aggregated_colors = aggregated_colors.sort_by{ |color, count| -count }
+    background_color = detect_background_color(image, sorted_aggregated_colors, canonical_colors)
+    
+    colors = sorted_aggregated_colors.map{ |(color, count)| color }.select{ |c| background_color.nil? || c != background_color }
+    
+    saturated_colors = colors.select{ |color| calculate_saturation(color) >= MIN_SATURATION }
+    if background_color && calculate_opacity(background_color).zero?
+      background_color = nil
+    end
+
+    if saturated_colors.size > 0
+      colors = saturated_colors
+    else
+      colors = [ colors.first ]
+    end
+
+    palette_colors = []
+    colors.each do |color|
+      if calculate_prominence(color, sorted_aggregated_colors, pixels_count) >= calculate_prominence(colors.first, sorted_aggregated_colors, pixels_count) * MIN_PROMINENCE
+        palette_colors << color
+      end
+
+      break if palette_colors.size >= MAX_COLORS
+    end
+
+    new(palette_colors.map{ |c| c[0..6] }, background_color ? background_color[0..6] : nil)
+  end
+
+  attr_reader :colors, :background_color
+
+  def initialize(colors, background_color)
+    @colors           = colors
+    @background_color = background_color
+  end
+
+  private
+
+  def self.open_image(filename)
+    MiniMagick::Image.open(filename)
+  end
+
+  def self.image_mode_is_rgb?(image)
+    image['colorspace'] =~ /rgb/i
+  end
+
+  def self.convert_image_mode_to_rgb(image)
+    image.tap{ |i| i.colorspace "sRGB" }
+  end
+
+  def self.trim_image(image)
+    image.tap(&:trim)
+  end
+
+  def self.resize_image(image)
+    image.tap{ |i| i.resize '600x600\>' }
+  end
+
+  def self.reduce_colors_in_image(image, max_colors)
+    image.tap{ |i| i.combine_options{ |o| o.dither 'None'; o.colors max_colors } }
+  end
+
+  def self.get_pixels_from_image(image)
+    output = `convert #{ image.path } -dither None -colors 100 -define histogram:unique-colors=true -format %c histogram:info:`
+    grouped_pixels = Hash[ *output.scan(/(\d+?):.+(#[0-9a-fA-F]{6,8})/).map{ |a, b| [b, a.to_i] }.flatten ]
+  end
+
+  def self.find_closest_color(color, colors)
+    color, _ = colors.min_by do |(c, _)| 
+      distance(c, color)
+    end
+
+    color
+  end
+  
+  def self.distance(color1, color2)
+    color1_transparency = calculate_opacity(color1)
+    color2_transparency = calculate_opacity(color2)
+    Color::RGB.new.delta_e94(Color::RGB.by_hex(color1[1..6]).to_lab, Color::RGB.by_hex(color2[1..6]).to_lab) + (color1_transparency - color2_transparency).abs
+  end
+
+  def self.calculate_opacity(color)
+    color.size > 7 ? color[7..8].to_i(16) : 255
+  end
+
+  def self.detect_background_color(image, colors, canonical_colors)
+    # We want to remove background color based on key points only. Some logos might be solid color based and they are treated as background then.
+    # TODO: remove commented code if it is not needed anymore
+    # if colors.first && calculate_prominence(colors.first.first, colors, pixels.size) >= BACKGROUND_PROMINENCE
+    #   return colors.first.first
+    # end
+
+    width, height = get_image_size(image)
+  
+    points = [
+      [0,         0], 
+      [0,         height / 2], 
+      [0,         height - 1], 
+      [width - 1, height - 1],
+      [width - 1, height / 2],
+      [width - 1, 0], 
+      [width / 2, 0]
+    ]
+
+    edge_pixels = points.map{ |(left, top)| get_image_pixel_color(image, left, top) }
+    grouped_edge_pixels = Hash[ *edge_pixels.group_by{|i| i}.map{|k,v| [k, v.count] }.flatten ]
+    sorted_pixels = grouped_edge_pixels.sort_by{ |color, count| count }.reverse
+    majority_color, majority_count = sorted_pixels.first
+    if majority_count >= 3
+      canonical_colors[majority_color]
+    else
+      nil
+    end
+  end
+
+  def self.get_image_size(image)
+    image['dimensions']
+  end
+
+  def self.get_image_pixel_color(image, left, top)
+    image.run_command("convert", "#{image.path}[1x1+#{left.to_i}+#{top.to_i}]", 'txt:').split("\n").each do |line|
+      return $1 if /^0,0:.*(#[0-9a-fA-F]+)/.match(line)
+    end
+    nil
+  end
+
+  def self.calculate_prominence(color, colors, pixels_count)
+    colors = Hash[ *colors.flatten ] if colors.is_a?(Array)
+
+    colors[color] / pixels_count.to_f
+  end
+
+  def self.calculate_saturation(color)
+    Color::RGB.by_hex(color[1..6]).to_hsl.saturation / 100
+  end
+
+end

data/lib/coloractor.rb

@@ -0,0 +1,25 @@
+class Coloractor
+
+  def self.extract_colors(filename)
+    new(filename).tap do |instance|
+      instance.extract_colors
+    end
+  end
+
+  attr_reader :dominant_colors, :background_color
+
+  def initialize(filename)
+    @filename        = filename
+    @dominant_colors = []
+  end
+
+  def extract_colors
+    palette = Coloractor::Palette.build_from_file(@filename)
+
+    @dominant_colors  = palette.colors
+    @background_color = palette.background_color
+  end
+
+end
+
+require 'coloractor/palette'  

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: coloractor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Maxim Gladkov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: A simple ruby wrapper around colorific Python script.
+email: contact@maximgladkov.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/coloractor.rb
+- lib/coloractor/palette.rb
+homepage: http://rubygems.org/gems/colorator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Dominant colors extractor from an image file
+test_files: []
+has_rdoc: