photomosaic 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7723e9d41a717de2d939a43a5f3e1adcf26ef177
+  data.tar.gz: b2dc7d9424dcf7da90c67c2b5adf712e702178a6
+SHA512:
+  metadata.gz: d85772d554437ff18364f922d4149c8602d69e94367d1274c8ef139164da361b716982dc0bc3a844140e783303447581ce8b798d0dde29f796df826f73fd1f4f
+  data.tar.gz: 0a72143a5f51cf00854fe5233dee7d42fe40e2534d6e63233d25e6c15a93bad66a954fa58e60eb8f22514aa43f4fdb7d30d23750f1ba2123fb5be60735741a9d

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.envrc

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in photomosaic.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 dtan4
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+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.

data/README.md

@@ -0,0 +1,32 @@
+# Photomosaic
+[![Build Status](https://travis-ci.org/dtan4/photomosaic.svg?branch=master)](https://travis-ci.org/dtan4/photomosaic)
+[![Coverage Status](https://coveralls.io/repos/dtan4/photomosaic/badge.png)](https://coveralls.io/r/dtan4/photomosaic)
+[![Code Climate](https://codeclimate.com/github/dtan4/photomosaic.png)](https://codeclimate.com/github/dtan4/photomosaic)
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'photomosaic'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install photomosaic
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/photomosaic/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/bin/photomosaic

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "photomosaic"
+
+Photomosaic::Client.new(ARGV).execute

data/diagrams/sequence.uml

@@ -0,0 +1,70 @@
+@startuml
+
+actor User
+participant Client
+participant Bing
+participant ImageDownloader
+participant BaseImage
+participant PixelImage
+database Web
+
+User -> Client : Execute command
+activate Client
+create Bing
+Client -> Bing : << new >>
+Client -> Bing : Request to search images
+activate Bing
+Bing -> Web : Request to search images
+activate Web
+Web -> Web : Search images
+Web -> Bing : List of image urls
+deactivate Web
+Bing -> Client : List of image urls
+deactivate Bing
+
+create ImageDownloader
+Client -> ImageDownloader : << new >>
+Client -> ImageDownloader : Request to download images
+activate ImageDownloader
+ImageDownloader -> Web : Request images
+activate Web
+Web -> ImageDownloader : Download images
+deactivate Web
+ImageDownloader -> ImageDownloader : Save downloaded images
+ImageDownloader -> Client: List of downloaded image paths
+deactivate ImageDownloader
+
+create BaseImage
+Client -> BaseImage : << new >>
+BaseImage -> BaseImage : Preprocess
+
+create PixelImage
+Client -> PixelImage : << new >>
+
+Client -> BaseImage : Request to dispatch pixel images
+activate BaseImage
+BaseImage -> PixelImage : Request characteristic color
+activate PixelImage
+PixelImage -> PixelImage : Calculate characteristic color
+PixelImage -> BaseImage : Characteristic color
+deactivate PixelImage
+BaseImage -> BaseImage : Pick up the "nearest" image of the pixel
+BaseImage -> Client : Map of dispatched images
+deactivate BaseImage
+
+Client -> PixelImage : Request to resize to pixel size
+activate PixelImage
+PixelImage -> PixelImage : Resize to pixel size
+PixelImage -> Client : Done
+deactivate PixelImage
+
+Client->PixelImage : Request to compose mosaic image
+activate PixelImage
+PixelImage->PixelImage : Compose mosaic image
+PixelImage->Client : Done
+deactivate PixelImage
+
+Client->User : Done
+deactivate Client
+
+@enduml

data/diagrams/structure.uml

@@ -0,0 +1,21 @@
+@startuml
+
+package Photomosaic {
+  class Client
+  class Image
+  class ImageDownloader
+  class Options
+
+  Client o-- Options
+
+  package SearchEngine {
+    class Bing
+  }
+
+  package Color {
+    class HSV
+    class RGB
+  }
+}
+
+@enduml

data/lib/photomosaic.rb

@@ -0,0 +1,12 @@
+require "photomosaic/client"
+require "photomosaic/color/hsv"
+require "photomosaic/color/rgb"
+require "photomosaic/image"
+require "photomosaic/image_downloader"
+require "photomosaic/options"
+require "photomosaic/search_engine/bing"
+require "photomosaic/version"
+
+module Photomosaic
+  # Your code goes here...
+end

data/lib/photomosaic/client.rb

@@ -0,0 +1,57 @@
+module Photomosaic
+  class Client
+    def initialize(argv)
+      @options = Photomosaic::Options.parse(argv)
+    end
+
+    def execute
+      @image_downloader = Photomosaic::ImageDownloader.new
+
+      begin
+        resized_images = Photomosaic::Image.resize_images(pixel_images, 40, 20)
+        Photomosaic::Image.create_mosaic_image(resized_images, @options.output_path)
+      ensure
+        @image_downloader.remove_save_dir
+      end
+    end
+
+    private
+
+    def base_image
+      @base_image ||= Photomosaic::Image.preprocess_image(
+                                                          @options.base_image,
+                                                          @options.width,
+                                                          @options.height,
+                                                          @options.level,
+                                                          @options.colors
+                                                         )
+    end
+
+    def image_path_list
+      @image_path_list ||= @image_downloader.download_images(image_url_list)
+    end
+
+    def image_url_list
+      @image_url_list ||= search_engine.get_image_list(@options.keyword)
+    end
+
+    def image_list
+      @image_list ||= image_path_list.map do |path|
+        begin
+          Photomosaic::Image.new(path)
+        rescue Magick::ImageMagickError
+          nil
+        end
+      end.compact
+    end
+
+    def pixel_images
+      @pixel_images ||=
+        base_image.dispatch_images(image_list, 1, 2, @options.color_model)
+    end
+
+    def search_engine
+      @options.search_engine.new(@options.api_key, @options.results)
+    end
+  end
+end

data/lib/photomosaic/color/hsv.rb

@@ -0,0 +1,27 @@
+module Photomosaic
+  module Color
+    class HSV
+      attr_reader :hue, :saturation, :value
+
+      def initialize(hue, saturation, value)
+        @hue = hue
+        @saturation = saturation
+        @value = value
+      end
+
+      def calculate_distance(hsv)
+        Math.sqrt(squares_array(hsv).inject(&:+))
+      end
+
+      private
+
+      def squares_array(hsv)
+        [
+         (self.hue - hsv.hue)**2,
+         (self.saturation - hsv.saturation)**2,
+         (self.value - hsv.value)**2
+        ]
+      end
+    end
+  end
+end

data/lib/photomosaic/color/rgb.rb

@@ -0,0 +1,62 @@
+module Photomosaic
+  module Color
+    class RGB
+      attr_reader :red, :green, :blue
+
+      def initialize(red, green, blue)
+        @red = red
+        @green = green
+        @blue = blue
+      end
+
+      def max
+        @max ||= [@red, @green, @blue].max
+      end
+
+      def min
+        @min ||= [@red, @green, @blue].min
+      end
+
+      def to_hsv
+        HSV.new(hue, saturation, value)
+      end
+
+      def calculate_distance(rgb)
+        Math.sqrt(squares_array(rgb).inject(&:+))
+      end
+
+      private
+
+      def hue
+        return 0 if max == min
+
+        _hue = case max
+               when @red
+                 ((@green - @blue).to_f / (max - min)) % 6
+               when @green
+                 (@blue - @red).to_f / (max - min) + 2
+               else
+                 (@red - @green).to_f / (max - min) + 4
+               end
+
+        (_hue * 60).to_i
+      end
+
+      def saturation
+        max == 0 ? 0 : (max - min).to_f / max * 100
+      end
+
+      def squares_array(rgb)
+        [
+         (self.red - rgb.red)**2,
+         (self.green - rgb.green)**2,
+         (self.blue - rgb.blue)**2
+        ]
+      end
+
+      def value
+        (max * 100).to_f / 256
+      end
+    end
+  end
+end

data/lib/photomosaic/image.rb

@@ -0,0 +1,113 @@
+require "RMagick"
+
+module Photomosaic
+  class Image
+    def self.create_mosaic_image(image_list, output_path)
+      image_list.inject(Magick::ImageList.new) do |images, row|
+        images << row.inject(Magick::ImageList.new) do |col_images, image|
+          col_images << image.image.dup
+          col_images
+        end.append(false)
+
+        images
+      end.append(true).write(output_path)
+    end
+
+    def self.preprocess_image(image_path, width, height, level, colors)
+      image = Photomosaic::Image.new(image_path)
+      image.resize!(width, height, true)
+      image.posterize!(level)
+      image.reduce_colors!(colors)
+      image
+    end
+
+    def self.resize_images(images, width, height)
+      images.map do |row|
+        row.map { |image| image.resize!(width, height, false) }
+      end
+    end
+
+    def initialize(image_path)
+      @image = Magick::Image.read(image_path).first
+    end
+
+    def characteristic_color(color_model = :rgb)
+      @characteristic_color ||= get_characteristic_color(color_model)
+    end
+
+    def dispatch_images(source_image_list, row_step = 1, col_step = 1, color_model = :rgb)
+      (1..image_height).step(row_step).inject([]) do |images, y|
+        images << (1..image_width).step(col_step).inject([]) do |col_images, x|
+          col_images << nearest_image(source_image_list, x, y, color_model)
+          col_images
+        end
+
+        images
+      end
+    end
+
+    def image
+      @image
+    end
+
+    def posterize!(level)
+      @image = @image.posterize(level)
+      reload_image
+      self
+    end
+
+    def reduce_colors!(colors)
+      @image = @image.quantize(colors)
+      reload_image
+      self
+    end
+
+    def resize!(width, height, keep_ratio)
+      keep_ratio ? @image.resize_to_fit!(width, height) : @image.resize!(width, height)
+      reload_image
+      self
+    end
+
+    private
+
+    def get_characteristic_color(color_model = :rgb)
+      color = nil
+      original_image = @image.dup
+
+      begin
+        resize!(1, 1, false)
+        color = pixel_color(1, 1, color_model)
+      ensure
+        @image = original_image
+      end
+
+      color
+    end
+
+    def nearest_image(source_image_list, x, y, color_model)
+      pixel = pixel_color(x, y, color_model)
+
+      source_image_list.sort_by do |image|
+        image.characteristic_color(color_model).calculate_distance(pixel)
+      end.first
+    end
+
+    def pixel_color(x, y, color_model = :rgb)
+      pixel = @image.pixel_color(x, y)
+      rgb = Color::RGB.new(pixel.red / 257, pixel.green / 257, pixel.blue / 257)
+      color_model == :rgb ? rgb : rgb.to_hsv
+    end
+
+    def reload_image
+      @image = Magick::Image.from_blob(@image.to_blob).first
+    end
+
+    def image_height
+      @image.rows
+    end
+
+    def image_width
+      @image.columns
+    end
+  end
+end