gpx2png 0.2.0 → 0.3.0

data/Gemfile

@@ -2,9 +2,8 @@ source "http://rubygems.org"
 
 gem 'mini_exiftool'
 gem 'rmagick'
-# removed
-#gem 'chunky_png'
 gem 'gpx_utils'
+gem 'colorize'
 
 group :development do
   gem "rspec"

data/Gemfile.lock

@@ -3,6 +3,7 @@ GEM
   specs:
     addressable (2.3.5)
     builder (3.2.2)
+    colorize (0.6.0)
     diff-lcs (1.2.5)
     docile (1.1.1)
     faraday (0.8.8)
@@ -69,6 +70,7 @@ PLATFORMS
 
 DEPENDENCIES
   bundler
+  colorize
   gpx_utils
   jeweler
   mini_exiftool

data/README.md

@@ -1,75 +1,11 @@
-gpx2exif
+gpx2png
 =======
 
-Geotagging
-----------
-
-Geotag your photos using stored GPX files. At this moment it supports only Garmin eTrex devices.
-
-
-Disclaimer
-----------
-
-This gem add one executable which overwrite JPG files. BACKUP IS NEEDED!
-
-
-How to use it
--------------
-
-1. gem install gpx2exif
-
-2. Go to path where you have JPG/JPEG photos (case insensitive) and GPX files.
-
-3. From 0.0.1 there is 'simulation command'. Type 'geotag_simulate' and enter.
-
-4. WARNING! it will overwrite all your photos so MAKE A BACKUP!
-
-5. Type 'geotag_all_images' and press enter key.
-
-6. See a nice piece of output and now you have geotagged photos :)
-
-
-If something is not working send me e-mail and I'll fix it.
-
-
-Create waypoint files
----------------------
-
-You can prepare your own list of waypoints and then store into eTrex using GPX file. At this moment there is
-only possible to convert data from YAML file to GPX. It is also possible to integrate with other (web)apps.
-
-How to use it
--------------
-
-1. Check samples/sample_yaml_pois.yml as a template.
-
-2. Modify it, add yours POIs.
-
-3. Run command
-
-  generate_garmin_waypoints -y input_file.yml > output.gpx
-
-4. You can check inter-POI distances using
-
-  generate_garmin_waypoints -y input_file.yml -C
-
-   Distance conflict does not mean something is wrong. POIs can be close to each other so it
-   is a good idea to have your brain turned on ;)
-
-5. You can change inter-POI distances using 'latlon something' distance for distance checking
-   explained line before.
-
-  generate_garmin_waypoints -y samples/sample_yaml_pois.yml -C -t 1
-
-6. You can specify output file if you don't like using >> 'file.gpx'.
-
-  generate_garmin_waypoints -y samples/sample_yaml_pois.yml -o file.gpx
-
-
 Render track with OpenStreetMap
 ---------------------
 
-You can "convert" your tracks to images using this command.
+You can "convert" your tracks to map images using this command.
+
 
 How to use it
 -------------
@@ -92,13 +28,17 @@ How to use it
 
   gpx2png -g spec/fixtures/sample.gpx -z 11 -o map.png
 
-4. Adding -u forces using [UMP tiles](http://ump.waw.pl/) .
+4. You can change map provider:
+
+  * OpenStreetMap - defualt
+  * UMP - add -u to use [UMP tiles](http://ump.waw.pl/)
+  * Cycle - add -u to use [UMP tiles](http://ump.waw.pl/)
 
 
-Contributing to gpx2xif
+Contributing to gpx2png
 -------------------------------
 
-[![Flattr this git repo](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=bobik314&url=https://github.com/akwiatkowski/gpx2xif&title=gpx2xif&language=en_GB&tags=github&category=software)
+[![Flattr this git repo](http://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=bobik314&url=https://github.com/akwiatkowski/gpx2png&title=gpx2png&language=en_GB&tags=github&category=software)
 
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
@@ -112,6 +52,6 @@ Contributing to gpx2xif
 Copyright
 ---------
 
-Copyright (c) 2012 Aleksander Kwiatkowski. See LICENSE.txt for
+Copyright (c) 2012-2014 Aleksander Kwiatkowski. See LICENSE.txt for
 further details.
 

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/bin/gpx2png

@@ -6,7 +6,7 @@ require 'gpx2png/osm'
 require 'gpx2png/ump'
 require 'optparse'
 
-options = { }
+options = {}
 OptionParser.new do |opts|
   opts.banner = "Usage: gpx2png [options]"
 
@@ -22,8 +22,8 @@ OptionParser.new do |opts|
   opts.on("-o", "--output FILE", "Output image file") do |v|
     options[:output_file] = v
   end
-  opts.on("-u", "--ump", "Use UMP tiles rather than OSM") do
-    options[:ump] = true
+  opts.on("-k", "--klass CLASS", "Use different map provider (osm, ump, cycle, transport, outdoors, landscape)") do |v|
+    options[:klass] = v
   end
 end.parse!
 
@@ -40,15 +40,26 @@ if options[:zoom].nil? and options[:size].nil?
   @fail = true
 end
 
+klass = case options[:klass].to_s
+          when "ump" then
+            Gpx2png::Ump
+          when "cycle" then
+            Gpx2png::OpenCycle
+          when "transport" then
+            Gpx2png::Transport
+          when "outdoors" then
+            Gpx2png::Outdoors
+          when "landscape" then
+            Gpx2png::Landscape
+          else
+            Gpx2png::Osm
+        end
+
 unless @fail
   g = GpxUtils::TrackImporter.new
   g.add_file(options[:gpx])
 
-  if options[:ump]
-    e = Gpx2png::Ump.new
-  else
-    e = Gpx2png::Osm.new
-  end
+  e = klass.new
   e.coords = g.coords
 
   if options[:size]
@@ -58,7 +69,7 @@ unless @fail
   else
     # constant zoom
     e.zoom = options[:zoom].to_i
-    e.renderer_options = {crop_enabled: true}
+    e.renderer_options = { crop_enabled: true }
   end
 
   e.save(options[:output_file])

data/lib/gpx2png.rb

@@ -3,3 +3,7 @@ $:.unshift(File.dirname(__FILE__))
 require 'gpx_utils'
 require 'gpx2png/osm'
 require 'gpx2png/ump'
+require 'gpx2png/opencycle'
+require 'gpx2png/transport'
+require 'gpx2png/landscape'
+require 'gpx2png/outdoors'

data/lib/gpx2png/base.rb

@@ -1,29 +1,125 @@
-require 'rubygems'
-
-$:.unshift(File.dirname(__FILE__))
+require 'colorize'
+require 'logger'
+require 'gpx2png/layer'
+require 'gpx2png/calculations/base_class_methods'
+require 'gpx2png/calculations/base_instance_methods'
 
 module Gpx2png
   class Base
+    extend Calculations::BaseClassMethods
+    include Calculations::BaseInstanceMethods
 
     def initialize
-      @coords = Array.new
+      @layers = Array.new
+      _layer = Layer.new
+      _layer.parent = self
+      @layers << _layer
+      @single_layer = true
+
       @zoom = 9
-      @verbose = true
+
+      self.class.logger.debug("Init, default zoom #{@zoom.to_s.green}")
+    end
+
+    def add_layer(_layer_options)
+      if @single_layer
+        self.class.logger.debug("Created #{"first".to_s.red} layer")
+        # turn off single layer version
+        @single_layer = false
+        # set layer options for first layer and return it
+        _layer = @layers.first
+        _layer.options = _layer_options
+        return _layer
+      else
+        # create new layer with options, add to list and return
+        _layer = Layer.new
+        _layer.parent = self
+        _layer.options = _layer_options
+        @layers << _layer
+        self.class.logger.debug("Created layer, count: #{@layers.size.to_s.red}")
+        return _layer
+      end
     end
 
     def add(lat, lon)
-      @coords << { lat: lat, lon: lon }
+      if @single_layer
+        # add coord to first layer
+        _layer = @layers.first
+        _layer.add(lat, lon)
+      else
+        # I'm afraid Dave I can't do that
+        self.class.logger.fatal("After you've added first layer you can use coords only from layers")
+        raise StandardError
+      end
+    end
+
+    def coords=(_coords)
+      if @single_layer
+        # add coord to first layer
+        _layer = @layers.first
+        _layer.coords = _coords
+      else
+        # I'm afraid Dave I can't do that
+        self.class.fatal("After you've added first layer you can use coords only from layers")
+        raise StandardError
+      end
+    end
+
+    def color(_color)
+      if @single_layer
+        # add coord to first layer
+        _layer = @layers.first
+        _layer.color = _color
+      else
+        # I'm afraid Dave I can't do that
+        self.class.fatal("After you've added first layer you have to use layers")
+        raise StandardError
+      end
+    end
+
+    # Create image with fixed size
+    def fixed_size(_width, _height)
+      @fixed_width = _width
+      @fixed_height = _height
+      self.class.logger.debug("Map image fixed dimension set #{@fixed_width.to_s.red} x #{@fixed_height.to_s.red}")
+      true
     end
 
-    attr_accessor :zoom, :color, :coords
+    def zoom=(_zoom)
+      self.class.logger.debug("Map zoom set #{_zoom.to_s.red}")
+      @zoom = _zoom
+    end
+
+    def zoom
+      @zoom
+    end
+
+    attr_accessor :layers
+
+    # Simulate download of tiles
+    attr_accessor :simulate_download
+
+    def self.simulate_download=(b)
+      logger.debug("Simulate tiles download for class #{self.to_s.blue}") if b
+      @@simulate_download = b
+    end
+
+    def simulate_download?
+      return true if true == self.simulate_download or (defined? @@simulate_download and true == @@simulate_download)
+    end
+
+    def destroy
+      @r.destroy
+      self.class.logger.debug "Image destroyed"
+    end
 
-    # Some math stuff
-    def self.rad2deg(rad)
-      return rad * 180.0 / Math::PI
+    def self.logger=(_logger)
+      @@logger = _logger
     end
 
-    def self.deg2rad(deg)
-      return deg * Math::PI / 180.0
+    def self.logger
+      @@logger = Logger.new(STDOUT) unless defined? @@logger
+      return @@logger
     end
 
   end

data/lib/gpx2png/calculations/base_class_methods.rb

@@ -0,0 +1,15 @@
+module Gpx2png
+  module Calculations
+    module BaseClassMethods
+      # Some math stuff
+      def rad2deg(rad)
+        return rad * 180.0 / Math::PI
+      end
+
+      def deg2rad(deg)
+        return deg * Math::PI / 180.0
+      end
+
+    end
+  end
+end

data/lib/gpx2png/calculations/base_instance_methods.rb

@@ -0,0 +1,32 @@
+module Gpx2png
+  module Calculations
+    module BaseInstanceMethods
+
+      def calculate_minmax_latlon
+        @layers.each do |l|
+          enlarge_border_coords(l)
+        end
+        # when no coords specified
+        @lat_min ||= -0.01
+        @lat_max ||= 0.01
+        @lon_min ||= -0.01
+        @lon_max ||= 0.01
+      end
+
+      def enlarge_border_coords(layer)
+        _lat_min = layer.coords.collect { |c| c[:lat] }.min
+        _lat_max = layer.coords.collect { |c| c[:lat] }.max
+        _lon_min = layer.coords.collect { |c| c[:lon] }.min
+        _lon_max = layer.coords.collect { |c| c[:lon] }.max
+
+        @lat_min = _lat_min if @lat_min.nil? or _lat_min < @lat_min
+        @lat_max = _lat_max if @lat_max.nil? or _lat_max > @lat_max
+        @lon_min = _lon_min if @lon_min.nil? or _lon_min < @lon_min
+        @lon_max = _lon_max if @lon_max.nil? or _lon_max > @lon_max
+
+        self.class.logger.debug("Border coords #{@lat_min.to_s.green},#{@lon_min.to_s.green} - #{@lat_max.to_s.green},#{@lon_max.to_s.green}")
+      end
+
+    end
+  end
+end

data/lib/gpx2png/calculations/osm_class_methods.rb

@@ -0,0 +1,99 @@
+module Gpx2png
+  module Calculations
+    module OsmClassMethods
+
+      TILE_WIDTH = 256
+      TILE_HEIGHT = 256
+
+      # http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#X_and_Y
+      # Convert latlon deg to OSM tile coords
+      def convert(zoom, coord)
+        lat_deg, lon_deg = coord
+        lat_rad = deg2rad(lat_deg)
+        x = (((lon_deg + 180) / 360) * (2 ** zoom)).floor
+        y = ((1 - Math.log(Math.tan(lat_rad) + 1 / Math.cos(lat_rad)) / Math::PI) /2 * (2 ** zoom)).floor
+
+        logger.debug "Converted #{lat_deg.to_s.green},#{lat_deg.to_s.green} to [#{x.to_s.red},#{y.to_s.red}]"
+
+        return [x, y]
+      end
+
+      # Convert OSM tile coords to latlon deg in top-left corner
+      def reverse_convert(zoom, coord)
+        x, y = coord
+        n = 2 ** zoom
+        lon_deg = x.to_f / n.to_f * 360.0 - 180.0
+        lat_deg = rad2deg(Math.atan(Math.sinh(Math::PI * (1.to_f - 2.to_f * y.to_f / n.to_f))))
+
+        logger.debug "Reverse converted [#{x.to_s.red},#{y.to_s.red}] to #{lat_deg.to_s.green},#{lat_deg.to_s.green}"
+
+        return [lat_deg, lon_deg]
+      end
+
+      # Lazy calc proper zoom for drawing
+      def calc_zoom(lat_min, lat_max, lon_min, lon_max, width, height)
+        # because I'm lazy! :] and math is not my best side
+
+        last_zoom = 2
+        (5..18).each do |zoom|
+          # calculate drawing tile size and pixel size
+          tile_min = point_on_absolute_image(zoom, [lat_min, lon_min])
+          tile_max = point_on_absolute_image(zoom, [lat_max, lon_max])
+          current_pixel_x_distance = tile_max[0] - tile_min[0]
+          current_pixel_y_distance = tile_min[1] - tile_max[1]
+          if current_pixel_x_distance > width or current_pixel_y_distance > height
+            logger.debug "Calculated best zoom #{last_zoom.to_s.red}"
+            return last_zoom
+          end
+          last_zoom = zoom
+        end
+        return 18
+      end
+
+      # Convert latlon deg coords to image point (x,y) and OSM tile coord
+      # return where you should put point on tile
+      def point_on_image(zoom, geo_coord)
+        osm_tile_coord = convert(zoom, geo_coord)
+        top_left_corner = reverse_convert(zoom, osm_tile_coord)
+        bottom_right_corner = reverse_convert(zoom, [
+          osm_tile_coord[0] + 1, osm_tile_coord[1] + 1
+        ])
+
+        # some line math: y = ax + b
+
+        x_geo = geo_coord[1]
+        # offset
+        x_offset = x_geo - top_left_corner[1]
+        # scale
+        x_distance = (bottom_right_corner[1] - top_left_corner[1])
+        x = (TILE_WIDTH.to_f * (x_offset / x_distance)).round
+
+        y_geo = geo_coord[0]
+        # offset
+        y_offset = y_geo - top_left_corner[0]
+        # scale
+        y_distance = (bottom_right_corner[0] - top_left_corner[0])
+        y = (TILE_HEIGHT.to_f * (y_offset / y_distance)).round
+
+        logger.debug("Point on image: zoom #{zoom.to_s.green}, coord #{geo_coord[0].to_s.green},#{geo_coord[1].to_s.green} => [#{x.to_s.red}, #{y.to_s.red}]")
+
+        return { osm_title_coord: osm_tile_coord, pixel_offset: [x, y] }
+      end
+
+      # Useful for calculating distance on output image
+      # It is not position on output image because we don't know tile coords
+      # For upper-left tile
+      def point_on_absolute_image(zoom, geo_coord)
+        _p = point_on_image(zoom, geo_coord)
+        _x = _p[:osm_title_coord][0] * TILE_WIDTH + _p[:pixel_offset][0]
+        _y = _p[:osm_title_coord][1] * TILE_WIDTH + _p[:pixel_offset][1]
+
+        logger.debug("Point on abs. image: zoom #{zoom.to_s.green}, coord #{geo_coord[0].to_s.green},#{geo_coord[1].to_s.green} => [#{_x.to_s.red}, #{_y.to_s.red}]")
+
+        return [_x, _y]
+      end
+
+
+    end
+  end
+end

data/lib/gpx2png/calculations/osm_instance_methods.rb

@@ -0,0 +1,197 @@
+require 'gpx2png/calculations/osm_class_methods'
+
+module Gpx2png
+  module Calculations
+    module OsmInstanceMethods
+
+      TILE_WIDTH = OsmClassMethods::TILE_WIDTH
+      TILE_HEIGHT = OsmClassMethods::TILE_WIDTH
+
+      attr_reader :lat_min, :lat_max, :lon_min, :lon_max
+      attr_reader :tile_x_distance, :tile_y_distance
+      # points for cropping
+      attr_reader :bitmap_point_x_max, :bitmap_point_x_min, :bitmap_point_y_max, :bitmap_point_y_min
+
+      def initial_calculations
+        calculate_minmax_latlon
+
+        # auto zoom must be here
+        # drawing must fit into fixed resolution
+        # map must be bigger than fixed resolution
+        if @fixed_width and @fixed_height
+          @new_zoom = self.class.calc_zoom(
+            @lat_min, @lat_max,
+            @lon_min, @lon_max,
+            @fixed_width, @fixed_height
+          )
+          self.class.logger.debug "Calculated new zoom #{@new_zoom.to_s.red} (was #{@zoom.to_s.red})"
+          @zoom = @new_zoom
+        end
+
+        @border_tiles = [
+          self.class.convert(@zoom, [@lat_min, @lon_min]),
+          self.class.convert(@zoom, [@lat_max, @lon_max])
+        ]
+
+        @tile_x_range = (@border_tiles[0][0])..(@border_tiles[1][0])
+        @tile_y_range = (@border_tiles[1][1])..(@border_tiles[0][1])
+
+        # enlarging ranges to fill up map area
+        # both sizes are enlarged
+        if @fixed_width and @fixed_height
+          x_axis_expand_count = ((@fixed_width - (1 + @tile_x_range.max - @tile_x_range.min) * TILE_WIDTH).to_f / (TILE_WIDTH.to_f * 2.0)).ceil
+          y_axis_expand_count = ((@fixed_height - (1 + @tile_y_range.max - @tile_y_range.min) * TILE_HEIGHT).to_f / (TILE_HEIGHT.to_f * 2.0)).ceil
+          self.class.logger.debug "Expanding #{"X".to_s.blue} tiles from both sides #{x_axis_expand_count.to_s.green}"
+          self.class.logger.debug "Expanding #{"Y".to_s.blue} tiles from both sides #{y_axis_expand_count.to_s.green}"
+          @tile_x_range = ((@tile_x_range.min - x_axis_expand_count)..(@tile_x_range.max + x_axis_expand_count))
+          @tile_y_range = ((@tile_y_range.min - y_axis_expand_count)..(@tile_y_range.max + y_axis_expand_count))
+        end
+
+        # new/full image size
+        @full_image_x = (1 + @tile_x_range.max - @tile_x_range.min) * TILE_WIDTH
+        @full_image_y = (1 + @tile_y_range.max - @tile_y_range.min) * TILE_HEIGHT
+        @r.x = @full_image_x
+        @r.y = @full_image_y
+
+        if @fixed_width and @fixed_height
+          calculate_for_crop_with_auto_zoom
+        else
+          calculate_for_crop
+        end
+      end
+
+      # Calculate zoom level
+      def auto_zoom_for(x = 0, y = 0)
+        # TODO
+      end
+
+      # Calculate some numbers for cropping operation
+      def calculate_for_crop
+        point_min = self.class.point_on_image(@zoom, [@lat_min, @lon_min])
+        point_max = self.class.point_on_image(@zoom, [@lat_max, @lon_max])
+        @bitmap_point_x_min = (point_min[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_min[:pixel_offset][0]
+        @bitmap_point_x_max = (point_max[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_max[:pixel_offset][0]
+        @bitmap_point_y_max = (point_min[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_min[:pixel_offset][1]
+        @bitmap_point_y_min = (point_max[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_max[:pixel_offset][1]
+
+        @r.set_crop(@bitmap_point_x_min, @bitmap_point_x_max, @bitmap_point_y_min, @bitmap_point_y_max)
+      end
+
+      # Calculate some numbers for cropping operation with autozoom
+      def calculate_for_crop_with_auto_zoom
+        point_min = self.class.point_on_image(@zoom, [@lat_min, @lon_min])
+        point_max = self.class.point_on_image(@zoom, [@lat_max, @lon_max])
+        @bitmap_point_x_min = (point_min[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_min[:pixel_offset][0]
+        @bitmap_point_x_max = (point_max[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_max[:pixel_offset][0]
+        @bitmap_point_y_max = (point_min[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_min[:pixel_offset][1]
+        @bitmap_point_y_min = (point_max[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_max[:pixel_offset][1]
+
+        bitmap_x_center = (@bitmap_point_x_min + @bitmap_point_x_max) / 2
+        bitmap_y_center = (@bitmap_point_y_min + @bitmap_point_y_max) / 2
+
+        @r.set_crop_fixed(bitmap_x_center, bitmap_y_center, @fixed_width, @fixed_height)
+      end
+
+      def expand_map
+        # TODO expand min and max ranges
+      end
+
+      # Do everything
+      def download_and_join_tiles
+        self.class.logger.info "Output image dimension #{@full_image_x.to_s.red} x #{@full_image_y.to_s.red}"
+        @r.new_image
+
+        # {:x, :y, :blob}
+        @images = Array.new
+
+
+        @tile_x_range.each do |x|
+          @tile_y_range.each do |y|
+            url = self.class.url(@zoom, [x, y])
+
+            # blob time
+            unless simulate_download?
+              uri = URI.parse(url)
+              response = Net::HTTP.get_response(uri)
+              blob = response.body
+            else
+              blob = @r.blank_tile(TILE_WIDTH, TILE_HEIGHT, x+y)
+            end
+
+            @r.add_tile(
+              blob,
+              (x - @tile_x_range.min) * TILE_WIDTH,
+              (y - @tile_y_range.min) * TILE_HEIGHT
+            )
+
+            @images << {
+              url: url,
+              x: x,
+              y: y
+            }
+
+            self.class.logger.info "processed #{(x - @tile_x_range.min).to_s.red} x #{(y - @tile_y_range.min).to_s.red} (max #{(@tile_x_range.max - @tile_x_range.min).to_s.yellow} x #{(@tile_y_range.max - @tile_y_range.min).to_s.yellow})"
+          end
+        end
+
+        # sweet, image is joined
+
+        # min/max points used for cropping
+        @bitmap_point_x_max = (@full_image_x / 2).round
+        @bitmap_point_x_min = (@full_image_x / 2).round
+        @bitmap_point_y_max = (@full_image_y / 2).round
+        @bitmap_point_y_min = (@full_image_y / 2).round
+
+        # add all coords to the map
+        _coords_count = 0
+        @layers.each do |layer|
+          _coords = layer.coords
+          _coords_count += _coords.size
+          (1..._coords.size).each do |i|
+
+            lat_from = _coords[i-1][:lat]
+            lon_from = _coords[i-1][:lon]
+
+            lat_to = _coords[i][:lat]
+            lon_to = _coords[i][:lon]
+
+            point_from = self.class.point_on_image(@zoom, [lat_from, lon_from])
+            point_to = self.class.point_on_image(@zoom, [lat_to, lon_to])
+            # { osm_title_coord: osm_tile_coord, pixel_offset: [x, y] }
+
+            # first point
+            bitmap_xa = (point_from[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_from[:pixel_offset][0]
+            bitmap_ya = (point_from[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_from[:pixel_offset][1]
+            bitmap_xb = (point_to[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_to[:pixel_offset][0]
+            bitmap_yb = (point_to[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_to[:pixel_offset][1]
+
+            @r.line(
+              bitmap_xa, bitmap_ya,
+              bitmap_xb, bitmap_yb
+            )
+          end
+        end
+        self.class.logger.info "Layers - #{@layers.size.to_s.red} with #{_coords_count.to_s.yellow} coords have been added to image"
+
+        # add points
+        @markers.each do |point|
+          lat = point[:lat]
+          lon = point[:lon]
+
+          p = self.class.point_on_image(@zoom, [lat, lon])
+          bitmap_x = (p[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + p[:pixel_offset][0]
+          bitmap_y = (p[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + p[:pixel_offset][1]
+
+          point[:x] = bitmap_x
+          point[:y] = bitmap_y
+
+          @r.markers << point
+        end
+        self.class.logger.info "Markers - #{@markers.size.to_s.red} have been added to image"
+
+      end
+
+
+    end
+  end
+end

data/lib/gpx2png/landscape.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'gpx2png/osm'
+
+module Gpx2png
+  class Landscape < Osm
+
+    # Convert OSM/UMP tile coords to url
+    def self.url(zoom, coord, server = '3.')
+      x, y = coord
+      url = "http://tile.thunderforest.com/landscape/#{zoom}/#{x}/#{y}.png"
+      return url
+    end
+
+    def self.licence_string
+      "All maps copyright Thunderforest.com and OpenStreetMap contributors"
+    end
+
+  end
+end

data/lib/gpx2png/layer.rb

@@ -0,0 +1,36 @@
+module Gpx2png
+  class Layer
+    def initialize
+      @coords = Array.new
+      @options = Hash.new
+    end
+
+    attr_accessor :options, :coords, :parent
+
+    def coords=(_coords)
+      logger.debug("Set #{_coords.size.to_s.red} for layer #{self.index.to_s.green}")
+      @coords = _coords
+    end
+
+    def coords
+      @coords
+    end
+
+    # Number of this layer
+    def index
+      if @parent
+        return parent.layers.index(self)
+      end
+      return nil
+    end
+
+    def logger
+      @parent.class.logger
+    end
+
+    def add(lat, lon)
+      logger.debug("Added coord #{lat.to_s.red},#{lon.to_s.red} for layer #{self.index.to_s.green}, count #{(@coords.size + 1).to_s.blue}")
+      @coords << { lat: lat, lon: lon }
+    end
+  end
+end

data/lib/gpx2png/opencycle.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'gpx2png/osm'
+
+module Gpx2png
+  class OpenCycle < Osm
+
+    # Convert OSM/UMP tile coords to url
+    def self.url(zoom, coord, server = '3.')
+      x, y = coord
+      url = "http://tile.thunderforest.com/cycle/#{zoom}/#{x}/#{y}.png"
+      return url
+    end
+
+    def self.licence_string
+      "All maps copyright Thunderforest.com and OpenStreetMap contributors"
+    end
+
+  end
+end

data/lib/gpx2png/osm.rb

@@ -1,8 +1,6 @@
 require 'rubygems'
 require 'gpx2png/osm_base'
 
-$:.unshift(File.dirname(__FILE__))
-
 module Gpx2png
   class Osm < OsmBase
 

data/lib/gpx2png/osm_base.rb

@@ -1,36 +1,16 @@
-require 'rubygems'
 require 'gpx2png/base'
 require 'net/http'
 require "uri"
-
-$:.unshift(File.dirname(__FILE__))
+require 'gpx2png/calculations/osm_class_methods'
+require 'gpx2png/calculations/osm_instance_methods'
 
 module Gpx2png
   class OsmBase < Base
-    TILE_WIDTH = 256
-    TILE_HEIGHT = 256
-
-    # if true it will not download tiles
-    attr_accessor :simulate_download
+    extend Calculations::OsmClassMethods
+    include Calculations::OsmInstanceMethods
 
-    def self.simulate_download=(b)
-      @@simulate_download = b
-    end
-
-    def simulate_download?
-      return true if true == self.simulate_download or (defined? @@simulate_download and true == @@simulate_download)
-    end
-
-    # http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#X_and_Y
-    # Convert latlon deg to OSM tile coords
-    def self.convert(zoom, coord)
-      lat_deg, lon_deg = coord
-      lat_rad = deg2rad(lat_deg)
-      x = (((lon_deg + 180) / 360) * (2 ** zoom)).floor
-      y = ((1 - Math.log(Math.tan(lat_rad) + 1 / Math.cos(lat_rad)) / Math::PI) /2 * (2 ** zoom)).floor
-
-      return [x, y]
-    end
+    TILE_WIDTH = Calculations::OsmClassMethods::TILE_WIDTH
+    TILE_HEIGHT = Calculations::OsmClassMethods::TILE_HEIGHT
 
     # Convert latlon deg to OSM tile url
     # TODO add algorithm to choose from diff. servers
@@ -46,265 +26,11 @@ module Gpx2png
       return url
     end
 
-    # Convert OSM tile coords to latlon deg in top-left corner
-    def self.reverse_convert(zoom, coord)
-      x, y = coord
-      n = 2 ** zoom
-      lon_deg = x.to_f / n.to_f * 360.0 - 180.0
-      lat_deg = rad2deg(Math.atan(Math.sinh(Math::PI * (1.to_f - 2.to_f * y.to_f / n.to_f))))
-      return [lat_deg, lon_deg]
-    end
-
-    # Lazy calc proper zoom for drawing
-    def self.calc_zoom(lat_min, lat_max, lon_min, lon_max, width, height)
-      # because I'm lazy! :] and math is not my best side
-
-      last_zoom = 2
-      (5..18).each do |zoom|
-        # calculate drawing tile size and pixel size
-        tile_min = point_on_absolute_image(zoom, [lat_min, lon_min])
-        tile_max = point_on_absolute_image(zoom, [lat_max, lon_max])
-        current_pixel_x_distance = tile_max[0] - tile_min[0]
-        current_pixel_y_distance = tile_min[1] - tile_max[1]
-        if current_pixel_x_distance > width or current_pixel_y_distance > height
-          return last_zoom
-        end
-        last_zoom = zoom
-      end
-      return 18
-    end
-
-    # Convert latlon deg coords to image point (x,y) and OSM tile coord
-    # return where you should put point on tile
-    def self.point_on_image(zoom, geo_coord)
-      osm_tile_coord = convert(zoom, geo_coord)
-      top_left_corner = reverse_convert(zoom, osm_tile_coord)
-      bottom_right_corner = reverse_convert(zoom, [
-        osm_tile_coord[0] + 1, osm_tile_coord[1] + 1
-      ])
-
-      # some line math: y = ax + b
-
-      x_geo = geo_coord[1]
-      # offset
-      x_offset = x_geo - top_left_corner[1]
-      # scale
-      x_distance = (bottom_right_corner[1] - top_left_corner[1])
-      x = (TILE_WIDTH.to_f * (x_offset / x_distance)).round
-
-      y_geo = geo_coord[0]
-      # offset
-      y_offset = y_geo - top_left_corner[0]
-      # scale
-      y_distance = (bottom_right_corner[0] - top_left_corner[0])
-      y = (TILE_HEIGHT.to_f * (y_offset / y_distance)).round
-
-      return { osm_title_coord: osm_tile_coord, pixel_offset: [x, y] }
-    end
-
-    # Useful for calculating distance on output image
-    # It is not position on output image because we don't know tile coords
-    # For upper-left tile
-    def self.point_on_absolute_image(zoom, geo_coord)
-      _p = point_on_image(zoom, geo_coord)
-      _x = _p[:osm_title_coord][0] * TILE_WIDTH + _p[:pixel_offset][0]
-      _y = _p[:osm_title_coord][1] * TILE_WIDTH + _p[:pixel_offset][1]
-      return [_x, _y]
-    end
-
-    # Create image with fixed size
-    def fixed_size(_width, _height)
-      @fixed_width = _width
-      @fixed_height = _height
-    end
-
-    def initial_calculations
-      @lat_min = @coords.collect { |c| c[:lat] }.min
-      @lat_max = @coords.collect { |c| c[:lat] }.max
-      @lon_min = @coords.collect { |c| c[:lon] }.min
-      @lon_max = @coords.collect { |c| c[:lon] }.max
-
-      # auto zoom must be here
-      # drawing must fit into fixed resolution
-      # map must be bigger than fixed resolution
-      if @fixed_width and @fixed_height
-        @new_zoom = self.class.calc_zoom(
-          @lat_min, @lat_max,
-          @lon_min, @lon_max,
-          @fixed_width, @fixed_height
-        )
-        puts "Calculated new zoom #{@new_zoom} (was #{@zoom})" if @verbose
-        @zoom = @new_zoom
-      end
-
-      @border_tiles = [
-        self.class.convert(@zoom, [@lat_min, @lon_min]),
-        self.class.convert(@zoom, [@lat_max, @lon_max])
-      ]
-
-      @tile_x_range = (@border_tiles[0][0])..(@border_tiles[1][0])
-      @tile_y_range = (@border_tiles[1][1])..(@border_tiles[0][1])
-
-      # enlarging ranges to fill up map area
-      # both sizes are enlarged
-      # = ( ( (preferred size - real size) / tile width ) / 2 ).ceil
-      if @fixed_width and @fixed_height
-        x_axis_expand_count = ((@fixed_width - (1 + @tile_x_range.max - @tile_x_range.min) * TILE_WIDTH).to_f / (TILE_WIDTH.to_f * 2.0)).ceil
-        y_axis_expand_count = ((@fixed_height - (1 + @tile_y_range.max - @tile_y_range.min) * TILE_HEIGHT).to_f / (TILE_HEIGHT.to_f * 2.0)).ceil
-        puts "Expanding X tiles from both sides #{x_axis_expand_count}" if @verbose
-        puts "Expanding Y tiles from both sides #{y_axis_expand_count}" if @verbose
-        @tile_x_range = ((@tile_x_range.min - x_axis_expand_count)..(@tile_x_range.max + x_axis_expand_count))
-        @tile_y_range = ((@tile_y_range.min - y_axis_expand_count)..(@tile_y_range.max + y_axis_expand_count))
-      end
-
-      # new/full image size
-      @full_image_x = (1 + @tile_x_range.max - @tile_x_range.min) * TILE_WIDTH
-      @full_image_y = (1 + @tile_y_range.max - @tile_y_range.min) * TILE_HEIGHT
-      @r.x = @full_image_x
-      @r.y = @full_image_y
-
-      if @fixed_width and @fixed_height
-        calculate_for_crop_with_auto_zoom
-      else
-        calculate_for_crop
-      end
-    end
-
-    # Calculate zoom level
-    def auto_zoom_for(x = 0, y = 0)
-      # TODO
-    end
-
-    attr_reader :lat_min, :lat_max, :lon_min, :lon_max
-    attr_reader :tile_x_distance, :tile_y_distance
-    # points for cropping
-    attr_reader :bitmap_point_x_max, :bitmap_point_x_min, :bitmap_point_y_max, :bitmap_point_y_min
-
-    # Do everything
-    def download_and_join_tiles
-      puts "Output image dimension #{@full_image_x}x#{@full_image_y}" if @verbose
-      @r.new_image
-
-      # {:x, :y, :blob}
-      @images = Array.new
-
-
-      @tile_x_range.each do |x|
-        @tile_y_range.each do |y|
-          url = self.class.url(@zoom, [x, y])
-
-          # blob time
-          unless simulate_download?
-            uri = URI.parse(url)
-            response = Net::HTTP.get_response(uri)
-            blob = response.body
-          else
-            blob = @r.blank_tile(TILE_WIDTH, TILE_HEIGHT, x+y)
-          end
-
-          @r.add_tile(
-            blob,
-            (x - @tile_x_range.min) * TILE_WIDTH,
-            (y - @tile_y_range.min) * TILE_HEIGHT
-          )
-
-          @images << {
-            url: url,
-            x: x,
-            y: y
-          }
-
-          puts "processed #{x - @tile_x_range.min}x#{y - @tile_y_range.min} (max #{@tile_x_range.max - @tile_x_range.min}x#{@tile_y_range.max - @tile_y_range.min})" if @verbose
-        end
-      end
-
-      # sweet, image is joined
-
-      # min/max points used for cropping
-      @bitmap_point_x_max = (@full_image_x / 2).round
-      @bitmap_point_x_min = (@full_image_x / 2).round
-      @bitmap_point_y_max = (@full_image_y / 2).round
-      @bitmap_point_y_min = (@full_image_y / 2).round
-
-      # add some coords to the map
-      (1...@coords.size).each do |i|
-        lat_from = @coords[i-1][:lat]
-        lon_from = @coords[i-1][:lon]
-
-        lat_to = @coords[i][:lat]
-        lon_to = @coords[i][:lon]
-
-        point_from = self.class.point_on_image(@zoom, [lat_from, lon_from])
-        point_to = self.class.point_on_image(@zoom, [lat_to, lon_to])
-        # { osm_title_coord: osm_tile_coord, pixel_offset: [x, y] }
-
-        # first point
-        bitmap_xa = (point_from[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_from[:pixel_offset][0]
-        bitmap_ya = (point_from[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_from[:pixel_offset][1]
-        bitmap_xb = (point_to[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_to[:pixel_offset][0]
-        bitmap_yb = (point_to[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_to[:pixel_offset][1]
-
-        @r.line(
-          bitmap_xa, bitmap_ya,
-          bitmap_xb, bitmap_yb
-        )
-      end
-
-      # add points
-      @markers.each do |point|
-        lat = point[:lat]
-        lon = point[:lon]
-
-        p = self.class.point_on_image(@zoom, [lat, lon])
-        bitmap_x = (p[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + p[:pixel_offset][0]
-        bitmap_y = (p[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + p[:pixel_offset][1]
-
-        point[:x] = bitmap_x
-        point[:y] = bitmap_y
-
-        @r.markers << point
-      end
-    end
-
-    # Calculate some numbers for cropping operation
-    def calculate_for_crop
-      point_min = self.class.point_on_image(@zoom, [@lat_min, @lon_min])
-      point_max = self.class.point_on_image(@zoom, [@lat_max, @lon_max])
-      @bitmap_point_x_min = (point_min[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_min[:pixel_offset][0]
-      @bitmap_point_x_max = (point_max[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_max[:pixel_offset][0]
-      @bitmap_point_y_max = (point_min[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_min[:pixel_offset][1]
-      @bitmap_point_y_min = (point_max[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_max[:pixel_offset][1]
-
-      @r.set_crop(@bitmap_point_x_min, @bitmap_point_x_max, @bitmap_point_y_min, @bitmap_point_y_max)
-    end
-
-    # Calculate some numbers for cropping operation with autozoom
-    def calculate_for_crop_with_auto_zoom
-      point_min = self.class.point_on_image(@zoom, [@lat_min, @lon_min])
-      point_max = self.class.point_on_image(@zoom, [@lat_max, @lon_max])
-      @bitmap_point_x_min = (point_min[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_min[:pixel_offset][0]
-      @bitmap_point_x_max = (point_max[:osm_title_coord][0] - @tile_x_range.min) * TILE_WIDTH + point_max[:pixel_offset][0]
-      @bitmap_point_y_max = (point_min[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_min[:pixel_offset][1]
-      @bitmap_point_y_min = (point_max[:osm_title_coord][1] - @tile_y_range.min) * TILE_HEIGHT + point_max[:pixel_offset][1]
-
-      bitmap_x_center = (@bitmap_point_x_min + @bitmap_point_x_max) / 2
-      bitmap_y_center = (@bitmap_point_y_min + @bitmap_point_y_max) / 2
-
-      @r.set_crop_fixed(bitmap_x_center, bitmap_y_center, @fixed_width, @fixed_height)
-    end
-
-    def expand_map
-      # TODO expand min and max ranges
-    end
-
     def self.licence_string
       "Map data OpenStreetMap (CC-by-SA 2.0)"
     end
 
-    def destroy
-      @r.destroy
-      puts "Image destroyed" if @verbose
-    end
+
 
   end
 end

data/lib/gpx2png/outdoors.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'gpx2png/osm'
+
+module Gpx2png
+  class Outdoors < Osm
+
+    # Convert OSM/UMP tile coords to url
+    def self.url(zoom, coord, server = '3.')
+      x, y = coord
+      url = "http://tile.thunderforest.com/outdoors/#{zoom}/#{x}/#{y}.png"
+      return url
+    end
+
+    def self.licence_string
+      "All maps copyright Thunderforest.com and OpenStreetMap contributors"
+    end
+
+  end
+end

data/lib/gpx2png/renderers/chunky_png_renderer.rb

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'chunky_png'
 
-$:.unshift(File.dirname(__FILE__))
+# WARNING: deprecated
 
 # This renderer has some/a lot of features missing
 module Gpx2png

data/lib/gpx2png/renderers/rmagick_renderer.rb

@@ -2,8 +2,6 @@ require 'rubygems'
 require 'RMagick'
 require 'gpx2png/assets/sample_marker'
 
-$:.unshift(File.dirname(__FILE__))
-
 module Gpx2png
   class RmagickRenderer
     def initialize(_options = {})
@@ -77,8 +75,6 @@ module Gpx2png
 
     # Setup crop image using CSS padding style data
     def set_crop(x_min, x_max, y_min, y_max)
-      # puts @x, @y, @crop_margin, x_min, x_max, y_min, y_max
-
       @crop_t = y_min - @crop_margin
       @crop_r = (@x - x_max) - @crop_margin
       @crop_b = (@y - y_max) - @crop_margin

data/lib/gpx2png/transport.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'gpx2png/osm'
+
+module Gpx2png
+  class Transport < Osm
+
+    # Convert OSM/UMP tile coords to url
+    def self.url(zoom, coord, server = '3.')
+      x, y = coord
+      url = "http://tile.thunderforest.com/transport/#{zoom}/#{x}/#{y}.png"
+      return url
+    end
+
+    def self.licence_string
+      "All maps copyright Thunderforest.com and OpenStreetMap contributors"
+    end
+
+  end
+end

data/lib/gpx2png/ump.rb

@@ -1,8 +1,6 @@
 require 'rubygems'
 require 'gpx2png/osm'
 
-$:.unshift(File.dirname(__FILE__))
-
 module Gpx2png
   class Ump < Osm
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gpx2png
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-22 00:00:00.000000000 Z
+date: 2013-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mini_exiftool
@@ -59,6 +59,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -142,10 +158,19 @@ files:
 - lib/gpx2png.rb
 - lib/gpx2png/assets/sample_marker.rb
 - lib/gpx2png/base.rb
+- lib/gpx2png/calculations/base_class_methods.rb
+- lib/gpx2png/calculations/base_instance_methods.rb
+- lib/gpx2png/calculations/osm_class_methods.rb
+- lib/gpx2png/calculations/osm_instance_methods.rb
+- lib/gpx2png/landscape.rb
+- lib/gpx2png/layer.rb
+- lib/gpx2png/opencycle.rb
 - lib/gpx2png/osm.rb
 - lib/gpx2png/osm_base.rb
+- lib/gpx2png/outdoors.rb
 - lib/gpx2png/renderers/chunky_png_renderer.rb
 - lib/gpx2png/renderers/rmagick_renderer.rb
+- lib/gpx2png/transport.rb
 - lib/gpx2png/ump.rb
 homepage: http://github.com/akwiatkowski/gpx2png
 licenses:
@@ -162,7 +187,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2224186545062807777
+      hash: 828698515099526590
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: