mapcache 0.1.0

data/MIT-LICENCE

@@ -0,0 +1,7 @@
+Copyright (c) 2010 Valentine Bichkovsky
+
+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.rdoc

@@ -0,0 +1,31 @@
+= mapcache
+
+== Description
+
+Interactive GoogleMaps browser, caches all downloaded tiles on disk.
+
+== Install
+
+  gem install mapcache
+
+== Features
+
+* download map tiles as you browse the map
+* show tiles already on disk for (zoom + 1)..(zoom + 8)
+* export downloaded tiles in mgmaps[http://www.mgmaps.com] format
+
+== Usage
+
+* drag map to pan
+* mouse wheel - zoom in/out
+* m - toggle coverage
+* [] - coverage zoom in/out
+* e - export tiles to mgmaps
+
+== Files and directories
+
+config.yml - your settings are saved in this file
+
+<current dir>/maps - this is where map tiles are stored
+
+<current dir>/export - this is where export goes to

data/TODO

@@ -0,0 +1,21 @@
+- менять курсор в зависимости от действий пользователя, использовать "песочные часы" для длительных операций;
+
+--------------------------
+
+- возможность выделять области на карте и сохранять эти выделения. Область выделяется кистью в форме квадрата с привязкой к координатной сетке плиток. Размер квадрата можно менять (увеличивать и уменьшать в 2 раза, примерно как кисть в Фотошопе);
+
+- экспорт для выделенной области;
+
+- массовое скачивание плиток для выделенной области (возможно, с использованием прокси или с генерацией файла для другой программы скачивания);
+
+- отображение информации - сколько плиток в очереди на скачивание, сколько выделено, сколько потребуется скачать для текущего выделения, прогресс во время скачивания, сколько всего плиток есть для конкретного зума и т.п.
+
+--------------------------
+
+- поддержка различных карт, не только простых GoogleMaps;
+
+- хранение файлов плиток в одном большом файле (FUSE, tar, zip, ...);
+
+- запоминане отсутствующих плиток (404), чтобы не пытаться их каждый раз тянуть из сети. Можно отображать на карте другим цветом;
+
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/mapcache

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'wx'
+
+Dir[File.dirname(__FILE__) + '/../lib/*.rb'].each do |src|
+  require src
+end
+
+APP_VERSION = IO.read(File.dirname(__FILE__) + '/../VERSION')
+
+Wx::App.run { MapFrame.new }

data/lib/download_manager.rb

@@ -0,0 +1,45 @@
+require 'net/http'
+require 'thread'
+
+class DownloadManager
+
+  @queue = Queue.new
+  @thread = Thread.new do
+    loop do 
+      sleep if @queue.empty?
+      new_thread_from_queue
+    end
+  end
+
+  def self.enqueue(tile)
+    @queue << tile
+    @thread.run
+  end
+
+  def self.observer=(observer)
+    @observer = observer
+  end
+
+  private
+
+  def self.new_thread_from_queue
+    Thread.new do
+      tile = @queue.pop
+      dir = File.dirname(tile.path)
+      FileUtils.mkdir_p dir if !File.exist?(dir)
+      download(tile)
+      tile.load_image
+      @observer.tile_loaded(tile)
+    end
+  end
+
+  def self.download(tile)
+    uri = URI.parse(tile.url)
+    req = Net::HTTP::Get.new(uri.path, {"User-Agent" => "mapcache"})
+    res = Net::HTTP.new(uri.host).start {|http| http.request(req)}
+    if res.code == "200"
+      File.open(tile.path, 'wb') {|f| f.write(res.body)}
+    end
+  end
+
+end

data/lib/export_dialog.rb

@@ -0,0 +1,37 @@
+class ExportDialog < Wx::Dialog
+
+  def tiles_per_file
+    @tpf_choice.string_selection.to_i
+  end
+
+  def hash_size
+    @hs_choice.string_selection.to_i
+  end
+  
+  def initialize(parent)
+    super(parent, :title => 'Export')
+    grid = Wx::FlexGridSizer.new(2, 2, 5, 5)
+
+    label = Wx::StaticText.new(self, :label => "Tiles per file")
+    @tpf_choice = Wx::Choice.new(self, :choices => %w(1 8 16 32 64 256))
+    grid.add(label, 0, Wx::ALIGN_CENTER_VERTICAL|Wx::ALL, 5)
+    grid.add(@tpf_choice, 0, Wx::GROW|Wx::ALL, 5)
+    
+    label = Wx::StaticText.new(self, :label => "Hash size")
+    @hs_choice = Wx::Choice.new(self, :choices => %w(1 5 11 23 47 97))    
+    grid.add(label, 0, Wx::ALIGN_CENTER_VERTICAL|Wx::ALL, 5)
+    grid.add(@hs_choice, 0, Wx::GROW|Wx::ALL, 5)
+
+    sizer = Wx::BoxSizer.new(Wx::VERTICAL)
+    sizer.add(grid, 0, Wx::ALL, 5)
+    
+    button_sizer = create_button_sizer(Wx::OK|Wx::CANCEL)
+    sizer.add(button_sizer, 0, Wx::ALIGN_CENTER_VERTICAL|Wx::ALL, 5)
+
+    self.sizer = sizer
+    sizer.fit(self)
+
+    evt_choice(@tpf_choice) {|event| @hs_choice.string_selection = '1' if tiles_per_file != 1}
+    evt_choice(@hs_choice) {|event| @tpf_choice.string_selection = '1' if hash_size != 1}
+  end
+end

data/lib/map_frame.rb

@@ -0,0 +1,59 @@
+require 'yaml'
+
+class MapFrame < Wx::Frame
+
+  DEFAULT_CONFIG = {'width' => 512, 'height' => 512, 'left' => 0, 'top' => 0,
+    'map' => {'left_col' => 288, 'top_row' => 155, 'offset_x' => 0, 'offset_y' => 0, 
+      'zoom' => 9, 'show_cov' => true, 'cov_zoom' => 10} }
+
+  def initialize
+    config = load_config
+    super(nil, :title => "mapcache",
+          :pos => [config['left'], config['top']],
+          :size => [config['width'], config['height']] )
+
+    @status = Wx::StatusBar.new(self)
+    @status.fields_count = 3
+    @status.set_status_text("press F1 for help", 2)
+    self.status_bar = @status
+
+    box = Wx::HBoxSizer.new
+    @panel = MapPanel.new(self, config['map'])
+    box.add(@panel, 1, Wx::EXPAND)
+    self.sizer = box
+
+    evt_close do |event| 
+      save_config
+      destroy
+    end
+
+    show
+  end
+
+  def set_zoom(value)
+    @status.set_status_text("zoom: #{value}", 0)
+  end
+
+  def set_coverage_zoom(value)
+    text = value ? "coverage: #{value}" : ""
+    @status.set_status_text(text, 1)
+  end
+
+  private 
+
+  def load_config
+    File.exist?('config.yml') ? YAML::load_file('config.yml') : DEFAULT_CONFIG
+  end
+
+  def save_config
+    config = {
+      'left' => self.position.x,
+      'top' => self.position.y,
+      'width' => self.size.width,
+      'height' => self.size.height,
+      'map' => @panel.config
+    }
+   open('config.yml', 'w') { |f| YAML.dump(config, f) }
+  end
+
+end

data/lib/map_panel.rb

@@ -0,0 +1,140 @@
+class MapPanel < Wx::Panel
+  
+  def initialize(parent, config)
+    super(parent, :style => Wx::NO_BORDER)
+    @pan = false
+    DownloadManager.observer = self
+    @mgr = MatrixManager.new(self.size.width, self.size.height, config)
+
+    evt_paint {|event| draw_map}
+    
+    evt_size {|event| resize_map(event.size.width, event.size.height) }
+
+    evt_char do |event|
+      case event.key_code
+        when ?m : toggle_coverage
+        when ?[ : coverage_zoom_out
+        when ?] : coverage_zoom_in
+        when ?e : export_dialog
+        when Wx::K_F1: about_box
+      end
+    end
+
+    evt_left_down do |event| 
+      pan_start(event.x, event.y)
+      event.skip
+    end
+
+    evt_left_up {|event| pan_end}
+
+    evt_motion {|event| pan(event.x, event.y) }
+
+    evt_mousewheel do |event|
+      if event.wheel_rotation > 0
+        zoom_in(event.x, event.y)
+      else
+        zoom_out(event.x, event.y)
+      end
+    end
+
+    parent.set_zoom(@mgr.zoom)
+    parent.set_coverage_zoom(@mgr.cov_value)
+
+    set_focus
+  end
+
+  def config
+    @mgr.config
+  end
+
+  def tile_loaded(tile)
+    self.refresh
+  end
+
+  private
+
+  def draw_map
+    paint {|dc| @mgr.draw(dc) }
+  end
+
+  def toggle_coverage
+    draw_with_hourglass { @mgr.toggle_coverage }
+    parent.set_coverage_zoom(@mgr.cov_value)
+  end
+
+  def zoom_in(x, y)
+    draw_with_hourglass { @mgr.zoom_in(x, y) }
+    parent.set_zoom(@mgr.zoom)
+    parent.set_coverage_zoom(@mgr.cov_value)
+  end
+
+  def zoom_out(x, y)
+    draw_with_hourglass { @mgr.zoom_out(x, y) }
+    parent.set_zoom(@mgr.zoom)
+    parent.set_coverage_zoom(@mgr.cov_value)
+  end
+
+  def coverage_zoom_in
+    draw_with_hourglass { @mgr.coverage_zoom_in }
+    parent.set_coverage_zoom(@mgr.cov_value)
+  end
+
+  def coverage_zoom_out
+    draw_with_hourglass { @mgr.coverage_zoom_out }
+    parent.set_coverage_zoom(@mgr.cov_value)
+  end
+
+  def export_dialog
+    d = ExportDialog.new(parent)
+    if d.show_modal == Wx::ID_OK
+      MGMapsExport.export(d.tiles_per_file, d.hash_size)
+    end
+  end
+
+  def resize_map(width, height)
+    @mgr.resize(width, height)
+  end
+
+  def pan_start(x, y)
+    @pan = true
+    @start_x = x
+    @start_y = y
+  end
+
+  def pan_end
+    @pan = false
+  end
+
+  def pan(x, y)
+    if @pan
+      @mgr.pan(x - @start_x, y - @start_y)
+      @start_x = x
+      @start_y = y
+      draw_map
+    end
+  end
+
+  def draw_with_hourglass
+    self.cursor = Wx::HOURGLASS_CURSOR
+    yield
+    draw_map
+    self.cursor = Wx::NULL_CURSOR    
+  end
+
+  def about_box
+    box = Wx::AboutDialogInfo.new
+    box.name = "mapcache"
+    box.version = APP_VERSION
+    box.description = "
+      click and drag to pan
+      mouse wheel - zoom in/out
+      m - toggle coverage
+      [] - coverage zoom in/out
+      e - export to mgmaps
+      for more info visit http://wiki.github.com/vbichkovsky/mapcache/"
+    box.add_developer 'Valentine Bichkovsky'
+    box.web_site = "http://wiki.github.com/vbichkovsky/mapcache/"
+    Wx::about_box(box)
+  end
+
+end

data/lib/matrix_manager.rb

@@ -0,0 +1,189 @@
+TILE_WIDTH = 256
+MAX_ZOOM = 19
+MAX_ZOOM_DIFF = 8
+
+class MatrixManager
+  attr_reader :top_row, :left_col, :offset_x, :offset_y, :zoom, :show_cov, :cov_zoom
+
+  def initialize(width, height, config)
+    @show_cov = config['show_cov']
+    @cov_zoom = config['cov_zoom']
+    @zoom = config['zoom']
+    @left_col = config['left_col']
+    @top_row = config['top_row']
+    @offset_x = config['offset_x']
+    @offset_y = config['offset_y']
+    @width = width
+    @height = height
+    create_matrix
+  end
+
+  def config
+    result = {}
+    %w(left_col top_row offset_x offset_y zoom show_cov cov_zoom).each do |attr|
+      result[attr] = self.send(attr)
+    end
+    result
+  end
+
+  def zoom_in(x, y)
+    if @zoom < MAX_ZOOM
+      @zoom += 1
+      @cov_zoom = zoom + 1 if cov_zoom - zoom < 1 
+      @offset_x, @left_col = calc_start_and_offset_zoom_in(@left_col, x, @offset_x, @width)
+      @offset_y, @top_row = calc_start_and_offset_zoom_in(@top_row, y, @offset_y, @height)
+      create_matrix
+    end
+  end
+
+  def zoom_out(x, y)
+    if @zoom > 0
+      @zoom -= 1
+      @cov_zoom = zoom + MAX_ZOOM_DIFF if cov_zoom - zoom > MAX_ZOOM_DIFF
+      @offset_x, @left_col = calc_start_and_offset_zoom_out(@left_col, x, @offset_x, @width)
+      @offset_y, @top_row = calc_start_and_offset_zoom_out(@top_row, y, @offset_y, @height)
+      create_matrix
+    end
+  end
+
+  def draw(dc)
+    @matrix.each do |col, row, tile|
+      tile.draw(dc, TILE_WIDTH * (col - 1) + @offset_x, TILE_WIDTH * (row - 1) + @offset_y)
+    end
+  end
+
+  def toggle_coverage
+    @show_cov = !show_cov
+    recreate_coverage
+  end
+
+  def coverage_zoom_in
+    if cov_zoom - zoom < MAX_ZOOM_DIFF
+      @cov_zoom += 1
+      recreate_coverage
+    end
+  end
+
+  def coverage_zoom_out
+    if cov_zoom - zoom > 1
+      @cov_zoom -= 1
+      recreate_coverage
+    end
+  end
+
+  def pan(dx, dy)
+    @offset_x += dx
+    @offset_y += dy
+
+    if @offset_x < 0
+      @offset_x = TILE_WIDTH + @offset_x
+      @left_col += 1
+      @matrix.shift_left(get_tiles(:column, :last) )
+    elsif @offset_x >= TILE_WIDTH
+      @offset_x -= TILE_WIDTH
+      @left_col -= 1
+      @matrix.shift_right(get_tiles(:column, :first) )
+    end
+
+    if @offset_y < 0
+      @offset_y = TILE_WIDTH + @offset_y
+      @top_row += 1
+      @matrix.shift_up(get_tiles(:row, :last) )
+    elsif @offset_y >= TILE_WIDTH
+      @offset_y -= TILE_WIDTH
+      @top_row -= 1
+      @matrix.shift_down(get_tiles(:row, :first) )
+    end
+  end
+
+  def resize(viewport_width, viewport_height)
+    @width = viewport_width
+    @height = viewport_height
+    new_matrix_width = (viewport_width.to_f / TILE_WIDTH).ceil + 2
+    new_matrix_height = (viewport_height.to_f / TILE_WIDTH).ceil + 2
+    if new_matrix_width < @matrix.width || new_matrix_height < @matrix.height
+      @matrix.reduce(new_matrix_width, new_matrix_height)
+    else
+      if new_matrix_width > @matrix.width
+        (@left_col + @matrix.width..@left_col + new_matrix_width - 1).each do |col|
+          column = []
+          (@top_row..@top_row + @matrix.height - 1).each do |row|
+            column << get_tile(col, row, @zoom)
+          end
+          @matrix.add_column(column)
+        end
+      end
+      if new_matrix_height > @matrix.height
+        (@top_row + @matrix.height..@top_row + new_matrix_height - 1).each do |r|
+          row = []
+          (@left_col..@left_col + new_matrix_width - 1).each do |col|
+            row << get_tile(col, r, @zoom)
+          end
+          @matrix.add_row(row)
+        end
+      end
+    end
+  end
+
+  def cov_value
+    show_cov && cov_zoom
+  end
+
+  private
+
+  def calc_start_and_offset_zoom_in(start_idx, cursor_pos, offset, viewport_size)
+    middle_tile_idx = start_idx * 2 + 2 + (cursor_pos - offset).to_i / (TILE_WIDTH / 2)
+    from_edge = 2 * ( (cursor_pos - offset).to_i % (TILE_WIDTH / 2) )
+    calc_offset_and_first_idx(middle_tile_idx, viewport_size, from_edge)
+  end
+
+  def calc_start_and_offset_zoom_out(start_idx, cursor_pos, offset, viewport_size)
+    cursor_tile_idx = start_idx + (cursor_pos - offset).to_i / TILE_WIDTH + 1
+    middle_tile_idx = cursor_tile_idx / 2
+    from_edge = ( (cursor_pos - offset).to_i % TILE_WIDTH + 
+                  (cursor_tile_idx.even? ? 0 : TILE_WIDTH) ) / 2
+    calc_offset_and_first_idx(middle_tile_idx, viewport_size, from_edge)
+  end
+
+  def calc_offset_and_first_idx(middle_idx, viewport_size, from_tile_edge)
+    [ (viewport_size / 2 - from_tile_edge) % TILE_WIDTH,
+      middle_idx - ( (viewport_size / 2 - from_tile_edge) / TILE_WIDTH ) - 1 ]
+  end
+
+  def create_matrix
+    @matrix = TileMatrix.new
+    @matrix[0,0] = get_tile(@left_col, @top_row, @zoom)
+    resize(@width, @height)
+  end    
+
+  def get_tiles(what, which)
+    size = (what == :row ? @matrix.width - 1 : @matrix.height - 1)
+    col = @left_col
+    row = @top_row
+    if which == :last
+      what == :column ? col += @matrix.width - 1 : row += @matrix.height - 1
+    end
+    (0..size).map do |index|
+      get_tile(col + (what == :row ? index : 0),
+               row + (what == :column ? index : 0), @zoom)
+    end
+  end
+
+  def get_tile(col, row, zoom)
+    Tile.new(wraparound(col, zoom), wraparound(row, zoom), zoom, cov_value)
+  end
+
+  def wraparound(value, zoom)
+    max = 2 ** zoom
+    value = max - (value.abs % max) if value < 0
+    value = value % max if value >= max
+    value
+  end
+
+  def recreate_coverage
+    @matrix.each do |col, row, tile|
+      tile.create_coverage(show_cov && cov_zoom)
+    end
+  end
+
+end

data/lib/mgmaps_export.rb

@@ -0,0 +1,146 @@
+require 'pathname'
+
+class MGMapsExport
+
+  MAPS_ROOT = Pathname.new("maps")
+  EXPORT_ROOT = Pathname.new("export")
+
+  def self.export(tiles_per_file, hash_size)
+    if EXPORT_ROOT.exist?
+      error_dlg('Cannot export: export directory already exists!')
+      return
+    end
+
+    files = Dir['maps/*/*.mgm']
+
+    catch :cancelled do
+      if tiles_per_file > 1
+        export_as_mtpf(files, tiles_per_file)
+      elsif hash_size > 1
+        export_as_hashed(files, hash_size)
+      else
+        export_as_copy(files)
+      end
+
+      create_conf_file(tiles_per_file, hash_size)
+      success_msg
+    end
+  end
+
+  private
+
+  def self.error_dlg(msg)
+      Wx::MessageDialog.new(Wx::THE_APP.top_window, msg, 'Export',
+                            Wx::OK|Wx::ICON_ERROR).show_modal
+  end
+
+  def self.success_msg
+      Wx::MessageDialog.new(Wx::THE_APP.top_window, 'Export completed', 'Export',
+                            Wx::OK|Wx::ICON_INFORMATION).show_modal
+  end
+
+  def self.confirm(msg)
+      Wx::MessageDialog.new(Wx::THE_APP.top_window, msg, 'Export',
+                            Wx::YES_NO|Wx::ICON_QUESTION).show_modal == Wx::ID_YES
+  end
+
+  def self.create_conf_file(tiles_per_file, hash_size)
+    File.open('export/cache.conf', 'w') do |file|
+      file.puts "version=3"
+      file.puts "tiles_per_file=#{tiles_per_file}"
+      file.puts "hash_size=#{hash_size}"
+    end
+  end
+
+  def self.export_each_file(files)
+    progress = Wx::ProgressDialog.new('Export', 'Processing files...', 
+                                      files.size, Wx::THE_APP.top_window,
+                                      Wx::PD_AUTO_HIDE | Wx::PD_APP_MODAL | 
+                                      Wx::PD_CAN_ABORT | Wx::PD_REMAINING_TIME)
+    files_done = 0
+    files.each do |file|
+      yield file
+      files_done += 1
+      if !progress.update(files_done)
+        if confirm('Cancel export?') 
+          progress.destroy
+          throw :cancelled
+        else
+          progress.resume
+        end
+      end
+    end
+  end
+
+  def self.export_as_copy(files)
+    export_each_file(files) do |file|
+      src = Pathname.new(file)
+      dest = EXPORT_ROOT + src.relative_path_from(MAPS_ROOT)
+      FileUtils.mkdir_p dest.dirname
+      FileUtils.cp file, dest
+    end
+  end
+
+  def self.export_as_hashed(files, hash_size)
+    export_each_file(files) do |file|
+      src = Pathname.new(file)
+      x, y = src.basename('.mgm').to_s.split('_').map{|n| n.to_i}
+      subdir = Pathname.new( ((x * 256 + y) % hash_size).to_s )
+      zoomdir = src.relative_path_from(MAPS_ROOT).dirname
+      dest = EXPORT_ROOT + zoomdir + subdir + src.basename
+      FileUtils.mkdir_p dest.dirname
+      FileUtils.cp file, dest
+    end    
+  end
+
+  def self.export_as_mtpf(files, tiles_per_file)
+    tpf_x, tpf_y = tpf_xy(tiles_per_file)
+
+    export_each_file(files) do |file|
+      src = Pathname.new(file)
+      x, y = src.basename('.mgm').to_s.split('_').map{|n| n.to_i}
+      dest_x = x / tpf_x
+      dest_y = y / tpf_y
+      rel_x = x % tpf_x
+      rel_y = y % tpf_y
+
+      zoomdir = src.relative_path_from(MAPS_ROOT).dirname
+      dest = EXPORT_ROOT + zoomdir + Pathname.new("#{dest_x}_#{dest_y}.mgm")
+      blank_mtpf_file(dest, tiles_per_file) if !File.exists?(dest)
+      add_tile_to_file(src, dest, rel_x, rel_y)
+    end    
+  end
+
+  def self.tpf_xy(tpf)
+    log2 = (Math.log(tpf) / Math.log(2)).to_i
+    if log2.even?
+      tpf_x = Math.sqrt(tpf).to_i
+      tpf_y = tpf_x
+    else
+      tpf_x = Math.sqrt(tpf * 2).to_i
+      tpf_y = tpf_x / 2
+    end
+    [tpf_x, tpf_y]
+  end
+
+  def self.blank_mtpf_file(dest, tiles_per_file)
+    FileUtils.mkdir_p dest.dirname if !dest.dirname.exist?
+    File.open(dest, 'w') { |f| f.write 0.chr * (2 + 6 * tiles_per_file) }
+  end
+
+  def self.add_tile_to_file(src, dest, rel_x, rel_y)
+    File.open(dest, 'r+') do |file|
+      count = file.read(2).unpack('n').first + 1
+      file.seek(0, IO::SEEK_END)
+      file.write(IO.read(src))
+      pos = file.pos
+      file.rewind
+      file.write [count].pack('n')
+      file.pos = 2 + 6 * (count - 1)
+      file.write rel_x.chr
+      file.write rel_y.chr
+      file.write [pos].pack('N')
+    end
+  end
+
+end

data/lib/tile.rb

@@ -0,0 +1,82 @@
+require 'fileutils'
+
+class Tile
+  attr_reader :col, :row, :zoom
+  
+  def initialize(col, row, zoom, cov_zoom)
+    @col = col
+    @row = row
+    @zoom = zoom
+    if File.exist?(path)
+      load_image
+    else
+      DownloadManager.enqueue(self)
+    end
+    create_coverage(cov_zoom)
+  end
+
+  def create_coverage(cov_zoom)
+    if !cov_zoom
+      @mask = nil
+    else
+      @mask = Wx::Bitmap.new(TILE_WIDTH, TILE_WIDTH)
+      @mask.draw do |dc| 
+        dc.pen = Wx::TRANSPARENT_PEN
+        dc.brush = Wx::WHITE_BRUSH
+        dc.draw_rectangle(0, 0, TILE_WIDTH, TILE_WIDTH)
+        draw_subtiles(dc, cov_zoom)
+      end
+    end
+  end
+
+  def load_image
+    image = Wx::Image.new(path, Wx::BITMAP_TYPE_PNG)
+    @bitmap = Wx::Bitmap.from_image(image)
+  end
+
+  def draw(dc, x, y)
+    dc.pen = Wx::TRANSPARENT_PEN
+    dc.logical_function = Wx::COPY
+    if @bitmap
+      dc.draw_bitmap(@bitmap, x, y, false)
+    else
+      dc.brush = Wx::GREY_BRUSH
+      dc.draw_rectangle(x, y, TILE_WIDTH, TILE_WIDTH)
+    end
+    if @mask
+      dc.logical_function = Wx::AND
+      dc.draw_bitmap(@mask, x, y, false)
+    end
+  end
+
+  def url
+    server = (@col + 2 * @row) % 4
+    galileo = "Galileo"[0, (3 * @col + @row) % 8]
+    "http://mt#{server}.google.com/vt/lyrs=m@115&hl=en&x=#{@col}&y=#{@row}&z=#{@zoom}&s=#{galileo}"
+  end
+
+  def path
+    "maps/GoogleMap_#{zoom}/#{col}_#{row}.mgm"
+  end
+
+  private
+
+  def draw_subtiles(dc, cov_zoom)
+    dc.brush = Wx::GREEN_BRUSH
+    diff = cov_zoom - zoom
+    scale = 2 ** diff
+    Dir["maps/GoogleMap_#{cov_zoom}/*.mgm"].each do |file|
+      cov_col, cov_row = File.basename(file, '.mgm').split('_')
+      cov_col = cov_col.to_i
+      cov_row = cov_row.to_i
+      if ((cov_col / scale) == col) && ((cov_row / scale) == row)
+        subcol = cov_col % scale
+        subrow = cov_row % scale
+        dc.draw_rectangle(subcol * TILE_WIDTH / scale, 
+                          subrow * TILE_WIDTH / scale, 
+                          TILE_WIDTH / scale, TILE_WIDTH / scale)
+      end
+    end
+  end    
+
+end

data/lib/tile_matrix.rb

@@ -0,0 +1,73 @@
+class TileMatrix
+
+  def initialize
+    @columns = []
+  end
+
+  def [](col, row)
+    @columns[col][row]
+  end
+
+  def[]=(col, row, value)
+    @columns[col] ||= []
+    @columns[col][row] = value
+  end
+
+  def width
+    @columns.size
+  end
+
+  def height
+    @columns[0].size
+  end
+
+  def each
+    @columns.each_with_index do |row, col_idx|
+      row.each_with_index do |value, row_idx|
+        yield col_idx, row_idx, value
+      end
+    end
+  end
+
+  def shift_left(new_column)
+    @columns.shift
+    @columns.push(new_column)
+  end
+
+  def shift_right(new_column)
+    @columns.delete_at(@columns.length - 1)
+    @columns.unshift(new_column)
+  end
+
+  def shift_up(new_row)
+    @columns.each_with_index do |c, i|
+      c.shift
+      c.push(new_row[i])
+    end
+  end
+
+  def shift_down(new_row)
+    @columns.each_with_index do |c, i|
+      c.delete_at(c.length - 1)
+      c.unshift(new_row[i])
+    end
+  end
+
+  def reduce(width, height)
+    @columns.slice!(width..@columns.length - 1)
+    @columns.each do |c|
+      c.slice!(height..c.length - 1)
+    end
+  end
+
+  def add_column(new_column)
+    @columns << new_column
+  end
+
+  def add_row(new_row)
+    @columns.each_with_index do |c, i|
+      c << new_row[i]
+    end
+  end
+
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: mapcache
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Valentine Bichkovsky
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-04 00:00:00 +02:00
+default_executable: mapcache
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: wxruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.1
+    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: 
+email: valentin@livas.lv
+executables: 
+- mapcache
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- MIT-LICENCE
+- README.rdoc
+- TODO
+- VERSION
+- bin/mapcache
+- lib/download_manager.rb
+- lib/export_dialog.rb
+- lib/map_frame.rb
+- lib/map_panel.rb
+- lib/matrix_manager.rb
+- lib/mgmaps_export.rb
+- lib/tile.rb
+- lib/tile_matrix.rb
+has_rdoc: true
+homepage: http://wiki.github.com/vbichkovsky/mapcache/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Google Maps tile browser-downloader and manager
+test_files: []
+