map_print 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6dab073cc345466b64e2a4c61f06bc08edc4604b
-  data.tar.gz: b4c5678c67565e3372759c90b10becb8ab25f961
+  metadata.gz: 139b682f39bdac95f76c9c486a146dc16376e0f6
+  data.tar.gz: 6df45284cb99894a860474e60b8443cbe4adf458
 SHA512:
-  metadata.gz: bc8bfa8a173e93068ece013326b663c7f12e828bb6a9f43afb35ca4f4ae7fadb240b364a503a2ad10da372ed2069485005e15b860a6c3fd30725749e30a74d0f
-  data.tar.gz: 9c250065b686fb6c121ad5aba9a2fe3655f7577ed53baad3cdd3bd58d7ed9ae61753a5ef864c790fe9dbfbe6f9ffa8ade5172b56e07fc1100c5ef24b307c84e6
+  metadata.gz: 5ecda32b632e257d4e79bd22900480796e2bb0f3167de4c5b53661902a923b8508314be59e69b6dd1b23e0a24638cd22f8eca0ae31954c59ada553d7b190ad57
+  data.tar.gz: 298ed01e24f773854d869243140641f33a5982fc640a504a3c3aa958cb9f79bb08d289a3ac77af272bf8ab57f130c45b6e6c10756c893f4903ea025b83965640

data/Gemfile.lock

@@ -4,20 +4,55 @@ PATH
     map_print (0.1.0)
       geo-distance (~> 0.1)
       mini_magick (~> 4.3)
+      parallel (~> 1.6.1)
       prawn (~> 2.0)
+      prawn-fast-png (~> 0.2.3)
+      thor
 
 GEM
   remote: https://rubygems.org/
   specs:
-    geo-distance (0.1.2)
+    activesupport (4.2.5)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    geo-distance (0.2.0)
+      geo_point (~> 0.2.5)
+      geo_units (~> 0.2.4.1)
+    geo_calc (0.7.6)
+      activesupport (>= 3.0.1)
+      geo_units (~> 0.2.1)
+      i18n
+      require_all (~> 1.2.0)
+      sugar-high (~> 0.4.6.3)
+    geo_point (0.2.5)
+      geo_calc (~> 0.7.5)
+      geo_units (~> 0.2.1)
+    geo_units (0.2.4.1)
+      sugar-high (~> 0.4.6.2)
+    i18n (0.7.0)
+    json (1.8.3)
     mini_magick (4.3.6)
     minitest (5.8.2)
+    parallel (1.6.1)
     pdf-core (0.6.0)
     prawn (2.0.2)
       pdf-core (~> 0.6.0)
       ttfunk (~> 1.4.0)
+    prawn-fast-png (0.2.3)
+      prawn
+      rmagick
     rake (10.4.2)
+    require_all (1.2.1)
+    rmagick (2.15.4)
+    sugar-high (0.4.6.4)
+    thor (0.19.1)
+    thread_safe (0.3.5)
     ttfunk (1.4.0)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby
@@ -25,7 +60,7 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.10)
   map_print!
-  minitest
+  minitest (~> 5.8)
   rake (~> 10.0)
 
 BUNDLED WITH

data/README.md

@@ -20,7 +20,118 @@ Or install it yourself as:
 
 ## Usage
 
-map_print file.pdf
+### Executable 
+
+`map_print print --south-west="-35.026862,-58.425003" --north-east="-29.980172,-52.959305" --zoom="10" --output="output.png"`
+
+Indicating southwest and northeast to determine the bounding box. Set the zoom at which the tiles should be requested.
+
+In addition set the `output` path to which the resulting image will be written.
+
+This is intended to be more of a testing method as it doesn't support all the options available and always returns a png. In the future we might provide more functionality depending on feature request.
+
+### In ruby code
+
+The mos common usage you'll be expecting is to create a new instance with the map configuration and then call `print` with the output path. MapPrint will take the map configuration, generate the map and write the output to the output path. In the example below `./map.png`.
+
+```ruby
+MapPrint::Core.new(map_configuration).print('./map.png')```
+
+`map_configuration` is a hash with the following options:
+
+```ruby
+BASIC_MAP = {
+    format: 'pdf', # pdf or png
+    pdf_options: {
+      page_size: 'A4', # A0-10, B0-10, C0-10
+      page_layout: :portrait # :portrait, :landscape
+    },
+    map: {
+      sw: { # required
+        lat: -35.026862,
+        lng: -58.425003
+      },
+      ne: { # required
+        lat: -29.980172,
+        lng: -52.959305
+      },
+      zoom: 9, # whatever is supported by the source, typically between 1-15
+      position: { # x,y position on the PDF (as prawn determines it)
+        x: 50,
+        y: 50
+      },
+      size: { # Resize the map image, typically used to print the map on pdf
+        width: 500,
+        height: 800
+      },
+      layers: [{ # Whatever layers you want to include. Currently only OSM and Bing are supported
+        type: 'osm', # (osm, bing) to understand variable substitution and stitching toghether the final image
+        urls: ['http://a.tile.thunderforest.com/transport/${z}/${x}/${y}.png'], # currently only one is being used, in the future it will load balance
+        level: 1, # used to order the layer appearance
+        opacity: 1.0 # in case you want the layer to have some transparency
+      }], # see geojson specification for feature/object support. See http://leafletjs.com/reference.html#path-options for formatting options, the following attributes under properties are supported: `stroke, color, weight, opacity, fill, fillColor, fillOpacity, fillRule, dashArray, lineCap, lineJoin`
+      geojson: '{
+        "type": "FeatureCollection",
+        "features": [{
+          "type":"Feature",
+          "geometry":{"type":"Point", "coordinates":[-32.026862,-55.425003]},
+          "properties":{"image": "./marker.png"}
+        }, {
+          "type": "Feature",
+          "geometry": {"type": "LineString", "coordinates": [ [-32.026862,-55.425003], [-31.026862,-55.425003], [-31.026862,-54.425003], [-32.026862,-54.425003] ] },
+          "properties": {"color": "#000000"}
+        }, {
+          "type": "Feature",
+          "geometry": {"type": "Polygon", "coordinates": [ [-32.126862,-55.825003], [-31.426862,-55.225003], [-31.326862,-54.825003], [-32.146862,-54.835003] ] },
+          "properties": {
+            "stroke": true,
+            "color": "#000000",
+            "weight": 2,
+            "opacity": 1,
+            "fill": true,
+            "fillColor": "#ffffff",
+            "fillOpacity": 1,
+            "fillRule": "evenodd",
+            "dashArray": "5,2,3",
+            "lineCap": "round",
+            "lineJoin": "round"
+          }
+        }]
+      }'
+    },
+    images: [ # not supported yet
+      {
+        path: './file.png',
+        position: {x: 50, y: 50 },
+        size: {width: 50, height: 50},
+        options: {}
+      }
+    ],
+    texts: [ # not supported yet
+      {
+        text: "some text",
+        position: {x: 50, y: 50 },
+        size: {width: 50, height: 50},
+        options: {}
+      }
+    ],
+    legend: { # not supported yet
+      position: {x: 50, y: 50},
+      size: {width: 50, height: 50},
+      columns: 5,
+      rows: 5,
+      elements: [{
+        image: './file.png',
+        text: 'text'
+      }]
+    },
+    scalebar: { # not supported yet
+      unit: 'meters', # meters, km, miles, feet
+      position: {x: 50, y: 50},
+      size: {width: 50, height: 50}
+    }
+  }
+```
 
 ## Development
 

data/bin/map_print

@@ -1,6 +1,54 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "map_print"
+require 'thor'
+require 'bundler/setup'
+require 'map_print'
 
-MapPrint.print ARGV[0]
+class MapPrintCommand < Thor
+
+  desc "print", "Print a map using the given parameters"
+
+  method_option :south_west, type: :string, required: true
+  method_option :north_east, type: :string, required: true
+  method_option :output, type: :string, required: true
+  method_option :zoom, type: :numeric, default: 10
+
+  method_option :provider, type: :string, default: 'osm',
+                enum: ['osm', 'bing']
+
+  def print
+    south_west_coordinate = options[:south_west].split(',')
+      .map {|coordinate| Float(coordinate)}
+    north_east_coordinate = options[:north_east].split(',')
+        .map {|coordinate| Float(coordinate)}
+
+    south_west = MapPrint::LatLng.new(*south_west_coordinate)
+    north_east = MapPrint::LatLng.new(*north_east_coordinate)
+
+    map_options = {
+      format: 'png',
+      map: {
+        sw: {
+          lat: south_west.lat,
+          lng: south_west.lng
+        },
+        ne: {
+          lat: north_east.lat,
+          lng: north_east.lng
+        },
+        zoom: options[:zoom],
+        layers: [{
+          type: 'osm', # to understand variable substitution and stitching toghether the final image
+          urls: ['http://a.tile.thunderforest.com/transport/${z}/${x}/${y}.png'],
+          level: 1,
+          opacity: 1.0 # in case you want the layer to have some transparency
+        }]
+      }
+    }
+
+    MapPrint::Core.new(map_options).print(options[:output])
+  end
+
+end
+
+MapPrintCommand.start

data/lib/base.rb

@@ -0,0 +1,3 @@
+module MapPrint
+
+end

data/lib/map_print/core.rb

@@ -1,41 +1,132 @@
-require 'map_print/lat_lng'
-require 'map_print/osm/tile'
-require 'map_print/osm/tile_factory'
+require_relative 'lat_lng'
+require_relative 'tiles/tile'
+require_relative 'tiles/tile_factory'
+require_relative 'providers/base'
+require_relative 'providers/bing'
+require_relative 'providers/open_street_map'
+require_relative 'layer_handler'
+require_relative 'scalebar_handler'
+require_relative 'image_handler'
+require_relative 'text_handler'
+require_relative 'legend_handler'
+require_relative 'geo_json_handler'
 
 module MapPrint
   class Core
-    def self.print(path)
-      puts path
-      sw = LatLng.new(-35.026862, -58.425003)
-      ne = LatLng.new(-29.980172, -52.959305)
-      osm = OSM::TileFactory.new('http://a.tile.openstreetmap.org/${z}/${x}/${y}.png', sw, ne, 7)
-
-      osm.tiles.collect &:download
-
-      MiniMagick::Tool::Montage.new do |montage|
-        montage.mode('concatenate')
-        montage.tile("#{osm.x_size}x#{osm.y_size}")
-        montage.merge! osm.tiles.collect(&:path)
-        montage << 'output.jpg'
+    attr_accessor :map, :images, :texts, :legend, :scalebar
+
+    PROVIDERS = {
+      'bing' => MapPrint::Providers::Bing,
+      'osm'  => MapPrint::Providers::OpenStreetMap
+    }
+
+    def initialize(args)
+      @format = args[:format]
+      @pdf_options = args[:pdf_options]
+      @map = args[:map]
+      @images = args[:images]
+      @texts = args[:texts]
+      @legend = args[:legend]
+      @scalebar = args[:scalebar]
+    end
+
+    def print(output_path)
+      @output_path = output_path
+
+      if @format == 'pdf'
+        print_pdf
+      elsif @format == 'png'
+        print_png
+      else
+        raise "Unsupported format: #{@format}"
       end
+    end
+
+    private
+    def print_pdf
+      pdf = init_pdf
+      map_image = print_layers
+      map_image = print_geojson(MiniMagick::Image.new(map_image.path))
+
+      FileUtils.cp map_image.path, './map.png' if defined?(DEBUG)
+
+      pdf.image map_image.path, at: [@map[:position][:x], pdf.bounds.top - @map[:position][:y]]
+
+      print_images_on_pdf(pdf)
+      print_texts_on_pdf(pdf)
+      print_legend_on_pdf(pdf)
+
+      pdf.render_file(@output_path)
+      @output_path
+    end
+
+    def print_png
+      map_image = print_layers
+      map_image = print_geojson(MiniMagick::Image.new(map_image.path))
+
+      print_images_on_png(map_image)
+      print_texts_on_png(map_image)
+      print_legend_on_png(map_image)
+
+      FileUtils.cp map_image.path, @output_path
+    end
+
+    def init_file
+      @file = File.open @output_path, 'wb'
+    end
 
-      puts osm.px_offset
+    def init_pdf
+      Prawn::Document.new @pdf_options || {}
+    end
 
-      osm.tiles.each &:delete
+    def print_layers
+      file = LayerHandler.new(@map[:layers], @map[:sw], @map[:ne], @map[:zoom]).process
+      size = @map[:size]
 
-      image = MiniMagick::Image.new('output.jpg')
-      width = image.width - osm.px_offset[:left] - osm.px_offset[:right]
-      height = image.height - osm.px_offset[:top] - osm.px_offset[:bottom]
-      puts "width – old: #{image.width} - new #{width}"
-      puts "height – old: #{image.height} - new #{height}"
+      FileUtils.cp file.path, 'layers.png' if defined?DEBUG
 
-      image.crop("#{width}x#{height}+#{osm.px_offset[:left]}+#{osm.px_offset[:top]}").repage("#{width}x#{height}")
+      if size
+        image = MiniMagick::Image.new(file.path)
+        size[:width] ||= image.width
+        size[:height] ||= image.height
+        puts "Fitting map image (#{image.width}x#{image.height}) in #{size[:width]}x#{size[:height]}"
+        image.colorspace("RGB").resize("#{size[:width]}x#{size[:height]}\>").colorspace("sRGB").unsharp "0x0.75+0.75+0.008"
+      end
 
-      Prawn::Document.generate(path) do
-        image 'output.jpg', width: 500, at: [0, 700]
+      file
+    end
+
+    def print_geojson(map_image)
+      if @map[:geojson]
+        geojson_image = GeoJSONHandler.new(@map[:geojson], @map[:sw], @map[:ne], map_image.width, map_image.height).process
+        result = MiniMagick::Image.open(map_image.path).composite(geojson_image) do |c|
+          c.compose "atop"
+        end
+        result.write map_image.path
       end
 
-      #File.delete 'output.jpg' if File.exist?('output.jpg')
+      map_image
+    end
+
+    def print_images_on_pdf(pdf)
+    end
+
+    def print_texts_on_pdf(pdf)
+    end
+
+    def print_scalebar
+    end
+
+    def print_legend_on_pdf(pdf)
+    end
+
+    def print_images_on_png(png)
+    end
+
+    def print_texts_on_png(png)
+    end
+
+    def print_legend_on_png(png)
     end
   end
 end

data/lib/map_print/geo_json_handler.rb

@@ -0,0 +1,135 @@
+require 'json'
+
+module MapPrint
+  class GeoJSONHandler
+    def initialize(geojson, sw, ne, width, height)
+      @top_lat = ne[:lat]
+      @total_lat = ne[:lat] - sw[:lat]
+      @left_lng = sw[:lng]
+      @total_lng = ne[:lng] - sw[:lng]
+      @height = height
+      @width = width
+      @geojson = JSON[geojson]
+    end
+
+    def process
+      tempfile = Tempfile.new ['geojson', '.png']
+      `convert -size #{@width}x#{@height} xc:transparent #{tempfile.path}`
+      @image = MiniMagick::Image.new tempfile.path
+
+      draw_geojson
+
+      @image.write(tempfile.path)
+      MiniMagick::Image.open(tempfile.path)
+    ensure
+      tempfile.close
+    end
+
+    def draw_geojson
+      if @geojson['type'] == 'Feature'
+        feature(@geojson['geometry'], @geojson['properties'])
+      elsif @geojson['type'] == 'FeatureCollection'
+        feature_collection(@geojson['features'])
+      else
+        puts "Warning, expected type Feature with #{@geojson['type']} inside geometry and drawing properties, like: {'type': 'Feature', 'geometry':#{@geojson.to_json}, 'properties':{'image': 'path/or/url/to/image'}}"
+      end
+    end
+
+    def feature(geometry, properties={})
+      case geometry['type']
+      when 'Feature'
+        feature(geometry['geometry'], geometry['properties'])
+      when 'FeatureCollection'
+        feature_collection(geometry['features'])
+      when 'Point'
+        point(geometry, properties['image'])
+      when 'LineString'
+        line_string(geometry, properties)
+      when 'Polygon'
+        polygon(geometry, properties)
+      when 'MultiPoint'
+        multi_point(geometry, properties)
+      when 'MultiLineString'
+        multi_line_string(geometry, properties)
+      when 'MultiPolygon'
+        multi_polygon(geometry, properties)
+      when 'GeometryCollection'
+        geometry_collection(geometry, properties)
+      end
+    end
+
+    def feature_collection(features)
+      features.each do |object|
+        feature(object)
+      end
+    end
+
+    def point(point, image_path)
+      x = get_x(point['coordinates'][1])
+      y = get_y(point['coordinates'][0])
+
+      point_image = MiniMagick::Image.open(image_path)
+      x -= point_image.width / 2
+      y -= point_image.height / 2
+
+      @image.composite(point_image) do |c|
+        c.geometry("+#{x}+#{y}")
+      end.write @image.path
+    end
+
+    def line_string(geometry, properties)
+      properties ||= {}
+      points = geometry['coordinates'].map do |coord|
+        "#{get_x(coord[1])},#{get_y(coord[0])}"
+      end
+
+      draw_command = (0..(points.length - 2)).map do |i|
+        "line #{points[i]} #{points[i+1]}"
+      end.join(' ')
+
+      @image.combine_options do |c|
+        c.draw "#{draw_options(properties)} #{draw_command}"
+      end
+    end
+
+    def polygon(geometry, properties)
+      properties ||= {}
+      points = geometry['coordinates'].map do |coord|
+        "#{get_x(coord[1])},#{get_y(coord[0])}"
+      end
+
+      @image.combine_options do |c|
+        c.draw "#{draw_options(properties, false)} polygon #{points.join(' ')}"
+      end
+    end
+
+    private
+    def draw_options(properties, line=true)
+      options = ''
+      if properties['stroke'] || properties['stroke'].nil?
+        options += "stroke #{properties['color'] || '#0033ff'} "
+        options += "stroke-width #{properties['weight'] || 5} "
+        options += "stroke-opacity #{properties['opacity'] || 0.5} "
+      end
+
+      if properties['fill'] || (!line && properties['fill'].nil?)
+        options += "fill #{properties['fillColor'] || '#0033ff'} "
+        options += "fill-opacity #{properties['fillOpacity'] || 0.2} "
+        options += "fill-rule #{properties['fillRule'] || 'evenodd'} "
+      end
+
+      options += "stroke-dasharray #{properties['dashArray']} " if properties['dashArray']
+      options += "stroke-linecap #{properties['lineCap']} " if properties['lineCap']
+      options += "stroke-linejoin #{properties['lineJoin']} " if properties['lineJoin']
+      options
+    end
+
+    def get_x(lng)
+      @width * (lng - @left_lng) / @total_lng;
+    end
+
+    def get_y(lat)
+      @height * (1 - (@top_lat - lat) / @total_lat);
+    end
+  end
+end

data/lib/map_print/image_handler.rb

@@ -0,0 +1,9 @@
+module MapPrint
+  class ImageHandler
+    def initialize(images, file)
+    end
+
+    def process
+    end
+  end
+end

data/lib/map_print/layer_handler.rb

@@ -0,0 +1,44 @@
+module MapPrint
+  class LayerHandler
+    PROVIDERS = {
+      'bing' => MapPrint::Providers::Bing,
+      'osm'  => MapPrint::Providers::OpenStreetMap
+    }
+
+    def initialize(layers, south_west, north_east, zoom)
+      @layers = layers.sort_by { |layer| layer[:level] }
+      @south_west = MapPrint::LatLng.new(south_west[:lat], south_west[:lng])
+      @north_east = MapPrint::LatLng.new(north_east[:lat], north_east[:lng])
+      @zoom = zoom
+    end
+
+    def process
+      @layers.each do |layer|
+        provider_class = PROVIDERS[layer[:type]]
+        provider = provider_class.new(@south_west, @north_east, @zoom, layer[:urls].first)
+        layer[:image] = provider.download
+      end
+
+      @layers.first[:image].close
+      image = MiniMagick::Image.open(@layers.first[:image].path)
+      tmp_file = Tempfile.new(['layers', '.png'])
+
+      @layers[1..-1].each do |layer|
+        next_image = layer[:image]
+        next_image.close
+        tmp_image = MiniMagick::Image.open(next_image.path)
+        result = image.composite(tmp_image) do |c|
+          c.compose "atop"
+          if layer[:opacity] && layer[:opacity] < 1
+            c.blend layer[:opacity] * 100
+          end
+        end
+        result.write tmp_file.path
+        image = MiniMagick::Image.open(tmp_file.path)
+      end
+      image.write tmp_file.path
+      tmp_file.close
+      tmp_file
+    end
+  end
+end

data/lib/map_print/legend_handler.rb

@@ -0,0 +1,9 @@
+module MapPrint
+  class LegendHandler
+    def initialize(legend, file)
+    end
+
+    def process
+    end
+  end
+end

data/lib/map_print/osm/tile.rb

@@ -1,9 +1,11 @@
 require 'open-uri'
+require 'fileutils'
 
 module MapPrint
   module OSM
     class Tile
-      attr_reader :path
+
+      BIT_TO_QUADKEY = { [false, false] => "0", [false, true] => "1", [true, false] => "2", [true, true] => "3"}
 
       METERS_PER_PIXELS = {
         0 => 26862156543.031,
@@ -28,17 +30,18 @@ module MapPrint
       }
 
       class << self
+
         def meters_per_pixel(zoom)
           METERS_PER_PIXELS[zoom]
         end
+
       end
 
-      def initialize(x, y, z, base_url=nil)
+      def initialize(x, y, z, base_url)
         @base_url = base_url
         @x = x
         @y = y
         @z = z
-        @path = "#{@x}-#{@y}-#{@z}.png"
       end
 
       def coords
@@ -46,26 +49,14 @@ module MapPrint
       end
 
       def download
-        puts "getting url #{get_url}"
-
-        delete
-        @image = open(get_url).read
-        File.open @path, 'wb' do |f|
-          f.write @image
+        unless File.exists?(file_path)
+          content = open(get_url).read
+          write_file(content)
         end
       end
 
-      def delete
-        File.delete @path if File.exist?(@path)
-      end
-
       def get_pixel_difference(lat_lng)
         tile_lat_lng = tile_number_to_lat_lng
-        puts '================'
-        puts lat_lng.lat
-        puts lat_lng.lng
-        puts tile_lat_lng
-        puts '================'
 
         x_pixels = GeoDistance.distance(lat_lng.lat, lat_lng.lng, lat_lng.lat, tile_lat_lng[:lng]).meters.number / METERS_PER_PIXELS[@z]
         y_pixels = GeoDistance.distance(lat_lng.lat, lat_lng.lng, tile_lat_lng[:lat], lat_lng.lng).meters.number / METERS_PER_PIXELS[@z]
@@ -82,9 +73,52 @@ module MapPrint
         { lat: lat_deg, lng: lon_deg }
       end
 
+      def file_path
+        File.join(folder_name, "#{@y}.png")
+      end
+
+      def tile2quad
+        quadkey_chars = []
+
+        tx = @x.to_i
+        ty = @y.to_i
+
+        @z.times do
+          quadkey_chars.push BIT_TO_QUADKEY[[ty.odd?, tx.odd?]] # bit order y,x
+          tx >>= 1 ; ty >>= 1
+        end
+
+        quadkey_chars.join.reverse
+      end
+
       private
+
+      def write_file(content)
+        FileUtils.mkdir_p(folder_name)
+
+        File.open file_path, 'wb' do |f|
+          f.write content
+        end
+      end
+
+      def provider_name
+        if @base_url =~ /openstreetmap/
+          'osm'
+        elsif @base_url =~ /virtualearth/
+          'bing'
+        end
+      end
+
+      def folder_name
+        "cache/#{provider_name}/#{@z}/#{@x}"
+      end
+
       def get_url
-        @base_url.gsub('${x}', @x.to_s).gsub('${y}', @y.to_s).gsub('${z}', @z.to_s)
+        if provider_name == 'osm'
+          @base_url.gsub('${x}', @x.to_s).gsub('${y}', @y.to_s).gsub('${z}', @z.to_s)
+        elsif provider_name == 'bing'
+          @base_url.gsub('${quadkey}', tile2quad)
+        end
       end
     end
   end

data/lib/map_print/osm/tile_factory.rb

@@ -1,6 +1,7 @@
 module MapPrint
   module OSM
     class TileFactory
+
       def initialize(base_url, sw_lat_lng, ne_lat_lng, zoom)
         @base_url = base_url
         @sw_lat_lng = sw_lat_lng
@@ -19,6 +20,12 @@ module MapPrint
         @px_offset = offset
       end
 
+      def download
+        Parallel.each(tiles, in_processes: 20) do |tile|
+          tile.download
+        end
+      end
+
       def tiles
         return @tiles if @tiles
 

data/lib/map_print/providers/base.rb

@@ -0,0 +1,55 @@
+require 'tempfile'
+
+module MapPrint
+  module Providers
+
+    class Base
+
+      attr_accessor :provider
+
+      attr_accessor :south_west, :north_east, :zoom
+
+      def initialize(south_west, north_east, zoom, base_url=nil)
+        @south_west, @north_east, @zoom = south_west, north_east, zoom
+        @provider = build_provider(base_url)
+      end
+
+      def build_provider(base_url = nil)
+        raise 'SubClasses must override this method'
+      end
+
+      def download
+        provider.download
+
+        to_image
+      end
+
+      protected
+
+      def to_image
+        file = Tempfile.new(['map', '.png'])
+
+        MiniMagick::Tool::Montage.new do |montage|
+          montage.mode('concatenate')
+          montage.tile("#{provider.x_size}x#{provider.y_size}")
+          montage.merge! provider.tiles.collect(&:file_path)
+          montage << file.path
+        end
+
+        result_file = Tempfile.new(['result', '.png'])
+
+        image = MiniMagick::Image.new(file.path)
+        width = image.width - provider.px_offset[:left] - provider.px_offset[:right]
+        height = image.height - provider.px_offset[:top] - provider.px_offset[:bottom]
+
+        image.crop("#{width}x#{height}+#{provider.px_offset[:left]}+#{provider.px_offset[:top]}").repage("#{width}x#{height}")
+        image.write result_file.path
+
+        file.close
+        result_file
+      end
+
+    end
+
+  end
+end

data/lib/map_print/providers/bing.rb

@@ -0,0 +1,13 @@
+module MapPrint
+  module Providers
+
+    class Bing < Base
+      BASE_URL = 'http://ecn.t0.tiles.virtualearth.net/tiles/r${quadkey}.jpeg?g=1515&shading=hill'
+
+      def build_provider(base_url=nil)
+        TileFactory.new(base_url || BASE_URL, 'bing', @south_west, @north_east, @zoom)
+      end
+    end
+
+  end
+end

data/lib/map_print/providers/open_street_map.rb

@@ -0,0 +1,14 @@
+module MapPrint
+  module Providers
+
+    class OpenStreetMap < Base
+      BASE_URL = 'http://a.tile.openstreetmap.org/${z}/${x}/${y}.png'
+
+      def build_provider(base_url=nil)
+        TileFactory.new(base_url || BASE_URL, 'osm', @south_west, @north_east, @zoom)
+      end
+
+    end
+
+  end
+end

data/lib/map_print/scalebar_handler.rb

@@ -0,0 +1,9 @@
+module MapPrint
+  class ScalebarHandler
+    def initialize(scalebar, file)
+    end
+
+    def process
+    end
+  end
+end

data/lib/map_print/text_handler.rb

@@ -0,0 +1,9 @@
+module MapPrint
+  class TextHandler
+    def initialize(texts, file)
+    end
+
+    def process
+    end
+  end
+end

data/lib/map_print/tiles/bing_tile.rb

@@ -0,0 +1,42 @@
+module MapPrint
+
+  class BingTile < Tile
+
+    BIT_TO_QUADKEY = {
+      [false, false] => '0',
+      [false, true]  => '1',
+      [true, false]  => '2',
+      [true, true]   => '3'
+    }
+
+    def provider_name
+      'bing'
+    end
+
+    def cache_name
+      'bing-' + @base_url.scan(/\/\/(.*?)\/\$/).first.first.gsub('/', '-')
+    rescue
+      'bing'
+    end
+
+    def tile2quad
+      quadkey_chars = []
+
+      tx = @x.to_i
+      ty = @y.to_i
+
+      @z.times do
+        quadkey_chars.push BIT_TO_QUADKEY[[ty.odd?, tx.odd?]] # bit order y,x
+        tx >>= 1 ; ty >>= 1
+      end
+
+      quadkey_chars.join.reverse
+    end
+
+    def tile_url
+      @base_url.gsub('${quadkey}', tile2quad)
+    end
+
+  end
+
+end

data/lib/map_print/tiles/osm_tile.rb

@@ -0,0 +1,21 @@
+module MapPrint
+
+  class OSMTile < Tile
+
+    def provider_name
+      'osm'
+    end
+
+    def cache_name
+      'osm-' + @base_url.scan(/\/\/(.*?)\/\$/).first.first.gsub('/', '-')
+    rescue
+      'osm'
+    end
+
+    def tile_url
+      @base_url.gsub('${x}', @x.to_s).gsub('${y}', @y.to_s).gsub('${z}', @z.to_s)
+    end
+
+  end
+
+end

data/lib/map_print/tiles/tile.rb

@@ -0,0 +1,110 @@
+require 'open-uri'
+require 'fileutils'
+
+module MapPrint
+  class Tile
+
+    METERS_PER_PIXELS = {
+      0 => 26862156543.031,
+      1 => 8078271.521,
+      2 => 7739135.761,
+      3 => 6919567.881,
+      4 => 889783.941,
+      5 => 214891.9771,
+      6 => 222445.9801721,
+      7 => 161731222.991,
+      8 => 11611.5001,
+      9 => 52305.751,
+      10 => 152.871,
+      11 => 76.4371,
+      12 => 38.2191,
+      13 => 519.1091,
+      14 => 9.55461,
+      15 => 4.77731,
+      16 => 2.38871,
+      17 => 1.19431,
+      18 => 0.5972
+    }
+
+    class << self
+
+      def meters_per_pixel(zoom)
+        METERS_PER_PIXELS[zoom]
+      end
+
+    end
+
+    def initialize(x, y, z, base_url)
+      @base_url = base_url
+      @x = x
+      @y = y
+      @z = z
+    end
+
+    def coords
+      {x: @x, y: @y, z: @z}
+    end
+
+    def download
+      unless File.exists?(file_path)
+        content = open(tile_url).read
+        write_file(content)
+      end
+    end
+
+    def get_pixel_difference(lat_lng)
+      tile_lat_lng = tile_number_to_lat_lng
+      puts '================'
+      puts lat_lng.lat
+      puts lat_lng.lng
+      puts tile_lat_lng
+      puts '================'
+
+      x_pixels = GeoDistance.distance(lat_lng.lat, lat_lng.lng, lat_lng.lat, tile_lat_lng[:lng]).meters.number / METERS_PER_PIXELS[@z]
+      y_pixels = GeoDistance.distance(lat_lng.lat, lat_lng.lng, tile_lat_lng[:lat], lat_lng.lng).meters.number / METERS_PER_PIXELS[@z]
+
+      { x: x_pixels, y: y_pixels }
+    end
+
+    def tile_number_to_lat_lng
+      n = 2.0 ** @z
+      lon_deg = @x / n * 360.0 - 180.0
+      lat_rad = Math::atan(Math::sinh(Math::PI * (1 - 2 * @y / n)))
+      lat_deg = 180.0 * (lat_rad / Math::PI)
+
+      { lat: lat_deg, lng: lon_deg }
+    end
+
+    def file_path
+      File.join(folder_name, "#{@y}.png")
+    end
+
+    def provider_name
+      raise 'SubClasses should overwrite this method'
+    end
+
+    def cache_name
+      raise 'SubClasses should overwrite this method'
+    end
+
+    def tile_url
+      raise 'SubClasses should overwrite this method'
+    end
+
+    private
+
+    def write_file(content)
+      FileUtils.mkdir_p(folder_name)
+
+      File.open file_path, 'wb' do |f|
+        f.write content
+      end
+    end
+
+    def folder_name
+      "cache/#{cache_name}/#{@z}/#{@x}"
+    end
+
+  end
+
+end

data/lib/map_print/tiles/tile_factory.rb

@@ -0,0 +1,90 @@
+require_relative 'osm_tile'
+require_relative 'bing_tile'
+
+module MapPrint
+
+  class TileFactory
+
+    def initialize(base_url, type, sw_lat_lng, ne_lat_lng, zoom)
+      @base_url = base_url
+      @type = type
+      @sw_lat_lng = sw_lat_lng
+      @ne_lat_lng = ne_lat_lng
+      @zoom = zoom
+    end
+
+    def px_offset
+      return @px_offset if @px_offset
+      offset = {}
+
+      offset[:top] = (ne_offset[:y] * 256).to_i
+      offset[:right] = 256 - (ne_offset[:x] * 256).to_i
+      offset[:bottom] = 256 - (sw_offset[:y] * 256).to_i
+      offset[:left] = (sw_offset[:x] * 256).to_i
+      @px_offset = offset
+    end
+
+    def download
+      Parallel.each(tiles, in_processes: 20) do |tile|
+        tile.download
+      end
+    end
+
+    def tiles
+      return @tiles if @tiles
+
+      @tiles = []
+      y_array.each do |y|
+        x_array.each do |x|
+          @tiles << tile_class.new(x, y, @zoom, @base_url)
+        end
+      end
+
+      @tiles
+    end
+
+    def x_size
+      x_array.size
+    end
+
+    def y_size
+      y_array.size
+    end
+
+    def ne_offset
+      @ne_lat_lng.get_slippy_map_tile_number(@zoom)[:offset]
+    end
+
+    def sw_offset
+      @sw_lat_lng.get_slippy_map_tile_number(@zoom)[:offset]
+    end
+
+    def x_array
+      return @x_array if @x_array
+
+      x1 = @sw_lat_lng.get_slippy_map_tile_number(@zoom)[:x]
+      x2 = @ne_lat_lng.get_slippy_map_tile_number(@zoom)[:x]
+      @x_array ||= x1 < x2 ? x1..x2 : (x2..x1).to_a
+    end
+
+    def y_array
+      return @y_array if @y_array
+
+      y1 = @sw_lat_lng.get_slippy_map_tile_number(@zoom)[:y]
+      y2 = @ne_lat_lng.get_slippy_map_tile_number(@zoom)[:y]
+      @y_array ||= y1 < y2 ? y1..y2 : (y2..y1).to_a
+    end
+
+    private
+
+    def tile_class
+      if @type == 'osm'
+        OSMTile
+      elsif @type =~ 'bing'
+        BingTile
+      end
+    end
+
+  end
+
+end

data/lib/map_print/version.rb

@@ -1,3 +1,3 @@
 module MapPrint
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/map_print.rb

@@ -1,17 +1,8 @@
-require 'map_print/version'
 require 'prawn'
 require 'mini_magick'
 require 'geo-distance'
+require 'parallel'
 
-module MapPrint
-  # Your code goes here...
-end
-
-require 'map_print/core'
-
-
-module MapPrint
-  def self.print(path)
-    MapPrint::Core.print(path)
-  end
-end
+require_relative 'base'
+require_relative 'map_print/version'
+require_relative 'map_print/core'

data/map_print.gemspec

@@ -23,14 +23,17 @@ Gem::Specification.new do |spec|
   end
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'minitest', '~> 5.8'
   spec.add_dependency 'prawn', '~> 2.0'
+  spec.add_dependency 'prawn-fast-png', '~> 0.2.3'
   spec.add_dependency 'mini_magick', '~> 4.3'
   spec.add_dependency 'geo-distance', '~> 0.1'
+  spec.add_dependency 'parallel', '~> 1.6'
+  spec.add_dependency 'thor', '~> 0.19'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: map_print
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Andreas Fast
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2015-11-16 00:00:00.000000000 Z
+date: 2015-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: prawn-fast-png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
 - !ruby/object:Gem::Dependency
   name: mini_magick
   requirement: !ruby/object:Gem::Requirement
@@ -94,11 +108,42 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
 description: MapPrint allows to export many map sources and GeoJSON objects to a pdf
   file, along with legend and text elements to create rich maps.
 email:
 - andis.machine@gmail.com
-executables: []
+executables:
+- console
+- map_print
+- setup
 extensions: []
 extra_rdoc_files: []
 files:
@@ -113,13 +158,28 @@ files:
 - bin/console
 - bin/map_print
 - bin/setup
+- lib/base.rb
 - lib/map_print.rb
 - lib/map_print/core.rb
+- lib/map_print/geo_json_handler.rb
+- lib/map_print/image_handler.rb
 - lib/map_print/lat_lng.rb
+- lib/map_print/layer_handler.rb
+- lib/map_print/legend_handler.rb
 - lib/map_print/osm/tile.rb
 - lib/map_print/osm/tile_factory.rb
+- lib/map_print/providers/base.rb
+- lib/map_print/providers/bing.rb
+- lib/map_print/providers/open_street_map.rb
+- lib/map_print/scalebar_handler.rb
+- lib/map_print/text_handler.rb
+- lib/map_print/tiles/bing_tile.rb
+- lib/map_print/tiles/osm_tile.rb
+- lib/map_print/tiles/tile.rb
+- lib/map_print/tiles/tile_factory.rb
 - lib/map_print/version.rb
 - map_print.gemspec
+- marker.png
 homepage: http://github.com/afast/map_print
 licenses:
 - MIT