mapstatic 0.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,54 @@
+PATH
+  remote: .
+  specs:
+    mapstatic (0.0.1)
+      awesome_print (~> 1.2.0)
+      faraday (~> 0.8.8)
+      mini_magick (~> 3.6.0)
+      thor (~> 0.18.1)
+      typhoeus (~> 0.6.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    awesome_print (1.2.0)
+    crack (0.4.1)
+      safe_yaml (~> 0.9.0)
+    diff-lcs (1.2.4)
+    ethon (0.6.1)
+      ffi (>= 1.3.0)
+      mime-types (~> 1.18)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
+    ffi (1.9.3)
+    mime-types (1.25.1)
+    mini_magick (3.6.0)
+      subexec (~> 0.2.1)
+    multipart-post (1.2.0)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    safe_yaml (0.9.7)
+    subexec (0.2.3)
+    thor (0.18.1)
+    typhoeus (0.6.6)
+      ethon (~> 0.6.1)
+    vcr (2.7.0)
+    webmock (1.15.2)
+      addressable (>= 2.2.7)
+      crack (>= 0.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mapstatic!
+  rspec (~> 2.13.0)
+  vcr (~> 2.7.0)
+  webmock (~> 1.15.2)

data/bin/mapstatic

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "mapstatic/cli"
+
+Mapstatic::CLI.start

data/lib/mapstatic/cli.rb

@@ -0,0 +1,52 @@
+require 'mapstatic'
+require 'awesome_print'
+require 'thor'
+
+class Mapstatic::CLI < Thor
+
+  desc "map FILENAME", "Generate a map"
+  long_desc <<-LONGDESC
+     `mapstatic map FILENAME` will create a new static map.
+
+     A map can be created in two ways:
+
+     1. With a bounding box, e.g.
+
+     $ mapstatic map uk.png --zoom=6 --bbox=-10.93,49.64,3.15,59.57
+
+     When creating a map with a bounding box, the width and height of the map
+     will be determined by the zoom level.
+
+     2. With a center lat, lng, width and height, e.g.
+
+     $ mapstatic map greenwich.png --zoom=12 \
+                                   --lat=51.477222 \
+                                   --lng=0 \
+                                   --width=700 \
+                                   --height=700
+
+     By default, the map will be generated with the OpenStreetMap tile set (Copyright
+     OpenStreetMap contributors).
+
+     You can generate a map using any tile set by passing the --provider option.
+  LONGDESC
+
+  option :zoom,     :required => true
+  option :provider, :default => 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png'
+  option :bbox
+  option :lat
+  option :lng
+  option :width,  :default => 256
+  option :height, :default => 256
+  option :dryrun, :type => :boolean, :default => false
+
+  def map(filename)
+    params = Hash[options.map{|(k,v)| [k.to_sym,v]}]
+
+    map = Mapstatic::Map.new(params)
+
+    map.render_map(filename) unless options[:dryrun]
+    ap map.metadata
+  end
+
+end

data/lib/mapstatic/conversion.rb

@@ -0,0 +1,28 @@
+module Mapstatic
+
+  class Conversion
+
+    def lng_to_x(lng, zoom)
+      n = 2 ** zoom
+      ((lng.to_f + 180) / 360) * n
+    end
+
+    def x_to_lng(x, zoom)
+      n = 2.0 ** zoom
+      lon_deg = x / n * 360.0 - 180.0
+    end
+
+    def lat_to_y(lat, zoom)
+      n = 2 ** zoom
+      lat_rad = (lat / 180) * Math::PI
+      (1 - Math.log( Math.tan(lat_rad) + (1 / Math.cos(lat_rad)) ) / Math::PI) / 2 * n
+    end
+
+    def y_to_lat(y, zoom)
+      n = 2.0 ** zoom
+      lat_rad = Math.atan(Math.sinh(Math::PI * (1 - 2 * y / n)))
+      lat_deg = lat_rad / (Math::PI / 180.0)
+    end
+  end
+
+end

data/lib/mapstatic/map.rb

@@ -0,0 +1,158 @@
+require 'mini_magick'
+
+module Mapstatic
+
+  class Map
+    TILE_SIZE = 256
+
+    attr_reader :zoom, :lat, :lng, :width, :height
+    attr_accessor :tile_source
+
+    def initialize(params={})
+      if params[:bbox]
+        @bounding_box = params[:bbox].split(',').map(&:to_f)
+      else
+        @lat    = params.fetch(:lat).to_f
+        @lng    = params.fetch(:lng).to_f
+        @width  = params.fetch(:width).to_f
+        @height = params.fetch(:height).to_f
+      end
+      @zoom = params.fetch(:zoom).to_i
+      @tile_source = TileSource.new(params[:provider])
+    end
+
+    def width
+      @width ||= begin
+        left, bottom, right, top = bounding_box_in_tiles
+        (right - left) * TILE_SIZE
+      end
+    end
+
+    def height
+      @height ||= begin
+        left, bottom, right, top = bounding_box_in_tiles
+        (bottom - top) * TILE_SIZE
+      end
+    end
+
+    def render_map(filename)
+      base_image = create_uncropped_image
+      base_image = fill_image_with_tiles(base_image)
+      crop_to_size base_image
+      base_image.write filename
+    end
+
+    def metadata
+      {
+        :bbox => bounding_box.join(','),
+        :width => width.to_i,
+        :height => height.to_i,
+        :zoom => zoom,
+        :number_of_tiles => required_tiles.length,
+      }
+    end
+
+    private
+
+    def x_tile_space
+      Conversion.new.lng_to_x(lng, zoom)
+    end
+
+    def y_tile_space
+      Conversion.new.lat_to_y(lat, zoom)
+    end
+
+    def width_tile_space
+      width / TILE_SIZE
+    end
+
+    def height_tile_space
+      height / TILE_SIZE
+    end
+
+    def bounding_box
+      @bounding_box ||= begin
+        converter = Conversion.new
+        left      = converter.x_to_lng( x_tile_space - (width_tile_space / 2), zoom)
+        right     = converter.x_to_lng( x_tile_space + ( width_tile_space / 2 ), zoom)
+        top       = converter.y_to_lat( y_tile_space - ( height_tile_space / 2 ), zoom)
+        bottom    = converter.y_to_lat( y_tile_space + ( height_tile_space / 2 ), zoom)
+
+        [ left, bottom, right, top ]
+      end
+    end
+
+    def bounding_box_in_tiles
+      left, bottom, right, top = bounding_box
+      converter = Conversion.new
+      [
+        converter.lng_to_x(left, zoom),
+        converter.lat_to_y(bottom, zoom),
+        converter.lng_to_x(right, zoom),
+        converter.lat_to_y(top, zoom)
+      ]
+    end
+
+    def required_x_tiles
+      left, bottom, right, top = bounding_box_in_tiles
+      Range.new(*[left, right].map(&:floor)).to_a
+    end
+
+    def required_y_tiles
+      left, bottom, right, top = bounding_box_in_tiles
+      Range.new(*[top, bottom].map(&:floor)).to_a
+    end
+
+    def required_tiles
+      required_y_tiles.map do |y|
+        required_x_tiles.map{|x| Tile.new(x,y,zoom) }
+      end.flatten
+    end
+
+    def map_tiles
+      @map_tiles ||= tile_source.get_tiles(required_tiles)
+    end
+
+    def crop_to_size(image)
+      distance_from_left = (bounding_box_in_tiles[0] - required_x_tiles[0]) * TILE_SIZE
+      distance_from_top  = (bounding_box_in_tiles[3] - required_y_tiles[0]) * TILE_SIZE
+
+      image.crop "#{width}x#{height}+#{distance_from_left}+#{distance_from_top}"
+    end
+
+    def create_uncropped_image
+      image = MiniMagick::Image.read(map_tiles[0])
+
+      uncropped_width  = required_x_tiles.length * TILE_SIZE
+      uncropped_height = required_y_tiles.length * TILE_SIZE
+
+      image.combine_options do |c|
+        c.background 'none'
+        c.extent [uncropped_width,uncropped_height].join('x')
+      end
+
+      image
+    end
+
+    def fill_image_with_tiles(image)
+      start = 0
+
+      required_y_tiles.length.times do |row|
+        length = required_x_tiles.length
+
+        map_tiles.slice(start, length).each_with_index do |tile, column|
+          image = image.composite( MiniMagick::Image.read(tile) ) do |c|
+            c.geometry "+#{ (column) * TILE_SIZE }+#{ (row) * TILE_SIZE }"
+          end
+        end
+
+        start += length
+      end
+
+      image
+    end
+
+  end
+
+
+end

data/lib/mapstatic/tile.rb

@@ -0,0 +1,14 @@
+module Mapstatic
+
+  class Tile
+    attr_accessor :x, :y, :zoom
+
+    def initialize(x,y,zoom)
+      @x = x.floor
+      @y = y.floor
+      @zoom = zoom
+    end
+
+  end
+
+end

data/lib/mapstatic/tile_source.rb

@@ -0,0 +1,60 @@
+require 'faraday'
+require 'typhoeus'
+require 'typhoeus/adapters/faraday'
+
+module Mapstatic
+
+  class TileSource
+
+    attr_reader :url
+
+    def initialize(url)
+      @url = url
+    end
+
+    def get_tile(tile)
+      connection.get(tile_url(tile)).body
+    end
+
+    def get_tiles(tiles)
+      responses = []
+
+      connection.in_parallel do
+        tiles.each do |tile|
+          responses << connection.get(tile_url(tile))
+        end
+      end
+
+      responses.map(&:body)
+    end
+
+    private
+
+    attr_reader :connection
+
+    def tile_url(tile)
+      url.
+        gsub(/\{x\}/,tile.x.to_s).
+        gsub(/\{y\}/,tile.y.to_s).
+        gsub(/\{z\}/,tile.zoom.to_s).
+        gsub(/\{s\}/,subdomain_for_tile(tile))
+    end
+
+    def subdomain_for_tile(tile)
+      i = (tile.x + tile.y) % subdomains.length
+      subdomains[i]
+    end
+
+    def subdomains
+      ['a','b','c']
+    end
+
+    def connection
+      @connection ||= Faraday.new do |builder|
+        builder.adapter :typhoeus
+      end
+    end
+
+  end
+
+end

data/lib/mapstatic/version.rb

@@ -0,0 +1,3 @@
+module Mapstatic
+  VERSION = '0.0.1'
+end

data/lib/mapstatic.rb

@@ -0,0 +1,8 @@
+module Mapstatic
+end
+
+require 'mapstatic/version'
+require 'mapstatic/conversion'
+require 'mapstatic/map'
+require 'mapstatic/tile'
+require 'mapstatic/tile_source'