mormon 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+.rvmrc
+cache
+lib/mormon/cache

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mormon.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    mormon (0.0.1)
+      nokogiri
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    columnize (0.3.6)
+    debugger (1.2.0)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.1.1)
+      debugger-ruby_core_source (~> 1.1.3)
+    debugger-linecache (1.1.2)
+      debugger-ruby_core_source (>= 1.1.1)
+    debugger-ruby_core_source (1.1.3)
+    diff-lcs (1.1.3)
+    nokogiri (1.5.5)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  debugger
+  mormon!
+  rspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Geronimo Diaz
+
+MIT License
+
+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.md

@@ -0,0 +1,20 @@
+Mormon
+======
+
+OSM Routing in Ruby, based on pyroutelib2
+
+Usage
+=====
+
+      osm_loader = Mormon::OSM::Loader.new "path/to/file.osm"
+      osm_router = Mormon::OSM::Router.new osm_loader
+      osm_router.find_route node_start, node_end, transport
+
+- Notes:
+  - trasnports: must be one in [:cycle, :car, :train, :foot, :horse]
+  - node_start and node_end must be node ids
+  
+License
+=======
+
+- WTFYW License

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/mormon/osm_loader.rb

@@ -0,0 +1,229 @@
+require 'nokogiri'
+
+module Mormon
+  module OSM
+    class Loader
+      attr_reader :options, :routing, :nodes, :ways, :tiles, :routeable_nodes, :route_types
+
+      def initialize(filename, options = {})
+        @options = options
+
+        @tiles = {}
+        @nodes = {}
+        @ways  = {}
+        
+        @routing = {}
+        @routeable_nodes = {}
+        @route_types = [:cycle, :car, :train, :foot, :horse]
+
+        @route_types.each do |type|
+          @routing[type] = {}
+          @routeable_nodes[type] = {}
+        end
+
+        # @tilename  = Mormon::Tile::Name.new
+        # @tiledata  = Mormon::Tile::Data.new
+
+        parse filename
+      end
+
+      def parse(filename)
+        puts "Loading %s.." % filename
+        
+        if !File.exists?(filename)
+          print "No such data file %s" % filename
+          return false
+        end
+        
+        osm = Nokogiri::XML(File.open(filename))
+
+        load_nodes osm
+        load_ways osm
+      end
+
+      def report
+        report = "Loaded %d nodes,\n" % @nodes.keys.size
+        report += "%d ways, and...\n" % @ways.keys.size
+        
+        @route_types.each do |type|
+          report += " %d %s routes\n" % [@routing[type].keys.size, type]
+        end
+
+        report
+      end
+
+      private
+
+        def load_nodes(nokosm)
+          nokosm.css('node').each do |node|
+            node_id = node[:id]
+            
+            @nodes[node_id] = {
+              lat: node[:lat].to_f,
+              lon: node[:lon].to_f,
+              tags: {}
+            }
+            
+            node.css('tag').each do |t|
+              k,v = t[:k].to_sym, t[:v]
+              @nodes[node_id][:tags][k] = v unless useless_tags.include?(k)
+            end
+          end
+        end
+
+        def load_ways(nokosm)
+          nokosm.css('way').each do |way|
+            way_id = way[:id]
+            
+            @ways[way_id] = {
+              nodes: way.css('nd').map { |nd| nd[:ref] },
+              tags: {}
+            }
+            
+            way.css('tag').each do |t|
+              k,v = t[:k].to_sym, t[:v]
+              @ways[way_id][:tags][k] = v unless useless_tags.include?(k)
+            end
+
+            store_way @ways[way_id]
+          end
+        end
+
+        def useless_tags
+          [:created_by]
+        end
+    
+        def way_access(highway, railway)
+          access = {}
+          access[:cycle] = [:primary, :secondary, :tertiary, :unclassified, :minor, :cycleway, 
+                            :residential, :track, :service].include? highway.to_sym
+          
+          access[:car]   = [:motorway, :trunk, :primary, :secondary, :tertiary, 
+                            :unclassified, :minor, :residential, :service].include? highway.to_sym
+          
+          access[:train] = [:rail, :light_rail, :subway].include? railway.to_sym
+          access[:foot]  = access[:cycle] || [:footway, :steps].include?(highway.to_sym)
+          access[:horse] = [:track, :unclassified, :bridleway].include? highway.to_sym
+          access
+        end
+
+        def store_way(way)
+          tags = way[:tags]
+          
+          highway    = equivalent tags.fetch(:highway, "")
+          railway    = equivalent tags.fetch(:railway, "")
+          oneway     = tags.fetch(:oneway, "")
+          reversible = !['yes','true','1'].include?(oneway)
+          
+          access = way_access highway, railway
+          
+          # Store routing information
+          last = -1
+          way[:nodes].each do |node|
+            if last != -1
+              @route_types.each do |route_type|
+                if access[route_type]
+                  weight = Mormon::Weight.get route_type, highway.to_sym
+                  add_link(last, node, route_type, weight)
+                  add_link(node, last, route_type, weight) if reversible || route_type == :foot
+                end  
+              end
+            end
+            last = node
+          end
+        end
+
+        def routeable_from(node, route_type)
+          @routeable_nodes[route_type][node] = 1
+        end
+
+        def add_link(fr, to, route_type, weight = 1)
+          routeable_from fr, route_type
+          return if @routing[route_type][fr].keys.include?(to)
+          @routing[route_type][fr][to] = weight
+        rescue
+          @routing[route_type][fr] = { to => weight }
+        end
+
+        def way_type(tags)
+          # Look for a variety of tags (priority order - first one found is used)
+          [:highway, :railway, :waterway, :natural].each do |type|
+            value = tags.fetch(type, '')
+            return equivalent(value) if value
+          end
+          nil
+        end
+
+        def equivalent(tag)
+          { 
+            primary_link:   "primary",
+            trunk:          "primary",
+            trunk_link:     "primary",
+            secondary_link: "secondary",
+            tertiary:       "secondary",
+            tertiary_link:  "secondary",
+            residential:    "unclassified",
+            minor:          "unclassified",
+            steps:          "footway",
+            driveway:       "service",
+            pedestrian:     "footway",
+            bridleway:      "cycleway",
+            track:          "cycleway",
+            arcade:         "footway",
+            canal:          "river",
+            riverbank:      "river",
+            lake:           "river",
+            light_rail:     "railway"
+          }[tag.to_sym] || tag
+        end
+      
+        # def find_node(lat, lon, route_type)
+        #   # find the nearest node that can be the start of a route
+        #   load_area(lat, lon)
+          
+        #   max_dist   = 1E+20
+        #   node_found = nil
+        #   pos_found  = nil
+          
+        #   rnodes.values.each do |node_id, pos|
+        #     dy = pos[0] - lat
+        #     dx = pos[1] - lon
+        #     dist = dx * dx + dy * dy
+            
+        #     if dist < maxDist
+        #       max_dist = dist
+        #       node_found = node_id
+        #       pos_found = pos
+        #     end
+            
+        #     node_found
+        #   end
+        # end
+        
+        # @unused: load the specific area instead an osm file
+        # def load_area(lat, lon)
+        #   if options[:file]
+        #     puts "The %s file was already loaded" % options[:file]
+        #     return
+        #   end
+          
+        #   # Download data in the vicinity of a lat/long
+        #   z = Mormon::Tile::Data.download_level
+        #   (x,y) = @tilename.xy(lat, lon, z)
+
+        #   tile_id = '%d,%d' % [x, y]
+          
+        #   return if @tiles[tile_id]
+          
+        #   @tiles[tile_id] = true
+          
+        #   filename = @tiledata.get_osm(z, x, y)
+        #   # print "Loading %d,%d at z%d from %s" % (x,y,z,filename)
+          
+        #   parse filename
+        # end
+    
+    end
+  end
+end
+

data/lib/mormon/osm_router.rb

@@ -0,0 +1,107 @@
+module Mormon
+  module OSM
+    class Router
+      # attr_reader :data
+
+      def initialize(loader)
+        @loader = loader
+      end
+
+      # Calculate distance between two nodes via pitagoras c**2 = a**2 + b**2
+      def distance(n1, n2)
+        node1, node2 = @loader.nodes[n1.to_s], @loader.nodes[n2.to_s]
+
+        lat1, lon1 = node1[:lat], node1[:lon]
+        lat2, lon2 = node2[:lat], node2[:lon]
+        
+        # TODO: projection issues
+        dlat  = lat2 - lat1
+        dlon  = lon2 - lon1
+
+        Math.sqrt dlat**2 + dlon**2
+      end
+
+      def find_route(node_start, node_end, transport)
+        result, nodes = route(node_start, node_end, transport)
+        
+        return [result,[]] if result != 'success'
+        
+        nodes.map! do |node|
+          data = @loader.nodes[node.to_s]
+          [data[:lat], data[:lon]]
+        end
+
+        [result, nodes]
+      end
+
+      private
+
+        def route(node_start, node_end, transport)
+          return "no_such_transport" unless @loader.routing[transport]
+          return "no_such_node"      unless @loader.routing[transport][node_start.to_s]
+
+          @_end  = node_end
+          @queue = []
+
+          # Start by queueing all outbound links from the start node
+          @loader.routing[transport][node_start.to_s].each do |neighbor, weight|
+            add_to_queue(node_start, neighbor, { node_end: nil, distance: 0, nodes: [node_start] }, weight)
+          end
+
+          closed = [node_start]
+          
+          # Limit for how long it will search
+          (0..10000).each do
+            next_item = @queue.shift
+            return "no_route" unless next_item
+
+            x = next_item[:node_end]
+            next if closed.include?(x)
+              
+            # Found the end node - success
+            return ['success', next_item[:nodes]] if x == node_end
+
+            closed << x
+
+            @loader.routing[transport][x.to_s].each do |node, weight|
+              add_to_queue(x, node, next_item, weight) unless closed.include?(node)
+            end if @loader.routing[transport][x.to_s]
+          end
+
+          'gave_up'
+        end
+        
+        def add_to_queue(node_start, node_end, current_queue, weight = 1)
+          # Add another potential route to the queue
+          
+          node_start = node_start.to_i
+          node_end   = node_end.to_i
+          
+          # if already in queue
+          @queue.each { |other| return if other[:node_end] == node_end }
+
+          distance = distance(node_start, node_end)
+          
+          return if weight.zero?
+          distance = distance / weight
+          
+          # Create a hash for all the route's attributes
+          current_distance = current_queue[:distance]
+          nodes = current_queue[:nodes].dup
+          nodes << node_end
+
+          queue_item = {
+            distance:     current_distance + distance,
+            max_distance: current_distance + distance(node_end, @_end),
+            nodes:        nodes,
+            node_end:     node_end
+          }
+          
+          # Try to insert, keeping the queue ordered by decreasing worst-case distance
+          found = @queue.find { |other| other[:max_distance] > queue_item[:max_distance] }
+          found ? @queue.insert(@queue.index(found), queue_item) : @queue << queue_item
+        end
+
+    end
+  end
+end

data/lib/mormon/tile_data.rb

@@ -0,0 +1,67 @@
+require 'open-uri'
+require 'fileutils'
+
+module Mormon
+  module Tile
+    class Data
+      TILE_DIR = 'cache/%d/%d/%d'
+      TILE_URL = 'http://dev.openstreetmap.org/~ojw/api/?/map/%d/%d/%d'
+
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def self.download_level
+        # All primary downloads are done at a particular zoom level
+        15
+      end
+
+      def get_osm(z, x, y)
+        # Download OSM data for the region covering a slippy-map tile
+        if x < 0 or y < 0 or z < 0 or z > 25
+          puts "Disallowed %d,%d at %d" % [x, y, z]
+          return
+        end
+        
+        directory = TILE_DIR % [z,x,y]
+        FileUtils.mkdir_p(directory) unless Dir.exists?(directory)
+        
+        if z == Data.download_level
+          url = TILE_URL % [z,x,y]
+          filename = '%s/data.osm' % directory
+
+          # puts "URL: %s" % url
+          # puts "filename: %s" % filename
+
+          # download the data
+          if options[:reset_cache] || !File.exists?(filename)
+            begin
+              open(url) do |content|
+                File.new(filename) { |f| f.write content }
+              end
+              filename
+            rescue OpenURI::HTTPError
+              "Tile not found in #{url}"
+            end
+          end
+          
+        elsif z > Data.download_level
+          # use larger tile
+          while z > Data.download_level
+            z = z - 1
+            x = (x / 2).to_i
+            y = (y / 2).to_i
+          end
+          get_osm z, x, y
+        end
+
+      end
+
+    end
+  end
+end
+
+# tile = Mormon::Tile::Data.new :reset_cache => true
+# puts tile.get_osm(15, 16218, 10741)

data/lib/mormon/tile_name.rb

@@ -0,0 +1,112 @@
+module Mormon
+  module Tile
+    class Name
+
+      # "http://cassini.toolserver.org:8080/"
+      # "http://a.tile.openstreetmap.org/"
+      # "http://toolserver.org/~cmarqu/hill/",
+      # "http://tah.openstreetmap.org/Tiles/tile/"
+      LAYERS_URL = {
+        tah:    "http://a.tile.openstreetmap.org/",
+        oam:    "http://oam1.hypercube.telascience.org/tiles/1.0.0/openaerialmap-900913/",
+        mapnik: "http://tile.openstreetmap.org/mapnik/"
+      }
+
+      def edges(x, y, z)
+        lat1, lat2 = lat_edges(y, z)
+        lon1, lon2 = lon_edges(x, z)
+        [lat2, lon1, lat1, lon2] # S,W,N,E
+      end
+
+      def px_size
+        256
+      end
+
+      def layer_ext(layer)
+        layer == 'oam' ? 'jpg' : 'png'
+      end
+
+      def layer_base(layer)
+        LAYERS_URL[layer]
+      end
+
+      def url(x, y, z, layer = :mapnik)
+        "%s%d/%d/%d.%s" % [layer_base(layer), z, x, y, layer_ext(layer)]
+      end
+
+      def xy(lat, lon, z)
+        x, y = latlon_2_xy(lat, lon, z)
+        [x.to_i, y.to_i]
+      end
+
+      def xy_2_latlon(x, y, z)
+        n = num_tiles(z)
+        rel_y = y / n
+        lat = mercator_to_lat(Math::PI * (1 - 2 * rel_y))
+        lon = -180.0 + 360.0 * x / n
+        [lat, lon]
+      end
+
+
+      private
+
+      def num_tiles(z)
+        2 ** z.to_f
+      end
+
+      def sec(x)
+        1 / Math.cos(x)
+      end
+
+      def latlon_2_relative_xy(lat,lon)
+        x = (lon + 180) / 360
+        y = (1 - Math.log(Math.tan(to_radians(lat)) + sec(to_radians(lat))) / Math::PI) / 2
+        [x,y]
+      end
+
+      def to_radians(degrees)
+        degrees * Math::PI / 180
+      end
+
+      def to_degrees(radians)
+        radians * 180 / Math::PI
+      end
+
+      def latlon_2_xy(lat, lon, z)
+        n = num_tiles(z)
+        x, y = latlon_2_relative_xy(lat, lon)
+        [n * x, n * y]
+      end
+        
+      def mercator_to_lat(mercator_y)
+        to_degrees Math.atan(Math.sinh(mercator_y))
+      end
+        
+      def lat_edges(y, z)
+        n = num_tiles(z)
+        unit = 1 / n
+        rel_y1 = y * unit
+        rel_y2 = rel_y1 + unit
+        lat1 = mercator_to_lat(Math::PI * (1 - 2 * rel_y1))
+        lat2 = mercator_to_lat(Math::PI * (1 - 2 * rel_y2))
+        [lat1, lat2]
+      end
+
+      def lon_edges(x, z)
+        n = num_tiles(z)
+        unit = 360 / n
+        lon1 = -180 + x * unit
+        lon2 = lon1 + unit
+        [lon1, lon2]
+      end
+    end
+  end
+end
+
+# tile = Mormon::Tile::Name.new
+
+# (0..16).each do |z|
+#   x, y = tile.xy 51.50610, -0.119888, z
+#   s, w, n, e = tile.edges(x, y, z)
+#   # puts tile.url(x,y,z, :tah)
+# end

data/lib/mormon/version.rb

@@ -0,0 +1,3 @@
+module Mormon
+  VERSION = "0.0.2"
+end

data/lib/mormon/weight.rb

@@ -0,0 +1,32 @@
+module Mormon
+  class Weight
+    # Represents an hipotetical velocity of the transport in the way type
+    @weightings = {
+      motorway:     { car: 10 },
+      trunk:        { car: 10, cycle: 0.05 },
+      primary:      { cycle: 0.3, car: 2, foot: 1, horse: 0.1 },
+      secondary:    { cycle: 1, car: 1.5, foot: 1, horse: 0.2 },
+      tertiary:     { cycle: 1, car: 1, foot: 1, horse: 0.3 },
+      unclassified: { cycle: 1, car: 1, foot: 1, horse: 1 },
+      minor:        { cycle: 1, car: 1, foot: 1, horse: 1 },
+      cycleway:     { cycle: 3, foot: 0.2 },
+      residential:  { cycle: 3, car: 0.7, foot: 1, horse: 1 },
+      track:        { cycle: 1, car: 1, foot: 1, horse: 1, mtb: 3 },
+      service:      { cycle: 1, car: 1, foot: 1, horse: 1 },
+      bridleway:    { cycle: 0.8, foot: 1, horse: 10, mtb: 3 },
+      footway:      { cycle: 0.2, foot: 1 },
+      steps:        { foot: 1, cycle: 0.3 },
+      rail:         { train: 1 },
+      light_rail:   { train: 1 },
+      subway:       { train: 1 }
+    }
+
+    def self.weightings
+      @weightings
+    end
+
+    def self.get(transport, way_type)
+      @weightings[way_type] && @weightings[way_type][transport]
+    end
+  end
+end

data/lib/mormon.rb

@@ -0,0 +1,7 @@
+require "mormon/version"
+require "mormon/weight"
+require "mormon/tile_name"
+require "mormon/tile_data"
+require "mormon/osm_loader"
+require "mormon/osm_router"
+

data/mormon.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mormon/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "mormon"
+  gem.version       = Mormon::VERSION
+  gem.authors       = ["Geronimo Diaz"]
+  gem.email         = ["geronimod@gmail.com"]
+  gem.description   = %q{ OSM Router }
+  gem.summary       = %q{ OSM Routing with some extra features: reset tiles cache and random routes. It's based on Pyroute library. }
+  gem.homepage      = "https://github.com/geronimod/mormon"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.rubyforge_project = "mormon"
+  
+  gem.add_dependency "nokogiri"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "debugger"
+end