borealis 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7dc6e8b735da4b63a7edf43f7b2cc0964a67eff1
+  data.tar.gz: a98909c6d6398b291e8cabecb0ed7eb3a7d1e584
+SHA512:
+  metadata.gz: 806fc46d3831cf1425d2a52832185af7cbadda09c60b0fe19fc457a92b490e32f05d57ca62544164f6066cb607b819010629fcd68c7645adce461592ccc72990
+  data.tar.gz: 4279ff2b8a4a7830f967f5b22edf9832267cbb51b571265f6c1d282b639a6d32d21c247896e69ab2ebcd89eae376c92836b37964624cbc670ccad2f1c9465e78

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Josh Steiner
+Copyright (c) 2013 Josh Steiner and thoughtbot, inc.
 
 MIT License
 
@@ -19,4 +19,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,6 +1,8 @@
 # Borealis
 
-TODO: Write a gem description
+Borealis finds the most prominent colors in an image, attempting to find colors that are distinct from one another.
+
+It provides defaults which favor speed, but the defaults are easily changed if you prefer accuracy. For most purposes, the default settings should be accurate enough.
 
 ## Installation
 
@@ -18,7 +20,82 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Find the three prominent colors in an image:
+
+```ruby
+Borealis.new('image/path.jpg').colors # Returns 3 colors with hex and rgb attributes
+Borealis.new('image/path.jpg').hexes # Returns 3 hex values
+Borealis.new('image/path.jpg').rgbs # Returns 3 rgb values
+```
+
+Easily get color values out of a color:
+
+```ruby
+color = Borealis.new(file).colors.first
+color.rgb # "(222, 2, 15)"
+color.hex # "#DE020F"
+```
+
+Measure distance between colors:
+
+```ruby
+orange.rgb_distance_to red #=> 127.0
+orange.lab_distance_to red #=> 39.79252198414681
+
+maroon.rgb_distance_to dark_red #=> 11.0
+maroon.lab_distance_to dark_read #=> 5.071593528474779
+```
+
+Calculate CIE-L\*a\*b\* value of an sRGB color:
+
+```ruby
+cyan = Borealis::Color.new(0, 255, 255)
+cyan.to_lab #=> [91.11652110946342, -48.079618466228716, -14.138127754846131]
+```
+
+Change the defaults:
+
+```ruby
+borealis = Borealis.new('image/path.jpg',
+  size: '150x150',
+  colors: 3,
+  delta: 0.001,
+  static: false
+)
+```
+
+### Size
+
+_Default: '50x50'_
+
+Size takes any [Image Geometry](http://www.imagemagick.org/script/command-line-processing.php#geometry) that imagemagick handles.
+
+For more accurate results, use a larger image. However, this comes at a severe time cost.
+
+### Colors
+
+_Default: 3_
+
+The number of colors you want returned.
+
+### Iterations
+
+_Default: 3_
+
+### Static
+
+_Default: true_
+
+Static determines whether the color output will be the same each time given the same image. Use false if you want the colors to change each run.
+
+## How does it work?
+
+Borealis uses the [k-means](http://en.wikipedia.org/wiki/K-means_clustering) clustering algorithm, which in this case:
+
+1. Takes _n_ colors from the image as cluster centers
+2. Adds the rest of the colors to the cluster which they are closest to
+3. Finds the average color in each cluster, setting the results as new cluster centers
+4. Empties each cluster, except for the new center, and repeats steps 2-3 until convergance has been reached
 
 ## Contributing
 
@@ -27,3 +104,7 @@ TODO: Write usage instructions here
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+## License
+
+Borealis is copyright 2013 Josh Steiner and thoughtbot, inc., and may be redistributed under the terms specified in the LICENSE file.

data/borealis.gemspec

@@ -8,15 +8,18 @@ Gem::Specification.new do |gem|
   gem.version       = Borealis::VERSION
   gem.authors       = ["Josh Steiner"]
   gem.email         = ["josh@jsteiner.me"]
-  gem.description   = %q{Finds top colors in a given image.}
-  gem.summary       = %q{Finds top colors in a given image.}
+  gem.description   = %q{Finds most prominent colors in a given image.}
+  gem.summary       = %q{Finds most prominent colors in a given image.}
   gem.homepage      = ""
 
   gem.files         = `git ls-files`.split($/)
   gem.test_files    = gem.files.grep("spec")
   gem.require_paths = ["lib"]
 
+  gem.requirements << 'ImageMagick'
+
   gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'bourne'
 
   gem.add_dependency 'cocaine'
 end

data/lib/borealis.rb

@@ -1,27 +1,33 @@
-require "cocaine"
-require "borealis/color"
-require "borealis/image_analyzer"
-require "borealis/version"
+require 'borealis/cluster'
+require 'borealis/color'
+require 'borealis/image_converter'
+require 'borealis/kmeans'
+require 'borealis/version'
 
 class Borealis
   attr_reader :colors
 
-  def initialize(file, analyzer = ImageAnalyzer)
-    analysis = analyzer.new(file).process
-    @colors = analysis.split("\n").map { |line| line_to_color(line) }
-    colors.sort!
+  def initialize(file, options = {})
+    image_colors = ImageConverter.new(file, options[:size]).to_colors
+    clusters = KMeans.new(image_colors, parse_options(options)).run
+    @colors = clusters.map(&:center)
   end
 
   def hexes
-    colors.map(&:hex)
+    @colors.map(&:hex)
+  end
+
+  def rgbs
+    @colors.map(&:rgb)
   end
 
   private
 
-  def line_to_color(line)
-    line = line.scan(/\(([\s+\d+,]+)\).+([\#][0-9,A-F,a-f]{6})/).flatten
-    rgb = line.first.split(',').map { |value| value.to_i }
-    hex = line.last
-    Color.new(rgb, hex)
+  def parse_options(options)
+    {
+      number_of_clusters: options[:colors],
+      delta: options[:delta],
+      static: options[:static]
+    }.reject{ |_,v| v.nil? }
   end
 end

data/lib/borealis/cluster.rb

@@ -0,0 +1,31 @@
+class Borealis
+  class Cluster
+    attr_reader :center, :colors
+
+    def initialize(center)
+      @center = center
+      @colors = []
+    end
+
+    def recenter!
+      red_sum = green_sum = blue_sum = 0
+
+      colors.each do |color|
+        red_sum += color.red
+        green_sum += color.green
+        blue_sum += color.blue
+      end
+
+      old_center = @center
+      @center = Color.new(
+        red_sum / colors.length,
+        green_sum / colors.length,
+        blue_sum / colors.length
+      )
+
+      @colors.clear
+
+      old_center.rgb_distance_to @center
+    end
+  end
+end

data/lib/borealis/color.rb

@@ -1,18 +1,86 @@
 class Borealis
   class Color
-    attr_reader :rgb, :hex
+    include Math
 
-    def initialize(rgb, hex)
-      @rgb = rgb
-      @hex = hex
+    attr_reader :red, :green, :blue
+
+    def initialize(red, green, blue)
+      @red = red
+      @green = green
+      @blue = blue
+    end
+
+    def rgb_distance_to(other)
+      Math.sqrt((red - other.red) ** 2 + (green - other.green) ** 2 + (blue - other.blue) ** 2)
+    end
+
+    def lab_distance_to(other)
+      l, a, b = to_lab
+      other_l, other_a, other_b = other.to_lab
+      Math.sqrt((l - other_l) ** 2 + (a - other_a) ** 2 + (b - other_b) ** 2)
+    end
+
+    def rgb
+      "(#{red}, #{green}, #{blue})"
+    end
+
+    def hex
+      "##{hex_segment red}#{hex_segment green}#{hex_segment blue}"
+    end
+
+    def ==(other)
+      red == other.red && green == other.green && blue == other.blue
+    end
+
+    # http://www.easyrgb.com/index.php?X=MATH&H=07#text7
+    def to_lab
+      reference_white_X =  95.047
+      reference_white_Y = 100.000
+      reference_white_Z = 108.883
+
+      x, y, z = to_xyz
+      x = x / reference_white_X
+      y = y / reference_white_Y
+      z = z / reference_white_Z
+
+      x, y, z = [x, y, z].map do |value|
+        if value > 0.008856
+          value ** (1.0 / 3.0)
+        else
+          7.787 * value + 16.0 / 116.0
+        end
+      end
+
+      cie_L = 116 * y - 16
+      cie_a = 500 * (x - y)
+      cie_b = 200 * (y - z)
+
+      [cie_L, cie_a, cie_b]
     end
 
-    def distance
-      @distance ||= Math.sqrt(rgb[0] ^ 2 + rgb[1] ^ 2 + rgb[2] ^ 2)
+    private
+
+    def hex_segment(primary_color)
+      primary_color.to_s(16).rjust(2, '0').upcase
     end
 
-    def <=>(other)
-      distance <=> other.distance
+    # http://www.easyrgb.com/index.php?X=MATH&H=02#text2
+    def to_xyz
+      r, g, b = [@red, @green, @blue].map do |value|
+        value = value / 255.0
+        if value > 0.04045
+          value = ((value + 0.055) / 1.055) ** 2.4
+        else
+          value = value / 12.92
+        end
+        value * 100.0
+      end
+
+      x = r * 0.4124 + g * 0.3576 + b * 0.1805
+      y = r * 0.2126 + g * 0.7152 + b * 0.0722
+      z = r * 0.0193 + g * 0.1192 + b * 0.9505
+
+      [x, y, z]
     end
   end
 end

data/lib/borealis/image_converter.rb

@@ -0,0 +1,33 @@
+require 'cocaine'
+
+class Borealis
+  class ImageConverter
+    def initialize(image, size)
+      @image = image
+      @size = size || '50x50'
+    end
+
+    def read_image
+      Cocaine::CommandLine.new(
+        'convert',
+        "#{@image} -resize #{@size} txt:-"
+      ).run
+    end
+
+    def to_colors
+      colors_for(read_image)
+    end
+
+    private
+
+    def colors_for(data)
+      lines = data.split("\n").drop(1)
+      lines.map do |line|
+        line = line.scan(/\(([\d+\s+,]+)\)/).flatten
+        rgb_values = line.first.split(',').map { |value| value.to_i }
+
+        Color.new(*rgb_values)
+      end
+    end
+  end
+end

data/lib/borealis/kmeans.rb

@@ -0,0 +1,53 @@
+class Borealis
+  class KMeans
+    def initialize(colors, options = {})
+      @colors = colors
+      @number_of_clusters = options[:number_of_clusters] || 3
+      @delta = options[:delta] || 0.01
+      @static = options.has_key?(:static) ? options[:static] : true
+
+      if @number_of_clusters > @colors.length
+        raise 'You may not have more clusters than colors.'
+      end
+    end
+
+    def run
+      if @colors.length == @number_of_clusters
+        @colors.map { |color| Cluster.new(color) }
+      else
+        max_delta = 0
+        while max_delta <= @delta do
+          @colors.each { |color| add_to_closest_cluster(color) }
+          max_delta = clusters.map { |cluster| cluster.recenter! }.max
+        end
+
+        clusters
+      end
+    end
+
+    private
+
+    def clusters
+      @clusters ||= @number_of_clusters.times.map do |index|
+        if @static
+          # Find spaced out colors that are always the same
+          color_index = @colors.length * index / @number_of_clusters
+          color = @colors[color_index]
+        else
+          color = @colors.sample
+          @colors.delete color
+        end
+
+        Cluster.new(color)
+      end
+    end
+
+    def add_to_closest_cluster(color)
+      closest_cluster = clusters.min do |a, b|
+        color.rgb_distance_to(a.center) <=> color.rgb_distance_to(b.center)
+      end
+
+      closest_cluster.colors << color
+    end
+  end
+end

data/lib/borealis/version.rb

@@ -1,3 +1,3 @@
 class Borealis
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/borealis/borealis_spec.rb

@@ -1,29 +1,10 @@
 require 'spec_helper'
 
 describe Borealis, '#colors' do
-  it 'returns the colors from smallest to largest distance' do
-    image = 'spec/fixtures/winter.jpg'
-    histogram = Borealis.new(image)
-    expect(histogram.colors).to eq histogram.colors.sort
-  end
-end
-
-describe Borealis, '#hexes' do
-  it 'returns the correct hexes for the data provided' do
-    image = 'spec/fixtures/winter.jpg'
-    histogram = Borealis.new(image, FakeAnalyzer)
-    expect(histogram.hexes).to eq %w(#2A5E9F #2C2D48)
-  end
-end
-
-class FakeAnalyzer
-  def initialize(file)
-  end
+  it 'returns the number of colors requested' do
+    image = 'spec/fixtures/aurora_borealis.jpg'
+    borealis = Borealis.new(image, colors: 6)
 
-  def process
-    <<-eos
-      51076: ( 1, 2,3) #2A5E9F srgb(1,2,3)
-      47529: ( 4, 5, 6) #2C2D48 srgb(4,5,6)
-    eos
+    expect(borealis.colors.length).to eq 6
   end
 end

data/spec/borealis/cluster_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Borealis::Cluster, '#recenter!' do
+  it 'returns the distance to the old center' do
+    center = Borealis::Color.new(1, 2, 3)
+    cluster = Borealis::Cluster.new(center)
+    cluster.colors << Borealis::Color.new(2, 4, 6)
+    cluster.colors << Borealis::Color.new(4, 6, 8)
+
+    cluster.recenter!
+
+    expect(cluster.center).to eq Borealis::Color.new(3, 5, 7)
+  end
+
+  it 'creates a new color in the center of existing colors' do
+    center = stub('center', :rgb_distance_to)
+    cluster = Borealis::Cluster.new(center)
+    cluster.colors << Borealis::Color.new(2, 4, 6)
+    cluster.colors << Borealis::Color.new(4, 6, 8)
+
+    cluster.recenter!
+
+    expect(cluster.center).to eq Borealis::Color.new(3, 5, 7)
+  end
+
+  it 'empties its colors' do
+    center = stub('center', :rgb_distance_to)
+    cluster = Borealis::Cluster.new(center)
+    cluster.colors << Borealis::Color.new(1, 2, 3)
+
+    cluster.recenter!
+
+    expect(cluster.colors).to be_empty
+  end
+end

data/spec/borealis/color_spec.rb

@@ -1,20 +1,48 @@
 require 'spec_helper'
 
-describe Borealis::Color, '#distance' do
-  it 'calculates the distance correctly' do
-    color = Borealis::Color.new([1, 2, 3], 'hex')
-    expect(color.distance).to eq Math.sqrt(1 ^ 2 + 2 ^ 2 + 3 ^ 2)
+describe Borealis::Color, '#distance_to' do
+  it 'calculates the RGB distance correctly' do
+    color = Borealis::Color.new(1, 2, 3)
+    other_color = Borealis::Color.new(2, 3, 4)
+    distance = Math.sqrt((1 - 2) ** 2 + (2 - 3) ** 2 + (3 - 4) ** 2)
+
+    expect(color.rgb_distance_to(other_color)).to eq distance
+  end
+end
+
+describe Borealis::Color, '#rgb' do
+  it 'returns a string with the correct rgb value' do
+    color = Borealis::Color.new(1, 2, 3)
+    expect(color.rgb).to eq '(1, 2, 3)'
   end
 end
 
-describe Borealis::Color, 'comparison' do
-  it 'compares colors according to distance' do
-    large_color = Borealis::Color.new([4, 5, 6], 'arbitrary')
-    small_color = Borealis::Color.new([2, 3, 4], 'arbitrary')
-    smallest_color = Borealis::Color.new([1, 2, 3], 'arbitrary')
+describe Borealis::Color, '#hex' do
+  it 'returns a string with the correct hex value' do
+    color = Borealis::Color.new(222, 2, 15)
+    expect(color.hex).to eq '#DE020F'
+  end
+end
+
+describe Borealis::Color, 'equality' do
+  it 'returns true if the colors have the same rgb' do
+    color = Borealis::Color.new(1, 2, 3)
+    expect(color).to eq Borealis::Color.new(1, 2, 3)
+  end
+
+  it 'returns false if the colors have different rgbs' do
+    color = Borealis::Color.new(1, 2, 3)
+    expect(color).not_to eq Borealis::Color.new(2, 2, 3)
+  end
+end
 
-    colors = [smallest_color, large_color, small_color]
+describe Borealis::Color, '#to_lab' do
+  it 'converts rgb to lab correctly' do
+    color = Borealis::Color.new(255, 204, 0)
 
-    expect(colors.sort).to eq [smallest_color, small_color, large_color]
+    # http://www.easyrgb.com/index.php?X=CALC#Result
+    expect(color.to_lab[0]).to be_within(0.01).of(84.197)
+    expect(color.to_lab[1]).to be_within(0.01).of(3.680)
+    expect(color.to_lab[2]).to be_within(0.01).of(85.223)
   end
 end

data/spec/borealis/image_converter_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Borealis::ImageConverter, '#to_colors' do
+  it 'returns as many colors as there are pixels' do
+    image = 'spec/fixtures/aurora_borealis.jpg'
+    colors = Borealis::ImageConverter.new(image, '10x10!').to_colors
+
+    expect(colors.length).to eq 100
+  end
+end
+
+describe Borealis::ImageConverter, '#read_image' do
+  it 'returns colors in the correct format' do
+    image = 'spec/fixtures/aurora_borealis.jpg'
+    image_data = Borealis::ImageConverter.new(image, '10x10').read_image
+
+    expect(image_data).to match(/\(([\s+\d+,]+)\).+([\#][0-9,A-F,a-f]{6}).+(rgb)/)
+  end
+
+  it 'raises Cocaine::ExitStatusError when the image is not present' do
+    image = 'nonexistent.jpg'
+    image_converter = Borealis::ImageConverter.new(image, 'dimensions')
+
+    silence_stderr do
+      expect { image_converter.read_image }.to raise_error(Cocaine::ExitStatusError)
+    end
+  end
+end

data/spec/borealis/kmeans_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Borealis::KMeans do
+  it 'raises if there are more clusters than colors' do
+    colors = []
+    3.times { colors << Borealis::Color.new(1, 2, 3) }
+
+    expect do
+      Borealis::KMeans.new(colors, number_of_clusters: 4)
+    end.to raise_error 'You may not have more clusters than colors.'
+  end
+end
+
+describe Borealis::KMeans, '#run' do
+  it 'sets the colors as cluster centers if there are as many colors as clusters' do
+    colors = []
+    3.times { colors << stub('color') }
+
+    clusters = Borealis::KMeans.new(colors, number_of_clusters: 3).run
+
+    expect(clusters.map(&:center)).to eq colors
+  end
+
+  it 'returns number_of_clusters clusters' do
+    colors = []
+    20.times { |index| colors << Borealis::Color.new(index, index * 2, index * 3) }
+
+    clusters = Borealis::KMeans.new(colors, number_of_clusters: 8).run
+
+    expect(clusters.length).to eq 8
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,10 @@
 require 'borealis'
 
+require 'bourne'
+
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |file| require file }
 
 RSpec.configure do |config|
   config.order = 'random'
+  config.mock_with :mocha
 end

metadata

@@ -1,49 +1,58 @@
 --- !ruby/object:Gem::Specification
 name: borealis
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors:
 - Josh Steiner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-09 00:00:00.000000000 Z
+date: 2013-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bourne
+  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'
 - !ruby/object:Gem::Dependency
   name: cocaine
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Finds top colors in a given image.
+description: Finds most prominent colors in a given image.
 email:
 - josh@jsteiner.me
 executables: []
@@ -56,40 +65,48 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/stubs/autospec
+- bin/stubs/htmldiff
+- bin/stubs/ldiff
+- bin/stubs/rspec
 - borealis.gemspec
 - lib/borealis.rb
+- lib/borealis/cluster.rb
 - lib/borealis/color.rb
-- lib/borealis/image_analyzer.rb
+- lib/borealis/image_converter.rb
+- lib/borealis/kmeans.rb
 - lib/borealis/version.rb
 - spec/borealis/borealis_spec.rb
+- spec/borealis/cluster_spec.rb
 - spec/borealis/color_spec.rb
-- spec/borealis/image_analyzer_spec.rb
+- spec/borealis/image_converter_spec.rb
+- spec/borealis/kmeans_spec.rb
 - spec/borealis/version_spec.rb
-- spec/fixtures/winter.jpg
+- spec/fixtures/aurora_borealis.jpg
 - spec/spec_helper.rb
 - spec/support/silence_stderr.rb
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-requirements: []
+requirements:
+- ImageMagick
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
-summary: Finds top colors in a given image.
+specification_version: 4
+summary: Finds most prominent colors in a given image.
 test_files: []

data/lib/borealis/image_analyzer.rb

@@ -1,22 +0,0 @@
-class Borealis
-  class ImageAnalyzer
-    def initialize(image)
-      @image = image
-    end
-
-    def process
-      line = Cocaine::CommandLine.new(histogram_command)
-      line.run.strip
-    end
-
-    private
-
-    def histogram_command
-      quantize = "convert #{@image} +dither -colors 10 gif:-"
-      histogramize = "convert gif:- -define histogram:unique-colors=true \
-                      -format %c histogram:info:-"
-
-      "#{quantize} | #{histogramize}"
-    end
-  end
-end

data/spec/borealis/image_analyzer_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Borealis::ImageAnalyzer, '#process' do
-  it 'returns data in the correct format' do
-    image = 'spec/fixtures/winter.jpg'
-    analysis = Borealis::ImageAnalyzer.new(image).process
-
-    expect(analysis).to match(/\(([\s+\d+,]+)\).+([\#][0-9,A-F,a-f]{6})/)
-  end
-
-  it 'returns 10 lines' do
-    image = 'spec/fixtures/winter.jpg'
-    analysis = Borealis::ImageAnalyzer.new(image).process
-
-    expect(analysis.lines.count).to eq 10
-  end
-
-  it 'raises Cocaine::ExitStatusError when the image is not present' do
-    image = 'spec/fixtures/nonexistent.jpg'
-
-    silence_stderr do
-      expect {
-        Borealis::ImageAnalyzer.new(image).process
-      }.to raise_error(Cocaine::ExitStatusError)
-    end
-  end
-end