mapkit 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 inovex GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,55 @@
+## MapKit & TileKit
+
+MapKit and TileKit are tools to help you develop a tile rendering service in
+ruby. If you need to draw many markers in google maps then the performance
+limit is reached fast. Google has advices to use up to 20 markers at a time.
+With some tricks you can inrease the number of markes but with the cost of
+inprintability.
+
+If you want to take the full power of google maps you might have to render
+your own tile over the tiles of google. Like layers where your layer is on top
+of googles.
+
+The system is very simple. You have to add a new Layer to your Google Maps that
+request a tile with X, Y and Z like this:
+
+    var layer = new GTileLayer(null, 0, 21, {
+      isPng: true,
+      opacity: 1
+    });
+    layer.getTileUrl = function(tile, zoom) {
+      return "" + zoom + "/" + tile.x + "/" + tile.y + ".png";
+    }
+    map.addOverlay(new GTileLayerOverlay(layer));
+  
+Once this is done, google starts to request tiles from your server. To
+implement the server you need to decode X (tile x), Y (tile y) and 
+Z (zoom level) to a bounding box of latitude and longitude so that you can
+check what to draw in the tile that was requested. After you have fetched some
+points you have to draw them in the Tile. This is where TileKit comes into play.
+TileKit relies on gd2 a well known image rendering library (http://libgd.org).
+  
+    # this example assumes that a request with x, y and z was done
+    # by the browser and saved into x, y, z
+
+    POI = TileKit::Icon.new("images/poi.png", [20, 20], [3, 20], [0, 0, 20, 17])
+    bounding_box = MapKit.bounding_box(x, y, z)
+
+    # search for points_of_interest in a bigger bouning box (grow by 10%)
+    points = DB.points(bounding_box.grow(10))
+
+    unless points.empty?
+      # cerate tile
+      tile = TileKit::Image.new(bounding_box)
+  
+      # draw icons at point positions
+      for point in points do
+        tile.draw_icon(point, POI)
+      end
+  
+      # return tile
+      return tile.png
+    end
+
+To get an overview on the whole story checkout the sample application in the
+example directory. It requires json, sequel, sqlite3 and sinatra.

data/lib/google_local.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + "/mapkit"
+require 'httparty'
+
+# Class for searching with the google local search
+class GoogleLocal
+  include HTTParty
+  base_uri "www.google.com"
+  default_params :hl => :de, :v => "1.0", :rsz => :large
+  format :json
+  
+  # searches a term near point with sspn (span in degrees)
+  def self.search(term, point, sspn)
+    resp = get("/uds/GlocalSearch", :query => { :q => term, 
+    :sll => point.join(","), :sspn => sspn.join(",") })
+    if resp["responseStatus"] == 200
+      resp["responseData"]["results"]
+    else
+      raise Exception.new("Error in Google request")
+    end
+  end
+  
+  # just searches a term in a bounding box and returns points
+  def self.search_in_bounding_box(term, bounding_box)
+    crawl(term, bounding_box.center, bounding_box.sspn).map do |i| 
+      MapKit::Point.new(i["lat"].to_f, i["lng"].to_f)
+    end
+  end
+  
+  # searches a term near point with sspn (span in degrees)
+  def self.crawl(term, point, sspn)
+    print " - crawl for '#{term}' at #{point.inspect} within #{sspn.inspect} ("
+    count = 0
+    4.times do |i|
+      data = get("/uds/GlocalSearch", :query => { :q => term, :start => i * 8,
+      :sll => point.join(","), :sspn => sspn.join(",") }).to_hash
+      if data["responseStatus"] == 200
+        data["responseData"]["results"].each do |row|
+          yield(row)
+          count += 1
+        end
+      else
+        raise Exception.new("Error in Google request")
+      end
+      print "."
+    end  
+    print ") results: #{count}\n"
+  end
+  
+  # searches a term near point with sspn (span in degrees) n times n
+  def self.crawl_region(term, point, span, n = 10, &block) # :yields: data
+    half_span = span / 2
+    n.times do |x|
+      n.times do |y|
+        point = [point[0] + x * half_span, point[1] + y * half_span]
+        crawl(term, point, [half_span, half_span], &block)
+      end
+    end
+  end
+end

data/lib/mapkit.rb

@@ -0,0 +1,184 @@
+# Module to create tile for the google maps tile overlay
+module MapKit
+  # consant for radiants
+  RADIANT = Math::PI / 180.0
+  
+  # the size of tiles in google maps
+  TILE_SIZE = 256
+  
+  # the constant earth radius in meters
+  EARTH_RADIUS = 6_378_137
+  
+  # the min latitude based on the mercator projection
+  MIN_LATITUDE = -85.05112877
+  
+  # the max latitude based on the mercator projection
+  MAX_LATITUDE = 85.05112877
+  
+  # the min longitude based on the mercator projection
+  MIN_LONGITUDE = -180
+  
+  # the max longitude based on the mercator projection
+  MAX_LONGITUDE = 180
+  
+  # the resolution in meters per pixel
+  RESOLUTION = 2 * Math::PI * EARTH_RADIUS / TILE_SIZE
+  
+  # version of MapKit
+  VERSION = "0.0.1"
+  
+  # The class represents an lat/lng point
+  class Point
+    attr_accessor :lat, :lng
+  
+    # initializes a point object using latitude and longitude
+    def initialize(lat, lng)
+      @lat, @lng = lat, lng
+    end
+    
+    # returns true if point is in bounding_box, false otherwise
+    def in?(bounding_box)
+      top, left, bottom, right = bounding_box.coords
+      (left..right) === @lng && (top..bottom) === @lat
+    end
+    
+    # returns relative x and y for point in bounding_box
+    def pixel(bounding_box)
+      top, left, bottom, right = bounding_box.coords
+      ws = (right - left) / TILE_SIZE
+      hs = (bottom - top) / TILE_SIZE
+      [((@lng - left) / ws).to_i, ((@lat - top) / hs).to_i]
+    end
+  end
+  
+  # The class represents a bounding box specified by a top/left point and a 
+  # bottom/right point (the coordinates can be pixels or degrees)
+  class BoundingBox
+    attr_accessor :top, :left, :bottom, :right, :zoom
+    
+    # initialize the bounding box using the positions of two points and a 
+    # optional zoom level
+    #
+    #             top
+    #        left o------+
+    #             |      |
+    #             |      |
+    #             +------o right
+    #                    bottom
+    #
+    def initialize(top, left, bottom, right, zoom = nil)
+      @top, @left, @bottom, @right, @zoom = top, left, bottom, right, zoom
+    end
+    
+    # returns array of [top, left, bottom, right]
+    def coords
+      [@top, @left, @bottom, @right]
+    end
+
+    # returns array of [width, height] of sspn
+    def sspn
+      [(@right - @left) / 2, (@bottom - @top) / 2]
+    end
+
+    # returns [lat, lnt] of bounding box
+    def center
+      [@left + (@right - @left) / 2, @top + (@bottom - @top) / 2]
+    end
+    
+    # grow bounding box by percentage
+    def grow!(percent)
+      lng = percent * ((@right - @left) / 100)
+      lat = percent * ((@top - @bottom) / 100)
+      @top += lat
+      @left -= lng
+      @bottom -= lat
+      @right += lng
+    end
+    
+    # grow bounding box by percentage and return new bounding box object
+    def grow(percent)
+      copy = self.clone
+      copy.grow!(percent)
+      copy
+    end
+  end
+  
+  # return bounding box for passed tile coordinates tiles
+  def self.bounding_box(tile_x, tile_y, zoom)
+    top, left, bottom, right = tile_bounds(tile_x, tile_y, zoom)
+    BoundingBox.new(top, left, bottom, right, zoom)
+  end
+
+  # returns bounds [top, left, bottom, right] of the given tile 
+  # in WGS-94 coordinates
+  def self.tile_bounds(tile_x, tile_y, zoom)
+    pixel_x, pixel_y = tile2pixel(tile_x, tile_y)
+    top, left = pixel2latlng(pixel_x, pixel_y, zoom)
+    
+    pixel_x, pixel_y = tile2pixel(tile_x + 1, tile_y + 1)
+    bottom, right = pixel2latlng(pixel_x, pixel_y, zoom)
+    
+    [top, left, bottom, right]
+  end
+  
+  # returns [lat, lng] shifted using the passed pixels and zoom
+  def self.shift_latlng(lat, lng, shift_x, shift_y, zoom)
+    pixel_x, pixel_y = latlng2pixel(lat.to_f, lng.to_f, zoom)
+    pixel_x, pixel_y = pixel_x + shift_x, pixel_y + shift_y
+    pixel2latlng(pixel_x, pixel_y, zoom)
+  end
+
+  # returns pixel coordinates [x, y] based on the passed lat/lng WGS-84
+  # coordinates using the specified zoom level
+  def self.latlng2pixel(lat, lng, zoom)
+    lat = clip(lat.to_f, MIN_LATITUDE, MAX_LATITUDE)
+    lng = clip(lng.to_f, MIN_LONGITUDE, MAX_LONGITUDE)
+    
+    x = (lng + 180.0) / 360.0
+    sin_lat = Math.sin(lat * RADIANT)
+    y = 0.5 - Math.log((1.0 + sin_lat) / (1.0 - sin_lat)) / (4.0 * Math::PI)
+    sx, sy = map_size(zoom)
+    
+    pixel_x = clip(x * sx + 0.5, 0.0, sx - 1.0)
+    pixel_y = clip(y * sy + 0.5, 0.0, sy - 1.0)
+    [pixel_x.to_i, pixel_y.to_i]
+  end
+  
+  # returns lat/lng WGS-84 coordinates [lat, lng] basedon the passed pixel
+  # coordinates using the specified zoom level
+  def self.pixel2latlng(pixel_x, pixel_y, zoom)
+    sx, sy = map_size(zoom)
+    x = clip(pixel_x.to_f, 0.0, sx - 1.0) / sx - 0.5
+    y = 0.5 - clip(pixel_y.to_f, 0.0, sy - 1.0) / sy
+    
+    lat = 90.0 - 360.0 * Math.atan(Math.exp(-y * 2.0 * Math::PI)) / Math::PI
+    lng = 360.0 * x
+    [lat, lng]
+  end
+
+  # returns the passed value in case it is in the passed range or the 
+  # bounding min or max value 
+  def self.clip(val, min, max)
+    (val < min) ? min : (val > max) ? max : val
+  end
+
+  # returns coordinates of tiles using passed pixel coordinates
+  def self.pixel2tile(pixel_x, pixel_y)
+    [pixel_x / TILE_SIZE, pixel_y / TILE_SIZE]
+  end
+  
+  # returns coordinates of pixels using passed tile coordinates
+  def self.tile2pixel(tile_x, tile_y)
+    [tile_x * TILE_SIZE, tile_y * TILE_SIZE]
+  end
+  
+  # returns the size [x, y] of the map using the passed zoom level
+  def self.map_size(zoom)
+    [TILE_SIZE << zoom, TILE_SIZE << zoom]
+  end
+  
+  # returns resolution in meters per pixel for passed zoom level
+  def self.resolution(zoom)
+    RESOLUTION / (2 ** zoom)
+  end
+end

data/lib/tilekit.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + "/mapkit"
+require "gd2"
+
+module TileKit
+  class Icon
+    attr_reader :image, :size
+    
+    def initialize(path, size, peak_position, clickable_area)
+      @image = GD2::Image.import("images/gas.png")
+      @size_x, @size_y = size
+      @peak_x, @peak_y = peak_position
+      @shift_x, @shift_y, @width, @height = clickable_area
+    end
+    
+    def draw(canvas, x, y)
+      # position icon at peak point
+      x, y = x - @peak_x, y - @peak_y
+      
+      # copy image
+      canvas.copy_from(@image, x, y, 0, 0, @size_x, @size_y)
+    end
+    
+    def bounding_box(lat, lng, zoom)
+      top, left = MapKit.shift_latlng(lat, lng, @shift_x - @peak_x, @shift_y - @peak_y, zoom)
+      bottom, right = MapKit.shift_latlng(top, left, @width, @height, zoom)
+      MapKit::BoundingBox.new(top, left, bottom, right, zoom)
+    end
+  end
+  
+  class Image
+    attr_reader :canvas, :bounding_box
+    
+    def initialize(bounding_box)
+      @bounding_box = bounding_box
+      
+      # create image canvas
+      @canvas = GD2::Image.new(MapKit::TILE_SIZE, MapKit::TILE_SIZE)
+
+      # make image transparent
+      @canvas.save_alpha = true
+      @canvas.draw do |context|
+        context.color = GD2::Color::TRANSPARENT
+        context.fill
+      end
+    end
+    
+    # draw icon at position
+    def draw_icon(point, icon)
+      x, y = point.pixel(@bounding_box)
+      icon.draw(@canvas, x, y)
+    end
+    
+    def png
+      @canvas.png
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: mapkit
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Vincent Landgraf
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-10 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: gd2
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: |-
+  MapKit is an set of helpers to assist building tiles for
+    the google maps web client
+email: 
+- vincent.landgraf@inovex.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/google_local.rb
+- lib/mapkit.rb
+- lib/tilekit.rb
+- LICENSE
+- README.markdown
+has_rdoc: true
+homepage: http://github.com/threez/mapkit
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.5
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: MapKit helps rendering tiles for google maps
+test_files: []
+