color_sort 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 81e0d767639e5bb6b4ffd6915f0b4607ce65b05d
-  data.tar.gz: b399a98a8bcede7671af2d587e08bc5593a93bc7
+  metadata.gz: 9304b816bb21e888326ea5ece5445f87d3ed7d93
+  data.tar.gz: 96d2388ce66d707a4d7fb5fda94f3d0e6a714e87
 SHA512:
-  metadata.gz: 0c090a1934e79feb4dc86f608b0fc61da779f30de431fc5973aaa3eaafb2b0fd639505c9158e67577cefd79d3e20d67b2dba64f3e7a22d05a725bf6462bd6f82
-  data.tar.gz: 0ad0740c0cdca320c4f10c10c24abf10f5db10f20623437b47ba082c000a3d1d5031dca9cbb8c0fedefb4726bd9970b7cd939c65b4e197f6bf68b7c1e4406e7b
+  metadata.gz: 015c771e85c643b3e14568fe98701a4eb140e8d3f4831ca57d1d5a660957eb3b0798885883e8399941539ac65568abd2fab74ac25ecf06c1ad5e722d1b2da8ec
+  data.tar.gz: 4bdf11e523a9bdbc6bb38f9e006d5be39e5cafd0cf94ba49e3346e7b69fa68d21460ca648446b82f5204e3954be4c31b58312b776d425c282028de6056ef023b

data/README.md

@@ -33,6 +33,19 @@ sorted_colors = ColorSort.sort(unsorted_colors)
 	# => ["94ec1e", "93e482", "39ae1e", "35c047", "5f9d4c", "7f40ed"]
 ```
 
+You can also sort multiple groups of colors with
+`ColorSort.sort_groups`. This will leave the groups in the order
+originally given, but will sort the colors within the groups. It will
+also order them such that the last color in a group and the first color in
+the next group are as close as possible.
+
+```ruby
+unsorted_colors = [["35c047", "7f40ed"], ["39ae1e"], ["5f9d4c", "94ec1e", "93e482"]]
+
+sorted_colors = ColorSort.sort_groups(unsorted_colors)
+	# => [["7f40ed", "35c047"], ["39ae1e"], ["5f9d4c", "93e482", "94ec1e"]]
+```
+
 ## How it works
 
 Often when dealing with colors on computers, we're working with the [RGB color model](http://en.wikipedia.org/wiki/Color_model#RGB_color_model). As each color has three components, we can think of it as a point in 3D space. This allows us to use the [Euclidean distance](http://en.wikipedia.org/wiki/Euclidean_distance) to see how far apart two colors are.

data/lib/color_sort.rb

@@ -1,5 +1,8 @@
 require "color_sort/version"
 require "color_sort/ordering"
+require "color_sort/closest_pair_finder"
+require "color_sort/grouped"
+require "color_sort/group_sorter"
 require "color_sort/distance"
 require "color_sort/color_space_converter"
 require "color_sort/sorter"
@@ -8,4 +11,8 @@ module ColorSort
   def self.sort(colors)
     Sorter.new(colors).sorted
   end
+
+  def self.sort_groups(groups)
+    GroupSorter.new(groups).sorted
+  end
 end

data/lib/color_sort/closest_pair_finder.rb

@@ -0,0 +1,35 @@
+module ColorSort
+  class ClosestPairFinder
+    def initialize(group_a, group_b)
+      @group_a = group_a
+      @group_b = group_b
+    end
+
+    def self.pair(*args)
+      new(*args).pair
+    end
+
+    def pair
+      shortest_distance = 1_000_000
+      closest_pair = nil
+
+      group_a.each do |color_a|
+        group_b.each do |color_b|
+          if (current_distance = distance(color_a, color_b)) < shortest_distance
+            shortest_distance = current_distance
+            closest_pair = [color_a, color_b]
+          end
+        end
+      end
+
+      closest_pair
+    end
+
+  private
+    attr_reader :group_a, :group_b
+
+    def distance(color_a, color_b)
+      ColorSort::Distance.ciede2000(color_a, color_b)
+    end
+  end
+end

data/lib/color_sort/group_sorter.rb

@@ -0,0 +1,33 @@
+module ColorSort
+  class GroupSorter
+    def initialize(groups)
+      @groups = groups
+    end
+
+    def sorted
+      Grouped::GroupList.new(lab_groups).sorted.map { |group|
+        group.map { |lab_color|
+          color_map[lab_color]
+        }
+      }
+    end
+
+  private
+    attr_reader :groups
+
+    def color_map
+      @color_map ||= groups.flatten.each_with_object({}) { |hex_rgb_color, hash|
+        lab_color = ColorSort::ColorSpaceConverter.hex_rgb_to_lab(hex_rgb_color)
+        hash[lab_color] = hex_rgb_color
+      }
+    end
+
+    def lab_groups
+      @lab_groups ||= groups.map { |group|
+        group.map { |hex_rgb_color|
+          ColorSort::ColorSpaceConverter.hex_rgb_to_lab(hex_rgb_color)
+        }
+      }
+    end
+  end
+end

data/lib/color_sort/grouped.rb

@@ -0,0 +1,10 @@
+require "color_sort/grouped/base_group"
+require "color_sort/grouped/empty_group"
+require "color_sort/grouped/single_item_group"
+require "color_sort/grouped/multiple_item_group"
+require "color_sort/grouped/group_list"
+
+module ColorSort
+  module Grouped
+  end
+end

data/lib/color_sort/grouped/base_group.rb

@@ -0,0 +1,30 @@
+module ColorSort
+  module Grouped
+    class BaseGroup
+      attr_accessor :previous_group, :next_group
+
+      def initialize(items)
+        @items = items
+      end
+
+      def sorted
+        raise NotImplementedError
+      end
+
+      def start_color
+        raise NotImplementedError
+      end
+
+      def end_color
+        raise NotImplementedError
+      end
+
+      def empty?
+        items.empty?
+      end
+
+    protected
+      attr_reader :items
+    end
+  end
+end

data/lib/color_sort/grouped/empty_group.rb

@@ -0,0 +1,9 @@
+module ColorSort
+  module Grouped
+    class EmptyGroup < BaseGroup
+      def sorted
+        []
+      end
+    end
+  end
+end

data/lib/color_sort/grouped/group_list.rb

@@ -0,0 +1,30 @@
+module ColorSort
+  module Grouped
+    class GroupList
+      def initialize(initial_groups)
+        @groups = initial_groups.map { |items| initialize_group(items) }
+        groups.reject(&:empty?).each_cons(2) do |group_a, group_b|
+          group_a.next_group = group_b
+          group_b.previous_group = group_a
+        end
+      end
+
+      def sorted
+        groups.map(&:sorted)
+      end
+
+    private
+      attr_reader :groups
+
+      def initialize_group(items)
+        if items.size == 0
+          EmptyGroup.new(items)
+        elsif items.size == 1
+          SingleItemGroup.new(items)
+        else
+          MultipleItemGroup.new(items)
+        end
+      end
+    end
+  end
+end

data/lib/color_sort/grouped/multiple_item_group.rb

@@ -0,0 +1,51 @@
+module ColorSort
+  module Grouped
+    class MultipleItemGroup < BaseGroup
+      def sorted
+        ordering = Ordering.new(start: start_color, finish: end_color)
+        items_except(start_color, end_color).each do |color|
+          ordering.add_lab_color(color)
+        end
+        ordering.colors
+      end
+
+      def start_color
+        @start_color ||= calculate_start_color
+      end
+
+      def end_color
+        @end_color ||= calculate_end_color
+      end
+
+    private
+      def calculate_end_color
+        if next_group.nil?
+          nil
+        else
+          closest_color(items_except(start_color), next_group.items)
+        end
+      end
+
+      def calculate_start_color
+        if previous_group.nil? || previous_group.end_color.nil?
+          nil
+        else
+          closest_color(items, [previous_group.end_color])
+        end
+      end
+
+      def closest_color(my_colors, other_colors)
+        color, _ = *ClosestPairFinder.pair(my_colors, other_colors)
+        color
+      end
+
+      def items_except(*ignored_items)
+        remaining = items.dup
+        ignored_items.each do |ignored_item|
+          remaining.delete_at(remaining.index(ignored_item)) unless ignored_item.nil?
+        end
+        remaining
+      end
+    end
+  end
+end

data/lib/color_sort/grouped/single_item_group.rb

@@ -0,0 +1,17 @@
+module ColorSort
+  module Grouped
+    class SingleItemGroup < BaseGroup
+      def sorted
+        items
+      end
+
+      def start_color
+        @start_color ||= items.first
+      end
+
+      def end_color
+        @end_color ||= items.first
+      end
+    end
+  end
+end

data/lib/color_sort/ordering.rb

@@ -4,16 +4,27 @@ module ColorSort
   class Ordering
     attr_reader :colors
 
-    def initialize
+    def initialize(start: nil, finish: nil)
       @colors = []
+      @start = start
+      @finish = finish
+      colors << start unless start.nil?
+      colors << finish unless finish.nil?
     end
 
     def add_lab_color(color)
       if colors.size < 2
-        colors << color
+        if finish.nil?
+          colors << color
+        else
+          colors.unshift(color)
+        end
       else
-        min_delta = distance(color, colors.first)
         min_delta_index = 0
+        min_delta = 1_000_000
+        if start.nil?
+          min_delta = distance(color, colors.first)
+        end
 
         (1...colors.size).each do |i|
           remove_distance = distance(colors[i-1], colors[i])
@@ -25,7 +36,7 @@ module ColorSort
           end
         end
 
-        if distance(colors.last, color) < min_delta
+        if finish.nil? && distance(colors.last, color) < min_delta
           min_delta_index = colors.size
         end
 
@@ -34,6 +45,8 @@ module ColorSort
     end
 
   private
+    attr_reader :start, :finish
+
     def distance(color_a, color_b)
       ColorSort::Distance.ciede2000(color_a, color_b)
     end

data/lib/color_sort/version.rb

@@ -1,3 +1,3 @@
 module ColorSort
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/lib/closest_pair_finder_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe ColorSort::ClosestPairFinder, :color_doubles do
+  describe ".pair" do
+    subject { ColorSort::ClosestPairFinder }
+
+    it "returns the pair of colors (one from each group) that are closest" do
+      expect(subject.pair([red, green], [blue])).to eq([red, blue])
+    end
+  end
+end

data/spec/lib/group_list_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe ColorSort::Grouped::GroupList, :color_doubles do
+  describe "#sorted" do
+    let(:group_a) { [red, green, blue, yellow] }
+    let(:group_b) { [yellow] }
+    let(:group_c) { [red, blue, green] }
+    let(:group_d) { [] }
+    let(:group_e) { [red, blue, yellow] }
+    let(:group_f) { [] }
+
+    let(:expected_a) { [green, blue, red, yellow] }
+    let(:expected_b) { [yellow] }
+    let(:expected_c) { [red, green, blue] }
+    let(:expected_d) { [] }
+    let(:expected_e) { [blue, red, yellow] }
+    let(:expected_f) { [] }
+
+    it "sorts the colors within their groups" do
+      grouped_sort = ColorSort::Grouped::GroupList.new(
+        [group_a, group_b, group_c, group_d, group_e, group_f]
+      )
+
+      expect(grouped_sort.sorted).to eq(
+        [expected_a, expected_b, expected_c, expected_d, expected_e, expected_f]
+      )
+    end
+  end
+end

data/spec/lib/ordering_spec.rb

@@ -1,20 +1,6 @@
 require "spec_helper"
 
-describe ColorSort::Ordering do
-  let(:red) { double(:red) }
-  let(:green) { double(:green) }
-  let(:blue) { double(:blue) }
-
-  before do
-    set_distance(red, red, 0)
-    set_distance(green, green, 0)
-    set_distance(blue, blue, 0)
-
-    set_distance(red, blue, 1)
-    set_distance(blue, green, 2)
-    set_distance(red, green, 3)
-  end
-
+describe ColorSort::Ordering, :color_doubles do
   describe "#add_lab_color" do
     context "with an empty ordering" do
       it "adds the color to the end of the array" do
@@ -64,14 +50,37 @@ describe ColorSort::Ordering do
         end
       end
     end
-  end
 
-  def set_distance(color_a, color_b, distance)
-    allow(ColorSort::Distance).to receive(:ciede2000)
-                                    .with(color_a, color_b)
-                                    .and_return(distance)
-    allow(ColorSort::Distance).to receive(:ciede2000)
-                                    .with(color_b, color_a)
-                                    .and_return(distance)
+    context "with a fixed start color" do
+      subject { ColorSort::Ordering.new(start: blue) }
+
+      it "doesn't add color at the start, even if it minimises total distance" do
+        subject.add_lab_color(green)
+        subject.add_lab_color(red)
+
+        expect(subject.colors).to eq([blue, red, green])
+      end
+    end
+
+    context "with a fixed finish color" do
+      subject { ColorSort::Ordering.new(finish: blue) }
+
+      it "doesn't add color at end, even if it minimises total distance" do
+        subject.add_lab_color(green)
+        subject.add_lab_color(red)
+
+        expect(subject.colors).to eq([green, red, blue])
+      end
+    end
+
+    context "with fixed start and finish colors" do
+      subject { ColorSort::Ordering.new(start: red, finish: blue) }
+
+      it "doesn't add color at start or end, even if it minimises total distance" do
+        subject.add_lab_color(green)
+
+        expect(subject.colors).to eq([red, green, blue])
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,38 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'color_sort'
 require "rspec/radar"
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  shared_context "with color doubles", :color_doubles do
+    let(:red) { double(:red) }
+    let(:green) { double(:green) }
+    let(:blue) { double(:blue) }
+    let(:yellow) { double(:yellow) }
+
+    before do
+      set_distance(red, red, 0)
+      set_distance(green, green, 0)
+      set_distance(blue, blue, 0)
+      set_distance(yellow, yellow, 0)
+
+      set_distance(red, blue, 1)
+      set_distance(blue, green, 2)
+      set_distance(red, green, 3)
+
+      set_distance(yellow, red, 4)
+      set_distance(yellow, green, 5)
+      set_distance(yellow, blue, 6)
+    end
+
+    def set_distance(color_a, color_b, distance)
+      allow(ColorSort::Distance).to receive(:ciede2000)
+                                      .with(color_a, color_b)
+                                      .and_return(distance)
+      allow(ColorSort::Distance).to receive(:ciede2000)
+                                      .with(color_b, color_a)
+                                      .and_return(distance)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: color_sort
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Pip Taylor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-29 00:00:00.000000000 Z
+date: 2014-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorscore
@@ -109,14 +109,24 @@ files:
 - Rakefile
 - color_sort.gemspec
 - lib/color_sort.rb
+- lib/color_sort/closest_pair_finder.rb
 - lib/color_sort/color_space_converter.rb
 - lib/color_sort/distance.rb
+- lib/color_sort/group_sorter.rb
+- lib/color_sort/grouped.rb
+- lib/color_sort/grouped/base_group.rb
+- lib/color_sort/grouped/empty_group.rb
+- lib/color_sort/grouped/group_list.rb
+- lib/color_sort/grouped/multiple_item_group.rb
+- lib/color_sort/grouped/single_item_group.rb
 - lib/color_sort/ordering.rb
 - lib/color_sort/sorter.rb
 - lib/color_sort/version.rb
 - spec/color_sort_spec.rb
+- spec/lib/closest_pair_finder_spec.rb
 - spec/lib/color_space_converter_spec.rb
 - spec/lib/distance_spec.rb
+- spec/lib/group_list_spec.rb
 - spec/lib/ordering_spec.rb
 - spec/lib/sorter_spec.rb
 - spec/spec_helper.rb
@@ -146,8 +156,10 @@ specification_version: 4
 summary: Sorts colors perceptually
 test_files:
 - spec/color_sort_spec.rb
+- spec/lib/closest_pair_finder_spec.rb
 - spec/lib/color_space_converter_spec.rb
 - spec/lib/distance_spec.rb
+- spec/lib/group_list_spec.rb
 - spec/lib/ordering_spec.rb
 - spec/lib/sorter_spec.rb
 - spec/spec_helper.rb