camalian 0.0.3 → 0.2.2

data/lib/camalian/image.rb

@@ -1,6 +1,7 @@
-require 'rmagick'
+# frozen_string_literal: true
 
 module Camalian
+  # Load image into Camalian
   class Image
     attr_accessor :src_file_path
 
@@ -8,29 +9,30 @@ module Camalian
       @src_file_path = file_path
     end
 
-    def prominent_colors(count=Camalian.options[:color_count])
-      image = ::Magick::Image.read(@src_file_path)[0]
-      image.resize!(100,100)
-      colors = Palette.new
-      initial_count = count
-      q = nil
-      loop do
-        q = image.quantize(initial_count, Magick::RGBColorspace)
-        break if q.color_histogram.size > count
-        initial_count = initial_count + 10
+    def prominent_colors(count = Camalian.options[:color_count],
+                         quantization: Camalian.options[:quantization],
+                         optimal: true)
+      image = ::ChunkyPNG::Image.from_file(@src_file_path)
+
+      colors = image.pixels.map do |val|
+        Color.new(
+          ChunkyPNG::Color.r(val),
+          ChunkyPNG::Color.g(val),
+          ChunkyPNG::Color.b(val)
+        )
       end
-      palette = q.color_histogram.sort {|a, b| b[1] <=> a[1]}
-      (0..[count, palette.count].min - 1).each do |i|
-          c = palette[i].first.to_s.split(',').map {|x| x[/\d+/]}
-          c.pop
-          c[0], c[1], c[2] = [c[0], c[1], c[2]].map { |s|
-              s = s.to_i
-              s = s / 256 if s / 256 > 0 # not all ImageMagicks are created equal....
-              s
-          }
-          colors << Color.new(c[0],c[1],c[2])
+
+      quantize = quantization.new
+
+      palette = quantize.process(colors, count)
+
+      retry_count = 1
+      while !optimal && palette.size < count
+        palette = quantize.process(colors, count + retry_count)
+        retry_count += 1
       end
-      return colors.uniq(&:to_hex)
+
+      palette
     end
   end
 end

data/lib/camalian/palette.rb

@@ -1,27 +1,46 @@
+# frozen_string_literal: true
+
 module Camalian
+  # Collection of colors with some useful features
   class Palette < Array
+    def self.from_hex(hex_values)
+      new(hex_values.map { |v| Color.from_hex(v) })
+    end
 
     def sort_by_lightness
-      Palette.new(self.sort_by { |a| a.l }.reverse)
+      Palette.new(sort_by(&:l).reverse)
     end
 
     def sort_by_hue
-      Palette.new(self.sort_by { |a| a.h }.reverse)
+      Palette.new(sort_by(&:h).reverse)
     end
 
     def sort_similar_colors
-      Palette.new(self.sort_by { |a| a.hsv })
+      Palette.new(sort_by(&:hsv))
     end
 
     def sort_by_saturation
-      Palette.new(self.sort_by { |a| a.s }.reverse)
+      Palette.new(sort_by(&:s).reverse)
+    end
+
+    def average_color
+      r = map(&:r).inject(&:+)
+      g = map(&:g).inject(&:+)
+      b = map(&:b).inject(&:+)
+      size = self.size
+
+      Color.new(r / size, g / size, b / size)
     end
 
     def light_colors(limit1, limit2)
       min = [limit1, limit2].min
       max = [limit1, limit2].max
-      table = self.dup
+      table = dup
       Palette.new(table.delete_if { |color| color.l > max or color.l < min })
     end
+
+    def to_hex
+      map(&:to_hex)
+    end
   end
 end

data/lib/camalian/quantization/histogram.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Camalian
+  module Quantization
+    class Histogram # :nodoc:
+      def process(colors, count)
+        bucket_size = (255.0 / count).ceil
+        buckets = {}
+
+        colors.each do |color|
+          key = bucket_key(color, bucket_size)
+          buckets[key] ||= Palette.new
+          buckets[key].push(color)
+        end
+
+        buckets = buckets.values
+        buckets = buckets.sort_by(&:size).reverse
+        average_colors = buckets.map(&:average_color)
+        Palette.new(average_colors[0...count])
+      end
+
+      private
+
+      def bucket_key(color, bucket_size)
+        "#{color.r / bucket_size}:#{color.g / bucket_size}:#{color.b / bucket_size}"
+      end
+    end
+  end
+end

data/lib/camalian/quantization/k_means.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Camalian
+  module Quantization
+    class KMeans # :nodoc:
+      INIT_TRIES = 10
+
+      def process(colors, count)
+        # Its faster to extract unique colors once
+        colors = colors.uniq
+        means = initial_means(colors, count)
+
+        done = false
+
+        until done
+          groups = group_by_means(colors, means)
+          new_means = groups.map do |group|
+            Palette.new(group).average_color
+          end
+          common = means & new_means
+
+          done = common.size == means.size
+          means = new_means
+        end
+
+        Palette.new(means)
+      end
+
+      private
+
+      def initial_means(colors, count)
+        count = colors.size if count > colors.size
+        means = []
+        tries = 0
+        while means.size != count && tries < INIT_TRIES
+          (count - means.size).times { means << colors[rand(colors.size)] }
+          means.uniq!
+          tries += 1
+        end
+
+        means
+      end
+
+      def group_by_means(pixels, means)
+        groups = {}
+
+        pixels.each do |p|
+          distances = means.map { |m| p.rgb_distance(m) }
+          min_distance_index = distances.index(distances.min)
+
+          groups[min_distance_index] ||= []
+          groups[min_distance_index] << p
+        end
+
+        groups.values
+      end
+    end
+  end
+end

data/lib/camalian/quantization/median_cut.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Camalian
+  module Quantization
+    class MedianCut # :nodoc:
+      SplitInfo = Struct.new(:range, :group_index, :color, keyword_init: true)
+      def process(colors, count)
+        # Its faster to extract unique colors once
+        colors = colors.uniq
+        groups = [colors]
+        limit = [count, colors.size].min
+
+        loop do
+          split_info = determine_group_split(groups)
+          group1, group2 = split_group(groups[split_info.group_index], split_info)
+          groups.reject!.each_with_index { |_g, index| index == split_info.group_index }
+          groups << group1 unless group1.empty?
+          groups << group2 unless group2.empty?
+
+          break if groups.size >= limit
+        end
+
+        palletes = groups.map { |g| Palette.new(g.uniq) }
+        average_colors = palletes.map(&:average_color)
+
+        Palette.new(average_colors[0...count])
+      end
+
+      private
+
+      def determine_group_split(groups)
+        stats = []
+
+        groups.each_with_index do |group, index|
+          reds = group.map(&:r)
+          greens = group.map(&:g)
+          blues = group.map(&:b)
+
+          ranges = []
+          ranges << SplitInfo.new(group_index: index, range: reds.max - reds.min, color: :r) unless reds.empty?
+          ranges << SplitInfo.new(group_index: index, range: greens.max - greens.min, color: :g) unless greens.empty?
+          ranges << SplitInfo.new(group_index: index, range: blues.max - blues.min, color: :b) unless blues.empty?
+
+          stats << ranges.max_by(&:range)
+        end
+
+        stats.max_by(&:range)
+      end
+
+      def split_group(group, split_info)
+        split_color = split_info.color
+        colors = group.sort_by { |pixel| pixel.send split_color }
+
+        return [[colors[0]], [colors[1]]] if colors.size == 2
+
+        median_index = colors.size / 2
+        median_value = colors[median_index].send split_color
+
+        group1 = []
+        group2 = []
+
+        colors.each do |color|
+          if color.send(split_color) <= median_value
+            group1 << color
+          else
+            group2 << color
+          end
+        end
+
+        [group1, group2]
+      end
+    end
+  end
+end

data/lib/camalian/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Camalian
-  VERSION = "0.0.3"
+  VERSION = '0.2.2'
 end

data/test/color_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'camalian'
+
+describe Camalian::Color do
+  before do
+    @color = Camalian::Color.new(120, 255, 30)
+  end
+
+  describe 'Color initialized with 120, 255, 30 rgb values' do
+    it 'hex value must be #78ff1e' do
+      _(@color.to_hex).must_equal '#78ff1e'
+    end
+
+    it 'hsl color components must ' do
+      _([@color.h.to_i, @color.s.to_i, @color.l.to_i]).must_equal [96, 100, 55]
+    end
+
+    it 'hsv color components must ' do
+      _(@color.hsv.map(&:to_i)).must_equal [96, 88, 100]
+    end
+  end
+
+  describe 'initialized with 1 integer rgb value' do
+    it 'must have leading zero' do
+      _(Camalian::Color.new(7, 7, 7).to_hex).must_equal '#070707'
+    end
+  end
+end

data/test/palette_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'camalian'
+
+describe Camalian::Palette do
+  before do
+    mixed_colors = %w[#2560a2 #4dd915 #1530db #49cc23 #45c031 #3da84d #1d48be #399c5b #359069 #318478 #2d7886 #296c94
+                      #2154b0 #193ccc #41b43f].freeze
+
+    @palette = Camalian::Palette.from_hex(mixed_colors)
+  end
+
+  it 'initialize palette with correct size' do
+    _(@palette.size).must_equal 15
+  end
+
+  describe '#sort_by_lightness' do
+    it 'sort colors by lightness ' do
+      _(@palette.sort_by_lightness.to_hex).must_equal ['#41b43f', '#45c031', '#1530db', '#49cc23', '#4dd915',
+                                                       '#193ccc', '#3da84d', '#1d48be', '#399c5b', '#2154b0',
+                                                       '#2560a2', '#359069', '#296c94', '#318478', '#2d7886']
+    end
+  end
+
+  describe '#sort_by_hue' do
+    it 'sort colors by hue' do
+      _(@palette.sort_by_hue.to_hex).must_equal ['#1530db', '#193ccc', '#1d48be', '#2154b0', '#2560a2', '#296c94',
+                                                 '#2d7886', '#318478', '#359069', '#399c5b', '#3da84d', '#41b43f',
+                                                 '#45c031', '#49cc23', '#4dd915']
+    end
+  end
+
+  describe '#sort_by_saturation' do
+    it 'sort colors by saturation' do
+      _(@palette.sort_by_saturation.to_hex).must_equal ['#1530db', '#4dd915', '#193ccc', '#1d48be', '#49cc23',
+                                                        '#2154b0', '#2560a2', '#45c031', '#296c94', '#2d7886',
+                                                        '#41b43f', '#3da84d', '#399c5b', '#359069', '#318478']
+    end
+  end
+
+  describe '#sort_similar_colors' do
+    it 'sort colors by hsv' do
+      _(@palette.sort_similar_colors.to_hex).must_equal ['#4dd915', '#49cc23', '#45c031', '#41b43f', '#3da84d',
+                                                         '#399c5b', '#359069', '#318478', '#2d7886', '#296c94',
+                                                         '#2560a2', '#2154b0', '#1d48be', '#193ccc', '#1530db']
+    end
+  end
+
+  describe '#average_color' do
+    it 'return one average color' do
+      _(@palette.average_color.to_hex).must_equal '#318477'
+    end
+  end
+
+  describe '#light_colors' do
+    it 'extract light colors in provided limit' do
+      _(@palette.light_colors(40, 90).to_hex).must_equal ['#4dd915', '#1530db', '#49cc23', '#45c031', '#3da84d',
+                                                          '#1d48be', '#399c5b', '#2154b0', '#193ccc', '#41b43f']
+    end
+  end
+end

data/test/quantization/histogram_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'camalian'
+
+describe Camalian::Quantization::Histogram do
+  describe 'palette with 15 colors extracted' do
+    before do
+      @image = Camalian.load(File.join(File.dirname(__FILE__), '../assets/palette.png'))
+      @palette = @image.prominent_colors(15, optimal: false, quantization: Camalian::QUANTIZATION_HISTOGRAM)
+    end
+
+    it 'must have 15 colors' do
+      _(@palette.size).must_equal 15
+    end
+
+    it 'sort similar colors in order' do
+      _(@palette.sort_similar_colors.map(&:to_hex)).must_equal PALLET_IMAGE_COLORS
+    end
+  end
+
+  it 'should extract distinct colors' do
+    colors = %w[#FF0000 #00FF00 #0000FF].map { |c| Camalian::Color.from_hex(c) }
+    result = Camalian::Quantization::Histogram.new.process(colors, 3)
+
+    _(result.size).must_equal 3
+    _(result).must_equal colors
+  end
+
+  it 'should extract distinct colors lesser than pixels' do
+    colors = %w[#FF0000 #00FF00 #0000FF].map { |c| Camalian::Color.from_hex(c) }
+    result = Camalian::Quantization::Histogram.new.process(colors, 2)
+
+    _(result.size).must_equal 2
+  end
+
+  it 'should extract distinct colors not more than pixels' do
+    colors = %w[#FF0000 #00FF00 #0000FF].map { |c| Camalian::Color.from_hex(c) }
+    result = Camalian::Quantization::Histogram.new.process(colors, 4)
+
+    _(result.size).must_equal 3
+  end
+
+  it 'should extract same color' do
+    colors = %w[#FF0000 #FF0000 #FF0000].map { |c| Camalian::Color.from_hex(c) }
+    result = Camalian::Quantization::Histogram.new.process(colors, 3)
+
+    _(result.size).must_equal 1
+    _(result.to_hex).must_equal ['#ff0000']
+  end
+
+  it 'should extract multiple colors' do
+    colors = %w[#FF0000 #FF0000 #00FF00 #0000FF].map { |c| Camalian::Color.from_hex(c) }
+    result = Camalian::Quantization::Histogram.new.process(colors, 3)
+
+    _(result.size).must_equal 3
+    _(result.to_hex).must_equal %w[#ff0000 #00ff00 #0000ff]
+  end
+end