mormon 1.0.2 → 2.0.0

data/README.md

@@ -13,8 +13,50 @@ Usage
 - Notes:
   - trasnports: must be one in [:cycle, :car, :train, :foot, :horse]
   - node_start and node_end must be node ids
-  
+
+Caching
+=======
+
+You probably wants to cache the parsed osm file:
+      
+      osm_loader = Mormon::OSM::Loader.new "path/to/filename.osm", :cache => true   
+
+The previous code generate a filename.pstore file and it's stored in Dir.tmpdir, "mormon", "cache" depending of your so, if you need to change the cache dir try ie:
+      
+      cache_dir = File.join File.dirname(__FILE__), "cache"
+      Mormon::OSM::Loader.cache_dir = cache_dir
+      osm_loader = Mormon::OSM::Loader.new "path/to/file.osm", :cache => true
+
+
+Routing algorithm
+=======
+
+The default algorithm is A* with weights, but a Random algorithm is available, it traces a random route from start to end:
+
+      osm_loader = Mormon::OSM::Loader.new "path/to/file.osm"
+      osm_router = Mormon::OSM::Router.new osm_loader, :algorithm => :random
+      osm_router.find_route node_start, node_end, transport
+
+Breadth in Ramdom algorithm
+-----
+
+The programming technique to find a random route is Backtracking, so in order to don't loop forever we need to narrow the search in neighbors, for that reason i use a breadth value combined with distance between start and end nodes:
+      
+      max_amplitude = @breadth * distance(start, end)
+
+The default breadth value is 2 but you could change it doing one of:
+    
+      osm_router = Mormon::OSM::Router.new osm_loader, :algorithm => :random, :breadth => 1.5
+      or
+      osm_router.algorithm.breath = 2.5
+
 License
 =======
 
-- WTFYW License
+Copyright (c) 2012 Hugo Gerónimo Díaz
+
+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/lib/mormon.rb

@@ -1,3 +1,4 @@
+require "mormon/string_ex"
 require "mormon/version"
 require "mormon/weight"
 require "mormon/tile_name"

data/lib/mormon/osm_loader.rb

@@ -240,52 +240,6 @@ module Mormon
           }[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

@@ -1,51 +1,47 @@
 module Mormon
   module OSM
-    class Router
-      # attr_reader :data
+    
+    module Algorithm
+      class Base
+        def initialize(router, options = {})
+          @router = router
+          @queue = []
+        end
 
-      def initialize(loader)
-        @loader = loader
-      end
+        def route(node_start, node_end, transport)
+          raise "subclass responsability"
+        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]
+        def enqueue(*args)
+          raise "subclass responsability"
+        end
 
-        lat1, lon1 = node1[:lat], node1[:lon]
-        lat2, lon2 = node2[:lat], node2[:lon]
-        
-        # TODO: projection issues
-        dlat  = lat2 - lat1
-        dlon  = lon2 - lon1
+        private
 
-        Math.sqrt dlat**2 + dlon**2
-      end
+          # Calculate distance between two nodes via pitagoras c**2 = a**2 + b**2
+          def distance(n1, n2)
+            node1, node2 = @router.loader.nodes[n1.to_s], @router.loader.nodes[n2.to_s]
 
-      def find_route(node_start, node_end, transport)
-        result, nodes = route(node_start.to_i, node_end.to_i, transport.to_sym)
-        
-        return [result,[]] if result != 'success'
-        
-        nodes.map! do |node|
-          data = @loader.nodes[node.to_s]
-          [data[:lat], data[:lon]]
-        end
+            lat1, lon1 = node1[:lat], node1[:lon]
+            lat2, lon2 = node2[:lat], node2[:lon]
+            
+            dlat  = lat2 - lat1
+            dlon  = lon2 - lon1
 
-        [result, nodes]
+            Math.sqrt dlat**2 + dlon**2
+          end
       end
 
-      private
+      # A* Algorithm
+      class Astar < Base
 
         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 = []
+          return "no_such_transport" unless @router.loader.routing[transport]
+          return "no_such_node"      unless @router.loader.routing[transport][node_start.to_s]
 
           # 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)
+          @router.loader.routing[transport][node_start.to_s].each do |neighbor, weight|
+            enqueue(node_start, neighbor.to_i, node_end, { node_end: nil, distance: 0, nodes: [node_start] }, weight)
           end
 
           closed = [node_start]
@@ -63,22 +59,19 @@ module Mormon
 
             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]
+            @router.loader.routing[transport][x.to_s].each do |node, weight|
+              enqueue(x, node.to_i, node_end, next_item, weight) unless closed.include?(node.to_i)
+            end if @router.loader.routing[transport][x.to_s]
           end
 
           'gave_up'
         end
         
-        def add_to_queue(node_start, node_end, current_queue, weight = 1)
+        def enqueue(node_start, node_end, node_finish, 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 }
+          return if @queue.any? { |other| other[:node_end] == node_end }
 
           distance = distance(node_start, node_end)
           
@@ -92,15 +85,87 @@ module Mormon
 
           queue_item = {
             distance:     current_distance + distance,
-            max_distance: current_distance + distance(node_end, @_end),
+            max_distance: current_distance + distance(node_end, node_finish),
             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
+          ix = @queue.find_index { |other| other[:max_distance] > queue_item[:max_distance] } || -1
+          @queue.insert(ix, queue_item)
         end
+      end
+
+      class Random < Base
+
+        attr_accessor :breadth
+
+        def initialize(router, options = {})
+          super
+          @breadth = options[:breadth] || 2
+        end
+
+        def route(node_start, node_end, transport)
+          max_amplitude = @breadth * distance(node_start, node_end)
+          enqueue node_start, node_end, transport, [node_start], [], max_amplitude
+          @queue.any? ? ["success", @queue[rand(@queue.size-1)]] : ["no_route", []]
+        end
+
+        def enqueue(node_start, node_end, transport, current_route, visited, max_amplitude)
+          current_route ||= []
+          visited       ||= []
+
+          if node_start == node_end
+            @queue << current_route.dup
+          else
+            visited << node_start
+            neighbors = @router.loader.routing[transport][node_start.to_s]
+
+            if neighbors
+              neighbors   = neighbors.keys.map(&:to_i)
+              not_visited = neighbors - (neighbors & visited)
+              
+              # random sort in order to not take the same order for neighbors every time.
+              not_visited.sort_by { rand }.each do |neighbor|
+                # limit the width of the route go further more than max_distance the distance between start and end
+                next if distance(neighbor, node_end) > max_amplitude 
+                current_route << neighbor
+                enqueue neighbor, node_end, transport, current_route, visited, max_amplitude
+                current_route.delete neighbor
+              end
+            end
+            
+            visited.delete node_start
+          end
+        end
+
+      end
+    end
+
+
+    class Router
+      attr_reader :loader, :queue, :algorithm
+
+      def initialize(loader, options = {})
+        algorithm = options.delete(:algorithm) || :astar
+        algorithm_class = "Mormon::OSM::Algorithm::#{algorithm.to_s.capitalize}".constantize
+        
+        @loader = loader
+        @algorithm = algorithm_class.new self, options
+      end
+
+      def find_route(node_start, node_end, transport)
+        result, nodes = @algorithm.route(node_start.to_i, node_end.to_i, transport.to_sym)
+        
+        return [result,[]] if result != 'success'
+        
+        nodes.map! do |node|
+          data = @loader.nodes[node.to_s]
+          [data[:lat], data[:lon]]
+        end
+
+        [result, nodes]
+      end
 
     end
   end

data/lib/mormon/string_ex.rb

@@ -0,0 +1,12 @@
+class String
+  def constantize
+    names = self.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+    end
+    constant
+  end
+end

data/lib/mormon/version.rb

@@ -1,3 +1,3 @@
 module Mormon
-  VERSION = "1.0.2"
+  VERSION = "2.0.0"
 end

data/spec/loader_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'mormon'
+
+def spec_osm_file
+  File.join File.dirname(__FILE__), "spec.osm"
+end
+
+describe Mormon::OSM::Loader do
+  def common_specs(loader)
+    loader.nodes.keys.size.should eq 534
+    loader.ways.keys.size.should  eq 135
+    
+    loader.routing[:cycle].keys.size.should eq 240
+    loader.routing[:car].keys.size.should   eq 240
+    loader.routing[:train].keys.size.should eq 0
+    loader.routing[:foot].keys.size.should  eq 281
+    loader.routing[:horse].keys.size.should eq 216
+  end
+
+  describe "whitout cache" do
+    before :each do
+      @loader = Mormon::OSM::Loader.new spec_osm_file
+    end
+
+    it "should load the correct data" do
+      common_specs @loader
+    end
+
+    it "should has the correct nodes" do
+      map = { "448193026" => 1, "448193243" => 1, "448193220" => 1, "318099173" => 1 }
+      @loader.routing[:foot]["448193024"].should eq(map)
+    end
+  end
+
+  describe "with cache" do
+    it "should exists the cached version" do
+      @loader = Mormon::OSM::Loader.new spec_osm_file, :cache => true
+      File.exists?(@loader.cache_filename).should eq true
+      File.zero?(@loader.cache_filename).should eq false
+    end
+
+    it "should let change the cache dir" do
+      cache_dir = File.join File.dirname(__FILE__), "..", "cache"
+      Mormon::OSM::Loader.cache_dir = cache_dir
+      @loader = Mormon::OSM::Loader.new spec_osm_file, :cache => true
+      cache_filename = File.join Mormon::OSM::Loader.cache_dir, File.basename(spec_osm_file) + ".pstore"
+      @loader.cache_filename.should eq cache_filename
+    end
+
+    it "should have stored the same data" do
+      @without_cache = Mormon::OSM::Loader.new spec_osm_file
+      @with_cache    = Mormon::OSM::Loader.new spec_osm_file, :cache => true
+
+      common_specs @without_cache
+      common_specs @with_cache
+
+      @without_cache.nodes.should eq @with_cache.nodes
+      @without_cache.ways.should  eq @with_cache.ways
+      @without_cache.routing.should eq @with_cache.routing
+      @without_cache.routeable_nodes.should eq @with_cache.routeable_nodes
+    end
+
+  end
+
+end

data/spec/{mormon_spec.rb → router_spec.rb}

@@ -1,104 +1,10 @@
 require 'spec_helper'
 require 'mormon'
 
-describe Mormon::Weight do
-  it "get (transport, way type) must to return a value" do
-    Mormon::Weight.get(:car, :primary).should eq(2)
-  end
-end
-
-describe Mormon::Tile::Data do
-  before :each do
-    @tiledata = Mormon::Tile::Data.new :reset_cache => true
-  end
-
-  it "download a tile should not work at the moment" do
-    @tiledata.get_osm(15, 16218, 10741).should match(/Tile not found/)
-  end
-end
-
-describe Mormon::Tile::Name do
-  before :each do
-    @tilename = Mormon::Tile::Name.new
-  end
-
-  it "should return the correct xy coordinates" do
-    @tilename.xy(51.50610, -0.119888, 16).should eq([32746, 21792])
-  end
-
-  it "should return the correct edges" do
-    x, y = @tilename.xy(51.50610, -0.119888, 16)
-    @tilename.edges(x, y, 16).should eq([51.505323411493336, -0.120849609375, 51.50874245880333, -0.1153564453125])
-  end
-
-  it "should return the correct url for the tile" do
-    @tilename.url(51.50610, -0.119888, 16, :tah).should eq("http://a.tile.openstreetmap.org/16/51/0.png")
-  end
-end
-
 def spec_osm_file
   File.join File.dirname(__FILE__), "spec.osm"
 end
 
-describe Mormon::OSM::Loader do
-  def common_specs(loader)
-    loader.nodes.keys.size.should eq 534
-    loader.ways.keys.size.should  eq 135
-    
-    loader.routing[:cycle].keys.size.should eq 240
-    loader.routing[:car].keys.size.should   eq 240
-    loader.routing[:train].keys.size.should eq 0
-    loader.routing[:foot].keys.size.should  eq 281
-    loader.routing[:horse].keys.size.should eq 216
-  end
-
-  describe "whitout cache" do
-    before :each do
-      @loader = Mormon::OSM::Loader.new spec_osm_file
-    end
-
-    it "should load the correct data" do
-      common_specs @loader
-    end
-
-    it "should has the correct nodes" do
-      map = { "448193026" => 1, "448193243" => 1, "448193220" => 1, "318099173" => 1 }
-      @loader.routing[:foot]["448193024"].should eq(map)
-    end
-  end
-
-  describe "with cache" do
-    it "should exists the cached version" do
-      @loader = Mormon::OSM::Loader.new spec_osm_file, :cache => true
-      File.exists?(@loader.cache_filename).should eq true
-      File.zero?(@loader.cache_filename).should eq false
-    end
-
-    it "should let change the cache dir" do
-      cache_dir = File.join File.dirname(__FILE__), "..", "cache"
-      Mormon::OSM::Loader.cache_dir = cache_dir
-      @loader = Mormon::OSM::Loader.new spec_osm_file, :cache => true
-      cache_filename = File.join Mormon::OSM::Loader.cache_dir, File.basename(spec_osm_file) + ".pstore"
-      @loader.cache_filename.should eq cache_filename
-    end
-
-    it "should have stored the same data" do
-      @without_cache = Mormon::OSM::Loader.new spec_osm_file
-      @with_cache    = Mormon::OSM::Loader.new spec_osm_file, :cache => true
-
-      common_specs @without_cache
-      common_specs @with_cache
-
-      @without_cache.nodes.should eq @with_cache.nodes
-      @without_cache.ways.should  eq @with_cache.ways
-      @without_cache.routing.should eq @with_cache.routing
-      @without_cache.routeable_nodes.should eq @with_cache.routeable_nodes
-    end
-
-  end
-
-end
-
 describe Mormon::OSM::Router do
   it "should find the route if the params are strings" do
     @loader = Mormon::OSM::Loader.new spec_osm_file
@@ -134,6 +40,32 @@ describe Mormon::OSM::Router do
     ]
   end
 
+  it "should support random algorithm" do
+    @loader = Mormon::OSM::Loader.new spec_osm_file
+    @router = Mormon::OSM::Router.new @loader, :algorithm => :random
+    
+    response, route = @router.find_route 448193311, 448193334, :car
+    response.should eq "success"
+    route.size.should be > 1
+  end
+
+  it "should support change the breadth of random algorithm" do
+    @loader = Mormon::OSM::Loader.new spec_osm_file
+    @router = Mormon::OSM::Router.new @loader, :algorithm => :random
+    
+    @router.algorithm.breadth = 1
+    response, route = @router.find_route 448193311, 448193334, :car
+    response.should eq "success"
+    route.size.should be > 1
+
+    @router.algorithm.breadth = 3
+    response1, route1 = @router.find_route 448193311, 448193334, :car
+    response1.should eq "success"
+    route1.size.should be > 1
+
+    route.should_not eq route1
+  end
+
   describe "with tandil.osm map" do
 
     before :each do

data/spec/tile_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'mormon'
+
+describe Mormon::Tile::Data do
+  before :each do
+    @tiledata = Mormon::Tile::Data.new :reset_cache => true
+  end
+
+  xit "download a tile doesn't work at this moment because there is some wrong with the tiles url" do
+    @tiledata.get_osm(15, 16218, 10741).should match(/Tile not found/)
+  end
+end
+
+describe Mormon::Tile::Name do
+  before :each do
+    @tilename = Mormon::Tile::Name.new
+  end
+
+  it "should return the correct xy coordinates" do
+    @tilename.xy(51.50610, -0.119888, 16).should eq([32746, 21792])
+  end
+
+  it "should return the correct edges" do
+    x, y = @tilename.xy(51.50610, -0.119888, 16)
+    @tilename.edges(x, y, 16).should eq([51.505323411493336, -0.120849609375, 51.50874245880333, -0.1153564453125])
+  end
+
+  it "should return the correct url for the tile" do
+    @tilename.url(51.50610, -0.119888, 16, :tah).should eq("http://a.tile.openstreetmap.org/16/51/0.png")
+  end
+end

data/spec/weight_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'mormon'
+
+describe Mormon::Weight do
+  it "get (transport, way type) must to return a value" do
+    Mormon::Weight.get(:car, :primary).should eq(2)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mormon
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-05 00:00:00.000000000 Z
+date: 2012-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -75,15 +75,19 @@ files:
 - lib/mormon.rb
 - lib/mormon/osm_loader.rb
 - lib/mormon/osm_router.rb
+- lib/mormon/string_ex.rb
 - lib/mormon/tile_data.rb
 - lib/mormon/tile_name.rb
 - lib/mormon/version.rb
 - lib/mormon/weight.rb
 - mormon.gemspec
-- spec/mormon_spec.rb
+- spec/loader_spec.rb
+- spec/router_spec.rb
 - spec/spec.osm
 - spec/spec_helper.rb
 - spec/tandil.osm
+- spec/tile_spec.rb
+- spec/weight_spec.rb
 homepage: https://github.com/geronimod/mormon
 licenses: []
 post_install_message: 
@@ -110,7 +114,10 @@ specification_version: 3
 summary: ! 'OSM Routing with some extra features: reset tiles cache and random routes.
   It''s based on Pyroute library.'
 test_files:
-- spec/mormon_spec.rb
+- spec/loader_spec.rb
+- spec/router_spec.rb
 - spec/spec.osm
 - spec/spec_helper.rb
 - spec/tandil.osm
+- spec/tile_spec.rb
+- spec/weight_spec.rb