ym4r 0.5.1 → 0.5.2

data/README

@@ -1,5 +1,5 @@
 =YM4R
-This is YM4R 0.5.1. YM4R has features to ease the use of the Google Maps Geocoding API and the Yahoo! Maps building block API's from Ruby. It also offers 2 tools to create tiles to be used with user-defined layers in Google Maps. If you are looking to use the main Google Maps API from your Rails application, you should use the YM4R/GM plugin for Rails (http://thepochisuperstarmegashow.com/projects/#ym4r).
+This is YM4R 0.5.2. YM4R has features to ease the use of the Google Maps Geocoding API and the Yahoo! Maps building block API's from Ruby. It also offers 2 tools to create tiles to be used with user-defined layers in Google Maps. If you are looking to use the main Google Maps API from your Rails application, you should use the YM4R/GM plugin for Rails (http://thepochisuperstarmegashow.com/projects/#ym4r).
 
 ==Relation between the YM4R gem and the YM4R/GM plugin for Rails
 They are completely independent from each other.
@@ -88,36 +88,10 @@ Here is an example of request:
                                    :query => "chinese")
 +results+ is a LocalSearch::ResultSet object (subclass of +Array+), containing LocalSearch::Result objects, each containing information about one hit on the Yahoo! local search.
 
-===Tiling: Generating tiles to be used with pretiled layers in Google Maps
-
-The YM4R library provides 2 tools to generate tiles. They are in the +tools+ directory of the YM4R gem distribution. 
-
-====tile_wms.rb
-This is to generate tiles from an already existing WMS server. It can be useful if you don't want to setup a permanent WMS server but still want to display your geographic data files (any format compatible with your WMS server can then be used). It can also be used to cache data from public servers, which can sometimes be very slow to answer requests. Run <tt>ruby tile_wms.rb -h</tt> to know what the options are. Most are self-explanatory, although the <tt>-g</tt> (<tt>--gmap-setting</tt>) needs to be explained in more details. It uses the data that comes from this tool: http://www.onnyturf.com/google/latlontotile.html. Basically you need to center the map at the zoom you need to get your desired extent. When you are satisfied, the tool will give you the following data: the X and Y values of the upper left corner tile, 17 minus the zoom level (this is because the V2 of the Google Maps API reversed the zoom order), the number of horizontal and vertical tiles that you want. You will then pass to the <tt>-g</tt> option 5 integers in the order previously described, for example:
-	-g 300,383,7,3,2
-About the zoom level, if the tools tells you 7, you should pass 10 (17 - 7) to the <tt>-g</tt> option.
-
-Note that the zoom levels passed to the <tt>-z</tt> argument must be greater or equal to the zoom level passed to the <tt>-g</tt> argument.
-
-====tile_image.rb
-This is to generate tiles from a local image. You will need the RMagick library for it to work. Basically, you should use this tool: http://open.atlas.free.fr/GMapsTransparenciesImgOver.php. You should have an image that will be displayed at the lowest zoom level that you want and use it with this tool. You can translate and scale the image until you are statisfied. When you are, you must click a link to gather information about the transformation needed for your image. You will need to pass this data to the <tt>-p</tt> option of the tool in the following order: X and Y of the top left corner of the map, 17 minus the zoom level, X and Y padding, scale. So for example, you will have the following argument:
-	-p 2503,3667,4,241,115,0.8702928870292888
-Again, about the zoom level, if the tool tells you 7, you should pass 10 (17 - 7) to the <tt>-p</tt> option.
-
-About the padding, I had a slight problem on Firefox: I needed to substract 10 to the X and Y paddings given by the online tool to have the correct one to pass to the <tt>-p</tt> option. Maybe it has something to do with the 10-pixel bands at the top and left of the page.
-
-You should pass as many images to the tool as you have zoom levels in the <tt>-z</tt> argument: Each image will be used for one zoom level. The string order of the names of the image files must match the order of their corresponding zoom level. Moreover, each image should be exactly twice bigger (in both width and height) than the one in the zoom level immediately preceding it. Also note that the zoom levels passed to the <tt>-z</tt> argument must be greater or equal to the zoom level passed to the <tt>-p</tt> argument.
-
-By default, the tool will generate transparent borders. You can pass 4 integers (R, G, B and A) from 0 to 255 to the -b option to change that:
-	-b 255,123,456,42
-
-Here is an example of command line execution using the image at http://open.atlas.free.fr/GMapsTransparenciesImgOver.php. If you place it over the satellite images, you would get the following parameters: 2503,3667,13,149,76,1.0 (I have accounted for both the reversing of the zoom for v2 and the 10-pixel drift of the padding in Firefox). I have also created another version of the image, at double the size in width and height. Normally you should do the opposite: Get the highest resolution possible (if you scan the map) and downsize it for all the desired zoom levels until you get the image to use in this online tool (lowest zoom level). If you use vector graphics, you can easily create versions at different resolutions. I placed the 2 images (called MAP_zoom1.jpg for the smallest and MAP_zoom2.jpg for the biggest) in directory <tt>./input</tt>. And I launch the tool like this:
-	ruby tile_image.rb -o ./tiles -z 13..14 -p 2503,3667,13,149,76,1.0 ./input/*
-This will create tiles of the image for zoom levels 13 and 14. It should take just a few seconds.
 
 ==Changes since last version
-- Repackaging of the Google Maps web app related functionnalities to a separate plugin
-- Suppression of support for the JS Flash API, since it was limited anyway and has not been updated in a while.
+- Removed the tilers. They are now in a separately downloadable package.
+- Changed the Yahoo App Id
 
 ==TODO
 - Add more tests

data/lib/ym4r/yahoo_maps/app_id.rb

@@ -1,5 +1,5 @@
 module Ym4r
   module YahooMaps
-    APP_ID = "YahooMaps4Ruby"
+    APP_ID = "YellowMaps4R"
   end
 end

data/rakefile.rb

@@ -24,7 +24,7 @@ spec = Gem::Specification::new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.name = 'ym4r'
-  s.version = "0.5.1"
+  s.version = "0.5.2"
   s.summary = "Helping the use of Google Maps and Yahoo! Maps API's from Ruby and Rails"
   s.description = <<EOF
 EOF

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ym4r
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
-date: 2006-07-09 00:00:00 +05:00
+  version: 0.5.2
+date: 2006-07-22 00:00:00 +05:00
 summary: Helping the use of Google Maps and Yahoo! Maps API's from Ruby and Rails
 require_paths: 
 - lib
@@ -34,8 +34,6 @@ files:
 - lib/ym4r/yahoo_maps.rb
 - lib/ym4r/google_maps/api_key.rb
 - lib/ym4r/google_maps/geocoding.rb
-- lib/ym4r/google_maps/image_tiler.rb
-- lib/ym4r/google_maps/wms_tiler.rb
 - lib/ym4r/yahoo_maps/app_id.rb
 - lib/ym4r/yahoo_maps/building_block.rb
 - lib/ym4r/yahoo_maps/building_block/exception.rb
@@ -44,8 +42,6 @@ files:
 - lib/ym4r/yahoo_maps/building_block/map_image.rb
 - lib/ym4r/yahoo_maps/building_block/traffic.rb
 - lib/ym4r/google_maps/config/config.yml
-- tools/tile_image.rb
-- tools/tile_wms.rb
 - test/test_geocoding.rb
 - test/test_gm_geocoding.rb
 - test/test_local_search.rb

data/lib/ym4r/google_maps/image_tiler.rb

@@ -1,107 +0,0 @@
-require 'RMagick'
-
-module Ym4r
-  module GoogleMaps
-    module Tiler
-      module ImageTiler
-        class Point < Struct.new(:x,:y)
-          def -(point)
-            Point.new(x - point.x , y - point.y)
-          end
-          def +(point)
-            Point.new(x + point.x , y + point.y)
-          end
-          def *(scale)
-            Point.new(scale * x,scale * y)
-          end
-          def to_s
-            "Point #{x} #{y}"
-          end
-        end
-        
-        class TileParam < Struct.new(:ul_corner,:zoom,:padding,:scale)
-        end
-        
-        TILE_SIZE = 256
-        
-        def self.get_tiles(output_dir, input_files, tile_param, zooms, bg_color = Magick::Pixel.new(255,255,255,0), format = "png")
-          #order the input files: string order.
-          sorted_input_files = input_files.sort
-
-          #Whatever the zoom level, the tiles must cover the same surface : we get the surface of the furthest zoom. 
-          furthest_dimension_tiles = get_dimension_tiles(sorted_input_files[0],tile_param)
-          puts furthest_dimension_tiles.to_s
-
-          zooms.each do |zoom|
-            next if zoom < tile_param.zoom
-            return if (input_file = sorted_input_files.shift).nil?
-            
-            image = Magick::ImageList::new(input_file)
-            image.scale!(tile_param.scale)
-            image_size = Point.new(image.columns , image.rows)
-            
-            factor = 2 ** (zoom - tile_param.zoom)
-                        
-            #index of the upper left corner for the current zoom
-            start = tile_param.ul_corner * factor
-            dimension_tiles = furthest_dimension_tiles * factor
-            dimension_tiles_pixel = dimension_tiles * TILE_SIZE
-            padding = tile_param.padding * factor
-            
-            puts "Padding" + padding.to_s
-            puts "Size " + image_size.to_s
-            puts "Dimension " + dimension_tiles_pixel.to_s
-
-            #create an image at dimension_tiles_pixel ; copy the current image there  (a bit inefficient memory wise even if it simplifies )
-            image_with_padding = Magick::Image.new(dimension_tiles_pixel.x, dimension_tiles_pixel.y) do 
-              self.background_color = bg_color
-            end
-                
-            image_with_padding.import_pixels(padding.x,padding.y,image_size.x,image_size.y,"RGBA",image.export_pixels(0,0,image_size.x,image_size.y,"RGBA"))
-
-            image_with_padding.write(output_dir + "/tile_glob_#{zoom}.png")
-
-            total_tiles = dimension_tiles.x * dimension_tiles.y
-            
-            counter = Point.new(0,0)
-            
-            cur_tile = Point.new(start.x,start.y)
-            
-            1.upto(total_tiles) do |tile|
-              #progress column by column
-              if counter.y == dimension_tiles.y
-                counter.x += 1
-                counter.y = 0
-                cur_tile.x += 1
-                cur_tile.y = start.y
-              end
-              
-              pt_nw = counter * TILE_SIZE
-              
-              tile_image = Magick::Image.new(TILE_SIZE,TILE_SIZE)
-              tile_image.import_pixels(0,0,TILE_SIZE,TILE_SIZE,"RGBA",image_with_padding.export_pixels(pt_nw.x,pt_nw.y,TILE_SIZE,TILE_SIZE,"RGBA"))
-              tile_image.write("#{output_dir}/tile_#{zoom}_#{cur_tile.x}_#{cur_tile.y}.#{format}")
-              
-              counter.y += 1
-              cur_tile.y += 1
-              
-            end
-          end
-        end
-
-        
-        def self.get_dimension_tiles(file,tile_param)
-          #Get the size of the first input_file
-          image = Magick::ImageList::new(file)
-          image.scale!(tile_param.scale)
-          image_size = Point.new(image.columns , image.rows)
-          puts "ISize " + image_size.to_s
-          ending = tile_param.padding + image_size
-          puts "Ending " + ending.to_s
-          Point.new((ending.x / TILE_SIZE.to_f).ceil,(ending.y / TILE_SIZE.to_f).ceil)
-        end
-        
-      end
-    end
-  end
-end

data/lib/ym4r/google_maps/wms_tiler.rb

@@ -1,157 +0,0 @@
-require 'open-uri'
-
-module Ym4r
-  module GoogleMaps
-    module Tiler
-      module WmsTiler
-        #Contains LatLon coordinates
-        class LatLng < Struct.new(:lat,:lng)
-        end
-        
-        #Contain projected coordinates (in pixel or meter)
-        class Point < Struct.new(:x,:y)
-        end
-        
-        #Structure that contains configuration data for the WMS tiler
-        class FurthestZoom < Struct.new(:ul_corner, :zoom, :tile_size)
-        end
-        
-        #The size of a Google Maps tile. There are square so only one size.
-        TILE_SIZE = 256
-        
-        #Defines a Simple Mercator projection for one level of Google Maps zoom.
-        class MercatorProjection
-          DEG_2_RAD = Math::PI / 180
-          WGS84_SEMI_MAJOR_AXIS = 6378137.0
-          WGS84_ECCENTRICITY = 0.0818191913108718138
-          
-          attr_reader :zoom, :size, :pixel_per_degree, :pixel_per_radian, :origin
-          
-          def initialize(zoom)
-            @zoom = zoom
-            @size = TILE_SIZE * (2 ** zoom)
-            @pixel_per_degree = @size / 360.0
-            @pixel_per_radian = @size / (2 * Math::PI)
-            @origin = Point.new(@size / 2 , @size / 2)
-          end
-          
-          def borne(number, inf, sup)
-            if(number < inf)
-              inf
-            elsif(number > sup)
-              sup
-            else
-              number
-            end
-          end
-          
-          #Transforms LatLon coordinate into pixel coordinates in the Google Maps sense
-          #See http://www.math.ubc.ca/~israel/m103/mercator/mercator.html for details
-          def latlng_to_pixel(latlng)
-            answer = Point.new
-            answer.x = (@origin.x + latlng.lng * @pixel_per_degree).round
-            sin = borne(Math.sin(latlng.lat * DEG_2_RAD),-0.9999,0.9999)
-            answer.y = (@origin.y + 0.5 * Math.log((1 + sin) / (1 - sin)) * -@pixel_per_radian).round
-            answer
-          end
-          
-          #Transforms pixel coordinates in the Google Maps sense to LatLon coordinates
-          def pixel_to_latlng(point)
-            answer = LatLng.new
-            lng = (point.x - @origin.x) / @pixel_per_degree;
-            answer.lng = lng - (((lng + 180)/360).round * 360)
-            lat = (2 * Math.atan(Math.exp((point.y - @origin.y) / -@pixel_per_radian))- Math::PI / 2) / DEG_2_RAD
-            answer.lat = borne(lat,-90,90)
-            answer
-          end
-          
-          #Projects LatLon coordinates in the WGS84 datum to meter coordinates using the Simple Mercator projection
-          def self.latlng_to_meters(latlng)
-            answer = Point.new
-            answer.x = WGS84_SEMI_MAJOR_AXIS * latlng.lng * DEG_2_RAD
-            lat_rad = latlng.lat * DEG_2_RAD
-            answer.y = WGS84_SEMI_MAJOR_AXIS * Math.log(Math.tan((lat_rad + Math::PI / 2) / 2) * ( (1 - WGS84_ECCENTRICITY * Math.sin(lat_rad)) / (1 + WGS84_ECCENTRICITY * Math.sin(lat_rad))) ** (WGS84_ECCENTRICITY/2)) 
-            answer
-          end
-        end
-        
-        #Get tiles from a WMS server 
-        def self.get_tiles(output_dir, url, furthest_zoom, zooms, layers, geographic = false, epsg = 54004, styles = "", format = "png")
-          
-          unless geographic
-            srs_str = epsg
-          else
-            srs_str = 4326 #Geographic WGS84
-          end
-          
-          base_url = url << "?REQUEST=GetMap&SERVICE=WMS&VERSION=1.1&LAYERS=#{layers}&STYLES=#{styles}&BGCOLOR=0xFFFFFF&FORMAT=image/#{format}&TRANSPARENT=TRUE&WIDTH=#{TILE_SIZE}&HEIGHT=#{TILE_SIZE}&SRS=EPSG:#{srs_str}&reaspect=false"
-          
-          zooms.each do |zoom|
-            next if zoom < furthest_zoom.zoom
-
-            proj = MercatorProjection.new(zoom)
-            
-            #from mapki.com
-            factor = 2 ** (zoom - furthest_zoom.zoom)
-            
-            #index of the upper left corner
-            x_start = furthest_zoom.ul_corner.x * factor
-            y_start = furthest_zoom.ul_corner.y * factor
-            
-            x_tiles = furthest_zoom.tile_size.x * factor
-            y_tiles = furthest_zoom.tile_size.y * factor
-            
-            total_tiles = x_tiles * y_tiles
-            
-            x_counter = 0
-            y_counter = 0
-            
-            x_tile = x_start
-            y_tile = y_start
-            
-            1.upto(total_tiles) do |tile|
-              #progress column by column
-              if y_counter == y_tiles
-                x_counter += 1
-                y_counter = 0
-                x_tile += 1
-                y_tile = y_start
-              end
-              
-              pt_sw = Point.new( (x_start + x_counter) * TILE_SIZE, (y_start + (y_counter + 1)) * TILE_SIZE) #y grows southbound
-              pt_ne = Point.new((x_start + (x_counter + 1)) * TILE_SIZE, (y_start + y_counter) * TILE_SIZE)
-              
-              ll_sw = proj.pixel_to_latlng(pt_sw)
-              ll_ne = proj.pixel_to_latlng(pt_ne)
-              
-              unless geographic
-                pt_sw = MercatorProjection.latlng_to_meters(ll_sw)
-                pt_ne = MercatorProjection.latlng_to_meters(ll_ne)
-                bbox_str = "#{pt_sw.x},#{pt_sw.y},#{pt_ne.x},#{pt_ne.y}"
-              else
-                bbox_str = "#{ll_sw.lon},#{ll_sw.lat},#{ll_ne.lon},#{ll_ne.lat}"
-              end
-              
-              request_url = "#{base_url}&BBOX=#{bbox_str}"
-                    
-              begin
-                open("#{output_dir}/tile_#{zoom}_#{x_tile}_#{y_tile}.#{format}","wb") do |f|
-                  f.write open(request_url).read
-                end
-              rescue Exception => e
-                puts e
-                raise
-              end
-              
-              y_counter += 1
-              y_tile += 1
-              
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-

data/tools/tile_image.rb

@@ -1,67 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-
-require 'ym4r/google_maps/image_tiler'
-include Ym4r::GoogleMaps::Tiler
-
-require 'optparse'
-require 'ostruct'
-
-OptionParser.accept(Range, /(\d+)\.\.(\d+)/) do |range,start,finish|
-  Range.new(start.to_i,finish.to_i)
-end
-
-OptionParser.accept(ImageTiler::TileParam, /(\d+),(\d+),(\d+),(\d+),(\d+),([\d.]+)/) do |setting,l_corner, u_corner, zoom, padding_x, padding_y, scale|
-  ImageTiler::TileParam.new(ImageTiler::Point.new(l_corner.to_i,u_corner.to_i),zoom.to_i,ImageTiler::Point.new(padding_x.to_i,padding_y.to_i),scale.to_f)
-end
-
-OptionParser.accept(Magick::Pixel,/(\d+),(\d+),(\d+),(\d+)/) do |pixel, r,g,b,a|
-  Magick::Pixel.new(r.to_f,g.to_f,b.to_f,a.to_f)
-end
-
-options = OpenStruct.new
-#set some defaults
-options.format = "png"
-options.zoom_range = 0..17
-options.bg_color = Magick::Pixel.new(255,255,255,255)
-
-opts = OptionParser.new do |opts|
-  opts.banner = "Image Tiler for Google Maps\nUsage: tile_image.rb [options]\nExample: tile_image.rb -o ./tiles -z 11..12 -p 602,768,11,78,112,1.91827348 ./input_files/*.jpg"
-  opts.separator "" 
-  opts.on("-o","--output OUTPUT_DIR","Directory where the tiles will be created") do |dir| 
-    options.output_dir = dir
-  end
-  opts.on("-f","--format FORMAT","Image format in which to get the file (gif, jpeg, png...). Is png by default") do |format|
-    options.format = format
-  end
-  opts.on("-z","--zooms ZOOM_RANGE",Range,"Range of zoom values at which the tiles must be generated. Is 0..17 by default") do |range|
-    options.zoom_range = range
-  end
-  opts.on("-p","--tile-param PARAM",ImageTiler::TileParam,"Corner coordinates, furthest zoom level, padding in X and Y, scale") do |tp|
-    options.tile_param = tp
-  end
-  opts.on("-b","--background COLOR",Magick::Pixel,"Background color components. Is fully transparent par default") do |bg|
-    options.bg_color = bg
-  end
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-end
-
-opts.parse!(ARGV)
-
-#test the presence of all the options and exit with an error message
-error = []
-error << "No output directory defined (-o,--output)" if options.output_dir.nil?
-error << "No tile parameter defined (-p,--tile-param)" if options.tile_param.nil?
-error << "No input files defined" if ARGV.empty?
-
-unless error.empty?
-  puts error * "\n" + "\n\n"
-  puts opts
-  exit
-end
-
-ImageTiler.get_tiles(options.output_dir,ARGV,options.tile_param,options.zoom_range,options.bg_color,options.format)
-
-                      

data/tools/tile_wms.rb

@@ -1,79 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-
-require 'ym4r/google_maps/wms_tiler'
-include Ym4r::GoogleMaps::Tiler
-
-require 'optparse'
-require 'ostruct'
-
-OptionParser.accept(Range, /(\d+)\.\.(\d+)/) do |range,start,finish|
-  Range.new(start.to_i,finish.to_i)
-end
-
-OptionParser.accept(WmsTiler::FurthestZoom, /(\d+),(\d+),(\d+),(\d+),(\d+)/) do |setting,l_corner, u_corner, zoom, width, height|
-  WmsTiler::FurthestZoom.new(WmsTiler::Point.new(l_corner.to_i,u_corner.to_i),zoom.to_i,WmsTiler::Point.new(width.to_i,height.to_i))
-end
-
-options = OpenStruct.new
-#set some defaults
-options.format = "png"
-options.zoom_range = 0..17
-options.styles = ""
-options.srs = 54004
-options.geographic = false
-
-opts = OptionParser.new do |opts|
-  opts.banner = "WMS Tiler for Google Maps\nUsage: tile_wms.rb [options]\nExample: tile_wms.rb -o ./tiles -u http://localhost:8080/geoserver/wms -l \"topp:states\" -z 11..12 -g 602,768,11,3,3"
-  opts.separator "" 
-  opts.on("-o","--output OUTPUT_DIR","Directory where the tiles will be created") do |dir| 
-    options.output_dir = dir
-  end
-  opts.on("-u","--url WMS_SERVICE","URL to the WMS server") do |url|
-    options.url = url
-  end
-  opts.on("-l","--layers LAYERS","String of comma-separated layer names") do |layers|
-    options.layers = layers
-  end
-  opts.on("-s","--styles STYLES","String of comma-separated style names. Is empty by default") do |styles|
-    options.styles = styles
-  end
-  opts.on("-f","--format FORMAT","Image format in which to get the file (gif, jpeg, png...). Is png by default") do |format|
-    options.format = format
-  end
-  opts.on("-z","--zooms ZOOM_RANGE",Range,"Range of zoom values at which the tiles must be generated. Is 0..17 by default") do |range|
-    options.zoom_range = range
-  end
-  opts.on("-g","--gmap-setting SETTING",WmsTiler::FurthestZoom,"Corner coordinates, furthest zoom level, tile width and height") do |fz|
-    options.furthest_zoom = fz
-  end
-  opts.on("-w","--[no-]geographic","Query the WMS server with LatLon coordinates instead of using the Mercator projection") do |g|
-    options.geographic = g
-  end
-  opts.on("-e", "--epsg SRS","SRS to query the WMS server. Should be a the SRS id of a Simple Mercator projection. Can vary between WMS servers. Is 54004 (Simple Mercator for Mapserver) by default. For GeoServer use 41001.") do |srs|
-    options.srs = srs
-                    
-  end
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-end
-
-opts.parse!(ARGV)
-
-#test the presence of all the options and exit with an error message
-error = []
-error << "No output directory defined (-o,--output)" if options.output_dir.nil?
-error << "No WMS URL defined (-u,--url)" if options.url.nil?
-error << "No Google Maps setting defined (-g,--gmap-setting)" if options.furthest_zoom.nil?
-error << "No WMS layer defined (-l,--layers)" if options.layers.nil?
-
-unless error.empty?
-  puts error * "\n" + "\n\n"
-  puts opts
-  exit
-end
-
-WmsTiler.get_tiles(options.output_dir,options.url,options.furthest_zoom,options.zoom_range,options.layers,options.geographic,options.srs,options.styles,options.format)
-
-