parosm 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+cache/
+.rvmrc
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 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,34 @@
+# Parosm
+
+Simple OSM parser. Extracted from [Mormon](https://github.com/geronimod/mormon) to reuse. It include nodes, ways and simple routing information between nodes.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'parosm'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install parosm
+
+## Usage
+
+loader = Parosm::Loader.new osm_file
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+See [LICENSE.txt](LICENSE.txt)

data/Rakefile

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

data/lib/parosm.rb

@@ -0,0 +1,3 @@
+require "parosm/loader"
+require "parosm/weight"
+

data/lib/parosm/loader.rb

@@ -0,0 +1,243 @@
+require "parosm/version"
+
+require 'nokogiri'
+require 'tmpdir'
+
+module Parosm
+  class Loader
+    
+    @route_types = [:cycle, :car, :train, :foot, :horse]
+    @cache_dir   = File.join Dir.tmpdir, "parosm", "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
+
+    def initialize(filename, options = {})
+      @options = options
+
+      @tiles = {}
+      @nodes = {}
+      @ways  = {}
+      
+      @routing = {}
+      @routeable_nodes = {}
+
+      Loader.route_types.each do |type|
+        @routing[type] = {}
+        @routeable_nodes[type] = {}
+      end
+
+      @osm_filename = filename
+      @options[:cache] ? load_cached : parse
+    end
+
+    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
+
+      report
+    end
+
+    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
+
+          store.transaction(true) do
+            @tiles = store[:tiles]
+            @nodes = store[:nodes]
+            @ways  = store[:ways]
+            @tiles = store[:tiles]
+
+            Loader.route_types.each do |type|
+              @routing[type]         = store[:routing][type]
+              @routeable_nodes[type] = store[:routeable_nodes][type]
+            end
+          end
+        
+        else
+          puts "Parsing %s..." % @osm_filename
+          parse
+
+          puts "Creating cache %s..." % store.path
+          store.transaction do
+            store[:tiles] = @tiles
+            store[:nodes] = @nodes
+            store[:ways]  = @ways  
+            store[:tiles] = @tiles
+
+            store[:routing]         = {}
+            store[:routeable_nodes] = {}
+
+            Loader.route_types.each do |type|
+              store[:routing][type]         = @routing[type]
+              store[:routeable_nodes][type] = @routeable_nodes[type]
+            end
+          end
+        end
+
+      end
+
+      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
+        load_ways osm
+      end
+
+      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
+            Loader.route_types.each do |route_type|
+              if access[route_type]
+                weight = Parosm::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",
+          living_street:  "unclassified"
+        }[tag.to_sym] || tag
+      end
+    
+  end
+end
+

data/lib/parosm/version.rb

@@ -0,0 +1,3 @@
+module Parosm
+  VERSION = "0.0.1"
+end

data/lib/parosm/weight.rb

@@ -0,0 +1,32 @@
+module Parosm
+  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/parosm.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'parosm/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "parosm"
+  gem.version       = Parosm::VERSION
+  gem.authors       = ["Geronimo Diaz"]
+  gem.email         = ["geronimod@gmail.com"]
+  gem.description   = %q{ OSM Parser }
+  gem.summary       = %q{ Simple ruby OSM data parser }
+  gem.homepage      = ""
+
+  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 = "parosm"
+  
+  gem.add_dependency "nokogiri"
+  gem.add_development_dependency "rspec"
+
+end

data/spec/parosm_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'parosm'
+
+def spec_osm_file
+  File.join File.dirname(__FILE__), "spec.osm"
+end
+
+describe Parosm::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 = Parosm::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 = Parosm::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"
+      Parosm::Loader.cache_dir = cache_dir
+      @loader = Parosm::Loader.new spec_osm_file, :cache => true
+      cache_filename = File.join Parosm::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 = Parosm::Loader.new spec_osm_file
+      @with_cache    = Parosm::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