photomosaic 0.0.1

data/lib/photomosaic/image_downloader.rb

@@ -0,0 +1,39 @@
+require "fileutils"
+require "open-uri"
+require "tmpdir"
+
+module Photomosaic
+  class ImageDownloader
+    def initialize(save_dir = tmp_dir)
+      @save_dir = save_dir
+    end
+
+    def download_images(image_url_list)
+      image_url_list.inject([]) do |path_list, image_url|
+        image_path = File.join(@save_dir, File.basename(image_url))
+
+        begin
+          download_image(image_url, image_path)
+          path_list << image_path
+        rescue
+        end
+
+        path_list
+      end
+    end
+
+    def remove_save_dir
+      FileUtils.remove_entry_secure(@save_dir)
+    end
+
+    private
+
+    def download_image(image_url, image_path)
+      open(image_path, "wb+") { |f| f.puts open(image_url).read }
+    end
+
+    def tmp_dir
+      Dir.mktmpdir("photomosaic")
+    end
+  end
+end

data/lib/photomosaic/options.rb

@@ -0,0 +1,80 @@
+require "optparse"
+
+module Photomosaic
+  class Options
+    KEYS = %w(
+    api_key
+    base_image
+    color_model
+    colors
+    height
+    keyword
+    level
+    output_path
+    results
+    search_engine
+    width
+    )
+
+    REQUIRED_KEYS = %w(
+    api_key
+    base_image
+    output_path
+    )
+
+    def self.parse(argv)
+      options = default_options
+      parser(options).parse(argv)
+      options[:api_key] = api_key
+      check_options(options)
+
+      self.new(options)
+    end
+
+    def initialize(options)
+      @options = options
+    end
+
+    KEYS.each do |key|
+      define_method(key) { @options[key.to_sym] }
+    end
+
+    private
+
+    def self.api_key
+      ENV["PHOTOMOSAIC_API_KEY"]
+    end
+
+    def self.check_options(options)
+      REQUIRED_KEYS.each do |key|
+        raise OptionParser::MissingArgument, key unless options[key.to_sym]
+      end
+    end
+
+    def self.default_options
+      {
+       color_model: :rgb,
+       colors: 16,
+       height: 200,
+       level: 4,
+       results: 50,
+       search_engine: Photomosaic::SearchEngine::Bing,
+       width: 200,
+      }
+    end
+
+    def self.parser(options)
+      OptionParser.new do |opt|
+        opt.on("-b", "--base_image=VAL", "Path of base image") { |val| options[:base_image] = File.expand_path(val) }
+        opt.on("-c", "--colors=VAL", "Number of colors") { |val| options[:colors] = val.to_i }
+        opt.on("-h", "--height=VAL", "Height of output image") { |val| options[:height] = val.to_i }
+        opt.on("-k", "--keyword=VAL", "Keyword") { |val| options[:keyword] = val }
+        opt.on("-l", "--level=VAL", "Color level") { |val| options[:level] = val.to_i }
+        opt.on("-o", "--output_path=VAL", "Path of mosaic image") { |val| options[:output_path] = File.expand_path(val) }
+        opt.on("-r", "--results=VAL", "Number of results") { |val| options[:results] = val.to_i }
+        opt.on("-w", "--width=VAL", "Width of output image") { |val| options[:width] = val.to_i }
+        opt.on("--hsv", "Use HSV") { |val| options[:color_model] = :hsv }
+      end
+    end
+  end
+end

data/lib/photomosaic/search_engine/bing.rb

@@ -0,0 +1,15 @@
+require "searchbing"
+
+module Photomosaic
+  module SearchEngine
+    class Bing
+      def initialize(api_key, results)
+        @client = ::Bing.new(api_key, results, "Image")
+      end
+
+      def get_image_list(keyword)
+        @client.search(keyword)[0][:Image].map { |image| image[:MediaUrl] }
+      end
+    end
+  end
+end

data/lib/photomosaic/version.rb

@@ -0,0 +1,3 @@
+module Photomosaic
+  VERSION = "0.0.1"
+end

data/photomosaic.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'photomosaic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "photomosaic"
+  spec.version       = Photomosaic::VERSION
+  spec.authors       = ["Daisuke Fujita"]
+  spec.email         = ["dtanshi45@gmail.com"]
+  spec.summary       = %q{Photomosaic Generator}
+  spec.description   = %q{Photomosaic Generator}
+  spec.homepage      = "https://github.com/dtan4/photomosaic"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "searchbing"
+  spec.add_dependency "rmagick"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency "terminal-notifier-guard"
+  spec.add_development_dependency "webmock"
+end

data/spec/photomosaic/client_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+require "ostruct"
+
+module Photomosaic
+  describe Client do
+    let(:api_key) { "api_key" }
+    let(:base_image) { fixture_path("lena.png") }
+    let(:color_model) { :rgb }
+    let(:colors) { 16 }
+    let(:height) { 200 }
+    let(:keyword) { "keyword" }
+    let(:level) { 4 }
+    let(:output_path) { tmp_path("output.png") }
+    let(:results) { 50 }
+    let(:search_engine) { SearchEngine::Bing }
+    let(:width) { 200 }
+
+    let(:options) do
+      {
+       api_key: api_key,
+       base_image: base_image,
+       color_model: color_model,
+       colors: colors,
+       height: height,
+       keyword: keyword,
+       level: level,
+       output_path: output_path,
+       results: results,
+       search_engine: search_engine,
+       width: width
+      }
+    end
+
+    let(:client) do
+      described_class.new("argv")
+    end
+
+    let(:dispatched_images)  do
+      [
+       [image],
+       [image],
+       [image]
+      ]
+    end
+
+    let(:image) do
+      double(Photomosaic::Image)
+    end
+
+    let(:image_name_list) do
+      [
+       "lena_0.png",
+       "lena_1.png",
+       "lena_2.png",
+       "notfound.png"
+      ]
+    end
+
+    let(:image_path_list) do
+      image_name_list.map { |name| fixture_path(name) }
+    end
+
+    let(:image_url_list) do
+      image_name_list.map { |name| "http://example.com/#{name}" }
+    end
+
+    before do
+      allow(Photomosaic::Options).to receive(:parse).and_return(OpenStruct.new(options))
+    end
+
+    describe "#execute" do
+      before do
+        allow_any_instance_of(Photomosaic::SearchEngine::Bing).to receive(:get_image_list).and_return(image_url_list)
+        allow_any_instance_of(Photomosaic::ImageDownloader).to receive(:download_images).and_return(image_path_list)
+        allow(Photomosaic::Image).to receive(:create_mosaic_image)
+        allow(Photomosaic::Image).to receive(:new).with(/lena(?:_\d)?\.png/).and_return(image)
+        allow(Photomosaic::Image).to receive(:new).with(/notfound.png/).and_raise Magick::ImageMagickError
+        allow(Photomosaic::Image).to receive(:resize_to_pixel_size)
+        allow(image).to receive(:dispatch_images).and_return(dispatched_images)
+        allow(image).to receive(:posterize!)
+        allow(image).to receive(:reduce_colors!)
+        allow(image).to receive(:resize!)
+      end
+
+      it "should execute the program" do
+        expect(Photomosaic::Image).to receive(:create_mosaic_image)
+        client.execute
+      end
+    end
+  end
+end

data/spec/photomosaic/color/hsv_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+module Photomosaic
+  module Color
+    describe HSV do
+      describe "#calculate_distance" do
+        it "should calculate color distance" do
+          color_a = described_class.new(100, 50.0, 70.0)
+          color_b = described_class.new(50, 30.0, 50.0)
+
+          expect(color_a.calculate_distance(color_b)).to be_within(0.1).of(57.4)
+        end
+      end
+    end
+  end
+end

data/spec/photomosaic/color/rgb_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+module Photomosaic
+  module Color
+    describe RGB do
+      describe "#calculate_distance" do
+        it "should calculate color distance" do
+          color_a = described_class.new(50, 100, 200)
+          color_b = described_class.new(10, 20, 30)
+
+          expect(color_a.calculate_distance(color_b)).to be_within(0.5).of(192.0)
+        end
+      end
+
+      describe "#to_hsv" do
+        # cf. http://tech-unlimited.com/color.html
+
+        it "should convert (50, 50, 50) to (0, 0, 20)" do
+          rgb = described_class.new(50, 50, 50)
+          hsv = rgb.to_hsv
+          expect(hsv.hue).to eq 0
+          expect(hsv.saturation).to be_within(1).of(0)
+          expect(hsv.value).to be_within(1).of(20)
+        end
+
+        it "should convert (50, 100, 200) to (220, 75, 78)" do
+          rgb = described_class.new(50, 100, 200)
+          hsv = rgb.to_hsv
+          expect(hsv.hue).to eq 220
+          expect(hsv.saturation).to be_within(1).of(75)
+          expect(hsv.value).to be_within(1).of(78)
+        end
+
+        it "should convert (100, 50, 200) to (260, 75, 78)" do
+          rgb = described_class.new(100, 50, 200)
+          hsv = rgb.to_hsv
+          expect(hsv.hue).to eq 260
+          expect(hsv.saturation).to be_within(1).of(75)
+          expect(hsv.value).to be_within(1).of(78)
+        end
+
+        it "should convert (100, 200, 50) to (100, 75, 78)" do
+          rgb = described_class.new(100, 200, 50)
+          hsv = rgb.to_hsv
+          expect(hsv.hue).to eq 100
+          expect(hsv.saturation).to be_within(1).of(75)
+          expect(hsv.value).to be_within(1).of(78)
+        end
+      end
+    end
+  end
+end

data/spec/photomosaic/image_downloader_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+require "fileutils"
+require "webmock/rspec"
+
+module Photomosaic
+  describe ImageDownloader do
+    let(:downloader) do
+      described_class.new(tmp_dir)
+    end
+
+    describe "#initialize" do
+      context "with save directory" do
+        it "should set the specified directory to @save_dir" do
+          downloader = described_class.new(tmp_dir)
+          expect(downloader.instance_variable_get(:@save_dir)).to eq tmp_dir
+        end
+      end
+
+      context "without save directory" do
+        it "should set temporary directory to @save_dir" do
+          downloader = described_class.new
+          expect(downloader.instance_variable_get(:@save_dir)).to match(/photomosaic/)
+        end
+      end
+    end
+
+    describe "#download_images" do
+      let(:image_url_list) do
+        [
+         "http://example.com/image01.jpg",
+         "http://example.com/image02.jpg",
+         "http://example.com/notfound.jpg"
+        ]
+      end
+
+      before do
+        stub_request(:get, %r(http://example\.com/image0\d\.jpg))
+          .to_return(status: 200, body: "hoge")
+        stub_request(:get, "http://example.com/notfound.jpg")
+          .to_return(status: 404)
+        FileUtils.rm_rf(tmp_dir) if Dir.exist?(tmp_dir)
+        Dir.mkdir(tmp_dir)
+      end
+
+      it "should download listed images to temporary directory" do
+        downloader.download_images(image_url_list)
+
+        %w(image01.jpg image02.jpg).each do |image|
+          expect(File.exist?(tmp_path(image))).to be_truthy
+        end
+      end
+
+      it "should return the path list" do
+        result = downloader.download_images(image_url_list)
+        expect(result).to match_array %w(image01.jpg image02.jpg).map { |image| tmp_path(image) }
+      end
+
+      after do
+        FileUtils.rm_rf(tmp_dir)
+      end
+    end
+
+    describe "#remove_save_dir" do
+      before do
+        Dir.mkdir(tmp_dir)
+      end
+
+      it "should remove save directory" do
+        downloader.remove_save_dir
+        expect(Dir.exist?(tmp_dir)).to be_falsy
+      end
+    end
+  end
+end

data/spec/photomosaic/image_spec.rb

@@ -0,0 +1,151 @@
+require "spec_helper"
+require "fileutils"
+require "tempfile"
+
+module Photomosaic
+  describe Image do
+    let(:image_path) do
+      fixture_path("lena.png")
+    end
+
+    let(:image_path_list) do
+      [
+       fixture_path("lena_0.png"),
+       fixture_path("lena_1.png"),
+       fixture_path("lena_2.png"),
+       fixture_path("lena_3.png"),
+       fixture_path("lena_4.png"),
+       fixture_path("lena_5.png")
+      ]
+    end
+
+    context "class methods" do
+      describe "#create_mosaic_image" do
+        let(:image_list) do
+          5.times.inject([]) do |image_list, _|
+            image_list << image_path_list.map { |path| described_class.new(path) }
+            image_list
+          end
+        end
+
+        let(:output_path) do
+          tmp_path("tiled_image.jpg")
+        end
+
+        before do
+          FileUtils.rm_rf(tmp_dir) if Dir.exist?(tmp_dir)
+          Dir.mkdir(tmp_dir)
+        end
+
+        it "should create the mosaic image" do
+          described_class.create_mosaic_image(image_list, output_path)
+          expect(File.exist?(output_path)).to be_truthy
+        end
+
+        after do
+          FileUtils.rm_rf(tmp_dir)
+        end
+      end
+
+      describe "#preprocess_image" do
+        it "should preprocess image" do
+          expect_any_instance_of(described_class).to receive(:resize!).with(100, 100, true).once
+          expect_any_instance_of(described_class).to receive(:posterize!).with(4).once
+          expect_any_instance_of(described_class).to receive(:reduce_colors!).with(8).once
+          described_class.preprocess_image(image_path, 100, 100, 4, 8)
+        end
+      end
+
+      describe "#resize_images" do
+        let(:image) do
+          double(:resize!)
+        end
+
+        let(:image_list) do
+          5.times.inject([]) do |image_list, _|
+            image_list << [image]
+            image_list
+          end
+        end
+
+        it "should resize images" do
+          expect(image).to receive(:resize!).exactly(5).times
+          described_class.resize_images(image_list, 40, 20)
+        end
+      end
+    end
+
+    context "instance methods" do
+      let(:image) do
+        described_class.new(image_path)
+      end
+
+      describe "#characteristic_color" do
+        context "by RGB" do
+          it "should return characteristic color in RGB" do
+            characteristic_color = image.characteristic_color(:rgb)
+            expect(characteristic_color.red).to be_within(1).of(180)
+            expect(characteristic_color.green).to be_within(1).of(100)
+            expect(characteristic_color.blue).to be_within(1).of(107)
+          end
+        end
+
+        context "by HSV" do
+          it "should return characteristic color in HSV" do
+            characteristic_color = image.characteristic_color(:hsv)
+            expect(characteristic_color.hue).to eq 354
+            expect(characteristic_color.saturation).to be_within(0.5).of(44.7)
+            expect(characteristic_color.value).to be_within(0.5).of(70.0)
+          end
+        end
+      end
+
+      describe "#dispatch_images" do
+        let(:image_list) do
+          image_path_list.map { |path| described_class.new(path) }
+        end
+
+        it "should return the map of dispatched images as a 2-dimentional array" do
+          images = image.dispatch_images(image_list, 8, 8)
+          expect(images.length).to eq 64
+          expect(images[0].length).to eq 64
+          expect(images[0][0]).to be_a described_class
+        end
+      end
+
+      describe "#posterize!" do
+        it "should posterize itself" do
+          expect_any_instance_of(Magick::Image).to receive(:posterize).with(4)
+          expect_any_instance_of(described_class).to receive(:reload_image)
+          image.posterize!(4)
+        end
+      end
+
+      describe "#reduce_colors!" do
+        it "should reduce its colors" do
+          expect_any_instance_of(Magick::Image).to receive(:quantize).with(8)
+          expect_any_instance_of(described_class).to receive(:reload_image)
+          image.reduce_colors!(8)
+        end
+      end
+
+      describe "#resize!" do
+        context "to keep aspect ratio" do
+          it "should resize itself" do
+            expect_any_instance_of(Magick::Image).to receive(:resize_to_fit!).with(25, 50)
+            expect_any_instance_of(described_class).to receive(:reload_image)
+            image.resize!(25, 50, true)
+          end
+        end
+
+        context "not to keep aspect ratio" do
+          it "should resize itself" do
+            expect_any_instance_of(Magick::Image).to receive(:resize!).with(25, 50)
+            expect_any_instance_of(described_class).to receive(:reload_image)
+            image.resize!(25, 50, false)
+          end
+        end
+      end
+    end
+  end
+end