gauguin 0.0.2

data/lib/gauguin/version.rb

@@ -0,0 +1,3 @@
+module Gauguin
+  VERSION = "0.0.2"
+end

data/lib/gauguin.rb

@@ -0,0 +1,43 @@
+require "gauguin/version"
+require "gauguin/color"
+require "gauguin/color_space"
+require "gauguin/colors_retriever"
+require "gauguin/colors_limiter"
+require "gauguin/colors_clusterer"
+require "gauguin/noise_reducer"
+require "gauguin/image_recolorer"
+require "gauguin/painting"
+require "gauguin/image"
+require "gauguin/image_repository"
+require "gauguin/palette_serializer"
+
+module Gauguin
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration) if block_given?
+  end
+
+  class Configuration
+    DEFAULT_MAX_COLORS_COUNT = 10
+    DEFAULT_COLORS_LIMIT = 10000
+    DEFAULT_MIN_PERCENTAGE_SUM = 0.981
+    DEFAULT_COLOR_SIMILARITY_THRESHOLD = 25
+
+    attr_accessor :max_colors_count, :colors_limit,
+      :min_percentage_sum, :color_similarity_threshold
+
+    def initialize
+      @max_colors_count = DEFAULT_MAX_COLORS_COUNT
+      @colors_limit = DEFAULT_COLORS_LIMIT
+      @min_percentage_sum = DEFAULT_MIN_PERCENTAGE_SUM
+      @color_similarity_threshold = DEFAULT_COLOR_SIMILARITY_THRESHOLD
+    end
+  end
+end
+
+Gauguin.configure
+

data/spec/integration/painting_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+module Gauguin
+  describe Painting do
+    let(:path) do
+      File.join("spec", "support", "pictures", file_name)
+    end
+
+    let(:gray) { Color.new(204, 204, 204) }
+    let(:black) { Color.new(0, 0, 0) }
+    let(:white) { Color.new(255, 255, 255) }
+
+    let(:painting) { Painting.new(path) }
+
+    describe "#palette" do
+      shared_examples_for "retrieves unique colors" do
+        it { expect(subject.count).to eq 5 }
+        it do
+          expect(subject.keys).to include(white)
+        end
+      end
+
+      subject { painting.palette }
+
+      context "unique colors in the picture" do
+        let(:file_name) { "unique_colors.png" }
+
+        it_behaves_like "retrieves unique colors"
+      end
+
+      context "not unique colors in the picture" do
+        let(:file_name) { "not_unique_colors.png" }
+
+        it_behaves_like "retrieves unique colors"
+      end
+
+      context "image has two colors but with different gradients
+        so actually 1942 unique colors" do
+        let(:file_name) { "gray_and_black.png" }
+        let(:values) { subject.values.flatten }
+
+        it { expect(subject.count).to eq 2 }
+        it { expect(values.include?(black)).to be true }
+        it { expect(values.include?(gray)).to be true }
+      end
+
+      context "transparent background" do
+        let(:file_name) { "transparent_background.png" }
+
+        it { expect(subject.count).to eq 1 }
+        it do
+          expect(subject.keys).to eq [Color.new(2, 0, 0)]
+        end
+      end
+
+      context "image with 10 colors" do
+        let(:file_name) { "10_colors.png" }
+
+        it { expect(subject.count).to eq 10 }
+      end
+
+      context "image with over than max_colors_count colors" do
+        let(:file_name) { "12_colors.png" }
+
+        it { expect(subject.count).to eq 10 }
+
+        context "image with over than colors_limit colors" do
+          configure(:colors_limit, 9)
+          configure(:max_colors_count, 12)
+
+          it "returns colors_limit colors" do
+            expect(subject.count).to eq 9
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/integration/samples_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module Gauguin
+  describe "samples" do
+    def self.picture_path(file_name)
+      File.join("spec", "support", "pictures", file_name)
+    end
+
+    let(:painting) { Painting.new(picture_path(file_name)) }
+
+    def self.paths
+      (1..11).map { |i| picture_path(File.join("samples", "sample#{i}.png")) }
+    end
+
+    def self.expected_results
+      [
+        ["rgb(219, 12, 38)", "rgb(255, 255, 255)"],
+        ["rgb(168, 36, 40)", "rgb(255, 255, 255)"],
+        ["rgb(0, 0, 0)", "rgb(204, 204, 204)"],
+        ["rgb(154, 79, 54)", "rgb(187, 196, 201)", "rgb(236, 112, 48)", "rgb(28, 28, 64)", "rgb(92, 54, 59)"],
+        ["rgb(254, 254, 254)", "rgb(255, 195, 13)", "rgb(60, 4, 67)"],
+        ["rgb(2, 0, 0)"],
+        ["rgb(148, 158, 149)", "rgb(198, 64, 63)"],
+        ["rgb(109, 207, 246)", "rgb(237, 28, 36)", "rgb(255, 255, 255)"],
+        ["rgb(255, 255, 255)", "rgb(87, 196, 15)"],
+        ["rgb(240, 110, 170)", "rgb(255, 255, 255)"],
+        ["rgb(0, 165, 19)", "rgb(0, 71, 241)", "rgb(230, 27, 49)", "rgb(249, 166, 0)", "rgb(255, 255, 255)"]
+      ]
+    end
+
+    def self.samples
+      Hash[paths.zip(expected_results)]
+    end
+
+    samples.each do |sample_path, expected_result|
+      it "returns expected result for #{sample_path}" do
+        painting = Painting.new(sample_path)
+        expect(painting.palette.keys.map(&:to_s).sort).to eq(expected_result.sort)
+      end
+    end
+  end
+end
+

data/spec/lib/gauguin/color_space/rgb_vector_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Gauguin::ColorSpace
+  describe RgbVector do
+    describe "#to_xyz" do
+      let(:red) { RgbVector[255, 0, 0] }
+
+      it "converts to lab space" do
+        expect(red.to_xyz).to eq(
+          XyzVector[41.24, 21.26, 1.9300000000000002])
+      end
+    end
+  end
+end
+

data/spec/lib/gauguin/color_space/xyz_vector_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Gauguin::ColorSpace
+  describe XyzVector do
+    describe "#to_lab" do
+      let(:red) { XyzVector[41.24, 21.26, 1.9300000000000002] }
+
+      it "converts to lab space" do
+        expect(red.to_lab).to eq(
+          LabVector[53.23288178584245, 80.10930952982204, 67.22006831026425])
+      end
+    end
+  end
+end
+

data/spec/lib/gauguin/color_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+module Gauguin
+  describe Color do
+    let(:black) { Color.new(0, 0, 0) }
+    let(:red) { Color.new(255, 0, 0) }
+
+    describe "initialize" do
+      let(:red) { 1 }
+      let(:green) { 2 }
+      let(:blue) { 3 }
+      let(:percentage) { 0.5 }
+
+      subject { Color.new(red, green, blue, percentage) }
+
+      it { expect(subject.red).to eq red }
+      it { expect(subject.green).to eq green }
+      it { expect(subject.blue).to eq blue }
+      it { expect(subject.percentage).to eq percentage }
+    end
+
+    describe "#==" do
+      it "returns true for colors with the same key values" do
+        expect(black == Color.new(0, 0, 0)).to be true
+      end
+
+      it "returns false if any key value is different" do
+        expect(black == Color.new(0, 0, 1)).to be false
+      end
+
+      it "returns false for objects with different classes" do
+        expect(black == "black").to be false
+      end
+    end
+
+    describe "#similar?" do
+      context "similar colors" do
+        it { expect(black.similar?(Color.new(0, 0, 1))).to be true }
+      end
+
+      context "different colors" do
+        it { expect(black.similar?(red)).to be false }
+      end
+    end
+
+    describe '#distance' do
+      it 'returns circa 178.36 between black & red' do
+        expect(black.distance(red)).to be_within(0.01).of(117.34)
+      end
+    end
+
+    describe "#to_lab" do
+      let(:red) { 1 }
+      let(:green) { 2 }
+      let(:blue) { 3 }
+
+      subject { Color.new(red, green, blue).to_lab }
+
+      it "returns lab vector" do
+        rgb_vector = double
+        xyz_vector = double
+        expect(ColorSpace::RgbVector).to receive(:[]).with(red, green, blue).and_return(rgb_vector)
+        expect(rgb_vector).to receive(:to_xyz).and_return(xyz_vector)
+        expect(xyz_vector).to receive(:to_lab)
+
+        subject
+      end
+    end
+
+    describe "#to_s" do
+      subject { black.to_s }
+
+      it { expect(subject).to eq("rgb(0, 0, 0)") }
+    end
+
+    let(:color) { Color.new(1, 2, 3, 0.4, true) }
+
+    describe "#to_rgb" do
+      subject { color.to_rgb }
+
+      it { expect(subject).to eq([1, 2, 3]) }
+    end
+
+    describe "#to_key" do
+      subject { color.to_key }
+
+      it { expect(subject).to eq([1, 2, 3, true]) }
+    end
+
+    describe "#to_a" do
+      subject { color.to_a }
+
+      it { expect(subject).to eq([1, 2, 3, 0.4, true]) }
+    end
+
+    describe ".from_a" do
+      subject { Color.from_a([1, 2, 3, 0.4, true]) }
+
+      it { expect(subject.red).to eq(1) }
+      it { expect(subject.green).to eq(2) }
+      it { expect(subject.blue).to eq(3) }
+      it { expect(subject.percentage).to eq(0.4) }
+      it { expect(subject.transparent).to be true }
+    end
+
+    describe "#transparent?" do
+      subject { color.transparent? }
+
+      it { expect(subject).to be true }
+    end
+
+    describe "#hash" do
+      it "can be used as keys in the hash"  do
+        hash = { Color.new(255, 255, 255) => 777 }
+        expect(hash[Color.new(255, 255, 255)]).to eq(777)
+      end
+    end
+
+    describe "#inspect" do
+      subject { color.inspect }
+
+      it { expect(subject).to eq("rgb(1, 2, 3)[0.4][transparent]")}
+    end
+  end
+end

data/spec/lib/gauguin/colors_clusterer_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+module Gauguin
+  describe ColorsClusterer do
+    let(:black) { Color.new(0, 0, 0, 0.597) }
+    let(:white) { Color.new(255, 255, 255, 0.4) }
+
+    let(:clusterer) { ColorsClusterer.new }
+
+    describe "call" do
+      subject { clusterer.call(colors) }
+
+      context "colors is empty" do
+        let(:colors) { [] }
+
+        it { expect(subject).to eq({}) }
+      end
+
+      context "colors includes similar colors" do
+        let(:pseudo_black) { Color.new(4, 0, 0, 0.001) }
+        let(:other_pseudo_black) { Color.new(5, 0, 0, 0.001) }
+        let(:another_pseudo_black) { Color.new(6, 0, 0, 0.001) }
+
+        let(:colors) do
+          [black, white, pseudo_black, other_pseudo_black,
+           another_pseudo_black]
+        end
+
+        it "make separate groups for them" do
+          expect(subject).to eq({
+            white => [white],
+            black => [black, pseudo_black, other_pseudo_black,
+                      another_pseudo_black]
+          })
+        end
+
+        context do
+          let(:white) { Color.new(255, 255, 255, 0.3) }
+          let(:transparent_white) do
+            Color.new(255, 255, 255, 0.1, Image::Pixel::MAX_TRANSPARENCY)
+          end
+
+          it "make separate groups for fully transparent colors" do
+            colors << transparent_white
+
+            expect(subject).to eq({
+              white => [white],
+              transparent_white => [transparent_white],
+              black => [black, pseudo_black, other_pseudo_black,
+                        another_pseudo_black]
+            })
+          end
+        end
+
+        it "updates percentage of leader of each group" do
+          subject
+          expect(white.percentage).to eq(0.4)
+          expect(black.percentage).to eq(0.6)
+        end
+
+        context "there is color with bigger percentage
+                  than pivot in the group" do
+          before do
+            black.percentage = 0.001
+            other_pseudo_black.percentage = 0.597
+          end
+
+          it "chooses it as pivot" do
+            expect(subject).to eq({
+              white => [white],
+              other_pseudo_black => [black, pseudo_black,
+                                     other_pseudo_black,
+                                     another_pseudo_black]
+            })
+          end
+
+          context "pivots are similar" do
+            before do
+              other_pseudo_black.red = 30
+              another_pseudo_black.red = 60
+            end
+
+            it "merge their groups" do
+              expect(subject).to eq({
+                white => [white],
+                other_pseudo_black => [black, pseudo_black,
+                                      other_pseudo_black,
+                                      another_pseudo_black]
+              })
+            end
+          end
+        end
+      end
+
+      context "colors includes different colors" do
+        let(:colors) do
+          [black, white]
+        end
+
+        before do
+          expect(white).to receive(:similar?).
+            with(black).and_return(false)
+        end
+
+        it "make separate groups for them" do
+          expect(subject).to eq({
+            black => [black],
+            white => [white]
+          })
+        end
+      end
+    end
+
+    describe "#clusters" do
+      let(:red) { Color.new(255, 0, 0, 0.1) }
+      let(:colors) { [black, red, white] }
+
+      subject { clusterer.clusters(colors) }
+
+      configure(:max_colors_count, 2)
+
+      before do
+        expect(clusterer).to receive(:call).and_return({
+          black => [black],
+          red => [red],
+          white => [white]
+        })
+      end
+
+      it "returns max_colors_count most common colors" do
+        expect(subject).to eq({
+          white => [white],
+          black => [black]
+        })
+      end
+    end
+
+    describe "#reversed_clusters" do
+      let(:gray) { Color.new(0, 0, 10, 0.4) }
+      let(:clusters) do
+        {
+          white => [white],
+          black => [black, gray]
+        }
+      end
+
+      subject { clusterer.reversed_clusters(clusters) }
+
+      it "returns reversed clusters" do
+        expect(subject).to eq({
+          white => white,
+          black => black,
+          gray => black
+        })
+      end
+    end
+  end
+end

data/spec/lib/gauguin/colors_limiter_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+module Gauguin
+  describe ColorsLimiter do
+    describe "#limit" do
+      let(:limiter) { ColorsLimiter.new }
+      let(:colors) { [black, red, white] }
+      let(:white) { Color.new(255, 255, 255, 0.01) }
+      let(:red) { Color.new(255, 0, 0, 0.02) }
+      let(:black) { Color.new(0, 0, 0, 0.97) }
+
+      subject { limiter.call(colors) }
+
+      it "returns all colors" do
+        expect(subject).to eq([black, red, white])
+      end
+
+      context "colors count is greater than colors_limit" do
+        configure(:colors_limit, 2)
+
+        it "reduces colors to colors_limit" do
+          expect(subject).to eq([black, red])
+        end
+      end
+    end
+  end
+end

data/spec/lib/gauguin/colors_retriever_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module Gauguin
+  describe ColorsRetriever do
+    let(:retriever) { ColorsRetriever.new(image) }
+    let(:image) do
+      fake = FakeImage.new
+
+      fake.magic_black_pixel = magic_black_pixel
+      fake.magic_white_pixel = magic_white_pixel
+      fake.magic_red_pixel = magic_red_pixel
+      fake.magic_red_little_transparent_pixel = magic_red_little_transparent_pixel
+
+      fake.pixels_repository = {
+        magic_white_pixel => FakeImage::Pixel.new(magic_white_pixel),
+        magic_red_pixel => FakeImage::Pixel.new(magic_red_pixel),
+        magic_black_pixel => FakeImage::Pixel.new(magic_black_pixel),
+        magic_red_little_transparent_pixel => FakeImage::Pixel.new(
+          magic_red_little_transparent_pixel)
+      }
+
+      fake.color_histogram = {
+        magic_white_pixel => 20,
+        magic_black_pixel => 30,
+        magic_red_pixel => 10
+      }
+
+      fake.rows = 10
+      fake.columns = 10
+
+      fake
+    end
+
+    def magic_pixel(rgb, opacity)
+      double(rgb: rgb, opacity: opacity)
+    end
+
+    let(:magic_black_pixel) { magic_pixel([0, 0, 0], 0) }
+    let(:magic_white_pixel) { magic_pixel([255, 255, 255], 0) }
+    let(:magic_red_pixel) { magic_pixel([255, 0, 0], 0) }
+    let(:magic_red_little_transparent_pixel) { magic_pixel([255, 0, 0], 50) }
+
+    describe "#colors" do
+      subject { retriever.colors.sort_by(&:percentage) }
+
+      it "returns array with colors with percentages" do
+        expect(subject).to eq([
+          Color.new(255, 0, 0, 0.1),
+          Color.new(255, 255, 255, 0.2),
+          Color.new(0, 0, 0, 0.3)
+        ])
+      end
+
+      context "histogram contains different magic pixels
+        for the same color with different opacity" do
+        before do
+          image.color_histogram[magic_red_little_transparent_pixel] = 40
+        end
+
+        it "sums percentage" do
+          expect(subject).to eq([
+            Color.new(255, 255, 255, 0.2),
+            Color.new(0, 0, 0, 0.3),
+            Color.new(255, 0, 0, 0.5)
+          ])
+        end
+
+        context "fully transparent colors" do
+          let(:magic_red_little_transparent_pixel) do
+            magic_pixel([255, 0, 0], Image::Pixel::MAX_TRANSPARENCY)
+          end
+
+          it "should be treated separately" do
+            expect(subject).to eq([
+              Color.new(255, 0, 0, 0.1),
+              Color.new(255, 255, 255, 0.2),
+              Color.new(0, 0, 0, 0.3),
+              Color.new(255, 0, 0, 0.4, true)
+            ])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/gauguin/image_recolorer_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module Gauguin
+  describe ImageRecolorer do
+    describe "#recolor" do
+      let(:image) do
+        fake = FakeImage.new
+
+        fake.pixels = pixels
+        fake.rows = pixels.count
+        fake.columns = pixels.first.count
+        fake.colors_to_pixels = {
+          white.to_s => white_pixel,
+          red.to_s => red_pixel,
+          black.to_s => black_pixel
+        }
+
+        fake
+      end
+      let(:pixels) do
+        [
+          [black_pixel, white_pixel, white_pixel],
+          [black_pixel, black_pixel, white_pixel],
+          [black_pixel, black_pixel, black_pixel]
+        ]
+      end
+      let(:image_recolorer) { ImageRecolorer.new(image) }
+      let(:white_pixel) do
+        double('white', to_rgb: [255, 255, 255], transparent?: false)
+      end
+      let(:black_pixel) do
+        double('black', to_rgb: [0, 0, 0], transparent?: false)
+      end
+      let(:red_pixel) do
+        double('red', to_rgb: [255, 0, 0], transparent?: false)
+      end
+      let(:white) { Color.new(255, 255, 255) }
+      let(:black) { Color.new(0, 0, 0) }
+      let(:red) { Color.new(255, 0, 0) }
+      let(:new_colors) do
+        {
+          black => white,
+          white => black
+        }
+      end
+
+      subject { image_recolorer.recolor(new_colors) }
+
+      before do
+        allow(Image).to receive(:blank).and_return(image)
+      end
+
+      it "recolors image based on new_colors" do
+        expect(subject.pixels).to eq([
+          [white_pixel, black_pixel, black_pixel],
+          [white_pixel, white_pixel, black_pixel],
+          [white_pixel, white_pixel, white_pixel]
+        ])
+      end
+
+      context "transparent pixel" do
+        let(:black_pixel) do
+          double('black', to_rgb: [0, 0, 0], transparent?: true)
+        end
+
+        it "stays the same" do
+          expect(subject.pixels).to eq([
+            [black_pixel, black_pixel, black_pixel],
+            [black_pixel, black_pixel, black_pixel],
+            [black_pixel, black_pixel, black_pixel]
+          ])
+        end
+      end
+
+      context "color not present in new_colors" do
+        let(:pixels) do
+          [
+            [red_pixel, white_pixel, white_pixel],
+            [red_pixel, red_pixel, white_pixel],
+            [red_pixel, red_pixel, red_pixel]
+          ]
+        end
+
+        it "stays the same" do
+          expect(subject.pixels).to eq([
+            [red_pixel, black_pixel, black_pixel],
+            [red_pixel, red_pixel, black_pixel],
+            [red_pixel, red_pixel, red_pixel]
+          ])
+        end
+      end
+    end
+  end
+end