moiristo-tileup 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c2f73ac375c4eacafa750e4e03ef7343fa988544
+  data.tar.gz: c6ec4fe16e14a3c943fe5f486359df568873fbf0
+SHA512:
+  metadata.gz: 5f037259541831f2af80bf5cfc74ea9a66fc6e51c0b346aa2d9032d7b2dfc1c8c244b65c4d1d139c759e695e6cfa4c0a3bdf154c56a5afcdb52b760cfae833a6
+  data.tar.gz: 31751b7bc4d79339912bed4fc4e057005332b60f27b051009b27eda19ce5cefc7c3238e676359775813f544e859f2e867f003aca3fa5b489feb1b202c8adb1e5

data/.gitignore

@@ -0,0 +1,22 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+test/out

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+
+sudo: false
+cache: bundler
+
+rvm:
+  - 2.1.10
+  - 2.2.3
+  - 2.3.4
+
+gemfile:
+  - Gemfile

data/CHANGES.md

@@ -0,0 +1,43 @@
+Tileup Change Log
+=================
+
+v1.0.0
+------
+
+- Added: MiniMagick support
+- Added: Null logger
+- Added: Test suite
+- Added: Travis-ci integration
+- Changed: Refactored implementation, split up functionality
+
+v0.1.4
+------
+
+- Fixed: Background color for extended tiles (now transparent instead of white,
+       which would clobber transparent backgrounds)
+
+v0.1.3
+------
+
+- Added: Functionality to automatically pad tiles that are not tile_width x tile_height
+- Added: CLI switch to disable functionality (`dont-extend-incomplete-tiles`)
+
+v0.1.2
+------
+
+- Lost to history
+
+v0.1.1
+------
+
+- Lost to history
+
+v0.1.0
+------
+
+- Lost to history
+
+v0.0.1
+------
+
+- Lost to history

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    moiristo-tileup (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    method_source (0.8.2)
+    mini_magick (4.7.0)
+    minitest (5.10.2)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.5.0)
+    rmagick (2.16.0)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.13)
+  mini_magick (~> 4.7)
+  minitest (~> 5.10)
+  moiristo-tileup!
+  pry
+  rake (~> 10.0)
+  rmagick (~> 2.16)
+
+BUNDLED WITH
+   1.15.3

data/LICENCE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Reinier de Lange
+
+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,94 @@
+# Tile Up
+
+*Tile Up* is a ruby Ruby gem that splits a large image into a set of tiles to use with javascript mapping libraries such as [Leaflet.js](http://leafletjs.com) or [Modest Maps](http://modestmaps.com/). You can also use *Tile Up* to make tiles for `CATiledLayer` (or anything else really...).
+
+[![Build Status](https://travis-ci.org/moiristo/tileup.svg?branch=master)](https://travis-ci.org/moiristo/tileup)
+
+*Note* This is not the official version of tileup. Since the offical version was poorly maintained, I decided to create my own version instead.
+
+## Installation
+
+`gem install moiristo-tileup`
+
+`tileup` requires `rmagick` or `mini_magick` for image manipulation, which depends on `imagemagick`. `imagemagick` is avaliable through `homebrew`.
+
+## Usage
+
+### Basics
+
+To generate some tiles from a large image, you'll probably use something like:
+
+```
+tileup --in huge_image.png --output-dir image_tiles \
+        --prefix my_tiles --verbose
+```
+
+Which will split `huge_image.png` up into `256x256` (default) sized tiles, and save them into the directory `image_tiles`. The images will be saved as `my_tiles_[COLUMN]_[ROW].png`
+
+```
+image_tiles/my_tiles_0_0.png
+image_tiles/my_tiles_0_1.png
+image_tiles/my_tiles_0_2.png
+...
+```
+
+### Using `Tiler` directly
+
+You can also call `Tiler` directly from your application code:
+
+```
+  tiler = TileUp::Tiler.new('huge_image.png', output_dir: 'image_tiles', processor: 'mini_magick', auto_zoom_level: 'auto', logger: 'none')
+
+  # Metadata
+  tiler.recommended_auto_zoom_level # Yields the recommended zoom level
+  tiler.image_processor.width(tiler.image) # Get the image width of 'huge_image.png' using the specified image processor
+  tiler.image_processor.height(tiler.image) # Get the image height of 'huge_image.png' using the specified image processor
+
+  # Tile generation
+  tiler.make_tiles!
+```
+
+### Auto zooming
+
+`tileup` can also scale your image for a number of zoom levels (max 20 levels). This is done by *scaling down* the original image, so make sure its pretty big.
+
+```
+tileup --in really_huge_image.png --auto-zoom auto \
+       --output-dir map_tiles
+```
+
+`--auto-zoom auto` means that `tileup` will autoamtically try to determine the best auto zoom level. The level will be based on the image size and the tile dimensions specified.
+
+```
+tileup --in really_huge_image.png --auto-zoom 4 \
+       --output-dir map_tiles
+```
+
+`--auto-zoom 4` means, make 4 levels of zoom, starting from `really_huge_image.png` at zoom level 20, then scale that down for 19, etc.
+
+You should see something like:
+
+```
+map_tiles/20/map_tile_0_0.png
+map_tiles/20/map_tile_0_1.png
+map_tiles/20/map_tile_0_2.png
+...
+map_tiles/19/map_tile_0_0.png
+map_tiles/19/map_tile_0_1.png
+map_tiles/19/map_tile_0_2.png
+...
+```
+*(where `20` is zoom level 20, the largest zoom, `19` is half the size of `20`, `18` is half the size of `19`, …)*
+
+
+## Getting help
+
+You can get help by running `tileup -h`.
+
+### Contributing
+
+Fixes and patches welcome, to contribute:
+
+1. Fork this project
+1. Create a feature or fix branch *off the develop branch*
+1. Submit a pull request on that branch

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Run tests'
+task default: :test

data/bin/tileup

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'tileup'
+require 'optparse'
+
+options = TileUp::Tiler::DEFAULT_OPTIONS.dup
+
+OptionParser.new do |o|
+  o.on('--in=input_file', "Required input file, your large image to tile up.") { |input_filename| options[:input_filename] = input_filename }
+  o.on('--prefix=map_tile', "Prefix to append to tile files, e.g. --prefix=my_tile => my_tile_[XN]_[YN].png.") { |prefix| options[:filename_prefix] = prefix }
+  o.on('--tile-width=256', "Tile width, should normally equal tile height.") { |width| options[:tile_width] = width }
+  o.on('--tile-height=256', "Tile height, should normally equal tile width.") { |height| options[:tile_height] = height }
+  o.on('--auto-zoom=auto', "Automatically scale input image N times when given a number. When 'auto' is specified, the auto zoom level is automatically determined"){ |zoom_level| options[:auto_zoom_level] = zoom_level }
+  o.on('--output-dir=', "Output directory (will be created if it doesn't exist).") { |output_dir| options[:output_dir] = output_dir }
+  o.on('--processor=rmagick', "Image processor, should be 'rmagick' or 'mini_magick'") { |processor| options[:processor] = processor }
+  o.on('--logger=console', "Sets logger, should be 'console' or 'none'") { |logger| options[:logger] = logger }
+  o.on('--extend-color=none', "Extend color for edge tiles.") {|extend_color| options[:extend_color] = extend_color }
+  o.on('--dont-extend-incomplete-tiles',
+       "Do not extend edge tiles if they do not fill an entire tile_width x tile_height. " +
+       "By default tileup will extend tiles to tile_width x tile_height if required.") {|e| options[:extend_incomplete_tiles] = false}
+  o.on('-v', '--verbose', "Enable verbose logging.") { |verbose| options[:verbose] = true }
+  o.on('-h', '--help', "You're looking at it.") { puts o; exit }
+  o.on('--version', "Version information (v#{TileUp::VERSION})") { puts TileUp::VERSION; exit }
+  begin
+    o.parse!
+  rescue SystemExit => e
+    exit
+  rescue Exception => e
+    puts e.class
+    puts "Argument error, #{e.message}. Try running '#{File.basename($PROGRAM_NAME)} -h'"
+    exit
+  end  
+end
+
+if options[:input_filename].nil?
+  puts "No input file specified, Try running '#{File.basename($PROGRAM_NAME)} -h'"
+  exit 1
+end
+
+begin
+  TileUp::Tiler.new(options[:input_filename], options).make_tiles!
+rescue Interrupt
+  puts "\n\nInterrupt received, exiting.\n"
+  exit
+end

data/lib/tileup.rb

@@ -0,0 +1,10 @@
+require 'tileup/logger'
+require 'tileup/loggers/console'
+require 'tileup/loggers/none'
+
+require 'tileup/image_processor'
+require 'tileup/image_processors/mini_magick'
+require 'tileup/image_processors/rmagick'
+
+require 'tileup/tiler'
+require 'tileup/version'

data/lib/tileup/image_processor.rb

@@ -0,0 +1,66 @@
+module TileUp
+  class ImageProcessor
+    attr_accessor :logger
+
+    def self.build(processor, logger)
+      case processor
+      when 'mini_magick' then TileUp::ImageProcessors::MiniMagick.new(logger)
+      else TileUp::ImageProcessors::RMagick.new(logger)
+      end
+    end
+
+    def initialize logger
+      self.logger = logger
+    end
+
+    def open image_filename
+      image = open_image(image_filename)
+      logger.info "Opened #{image_filename}, #{width(image)} x #{height(image)}"
+      image
+    rescue => e
+      logger.error "Could not open image #{image_filename}: #{e.message}"
+      raise e
+    end
+
+    def scale image, scale
+      logger.verbose "Scale: #{scale}"
+
+      if scale != 1.0
+        scale_image(image, scale)
+      else
+        image
+      end
+    end
+
+    def crop_and_save image, crop, filename:, extend_crop: false, extend_color: 'none'
+      logger.verbose "Crop: x: #{crop[:x]}, y: #{crop[:y]}, w: #{crop[:width]}, h: #{crop[:height]}"
+      crop_and_save_image(image, crop, filename: filename, extend_crop: extend_crop, extend_color: extend_color)
+    end
+
+    # Interface
+
+    def width image
+      raise NotImplementedError
+    end
+
+    def height image
+      raise NotImplementedError
+    end
+
+  private
+
+    def open_image image
+      raise NotImplementedError
+    end
+
+    def scale_image image
+      raise NotImplementedError
+    end
+
+    def crop_image image, crop, extend_crop: false, extend_color: 'none'
+      raise NotImplementedError
+    end
+
+    # / Interface
+  end
+end

data/lib/tileup/image_processors/mini_magick.rb

@@ -0,0 +1,62 @@
+module TileUp
+  module ImageProcessors
+    class MiniMagick < TileUp::ImageProcessor
+
+      def initialize logger
+        require 'mini_magick'
+        super(logger)
+      end
+
+      def width image
+        image.width
+      end
+
+      def height image
+        image.height
+      end
+
+    private
+
+      def open_image(image_filename)
+        ::MiniMagick::Image.open(image_filename)
+      end
+
+      def scale_image image, scale
+        open_image(image.path).resize("#{100.0 * scale}%")
+      rescue RuntimeError => e
+        logger.error "Failed to scale image, are you sure the original image is large enough (#{image.width} x #{image.height})?"
+        return false
+      end
+
+      def crop_and_save_image image, crop, filename:, extend_crop: false, extend_color: 'none'
+        logger.verbose "Saving tile: #{crop[:column]}, #{crop[:row]}..."
+
+        ::MiniMagick::Tool::Convert.new do |convert|
+          convert << mpc(image).path
+          convert.merge! ['-crop', "#{crop[:width]}x#{crop[:height]}+#{crop[:x]}+#{crop[:y]}"]
+
+          if extend_crop
+            convert.merge! ['-background', extend_color]
+            convert.merge! ['-extent', "#{crop[:width]}x#{crop[:height]}"]
+          end
+
+          convert << filename
+        end
+
+        logger.verbose "Saving tile: #{crop[:column]}, #{crop[:row]}... saved"
+
+        true
+      rescue RuntimeError => e
+        raise e
+        logger.error "Failed to crop image: #{e.message}"
+        return false
+      end
+
+      def mpc image
+        @mpcs ||= {}
+        @mpcs[image] ||= open_image(image.path).format 'mpc'
+      end
+
+    end
+  end
+end

data/lib/tileup/image_processors/rmagick.rb

@@ -0,0 +1,57 @@
+module TileUp
+  module ImageProcessors
+    class RMagick < TileUp::ImageProcessor
+
+      def initialize logger
+        require 'rmagick'
+        super(logger)
+      end
+
+      def width image
+        image.columns
+      end
+
+      def height image
+        image.rows
+      end
+
+    private
+
+      def open_image(image_filename)
+        ::Magick::Image.read(image_filename).first
+      end
+
+      def scale_image image, scale
+        image.scale(scale)
+      rescue RuntimeError => e
+        logger.error "Failed to scale image, are you sure the original image is large enough (#{image.columns} x #{image.rows})?"
+        false
+      end
+
+      def crop_and_save_image image, crop, filename:, extend_crop: false, extend_color: 'none'
+        cropped_image = image.crop(crop[:x], crop[:y], crop[:width], crop[:height], true)
+
+        # unless told to do otherwise, extend tiles in the last row and column
+        # if they do not fill an entire tile width and height.
+        needs_extension = cropped_image.columns != crop[:width] || cropped_image.rows != crop[:height]
+
+        if extend_crop && needs_extension
+          # defaults to white background color, but transparent is probably
+          # a better default for our purposes.
+          cropped_image.background_color = extend_color
+          # fill to width height, start from top left corner.
+          cropped_image = cropped_image.extent(crop[:width], crop[:height], 0, 0)
+        end
+
+        logger.verbose "Saving tile: #{crop[:column]}, #{crop[:row]}..."
+        cropped_image.write(filename)
+        logger.verbose "Saving tile: #{crop[:column]}, #{crop[:row]}... saved"
+
+        true
+      rescue RuntimeError => e
+        logger.error "Failed to crop image: #{e.message}"
+        false
+      end
+    end
+  end
+end

data/lib/tileup/logger.rb

@@ -0,0 +1,94 @@
+require 'ostruct'
+require 'logger'
+
+module TileUp
+
+  # Base logger class, subclass this, do not use directly.
+  class Logger
+
+    def self.build type, level, options = {}
+      case type
+      when 'none' then TileUp::Loggers::None.new(level, options)
+      when ::Logger then TileUp::Logger.new(level, options.merge(logger: type))
+      else TileUp::Loggers::Console.new(level, options)
+      end
+    end
+
+    def self.sym_to_severity(sym)
+      severities =  {
+        :debug   => ::Logger::DEBUG,
+        :info    => ::Logger::INFO,
+        :warn    => ::Logger::WARN,
+        :error   => ::Logger::ERROR,
+        :fatal   => ::Logger::FATAL
+      }
+      severity = severities[sym] || ::Logger::UNKNOWN
+    end
+
+    # create logger set to given level
+    # where level is a symbol (:debug, :info, :warn, :error, :fatal)
+    # options may specifiy verbose, which will log more info messages
+    def initialize(level, options = {})
+      @severity = level
+      @logger = options[:logger] if options[:logger]
+      default_options = { verbose: false }
+      @options = OpenStruct.new(default_options.merge(options))
+    end
+
+    def level
+      @level
+    end
+
+    def level=(severity)
+      logger.level = Logger.sym_to_severity(severity)
+    end
+
+    # log an error message
+    def error(message)
+      # note, we always log error messages
+      add(:error, message)
+    end
+
+    # log a regular message
+    def info(message)
+      add(:info, message)
+    end
+
+    def warn(message)
+      add(:warn, message)
+    end
+
+    # log a verbose message
+    def verbose(message)
+      add(:info, message) if verbose?
+    end
+
+    private
+
+    # add message to log
+    def add(severity, message)
+      severity = Logger.sym_to_severity(severity)
+      logger.add(severity, message)
+    end
+
+    # is logger in verbose mode?
+    def verbose?
+      @options.verbose
+    end
+
+    # create or return a logger
+    def logger
+      @logger ||= create_logger
+    end
+
+  private
+
+    # subclasses should overwrite this method, creating what ever
+    # logger they want to
+    def create_logger
+      raise "You should create your own `create_logger` method"
+    end
+
+  end
+
+end

data/lib/tileup/loggers/console.rb

@@ -0,0 +1,18 @@
+module TileUp
+  module Loggers
+    class Console < Logger
+
+      private
+
+      def create_logger
+        logger = ::Logger.new(STDOUT)
+        logger.formatter = Proc.new do |sev, time, prg, msg|
+          "#{time.strftime('%H:%M:%S').to_s} => #{msg}\n"
+        end
+
+        logger
+      end
+
+    end
+  end
+end

data/lib/tileup/loggers/none.rb

@@ -0,0 +1,18 @@
+module TileUp
+  module Loggers
+    class None < Logger
+
+      class NullLogger < ::Logger
+        def initialize(*args); end
+        def add(*args, &block); end
+      end
+
+      private
+
+      def create_logger
+        NullLogger.new
+      end
+
+    end
+  end
+end

data/lib/tileup/tiler.rb

@@ -0,0 +1,155 @@
+require 'ostruct'
+require 'fileutils'
+require 'tileup/logger'
+
+module TileUp
+
+  class Tiler
+
+    DEFAULT_OPTIONS = {
+      processor: 'rmagick', # or 'mini_magick'
+      auto_zoom_level: nil,
+      tile_width: 256,
+      tile_height: 256,
+      filename_prefix: 'map_tile',
+      output_dir: '.',
+      logger: 'console',
+      extend_incomplete_tiles: true,
+      extend_color: 'none',
+      verbose: false
+    }.freeze
+
+    attr_accessor :image_processor, :image, :options, :extension, :logger
+
+    def initialize image_filename, options = {}
+      self.options = options = OpenStruct.new(DEFAULT_OPTIONS.merge(options))
+      self.logger = TileUp::Logger.build(options.logger, :info, verbose: options.verbose)
+      self.image_processor = TileUp::ImageProcessor.build(options.processor, logger)
+      self.image = image_processor.open(image_filename)
+      self.extension = image_filename.split(".").last
+
+      %w(tile_width tile_height).each{|dimension| options[dimension] = options[dimension].to_i }
+
+      if options.auto_zoom_level
+        if options.auto_zoom_level == 'auto'
+          options.auto_zoom_level = recommended_auto_zoom_level
+        else
+          options.auto_zoom_level = options.auto_zoom_level.to_i
+        end
+
+        if options.auto_zoom_level > 20
+          logger.warn 'Warning: auto zoom levels hard limited to 20.'
+          options.auto_zoom_level = 20
+        elsif options.auto_zoom_level <= 0
+          options.auto_zoom_level = nil
+        end
+      end
+    end
+
+    def make_tiles! base_images = build_base_images
+      if base_images
+        result = base_images.map do |base_image|
+          FileUtils.mkdir_p(base_image[:image_path])
+          { base_image[:image_path] => make_tiles_for_base_image!(base_image[:image], File.join(base_image[:image_path], options.filename_prefix)) }
+        end
+        logger.verbose result
+        logger.info 'Done'
+        result
+      else
+        false
+      end
+    end
+
+    def build_base_images
+      logger.info 'Building base images'
+
+      base_images = base_image_processing_tasks.map do |task|
+        {
+          image: image_processor.scale(image, task[:scale]),
+          image_path: task[:output_dir]
+        }
+      end
+
+      if base_images
+        logger.info "Building base images finished."
+        base_images
+      else
+        logger.info 'Building base images failed.'
+        false
+      end
+    end
+
+    def recommended_auto_zoom_level
+      zoom_level = (1..20).detect do |zoom_level|
+        scale = (1.to_f / 2 ** (zoom_level - 1))
+
+        image_processor.width(image) * scale < options.tile_width ||
+        image_processor.height(image) * scale < options.tile_height
+      end
+
+      [1, zoom_level.to_i - 1].max
+    end
+
+    private
+    
+    def make_tiles_for_base_image!(base_image, filename_prefix)
+      # find image width and height
+      # then find out how many tiles we'll get out of
+      # the image, then use that for the xy offset in crop.
+      num_columns = (image_processor.width(base_image) / options.tile_width.to_f).ceil
+      num_rows = (image_processor.height(base_image) / options.tile_height.to_f).ceil
+
+      logger.info "Tiling image into columns: #{num_columns}, rows: #{num_rows}"
+
+      crops_for(num_columns, num_rows).map do |crop|
+        filename = "#{filename_prefix}_#{crop[:column]}_#{crop[:row]}.#{extension}"
+        is_edge = (crop[:row] == num_rows - 1 || crop[:column] == num_columns - 1)
+        image_processor.crop_and_save(base_image, crop, filename: filename, extend_crop: options.extend_incomplete_tiles && is_edge, extend_color: options.extend_color)
+        filename
+      end
+    end
+
+    def base_image_processing_tasks
+      if options.auto_zoom_level.nil?
+        [{ output_dir: options.output_dir, scale: 1.0 }]
+      else
+        current_scale = 1.0
+        (1..options.auto_zoom_level).to_a.reverse.map do |zoom_level|
+          task = {
+            output_dir: File.join(options.output_dir, zoom_level.to_s),
+            scale: current_scale
+          }
+
+          current_scale = current_scale / 2
+          task
+        end
+      end
+    end
+
+    def crops_for num_columns, num_rows
+      crops = []
+
+      x = y = column = row = 0
+      while row < num_rows
+        crops << {
+          row: row,
+          column: column,
+          x: column * options.tile_width,
+          y: row * options.tile_height,
+          width: options.tile_width,
+          height: options.tile_height
+        }
+
+        column += 1
+        if column >= num_columns
+          column = 0
+          row += 1
+        end
+      end
+
+      crops
+    end
+
+  end
+
+end

data/lib/tileup/version.rb

@@ -0,0 +1,3 @@
+module TileUp
+  VERSION = '1.0.0'
+end

data/tileup.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tileup/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'moiristo-tileup'
+  spec.version     = TileUp::VERSION
+  spec.authors     = ['Reinier de Lange']
+  spec.email       = 'rein@bookingexperts.nl'
+
+  spec.summary     = 'Turn an image into an X,Y tile set for use with JS mapping libraries'
+  spec.description = spec.summary
+  spec.homepage    = 'http://github.com/rktjmp/tileup'
+  spec.license     = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^test/})
+  end
+
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.10'
+  spec.add_development_dependency 'pry'
+
+  spec.add_development_dependency 'rmagick', '~> 2.16'
+  spec.add_development_dependency 'mini_magick', '~> 4.7'
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: moiristo-tileup
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Reinier de Lange
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.10'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.16'
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+description: Turn an image into an X,Y tile set for use with JS mapping libraries
+email: rein@bookingexperts.nl
+executables:
+- tileup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGES.md
+- Gemfile
+- Gemfile.lock
+- LICENCE.txt
+- README.md
+- Rakefile
+- bin/tileup
+- lib/tileup.rb
+- lib/tileup/image_processor.rb
+- lib/tileup/image_processors/mini_magick.rb
+- lib/tileup/image_processors/rmagick.rb
+- lib/tileup/logger.rb
+- lib/tileup/loggers/console.rb
+- lib/tileup/loggers/none.rb
+- lib/tileup/tiler.rb
+- lib/tileup/version.rb
+- tileup.gemspec
+homepage: http://github.com/rktjmp/tileup
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Turn an image into an X,Y tile set for use with JS mapping libraries
+test_files: []