mormon 2.0.0 → 2.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bc716b3e1ce51d7d6bc2da6aebd4015438b5998cfce3d08abcbfccbdf02e467f
+  data.tar.gz: 1fc718d5ec92bdc2ecb824f1c96c27e2fb2e611810ee1c12d5cb82fb69292d54
+SHA512:
+  metadata.gz: b8da4d1df4f858b633fcc476c042dceba19ccfde4c70ed689eb49a18f1f02b15027755084c21b1e8bb1f30ecc9875c9e1b299a5067902cfe113fbd2cd4669d03
+  data.tar.gz: 357cdddb94aff94615e355a5c6a5ce04d268e3695288d83c2f97d027b404cadf08489d8041b9548072240d09df91d57491ec4c5e8afb882fdaf07ce0eadd07f2

data/.gitignore

@@ -1,3 +1,5 @@
 .rvmrc
 cache
-lib/mormon/cache
+lib/mormon/cache
+.idea/*
+.*~

data/Gemfile.lock

@@ -1,20 +1,12 @@
 PATH
   remote: .
   specs:
-    mormon (0.0.1)
+    mormon (2.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)
@@ -30,6 +22,5 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  debugger
   mormon!
   rspec

data/README.md

@@ -3,26 +3,44 @@ Mormon
 
 OSM Routing in Ruby, based on pyroutelib2
 
-Usage
-=====
+Usage of OSM route
+==================
 
       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
+  - transports: must be one in [:cycle, :car, :train, :foot, :horse]
+  - node_start and node_end must be node ids associated with ways in osm (``<way ...> <nd ref="node_id"/</way>``)
+
+Usage of OSM distance optimizer
+================================
+
+      osm_loader = Mormon::OSM::Loader.new "path/to/file.osm"
+      osm_router = Mormon::OSM::Router.new osm_loader
+      route = osm_distance_optimizer.route_planer(*Array of Mormon::OSM::StopNode where at least node_id has value*, osm_loader)
+
+      - The route is a sorted array where each node is succeeded by the closest (not already visited). The stop nodes all have updated the distance value to represent the distance to the predecessor.
+      - The total distance of the route can be calculated by summing up all the distances
+
+- Notes
+  - All distances are measures in meters
+  - The calculation is not accurate:
+    - The calculation of latitude and longitude degrees are done by the algorithms from [http://en.wikipedia.org/wiki/Latitude](http://en.wikipedia.org/wiki/Latitude)
+    - The length of one degree is calculated as the average between latitude and longitude for simplicity as heading is not included. Which can be misleading in areas where the differences between these are high (close to the poles)
+    - In Denmark (11.000000,56.000000) this results in a margin of < 10 meters and together with gps-fixes this would be a estimated total of +/- 10%
+  - A route is considered an array of stops. The distance between stops (paths) is summed up by the distance between the OSM nodes.
 
 Caching
 =======
 
 You probably wants to cache the parsed osm file:
-      
-      osm_loader = Mormon::OSM::Loader.new "path/to/filename.osm", :cache => true   
+
+      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
@@ -37,15 +55,17 @@ The default algorithm is A* with weights, but a Random algorithm is available, i
       osm_router = Mormon::OSM::Router.new osm_loader, :algorithm => :random
       osm_router.find_route node_start, node_end, transport
 
-Breadth in Ramdom algorithm
+**KNOWN ISSUE**: the actual random algorithm has problems when the different between start and end is enough far, i'm working to fix it.
+
+Breadth in random 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
@@ -53,10 +73,4 @@ The default breadth value is 2 but you could change it doing one of:
 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.
+LICENSE.txt

data/lib/mormon/osm_distance_optimizer.rb

@@ -0,0 +1,128 @@
+module Mormon
+  module OSM
+    class StopNode
+      attr_accessor :node_id, :distance, :road, :house_number, :zip_code
+    end
+
+    class DistanceOptimizer
+      # encoding: UTF-8
+
+        # Takes an array of stops and computes an optimal route, so the stops are succeeded by the closest of the remaining.
+        def self.route_planer(stops, osm_loader)
+          @osm_loader = osm_loader
+
+          route = [stops]
+          route[0] = stops[0]
+          i = 0
+
+          # Iterates through the stops, adds the closest to the route and sets the stops with the start and the remaining stops
+          length = stops.length
+          while (i < length - 1)
+            stop, remaining_stops = find_next_stop(stops)
+            route.push stop
+            stops = remaining_stops
+            i = i + 1
+          end
+
+          return route
+        end
+
+        # Take an array of stops and return the closest stop with its distance in meters from the first way node in the array
+        def self.find_next_stop(stops)
+          sorted_stops = []
+          i = 0
+
+          # Sets the distance attribute of the stop_objects in the array
+          while (i < stops.length)
+            if (i == 0)
+              stops[i].distance = 0.0
+            else
+              stops[i].distance = route(stops[0].node_id,stops[i].node_id)
+            end
+            sorted_stops[i] = stops[i]
+            i = i + 1
+          end
+
+          sorted_stops.sort! { |a,b| a.distance <=> b.distance }
+
+          next_stop = sorted_stops[1]
+          sorted_stops.delete_at(1)
+
+          return next_stop, sorted_stops
+        end
+
+        # Calculates the distance of one part between two stops by using roads with a car
+        def self.route(from, to)
+          osm_router = Mormon::OSM::Router.new(@osm_loader)
+          route = osm_router.find_route(from, to, :car)
+          osm_loader =""       # Clears memory for osm data
+
+          # Puts error from finding way nodes
+          if  (route[0] != "success")
+            puts route[0]
+          end
+
+          return total_distance_calc(route[1]).round(2)
+        end
+
+        # Calculates the distance for this part by adding the distances between the way nodes in it
+        def self.total_distance_calc(distance_Array)
+          total_distance = 0.0
+          i = 0
+          latitude_1 = longitude_1 = latitude_2 = longitude_2  = 0.0
+
+          distance_Array.each {| point |
+            if (i == 0)
+              longitude_1 = point[0]
+              latitude_1 = point[1]
+              i = i + 1
+            elsif (i == 1)
+              longitude_2 = point[0]
+              latitude_2 = point[1]
+              total_distance = total_distance + distance_calc(latitude_1, longitude_1, latitude_2, longitude_2)
+              i = i + 1
+            elsif (i > 1)
+              longitude_1 = longitude_2
+              latitude_1 = latitude_2
+              longitude_2 = point[0]
+              latitude_2 = point[1]
+              total_distance = total_distance + distance_calc(latitude_1, longitude_1, latitude_2, longitude_2)
+              i = i + 1
+            end
+          }
+          return total_distance
+        end
+
+        # Calculates the distance between the coordinates of two way nodes in meters
+        def self.distance_calc(latitude_1, longitude_1, latitude_2, longitude_2)
+
+          difference_latitude  = latitude_2 - latitude_1
+          difference_longitude  = longitude_2 - longitude_1
+
+          result = Math.sqrt(difference_latitude**2 + difference_longitude**2)
+          latitude_longitude_length = latitude_longitude_length(difference_latitude, difference_longitude)
+          return result * latitude_longitude_length[2]
+        end
+
+        # Calculates the length in meters of one degree and returns an array of the results [0] = latitude degree, [1] = longitude degree, [2] average of these two
+        # The argument should represent the latitude the result shall reflect
+        # Inspired ny: http://en.wikipedia.org/wiki/Latitude :)
+        def self.latitude_longitude_length(latitude, longitude)
+          lat = latitude * ((2.0 * Math::PI)/360.0)
+          lon = longitude * ((2.0 * Math::PI)/360.0)
+
+          constant_1 = 111132.954
+          constant_2 = -559.822
+          constant_3 = 1.175
+          a = 6378137.0 # Earth radius
+          b = 6356752.3142 # Earth radius
+
+          #Calculate the length of a degree of latitude and longitude in meters
+          latitude_length = constant_1 + (constant_2 * Math.cos(2 * lat)) + (constant_3 * Math.cos(4 * lat))
+          longitude_length =  Math::PI * a * Math.cos(lon) / 180 * (1 - ((a - b) / a) ** 2 * Math.sin(lon) ** 2)**0.5
+
+          return latitude_length, longitude_length, (latitude_length + longitude_length)/2
+        end
+    end
+  end
+end

data/lib/mormon/osm_loader.rb

@@ -4,15 +4,15 @@ require 'tmpdir'
 module Mormon
   module OSM
     class Loader
-      
+
       @route_types = [:cycle, :car, :train, :foot, :horse]
       @cache_dir   = File.join Dir.tmpdir, "mormon", "cache"
-      
+
       class << self
         attr_reader   :route_types
         attr_accessor :cache_dir
       end
-      
+
       attr_reader :options, :routing, :nodes, :ways, :tiles, :routeable_nodes, :route_types,
                   :osm_filename
 
@@ -22,7 +22,7 @@ module Mormon
         @tiles = {}
         @nodes = {}
         @ways  = {}
-        
+
         @routing = {}
         @routeable_nodes = {}
 
@@ -41,7 +41,7 @@ module Mormon
       def report
         report = "Loaded %d nodes,\n" % @nodes.keys.size
         report += "%d ways, and...\n" % @ways.keys.size
-        
+
         Loader.route_types.each do |type|
           report += " %d %s routes\n" % [@routing[type].keys.size, type]
         end
@@ -52,18 +52,18 @@ module Mormon
       def cache_filename
         File.join Loader.cache_dir, File.basename(@osm_filename) + ".pstore"
       end
-      
+
       private
         def load_cached
           require "pstore"
-            
+
           store_path = cache_filename
 
           FileUtils.mkdir_p Loader.cache_dir
           FileUtils.touch store_path
-          
+
           store = PStore.new store_path
-          
+
           if !File.zero? store_path
             puts "Loading from cache %s..." % store.path
 
@@ -78,7 +78,7 @@ module Mormon
                 @routeable_nodes[type] = store[:routeable_nodes][type]
               end
             end
-          
+
           else
             puts "Parsing %s..." % @osm_filename
             parse
@@ -87,7 +87,7 @@ module Mormon
             store.transaction do
               store[:tiles] = @tiles
               store[:nodes] = @nodes
-              store[:ways]  = @ways  
+              store[:ways]  = @ways
               store[:tiles] = @tiles
 
               store[:routing]         = {}
@@ -104,12 +104,12 @@ module Mormon
 
         def parse
           puts "Loading %s.." % @osm_filename
-          
+
           if !File.exists?(@osm_filename)
             print "No such data file %s" % @osm_filename
             return false
           end
-          
+
           osm = Nokogiri::XML File.open(@osm_filename)
 
           load_nodes osm
@@ -119,13 +119,13 @@ module Mormon
         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)
@@ -136,12 +136,12 @@ module Mormon
         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)
@@ -154,31 +154,31 @@ module Mormon
         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[: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, :path].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|
@@ -188,7 +188,7 @@ module Mormon
                   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
             end
             last = node
@@ -207,17 +207,8 @@ module Mormon
           @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",
@@ -230,7 +221,6 @@ module Mormon
             driveway:       "service",
             pedestrian:     "footway",
             bridleway:      "cycleway",
-            track:          "cycleway",
             arcade:         "footway",
             canal:          "river",
             riverbank:      "river",
@@ -239,8 +229,6 @@ module Mormon
             living_street:  "unclassified"
           }[tag.to_sym] || tag
         end
-      
     end
   end
 end
-

data/lib/mormon/osm_router.rb

@@ -1,6 +1,5 @@
 module Mormon
   module OSM
-    
     module Algorithm
       class Base
         def initialize(router, options = {})
@@ -24,7 +23,7 @@ module Mormon
 
             lat1, lon1 = node1[:lat], node1[:lon]
             lat2, lon2 = node2[:lat], node2[:lon]
-            
+
             dlat  = lat2 - lat1
             dlon  = lon2 - lon1
 
@@ -45,7 +44,7 @@ module Mormon
           end
 
           closed = [node_start]
-          
+
           # Limit for how long it will search
           (0..10000).each do
             next_item = @queue.shift
@@ -53,7 +52,7 @@ module Mormon
 
             x = next_item[:node_end]
             next if closed.include?(x)
-              
+
             # Found the end node - success
             return ['success', next_item[:nodes]] if x == node_end
 
@@ -66,18 +65,18 @@ module Mormon
 
           'gave_up'
         end
-        
+
         def enqueue(node_start, node_end, node_finish, current_queue, weight = 1)
           # Add another potential route to the queue
-          
+
           # if already in queue
           return if @queue.any? { |other| 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
@@ -89,7 +88,7 @@ module Mormon
             nodes:        nodes,
             node_end:     node_end
           }
-          
+
           # Try to insert, keeping the queue ordered by decreasing worst-case distance
           ix = @queue.find_index { |other| other[:max_distance] > queue_item[:max_distance] } || -1
           @queue.insert(ix, queue_item)
@@ -124,17 +123,17 @@ module Mormon
             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 
+                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
@@ -144,21 +143,23 @@ module Mormon
 
 
     class Router
-      attr_reader :loader, :queue, :algorithm
+      attr_reader :loader
 
       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
+        @options = options
+
+        algorithm = @options.delete(:algorithm) || :astar
+        @algorithm_class = "Mormon::OSM::Algorithm::#{algorithm.to_s.capitalize}".constantize
       end
 
       def find_route(node_start, node_end, transport)
-        result, nodes = @algorithm.route(node_start.to_i, node_end.to_i, transport.to_sym)
-        
+        algorithm = @algorithm_class.new(self, @options)
+
+        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]]
@@ -166,7 +167,6 @@ module Mormon
 
         [result, nodes]
       end
-
     end
   end
-end
+end

data/lib/mormon/version.rb

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

data/lib/mormon/weight.rb

@@ -15,6 +15,7 @@ module Mormon
       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 },
+      path:         { foot: 1 },
       steps:        { foot: 1, cycle: 0.3 },
       rail:         { train: 1 },
       light_rail:   { train: 1 },

data/lib/mormon.rb

@@ -5,4 +5,6 @@ require "mormon/tile_name"
 require "mormon/tile_data"
 require "mormon/osm_loader"
 require "mormon/osm_router"
+require "mormon/osm_distance_optimizer"
+
 

data/mormon.gemspec

@@ -6,10 +6,10 @@ 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.author        = "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.summary       = %q{ OSM Routing with some extra features: reset tiles cache, random routes and distance optimizer for routes with several stops. It's based on Pyroute library. }
   gem.homepage      = "https://github.com/geronimod/mormon"
 
   gem.files         = `git ls-files`.split($/)
@@ -18,8 +18,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.rubyforge_project = "mormon"
-  
+
   gem.add_dependency "nokogiri"
   gem.add_development_dependency "rspec"
-  gem.add_development_dependency "debugger"
 end