ym4r 0.1.4 → 0.2.1

data/README

@@ -1,20 +1,20 @@
 =YM4R
-This is YM4R 0.1.3. The goal of YM4R (which naturally means Yellow Maps For Ruby...) is to ease the use of the Google Maps and Yahoo! Maps API's (including the Geocoding, Map Image, Traffic and Local Search API's) from Ruby and Rails.
+This is YM4R 0.2.1. The goal of YM4R (which naturally means Yellow Maps For Ruby...) is to ease the use of the Google Maps and Yahoo! Maps API's (including the Geocoding, Map Image, Traffic and Local Search API's) from Ruby and Rails.
 
-===Operations
-====Google Maps
+==Operations
+===Google Maps
 You can use the library to display Google maps easily with any ruby-based web framework. The version of the API used is v2. The library is engineered so updates to the map through Ajax are possible. I have made available 2 in-depth tutorials to show some of the functionalities of the library and how it can be integrated with GeoRuby and the Spatial Adapter for Rails:
 - http://thepochisuperstarmegashow.com/2006/06/02/ym4r-georuby-spatial-adapter-demo/
 - http://thepochisuperstarmegashow.com/2006/06/03/google-maps-yahoo-traffic-mash-up/
 Following is some notes about using the library:
 
-=====Naming conventions
+====Naming conventions
 The names of the Ruby class follow the ones in the JavaScript Google Maps API v2, except for GMap2, which in Ruby code is called simply GMap. To know what is possible to do with each class, you should refer to the documentation available on Google website.
 
 On top of that, you have some convenience methods for initializing the map (in the GMap class). Also, the constructors of some classes accept different types of arguments to be converted later in the correct JavaScript format. For example, the +GMarker+ aclass accepts an array of 2 floats as parameter, in addition of a GLatLng object, to indicate its position. It also facilitates the attribution of an HTML info window, displayed when the user clicks on it, since you can pass to the constructor an options hash with the <tt>:info_window</tt> key and the text to display as the value, instead of having to wire the response to a click event yourself.
 
-=====Binding JavaScript and Ruby
-Since the Google Maps API uses JavaScript to create and manipulate a map, most of what the library does is outputting JavaScript, although some convenience methods are provided to simplify some common operations at initialization time. When you create a YM4R mapping object (a Ruby object which includes the MappingObject module) and call methods on it, these calls are converted by the library into JavaScript code. At initialization time, you can pass arbitrary JavaScript code to the <tt>GMap#record_init</tt> and <tt>GMap#record_global_init</tt>.Then, at update time, if you use Ruby-on-Rails as your web framework, you can update your map through RJS by passing the result of the method calls to the <tt>page.send :record,...</tt> method to have it then interpreted by the browser.
+====Binding JavaScript and Ruby
+Since the Google Maps API uses JavaScript to create and manipulate a map, most of what the library does is outputting JavaScript, although some convenience methods are provided to simplify some common operations at initialization time. When you create a YM4R mapping object (a Ruby object which includes the MappingObject module) and call methods on it, these calls are converted by the library into JavaScript code. At initialization time, you can pass arbitrary JavaScript code to the <tt>GMap#record_init</tt> and <tt>GMap#record_global_init</tt>.Then, at update time, if you use Ruby-on-Rails as your web framework, you can update your map through RJS by passing the result of the method calls to the <tt>page << </tt> method to have it then interpreted by the browser.
 
 For example, here is a typical initialization sequence for a map
 	@map = GMap.new("map_div")
@@ -29,32 +29,91 @@ Starting with version 0.1.4 of the YM4R library, this call to +record_init+ to a
 which is strictly equivalent to
 	@map.record_init @map.add_overlay(new GMarker([35.12878, -110.578],:title => "Hello!"))
 
-=====Initialization of the map
-The map is represented by a GMap object. You need to pass to the constructor the id of a DIV that will contain the map. You have to place this DIV yourself in your HTML template. You can also optionnally pass to the constructor the JavaScript name of the variable that will reference the map, which by default will be global in JavaScript. You have convenience methods to setup the controls, the center, the zoom, overlays and the icons (which are also global). You can also pass arbitrary JavaScript to +record_init+ and +record_global_init+. Since, by default, the initialization of the map is performed in a callback function, if you want to have a globally accessible variable, you need to use the +global+ version.
+====Initialization of the map
+The map is represented by a GMap object. You need to pass to the constructor the id of a DIV that will contain the map. You have to place this DIV yourself in your HTML template. You can also optionnally pass to the constructor the JavaScript name of the variable that will reference the map, which by default will be global in JavaScript. You have convenience methods to setup the controls, the center, the zoom, overlays, map types and the icons (which are also global). You can also pass arbitrary JavaScript to +record_init+ and +record_global_init+. Since, by default, the initialization of the map is performed in a callback function, if you want to have a globally accessible variable, you need to use the +global+ version.
 
 Then in your template, you have 2 necessary calls:
 - <tt>GMap#header</tt>: Outputs the inclusion of the JavaScript file from Google to make use of the Google Maps API + a style declaration for VML objects, necessary to display polylines under IE.
-- <tt>GMap#to_html</tt>: Outputs the initialization code of the map. By default, it outputs the +script+ tags and initializes the map inside a +load+ function. These settings can however be overridden.
+- <tt>GMap#to_html</tt>: Outputs the initialization code of the map. By default, it outputs the +script+ tags and initializes the map in response to the onload event of the JavaScript window object.
 
-You need to have an <tt>onload="load()"</tt> on the body of the HTML document, as well as place a DIV with the chosen ID to have the map correctly displayed.
+Starting with version 0.2.1, there is no need to manually wire in the body element the response to the +load+ and +unload+ events on the JavaScript window object.
 
-=====Update of the map
+====Update of the map
 You are able to update the map through Ajax. For example, in Ruby-on-Rails, you have something called RJS, which sends JavaScript created on the server as a response to an action, which is later interpreted by the browser. It is usually used for visual effects and replacing or adding elements. It can also accept arbitrary JavaScript and this is what YM4R uses.
 
 For example, if you want to add a marker to the map, you need to do a few things. First, you have to bind a Ruby mapping object to the global JavaScript map variable. By default its name is +map+, but you could have overriden that at initialization time. You need to do something like this:
 	@map = Variable.new("map")
 +map+ in the Variable constructor is the name of the global JavaScript map variable. Then any method you call on <tt>@map</tt> will be converted in JavaScript to a method called on +map+. In your RJS code, you would do something like this to add a marker:
-	page.send :record, @map.add_overlay(GMarker.new([123123.1,12313.76],:title => "Hello again!"))
+	page << @map.add_overlay(GMarker.new([123123.1,12313.76],:title => "Hello again!"))
 What is sent to the browser will be the fllowing JavaScript code:
 	map.addOverlay(new GMarker(new GLatLng(123123.1,12313.76),{title:\"Hello again!\"}))
 
-====Yahoo Maps Building Block API
+====Adding new map types
+It is now possible to easily add new map types, on top of the already existing ones, like G_SATELLITE_MAP or G_NORMAL_MAP. The imagery for these new map types can come from layers of the standard map types or can be taken either from a WMS server or from pretiled images on a server (that can be generated with a tool that comes with the library). 
+
+For exemple, here is how you would setup layers from a public WMS server of the DMAP team of the American Navy:
+	layer = WMSLayer.new("http://columbo.nrlssc.navy.mil/ogcwms/servlet/WMSServlet/AccuWeather_Maps.wms",
+	"20:3,6:3,0:27,0:29,6:19","",
+	{'prefix' => "Map Copyright 2006", 'copyright_texts'=> ["DMAP"]},
+	true,:mapserver,0..17,0.8,"png")
+This sets up a connection to a WMS service, requesting layers <tt>20:3,6:3,0:27,0:29,6:19</tt> (you would have to look at the GetCapabilities document of the service to know what the valid layers are), with default styles and a copyright notice attributing the data to DMAP. The layers are valid for zoom levels 0 to 17 (all the zoom levels). The images will be 80% opaque and will come as PNG.
+
+The arguments +true+ and <tt>:mapserver</tt> warrant some explanation. The Google Maps are in the Simple Mercator projection in the WGS84 datum and currently do not support the display of data in projections other than that, although it may change in the future. Unfortunately, different WMS servers do not identify this projection the same way. So you can give to the WMSLayer constructor your server type and it will figure out what is the correct identifier. Currently, this works only for <tt>:mapserver</tt> (EPSG:54004) and <tt>:geoserver</tt> (EPSG:41001). For others you can directly pass a number corresponding to the EPSG definition of the simple Mercator projection of your server. On top of that, some servers just don't support the Simple Mercator projection. This is why there is a +true+ argument before <tt>:mapserver</tt> in the example. It is in order to tell the WMSLayer that it should request its tiles using LatLon coordinates in the WGS84 datum (which should be supported by any server). Unfortunately it is not perfect since the deformation is quite important for low zoom levels (< 5 for the US). Higher than that, the deformation is not that visible. However, if you control the WMS server, it is recommended that you have a +false+ in this argument and setup the Mercator projection in your server if it is not done by default.
+
+<b>Note that you need to include the wms-gs.js javascript file (in the <tt>lib/ym4r/google_maps/javascript</tt> folder) in your HTML page in order to make use of the WMSLayer functionality. It uses code by John Deck with the participation of others (read the top of the javascript file to know more).</b>
+
+Here is how to define a pretiled layer:
+	layer = PreTiledLayer.new("http://localhost:3000/tiles",
+	{'prefix' => "Map C 2006", 'copyright_texts' => ["Open Atlas"]},
+	13..13,0.7,"gif")
+I tell the PreTiledLayer constructor where I can find the tiles, setup the Copyright string, the valid zooms for the map, the opacity and the format. Tiles must have standardized names: <tt>tile_#{zoom}_#{x_tile}_#{y_tile}.#{format}</tt> (here the format is "gif"). You can use some tools (see below) to generate tiles in this format either from local maps or from WMS servers (useful to create tiles from geographic data files without having to run a map server or to cache images from slow servers).
+
+You can add such a layer to a new map type the following way:
+	map_type = GMapType.new(layer,"My WMS")
+This is actually the simplest configuration possible. Your map type has only one data layer and is called "My WMS". You can add more that one layer: Either one that you have created yourself or existing ones. For example:
+	map_type = GMapType.new([GMapType::G_SATELLITE_MAP.get_tile_layers[0],layer,GMapType::G_HYBRID_MAP.get_tile_layers[1]],
+	"Test WMS")
+Here for the "Test WMS" map type, we also take the first layer of the "Satellite" map type in the background and overlay the second layer of the "Hybrid" map type (roads, country boundaries, etc... transparently overlaid on top of the preceding layers) so when the "Test WMS" map type is selected in the interface, all three layers will be displayed.
+
+Finally to add a map type to a GMap:
+	@map.map_type_init(map_type)
+If you want to wipe out the existing map types (for example the 3 default ones), you can add a +false+ argument to the +map_type_init+ method and the +map_type+ will be the only one.
+
+
+====How to generated tiles for use in pretiled layers
+
+The YM4R library provides 2 tools to generate tiles. They are in the +tools+ directory of the YM4R 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 "ruby tile_wms.rb" to know what the options are. These are very similar to the ones passed to the WMSTiler constructor, 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> options 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.
+
+===Yahoo Maps Building Block API
 Building Block API's (Geocoding, Map Image, Traffic and Local Search) are supported. You have to pass to the +get+ method of the module a hash whose keys are a rubyfied version of the request parameters detailed in the documentation for these API's. You get back a ruby object, with accessors that let you get the returned data in a easy way. You get an exception if not all the parameters have been passed, if the connection to the service could not be made or if the parameters you have passed are of the incorrect value.
 
 To know what parameters to pass to the +get+ methods and what results you should expect, you should consult the documentation for the building block API's on Yahoo!'s website : http://developer.yahoo.com/maps/index.html#mapsBuildingBlocks . 
 
 Here are some examples and notes about using the different Building Block API's.
-=====Geocoding
+====Geocoding
 Here is an example of request:
 	require 'ym4r'
 	include Ym4r::BuildingBlock
@@ -64,7 +123,7 @@ Here is an example of request:
                                   :zip => "95014")
 +results+ is an array of Geocoding::Result objects. The API can return up to 50 results for one request. You can access the data in the result with attributes which are rubyfied versions of the XML elements forming the answer from the service: See the Yahoo! Geocoding documentation to know what these are and their meanings.
 
-=====Map Image
+====Map Image
 Here is an example of request:
 	require 'ym4r'
 	include Ym4r::BuildingBlock
@@ -75,7 +134,7 @@ Here is an example of request:
                                :image_type => "png")
 +result+ is a MapImage::Result object contains the URL for the requested image. You can download this image to a file by calling +download_to+ and passing a path.
 
-=====Traffic
+====Traffic
 Here is an example of request:
 	require 'ym4r'
 	include Ym4r::BuildingBlock
@@ -86,7 +145,7 @@ Here is an example of request:
                                :include_map => true)
 +results+ is a Traffic::ResultSet object (subclass of +Array+), containing Traffic::Result objects, each containing information about one traffic incident.
 
-=====Local Search 
+====Local Search 
 Here is an example of request:
 	require 'ym4r'
 	include Ym4r::BuildingBlock
@@ -97,23 +156,24 @@ 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.
 
-====Yahoo! Maps JS-Flash API
+===Yahoo! Maps JS-Flash API
 Preliminary support for this API has been added. It works along the same lines as with the Google Maps API but it is not very polished currently.
 
-===Changes since last version
-- Addition of support for the Google Maps API
-- Addition of preliminary support for the Yahoo! Maps JS-Flash API
+==Changes since last version
+- Addition of support for user-defined layers (WMS and pretiled layers)
+- Addition of tools to generate tiles to be used with the pretiled layers
 
-===TODO
+==TODO
+- Add support for easy manipulation of external Google Maps-related libraries: Advanced tooltip manipulation, GeoRSS, Clusterer...
 - Documentation! Documentation! Documentation!
 - Tutorials
 - Finish the support for the Yahoo! Maps JS-Flash API
 
-===Disclaimer
+==Disclaimer
 This software is not endorsed in any way by Yahoo! or Google.
 
-===License
+==License
 YM4R is released under the MIT license.
 
-===Support
+==Support
 Any questions, enhancement proposals, bug notifications or corrections can be sent to mailto:guilhem.vellut+ym4r@gmail.com.

data/lib/ym4r/google_maps/javascript/wms-gs.js

@@ -0,0 +1,69 @@
+/*
+ * Call generic wms service for GoogleMaps v2
+ * John Deck, UC Berkeley
+ * Inspiration & Code from:
+ *	Mike Williams http://www.econym.demon.co.uk/googlemaps2/ V2 Reference & custommap code
+ *	Brian Flood http://www.spatialdatalogic.com/cs/blogs/brian_flood/archive/2005/07/11/39.aspx V1 WMS code
+ *	Kyle Mulka http://blog.kylemulka.com/?p=287  V1 WMS code modifications
+ *      http://search.cpan.org/src/RRWO/GPS-Lowrance-0.31/lib/Geo/Coordinates/MercatorMeters.pm
+ *
+ * Modified by Chris Holmes, TOPP to work by default with GeoServer.
+ *
+ * Bundled with YM4R with John Deck's permission.
+ * Slightly modified to fit YM4R.
+ * See johndeck.blogspot.com for the original version and for examples and instructions of how to use it.
+ */
+
+var WGS84_SEMI_MAJOR_AXIS = 6378137.0; //equatorial radius
+var WGS84_ECCENTRICITY = 0.0818191913108718138;
+var DEG2RAD=0.0174532922519943;
+var PI=3.14159267;
+
+function dd2MercMetersLng(p_lng) { 
+	return WGS84_SEMI_MAJOR_AXIS * (p_lng*DEG2RAD); 
+}
+
+function dd2MercMetersLat(p_lat) {
+        var lat_rad = p_lat * DEG2RAD;
+	return WGS84_SEMI_MAJOR_AXIS * Math.log(Math.tan((lat_rad + PI / 2) / 2) * Math.pow( ((1 - WGS84_ECCENTRICITY * Math.sin(lat_rad)) / (1 + WGS84_ECCENTRICITY * Math.sin(lat_rad))), (WGS84_ECCENTRICITY/2)));
+}
+
+function addWMSPropertiesToLayer(tile_layer,base_url,layers,styles,format,merc_proj,use_geo){
+   tile_layer.format = format;
+   tile_layer.baseURL = base_url;
+   tile_layer.styles = styles;
+   tile_layer.layers = layers;
+   tile_layer.mercatorEpsg = merc_proj;
+   tile_layer.useGeographic = use_geo;
+   return tile_layer;
+}
+
+getTileUrlForWMS=function(a,b,c) {
+	var lULP = new GPoint(a.x*256,(a.y+1)*256);
+	var lLRP = new GPoint((a.x+1)*256,a.y*256);
+	var lUL = G_NORMAL_MAP.getProjection().fromPixelToLatLng(lULP,b,c);
+	var lLR = G_NORMAL_MAP.getProjection().fromPixelToLatLng(lLRP,b,c);
+	 
+	if (this.useGeographic){
+           var lBbox=lUL.x+","+lUL.y+","+lLR.x+","+lLR.y;
+    	   var lSRS="EPSG:4326";
+	}else{
+	   var lBbox=dd2MercMetersLng(lUL.x)+","+dd2MercMetersLat(lUL.y)+","+dd2MercMetersLng(lLR.x)+","+dd2MercMetersLat(lLR.y);
+    	   var lSRS="EPSG:" + this.mercatorEpsg;
+        }
+	var lURL=this.baseURL;
+	lURL+="?REQUEST=GetMap";
+	lURL+="&SERVICE=WMS";
+	lURL+="&VERSION=1.1.1";
+	lURL+="&LAYERS="+this.layers;
+	lURL+="&STYLES="+this.styles; 
+	lURL+="&FORMAT=image/"+this.format;
+	lURL+="&BGCOLOR=0xFFFFFF";
+	lURL+="&TRANSPARENT=TRUE";
+	lURL+="&SRS="+lSRS;
+	lURL+="&BBOX="+lBbox;
+	lURL+="&WIDTH=256";
+	lURL+="&HEIGHT=256";
+	lURL+="&reaspect=false";
+	return lURL;
+}

data/lib/ym4r/google_maps/layer.rb

@@ -0,0 +1,108 @@
+module Ym4r
+  module GoogleMaps
+    #Map types of the map
+    class GMapType
+      include MappingObject
+      
+      G_NORMAL_MAP = Variable.new("G_NORMAL_MAP")
+      G_SATELLITE_MAP = Variable.new("G_SATELLITE_MAP")
+      G_HYBRID_MAP = Variable.new("G_HYBRID_MAP")
+      
+      attr_accessor :layers, :name, :projection, :options
+      
+      def initialize(layers, name, projection = GMercatorProjection.new,options = {})
+        @layers = layers
+        @name = name
+        @projection = projection
+        @options = options
+      end
+
+      def create
+        "new GMapType(#{MappingObject.javascriptify_variable(Array(layers))}, #{MappingObject.javascriptify_variable(projection)}, #{MappingObject.javascriptify_variable(name)}, #{MappingObject.javascriptify_variable(options)})"
+      end
+    end
+
+    class GMercatorProjection
+      include MappingObject
+      
+      attr_accessor :n
+      
+      def initialize(n = nil)
+        @n = n
+      end
+
+      def create
+        if n.nil?
+          return "G_NORMAL_MAP.getProjection()"
+        else
+          "new GMercatorProjection(#{@n})"
+        end
+      end
+    end
+
+    class GTileLayer
+      include MappingObject
+            
+      attr_accessor :opacity, :zoom_inter, :copyright
+
+      def initialize(zoom_inter = 0..17, copyright= {'prefix' => '', 'copyright_texts' => [""]}, opacity = 1.0)
+        @opacity = opacity
+        @zoom_inter = zoom_inter
+        @copyright = copyright
+      end
+
+      def create
+        "addPropertiesToLayer(new GTileLayer(new GCopyrightCollection(\"\"),#{zoom_inter.begin},#{zoom_inter.end}),#{get_tile_url},function(a,b) {return #{MappingObject.javascriptify_variable(@copyright)};}\n,function() {return #{@opacity};})"
+      end
+      
+      #for subclasses to implement
+      def get_tile_url
+      end
+    end
+    
+    class PreTiledLayer < GTileLayer
+      attr_accessor :base_url, :format
+      
+      def initialize(base_url = "http://localhost:8080/tiles", copyright = {'prefix' => '', 'copyright_texts' => [""]}, zoom_inter = 0..17, opacity = 1.0,format = "png")
+        super(zoom_inter, copyright, opacity)
+        @base_url = base_url
+        @format = format
+      end
+      
+      #returns the code to determine the url to fetch the tile. Follows the convention adopted by the tiler: {base_url}/tile_{b}_{a.x}_{a.y}.{format}
+      def get_tile_url
+        "function(a,b,c) { return '#{@base_url}/tile_' + b + '_' + a.x + '_' + a.y + '.#{@format}';}"
+      end 
+    end
+    
+    #needs to include the JavaScript file wms-gs.js for this to work
+    #see http://docs.codehaus.org/display/GEOSDOC/Google+Maps
+    class WMSLayer < GTileLayer
+      attr_accessor :base_url, :layers, :styles, :format, :merc_proj, :use_geographic
+
+      def initialize(base_url, layers, styles = "", copyright = {'prefix' => '', 'copyright_texts' => [""]}, use_geographic = false, merc_proj = :mapserver, zoom_inter = 0..17, opacity = 1.0,format= "png")
+        super(zoom_inter, copyright, opacity)
+        @base_url = base_url
+        @layers = layers
+        @styles = styles
+        @format = format
+        @merc_proj = if merc_proj == :mapserver
+                       "54004"
+                     elsif merc_proj == :geoserver
+                       "41001"
+                     else
+                       merc_proj.to_s
+                     end
+        @use_geographic = use_geographic
+      end
+      
+      def get_tile_url
+        "getTileUrlForWMS"
+      end
+
+      def create
+        "addWMSPropertiesToLayer(#{super},#{MappingObject.javascriptify_variable(@base_url)},#{MappingObject.javascriptify_variable(@layers)},#{MappingObject.javascriptify_variable(@styles)},#{MappingObject.javascriptify_variable(@format)},#{MappingObject.javascriptify_variable(@merc_proj)},#{MappingObject.javascriptify_variable(@use_geographic)})"
+      end
+    end
+  end
+end

data/lib/ym4r/google_maps/map.rb

@@ -15,6 +15,7 @@ module Ym4r
         @container = container
         @variable = variable
         @init = []
+        @init_end = [] #for stuff that must be initialized at the end (controls)
         @global_init = []
       end
 
@@ -24,6 +25,11 @@ module Ym4r
         a << "<style type=\"text/css\">\n v\:* { behavior:url(#default#VML);}\n</style>" if with_vml
         a
       end
+     
+      #Outputs the <div id=...></div> which has been configured to contain the map
+      def div
+        "<div id=\"#{@container}\"></div>"
+      end
 
       #Outputs a style declaration setting the dimensions of the DIV container of the map. This info can also be set manually in a CSS.
       def header_width_height(width,height)
@@ -37,12 +43,12 @@ module Ym4r
 
       #Initializes the controls: you can pass a hash with keys <tt>:small_map</tt>, <tt>:large_map</tt>, <tt>:small_zoom</tt>, <tt>:scale</tt>, <tt>:map_type</tt> and <tt>:overview_map</tt> and a boolean value as the value (usually true, since the control is not displayed by default)
       def control_init(controls = {})
-        @init << add_control(GSmallMapControl.new) if controls[:small_map]
-        @init << add_control(GLargeMapControl.new) if controls[:large_map]
-        @init << add_control(GSmallZoomControl.new) if controls[:small_zoom]
-        @init << add_control(GScaleControl.new) if controls[:scale]
-        @init << add_control(GMapTypeControl.new) if controls[:map_type]
-        @init << add_control(GOverviewMapControl.new) if controls[:overview_map]
+        @init_end << add_control(GSmallMapControl.new) if controls[:small_map]
+        @init_end << add_control(GLargeMapControl.new) if controls[:large_map]
+        @init_end << add_control(GSmallZoomControl.new) if controls[:small_zoom]
+        @init_end << add_control(GScaleControl.new) if controls[:scale]
+        @init_end << add_control(GMapTypeControl.new) if controls[:map_type]
+        @init_end << add_control(GOverviewMapControl.new) if controls[:overview_map]
       end
 
       #Initializes the initial center and zoom of the map. +center+ can be both a GLatLng object or a 2-float array.
@@ -54,43 +60,64 @@ module Ym4r
         end
       end
 
-      #Initializes the map by adding an overlay (marker or polyline). It can be called multiple times
+      #Initializes the map by adding an overlay (marker or polyline).
       def overlay_init(overlay)
         @init << add_overlay(overlay)
       end
 
+      #Sets up a new map type. If +add+ is false, all the other map types of the map are wiped out. If +set+ is true, the current map type for the map is set to +map_type+. If you want to access the map type in other methods, you should declare the map type first.
+      def map_type_init(map_type, add = true)
+        unless add
+          @init << get_map_types.set_property(:length,0)
+        end
+        @init << add_map_type(map_type)
+      end
+
+      #Locally declare a MappingObject with variable name "name"
+      def declare_init(variable, name)
+        @init << variable.declare(name)
+      end
+
       #Records arbitrary JavaScript code and outputs it during initialization outside the +load+ function (ie globally).
       def record_global_init(code)
         @global_init << code
       end
       
       #Initializes an icon  and makes it globally accessible through the JavaScript variable of name +variable+.
-      def icon_init(icon , variable)
-        @global_init << icon.declare(variable)
+      def icon_init(icon , name)
+        declare_global_init(icon,name)
+      end
+
+      #Globally declare a MappingObject with variable name "name"
+      def declare_global_init(variable,name)
+        @global_init << variable.declare(name)
       end
       
       #Outputs the initialization code for the map. By default, it outputs the script tags, performs the initialization inside a function called +load+ and makes the map globally available.
       def to_html(options = {})
         no_load = options[:no_load]
-        load_method = options[:load_method] || "load"
         no_script_tag = options[:no_script_tag]
         no_declare = options[:no_declare]
         no_global = options[:no_global]
         
         html = ""
         html << "<script type=\"text/javascript\">\n" if !no_script_tag
+        #put the functions in a separate javascript file to be included in the page
         html << "function addInfoWindowToMarker(marker,info){\nGEvent.addListener(marker, \"click\", function() {\nmarker.openInfoWindowHtml(info);\n});\nreturn marker;\n}\n"
         html << "function addInfoWindowTabsToMarker(marker,info){\nGEvent.addListener(marker, \"click\", function() {\nmarker.openInfoWindowTabsHtml(info);\n});\nreturn marker;\n}\n"
+        html << "function addPropertiesToLayer(layer,getTile,copyright,opacity){\nlayer.getTileUrl = getTile;\nlayer.getCopyright = copyright;\nlayer.getOpacity = opacity;\nreturn layer;\n}\n"
         html << @global_init * "\n"
         html << "var #{@variable};\n" if !no_declare and !no_global
-        html << "function #{load_method}() {\nif (GBrowserIsCompatible()) {\n" if !no_load
+        html << "window.onload = function() {\nif (GBrowserIsCompatible()) {\n" if !no_load
         if !no_declare and no_global 
           html << "#{declare(@variable)}\n"
         else
           html << "#{assign_to(@variable)}\n"
         end
         html << @init * "\n"
+        html << @init_end * "\n"
         html << "\n}\n}\n" if !no_load
+        html << "window.onunload = GUnload;\n"
         html << "</script>" if !no_script_tag
         html
       end
@@ -101,12 +128,7 @@ module Ym4r
       end
     end
 
-    #Map types of the map
-    module GMapType
-      G_NORMAL_MAP = Variable.new("GMapType.G_NORMAL_MAP")
-      G_SATELLITE_MAP = Variable.new("GMapType.G_SATELLITE_MAP")
-      G_HYBRID_MAP = Variable.new("GMapType.G_HYBRID_MAP")
-    end
+    
   end
 end
 

data/lib/ym4r/google_maps/mapping.rb

@@ -8,42 +8,75 @@ module Ym4r
       #Creates javascript code for missing methods
       def method_missing(name,*args)
         args.collect! do |arg|
-          javascriptify_variable(arg)
+          MappingObject.javascriptify_variable(arg)
         end
-        Variable.new("#{to_javascript}.#{javascriptify_method(name.to_s)}(#{args.join(",")})")
+        Variable.new("#{to_javascript}.#{MappingObject.javascriptify_method(name.to_s)}(#{args.join(",")})")
+      end
+            
+      #Creates javascript code for array or hash indexing
+      def [](index) #index could be an integer or string
+        return Variable.new("#{to_javascript}[#{MappingObject.javascriptify_variable(index)}]")
       end
 
-      #Transforms a Ruby object into a JavaScript string
-      def javascriptify_variable(arg)
+      #Transforms a Ruby object into a JavaScript string : MAppingObject, String, Array, Hash and general case (using to_s)
+      def self.javascriptify_variable(arg)
         if arg.is_a?(MappingObject)
           arg.to_javascript
         elsif arg.is_a?(String)
-          "\"#{escape_javascript(arg)}\""
+          "\"#{MappingObject.escape_javascript(arg)}\""
+        elsif arg.is_a?(Array)
+          "[" + arg.collect{ |a| MappingObject.javascriptify_variable(a)}.join(",") + "]"
+        elsif arg.is_a?(Hash)
+          "{" + arg.to_a.collect do |v|
+            "#{MappingObject.javascriptify_method(v[0].to_s)} : #{MappingObject.javascriptify_variable(v[1])}"
+          end.join(",") + "}"
         else
           arg.to_s
         end
       end
       
       #Escape string to be used in JavaScript. Lifted from rails.
-      def escape_javascript(javascript)
+      def self.escape_javascript(javascript)
         javascript.gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
       end
       
       #Transform a ruby-type method name (like add_overlay) to a JavaScript-style one (like addOverlay).
-      def javascriptify_method(method_name)
+      def self.javascriptify_method(method_name)
         method_name.gsub(/_(\w)/){|s| $1.upcase}
       end
       
       #Declares a Mapping Object bound to a JavaScript variable of name +variable+.
       def declare(variable)
         @variable = variable
-        "var #{variable} = #{create};"
+        "var #{@variable} = #{create};"
+      end
+
+      #declare with a random variable name
+      def declare_random(init,size = 8)
+        s = init.clone
+        6.times { s << (i = Kernel.rand(62); i += ((i < 10) ? 48 : ((i < 36) ? 55 : 61 ))).chr }
+        declare(s)
+      end
+
+      #Checks if the MappinObject has been declared
+      def declared?
+        !@variable.nil?
       end
       
       #Binds a Mapping object to a previously declared JavaScript variable of name +variable+.
       def assign_to(variable)
         @variable = variable
-        "#{variable} = #{create};"
+        "#{@variable} = #{create};"
+      end
+
+      #Assign the +value+ to the +property+ of the MappingObject
+      def set_property(property, value)
+        "#{to_javascript}.#{MappingObject.javascriptify_method(property.to_s)} = #{MappingObject.javascriptify_variable(value)}"
+      end
+
+      #Returns the code to get a +property+ from the MappingObject
+      def get_property(property)
+        Variable.new("#{to_javascript}.#{MappingObject.javascriptify_method(property.to_s)}")
       end
       
       #Returns a Javascript code representing the object
@@ -61,7 +94,7 @@ module Ym4r
       end
     end
 
-    #Used to bind a ruby variable to an already existing JavaScript one. IT doesn't have to be a variable in the sense "var variable" but it can be any valid JavaScript expression that has a value.
+    #Used to bind a ruby variable to an already existing JavaScript one. It doesn't have to be a variable in the sense "var variable" but it can be any valid JavaScript expression that has a value.
     class Variable
       include MappingObject
       def initialize(variable)

data/lib/ym4r/google_maps/overlay.rb

@@ -20,19 +20,14 @@ module Ym4r
       #Creates a marker: If an info_window or info_window_tabs is present, the response to the click action from the user is setup here.
       def create
         if @options.empty?
-          creation = "new GMarker(#{@point.to_javascript})"
+          creation = "new GMarker(#{MappingObject.javascriptify_variable(@point)})"
         else
-          options = "{"
-          options << @options.to_a.collect do |v|
-            "#{v[0].to_s} : #{javascriptify_variable(v[1])}"
-          end.join(",")
-          options << "}"
-          creation = "new GMarker(#{@point.to_javascript},#{options})"
+          creation = "new GMarker(#{MappingObject.javascriptify_variable(@point)},#{MappingObject.javascriptify_variable(@options)})"
         end
         if @info_window
-          "addInfoWindowToMarker(#{creation},#{javascriptify_variable(@info_window)})"
+          "addInfoWindowToMarker(#{creation},#{MappingObject.javascriptify_variable(@info_window)})"
         elsif @tab_info_window
-          "addInfoWindowTabsToMarker(#{creation},[#{@tab_info_window.collect{ |tab| tab.to_javascript}.join(",")}])"
+          "addInfoWindowTabsToMarker(#{creation},#{MappingObject.javascriptify_variable(Array(@tab_info_window))})"
         else
           creation
         end
@@ -43,7 +38,7 @@ module Ym4r
     class GInfoWindowTab < Struct.new(:tab,:content)
       include MappingObject
       def create
-        "new GInfoWindowTab(#{javascriptify_variable(tab)},#{javascriptify_variable(content)})"
+        "new GInfoWindowTab(#{MappingObject.javascriptify_variable(tab)},#{MappingObject.javascriptify_variable(content)})"
       end
     end
         
@@ -61,7 +56,7 @@ module Ym4r
       #Creates a GIcon.
       def create
         if @copy_base
-          "new GIcon(#{@copy_base.to_javascript})"
+          "new GIcon(#{MappingObject.javascriptify_variable(@copy_base)})"
         else
           "new GIcon()"
         end
@@ -70,7 +65,7 @@ module Ym4r
       def declare(variable)
         decl = super(variable) + "\n"
         @options.each do |key,value|
-          decl << "#{to_javascript}.#{javascriptify_method(key.to_s)} = #{javascriptify_variable(value)};\n"
+          decl << "#{to_javascript}.#{MappingObject.javascriptify_method(key.to_s)} = #{MappingObject.javascriptify_variable(value)};\n"
         end
         decl
       end
@@ -93,10 +88,10 @@ module Ym4r
       end
       #Creates a new polyline.
       def create
-        a = "new GPolyline([#{@points.collect{|pt| pt.to_javascript}.join(",")}]"
-        a << ",#{javascriptify_variable(@color)}" if @color
-        a << ",#{javascriptify_variable(@weight)}" if @weight
-        a << ",#{javascriptify_variable(@opacity)}" if @opacity
+        a = "new GPolyline([#{@points.collect{|pt| MappingObject.javascriptify_variable(pt)}.join(",")}]"
+        a << ",#{MappingObject.javascriptify_variable(@color)}" if @color
+        a << ",#{MappingObject.javascriptify_variable(@weight)}" if @weight
+        a << ",#{MappingObject.javascriptify_variable(@opacity)}" if @opacity
         a << ")"
       end
       

data/lib/ym4r/google_maps/tiler/image_tiler.rb

@@ -0,0 +1,107 @@
+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/tiler/wms_tiler.rb

@@ -0,0 +1,157 @@
+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/lib/ym4r/google_maps.rb

@@ -4,4 +4,5 @@ require 'ym4r/google_maps/control'
 require 'ym4r/google_maps/overlay'
 require 'ym4r/google_maps/point'
 require 'ym4r/google_maps/api_key'
+require 'ym4r/google_maps/layer.rb'
 require 'ym4r/google_maps/helper'

data/rakefile.rb

@@ -24,7 +24,7 @@ spec = Gem::Specification::new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.name = 'ym4r'
-  s.version = "0.1.4"
+  s.version = "0.2.1"
   s.summary = "Using Google Maps and Yahoo! Maps from Ruby and Rails"
   s.description = <<EOF
 EOF
@@ -34,7 +34,7 @@ EOF
   
   s.requirements << 'none'
   s.require_path = 'lib'
-  s.files = FileList["lib/**/*.rb", "lib/**/*.yml","test/**/*.rb", "README","MIT-LICENSE","rakefile.rb"]
+  s.files = FileList["lib/**/*.rb", "lib/**/*.yml","lib/**/*.js","tools/**/*.rb","test/**/*.rb", "README","MIT-LICENSE","rakefile.rb"]
   s.test_files = FileList['test/test*.rb']
 
   s.has_rdoc = true

data/test/test_google_maps.rb

@@ -6,14 +6,49 @@ require 'test/unit'
 include Ym4r::GoogleMaps
 
 class TestGoogleMaps< Test::Unit::TestCase
-  def test_js_export
-    map = GMap.new("map_div")
-    var = Variable.new("hello")
-    yuo = Variable.new("salam")
-    poi = Variable.new("poi")
-    map.record_init map.add_overlay(GMarker.new([123.5,123.56]))
-    map.record_init map.dummy_method(var.other_dummy_method(yuo.kaka_boudin),poi)
-    map.control_init(:small_map => true)
-    puts map.to_html
+  def test_javascriptify_method
+    assert_equal("addOverlayToHello",MappingObject::javascriptify_method("add_overlay_to_hello"))
   end
+
+  def test_javascriptify_variable_mapping_object
+    map = GMap.new("div")
+    assert_equal(map.to_javascript,MappingObject::javascriptify_variable(map))
+  end
+
+  def test_javascriptify_variable_numeric
+    assert_equal("123.4",MappingObject::javascriptify_variable(123.4))
+  end
+
+  def test_javascriptify_variable_array
+    map = GMap.new("div")
+    assert_equal("[123.4,#{map.to_javascript},[123.4,#{map.to_javascript}]]",MappingObject::javascriptify_variable([123.4,map,[123.4,map]]))
+  end
+
+  def test_javascriptify_variable_hash
+    map = GMap.new("div")
+    test_str = MappingObject::javascriptify_variable("hello" => map, "chopotopoto" => [123.55,map])
+    assert("{hello : #{map.to_javascript},chopotopoto : [123.55,#{map.to_javascript}]}" == test_str || "{chopotopoto : [123.55,#{map.to_javascript}],hello : #{map.to_javascript}}" == test_str)
+  end
+
+  def test_method_call_on_mapping_object
+    map = GMap.new("div","map")
+    assert_equal("map.addHello(123.4);",map.add_hello(123.4).to_s)
+  end
+
+  def test_nested_calls_on_mapping_object
+    gmap = GMap.new("div","map")
+    assert_equal("map.addHello(map.hoYoYo(123.4),map);",gmap.add_hello(gmap.ho_yo_yo(123.4),gmap).to_s)
+  end
+  
+  def test_declare_variable_latlng
+    point = GLatLng.new([123.4,123.6])
+    assert_equal("var point = new GLatLng(123.4,123.6);",point.declare("point"))
+    assert_equal("point",point.variable)
+  end
+
+  def test_array_indexing
+    obj = Variable.new("obj")
+    assert_equal("obj[0]",obj[0].variable)
+  end
+  
 end

data/tools/tile_image.rb

@@ -0,0 +1,66 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'ym4r/google_maps/tiler/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

@@ -0,0 +1,78 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'ym4r/google_maps/tiler/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 isntead 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") 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)
+
+                      

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ym4r
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
-date: 2006-06-05 00:00:00 +05:00
+  version: 0.2.1
+date: 2006-06-12 00:00:00 +05:00
 summary: Using Google Maps and Yahoo! Maps from Ruby and Rails
 require_paths: 
 - lib
@@ -34,10 +34,13 @@ files:
 - lib/ym4r/google_maps/api_key.rb
 - lib/ym4r/google_maps/control.rb
 - lib/ym4r/google_maps/helper.rb
+- lib/ym4r/google_maps/layer.rb
 - lib/ym4r/google_maps/map.rb
 - lib/ym4r/google_maps/mapping.rb
 - lib/ym4r/google_maps/overlay.rb
 - lib/ym4r/google_maps/point.rb
+- lib/ym4r/google_maps/tiler/image_tiler.rb
+- lib/ym4r/google_maps/tiler/wms_tiler.rb
 - lib/ym4r/yahoo_maps/app_id.rb
 - lib/ym4r/yahoo_maps/building_block.rb
 - lib/ym4r/yahoo_maps/flash.rb
@@ -54,6 +57,9 @@ files:
 - lib/ym4r/yahoo_maps/flash/tool.rb
 - lib/ym4r/yahoo_maps/flash/widget.rb
 - lib/ym4r/google_maps/config/config.yml
+- lib/ym4r/google_maps/javascript/wms-gs.js
+- tools/tile_image.rb
+- tools/tile_wms.rb
 - test/test_geocoding.rb
 - test/test_google_maps.rb
 - test/test_local_search.rb