active_road 0.0.2 → 0.0.3

data/db/migrate/20120419093427_add_kind_to_physical_roads.rb

@@ -2,8 +2,8 @@ class AddKindToPhysicalRoads < ActiveRecord::Migration
   def change
     add_column :physical_roads, :kind, :string
 
-    ActiveRoad::PhysicalRoad.reset_column_information
-    ActiveRoad::PhysicalRoad.update_all :kind => "road"
+    #ActiveRoad::PhysicalRoad.reset_column_information
+    #ActiveRoad::PhysicalRoad.update_all :kind => "road"
 
     add_index :physical_roads, :kind
   end

data/db/migrate/20140206091734_create_boundaries.rb

@@ -0,0 +1,16 @@
+class CreateBoundaries < ActiveRecord::Migration
+
+  def change
+    create_table :boundaries do |t|
+      t.string :objectid
+      t.string :name
+      t.integer :admin_level
+      t.string :postal_code
+      t.string :insee_code
+      t.multi_polygon :geometry, :srid => ActiveRoad.srid
+    end
+    
+    add_index :boundaries, :geometry, :spatial => true
+  end
+     
+end

data/db/migrate/20140210132933_add_attributes_to_physical_road.rb

@@ -0,0 +1,9 @@
+class AddAttributesToPhysicalRoad < ActiveRecord::Migration
+  def change
+    add_column :physical_roads, :car, :boolean
+    add_column :physical_roads, :bike, :boolean
+    add_column :physical_roads, :train, :boolean
+    add_column :physical_roads, :pedestrian, :boolean
+    add_column :physical_roads, :name, :string    
+  end
+end

data/db/migrate/20140219095521_add_boundary_id_to_logical_road.rb

@@ -0,0 +1,5 @@
+class AddBoundaryIdToLogicalRoad < ActiveRecord::Migration
+  def change
+    add_column :logical_roads, :boundary_id, :integer
+  end
+end

data/db/migrate/20140228072448_add_boundary_id_to_physical_road.rb

@@ -0,0 +1,5 @@
+class AddBoundaryIdToPhysicalRoad < ActiveRecord::Migration
+  def change
+    add_column :physical_roads, :boundary_id, :integer
+  end
+end

data/db/migrate/20140304141150_add_marker_to_physical_road.rb

@@ -0,0 +1,5 @@
+class AddMarkerToPhysicalRoad < ActiveRecord::Migration
+  def change
+    add_column :physical_roads, :marker, :integer, :default => 0
+  end
+end

data/db/migrate/20140310083550_add_tags_to_street_number.rb

@@ -0,0 +1,5 @@
+class AddTagsToStreetNumber < ActiveRecord::Migration
+  def change
+    add_column :street_numbers, :tags, :hstore
+  end
+end

data/db/migrate/20140317153437_add_index_to_conditionnal_costs.rb

@@ -0,0 +1,6 @@
+class AddIndexToConditionnalCosts < ActiveRecord::Migration
+  def change
+    add_index :physical_road_conditionnal_costs, :physical_road_id
+    add_index :junction_conditionnal_costs, :junction_id
+  end
+end

data/db/migrate/20140602160047_add_physical_road_index_to_junctions_physical_road.rb

@@ -0,0 +1,5 @@
+class AddPhysicalRoadIndexToJunctionsPhysicalRoad < ActiveRecord::Migration
+  def change
+    add_index :junctions_physical_roads, [:physical_road_id]
+  end
+end

data/lib/active_road.rb

@@ -1,5 +1,13 @@
 require "active_road/engine"
 require 'erb'
+require 'saxerator'
+require "activerecord-postgres-hstore"
+require "enumerize"
+require "pbf_parser"
+require "postgis_adapter"
+require "georuby-ext"
+require 'snappy'
+require 'postgres-copy'
 
 module ActiveRoad
 
@@ -15,5 +23,3 @@ end
 
 require "active_road/shortest_path"
 require "active_road/shortest_path/finder"
-
-

data/lib/active_road/engine.rb

@@ -3,7 +3,10 @@ module ActiveRoad
     require "active_road/migration"
 
     class Engine < ::Rails::Engine
-
+      config.generators do |g|
+        g.test_framework :rspec
+      end
+      
       initializer "active_road.factories", :after => "factory_girl.set_factory_paths" do
         FactoryGirl.definition_file_paths << File.expand_path('../../../spec/factories', __FILE__) if defined?(FactoryGirl)
       end

data/lib/active_road/shortest_path/finder.rb

@@ -17,24 +17,22 @@ require 'shortest_path/finder'
 
 class ActiveRoad::ShortestPath::Finder < ShortestPath::Finder
 
-  attr_accessor :speed, :physical_road_filter, :follow_way_filter, :user_weights
+  attr_accessor :speed, :physical_road_filter, :follow_way_filter, :user_weights, :request_conditionnal_costs_linker, :constraints
 
-  def initialize(departure, arrival, speed = 4, constraints = {}, user_weights = {})    
+  def initialize(departure, arrival, speed = 4, constraints = [], follow_way_filter = {})    
     super departure, arrival
     @speed = speed * 1000 / 3600 # Convert speed in meter/second
-    @follow_way_filter, @physical_road_filter = {}, {}
-    constraints.each do |key, value|
-      if key == :uphill || key == :downhill || key == :height
-        @follow_way_filter[key] = value # filter to use with follow_way? method     
-      else
-        @physical_road_filter[key] = value  # filter to use with physical_roads
-      end
-    end
-    @user_weights = user_weights # Not used
+    @constraints = constraints
+    @follow_way_filter = follow_way_filter
+    @steps = 0
+  end
+
+  def request_conditionnal_costs_linker
+    @request_conditionnal_costs_linker ||= ActiveRoad::RequestConditionnalCostLinker.new(constraints)
   end
 
   def destination_accesses 
-    @destination_accesses ||= ActiveRoad::AccessPoint.to(destination, physical_road_filter)
+    @destination_accesses ||= ActiveRoad::AccessPoint.to(destination)
   end  
 
   # Return a time in second from node to destination
@@ -63,23 +61,18 @@ class ActiveRoad::ShortestPath::Finder < ShortestPath::Finder
     path_weights += path_weight(path.length_in_meter) if path.respond_to?(:length_in_meter)
     
     # Add junction weight if it's a junction with a waiting constraint
-    if path.class != GeoRuby::SimpleFeatures::Point && path.departure.class == ActiveRoad::Junction && path.departure && path.departure.waiting_constraint
+    if !(GeoRuby::SimpleFeatures::Point === path)  && ActiveRoad::Junction === path.departure && path.departure.waiting_constraint
       path_weights += path.departure.waiting_constraint
     end
-    
-    # TODO Refactor user weights
-    # if path.respond_to?(:road) # PhysicalRoad only no AccessLink
-    #   path_tags = path.road.tags
-    
-    #   user_weights.each do |key, value|
-    #     if path_tags.keys.include? key
-    #       min, max, percentage = value[0], value[1], value[2]
-      #       if min <= path_tags[key].to_i && path_tags[key].to_i <= max
-    #         path_weights += path_weight(path_length, percentage)
-    #       end                    
-    #     end
-    #   end
-    # end      
+
+    # Add physical road weight if it's a physical road
+    physical_road = path.physical_road if ActiveRoad::Path === path
+    physical_road_conditionnal_costs = physical_road.physical_road_conditionnal_costs if physical_road
+
+    if physical_road && physical_road_conditionnal_costs
+      cc_percentage = request_conditionnal_costs_linker.conditionnal_costs_sum(physical_road_conditionnal_costs)
+      path_weights += path_weight(path.length_in_meter, cc_percentage) if path.respond_to?(:length_in_meter)
+    end
     
     path_weights
   end 
@@ -89,15 +82,7 @@ class ActiveRoad::ShortestPath::Finder < ShortestPath::Finder
   end
   
   def geometry
-    @geometry ||= GeoRuby::SimpleFeatures::LineString.merge path.collect { |n| n.to_geometry }.select { |g| GeoRuby::SimpleFeatures::LineString === g }
-  end
-
-  # Use to profile code
-  def self.example
-    from = (ENV['FROM'] or "30.030238,-90.061541")
-    to = (ENV['TO'] or "29.991739,-90.06918")
-
-    ActiveRoad::ShortestPath::Finder.new GeoRuby::SimpleFeatures::Point.from_lat_lng(from), GeoRuby::SimpleFeatures::Point.from_lat_lng(to)
+    @geometry ||= GeoRuby::SimpleFeatures::LineString.merge path.collect{ |n| n.to_geometry }.select{ |g| GeoRuby::SimpleFeatures::LineString === g }
   end
 
   #-----------------------------------------
@@ -123,7 +108,7 @@ class ActiveRoad::ShortestPath::Finder < ShortestPath::Finder
     context_downhill = context[:downhill] ? context[:downhill] : 0
     context_height = context[:height] ? context[:height] : 0
 
-    if( node.class == ActiveRoad::Path )
+    if( ActiveRoad::Path === node )
       departure = node.departure
       physical_road = node.physical_road            
 
@@ -144,28 +129,34 @@ class ActiveRoad::ShortestPath::Finder < ShortestPath::Finder
     request = request && context[:uphill] <= follow_way_filter[:uphill] if follow_way_filter[:uphill] && context[:uphill].present?
     request = request && context[:downhill] <= follow_way_filter[:downhill] if follow_way_filter[:downhill] && context[:downhill].present?
     request = request && context[:height] <= follow_way_filter[:height] if follow_way_filter[:height] && context[:height].present?    
-    request = request && search_heuristic(node) + weight < time_heuristic(source) * 10
+    request = request && ( search_heuristic(node) + weight ) < ( time_heuristic(source) * 4 )
   end
 
-  def ways(node, context={})
+  def ways(node, context={})    
     paths =
       if GeoRuby::SimpleFeatures::Point === node
-        ActiveRoad::AccessLink.from(node, physical_road_filter)
+        # Search access to physical roads for departure
+        ActiveRoad::AccessLink.from(node)
       else
-        node.paths(physical_road_filter)
+        node.paths
       end
-    
-    unless GeoRuby::SimpleFeatures::Point === node # For the first point to access physical roads
+
+    # Search for each node if they have physical roads in common with arrival
+    # If true finish the trip and link to arrival
+    unless GeoRuby::SimpleFeatures::Point === node 
       destination_accesses.select do |destination_access|
-        if node.access_to_road?(destination_access.physical_road)
+        if node.access_to_road?(destination_access.physical_road) && !(ActiveRoad::AccessPoint === node.arrival)
           paths << ActiveRoad::Path.new(:departure => node.arrival, :arrival => destination_access, :physical_road => destination_access.physical_road)
         end
       end
     end
-
+    
     array = paths.collect do |path|
       [ path, path_weights(path)]
-    end
+    end       
+
+    @steps += 1
+    
     Hash[array]
   end
 

data/lib/active_road/simulation_tool.rb

@@ -0,0 +1,73 @@
+class ActiveRoad::SimulationTool
+    def self.sql_insert_junction( x, y)
+        x = (( x * 100000 ).to_i)/100000.0
+        y = (( y * 100000 ).to_i)/100000.0
+        "INSERT INTO junctions (objectid, created_at, updated_at, geometry) values ( '#{x}-#{y}', '2014-03-14 14:32:23.362164', '2014-03-14 14:32:23.362164', ST_geometryFromText('POINT( #{x} #{y})', 4326) );"
+    end
+    def self.sql_insert_physical_road( x1, y1, x2, y2)
+        x2 = (( x2 * 100000 ).to_i)/100000.0
+        y2 = (( y2 * 100000 ).to_i)/100000.0
+        x1 = (( x1 * 100000 ).to_i)/100000.0
+        y1 = (( y1 * 100000 ).to_i)/100000.0
+        "INSERT INTO physical_roads (objectid, created_at, updated_at, geometry) values ( '#{x1}-#{y1}-#{x2}-#{y2}', '2014-03-14 14:32:23.362164', '2014-03-14 14:32:23.362164', ST_geometryFromText('LINESTRING( #{x1} #{y1}, #{x2} #{y2})', 4326) );"
+    end
+    def self.save_simulated_square( size )
+        ActiveRoad::PhysicalRoad.connection.execute square_sqls( size ).join("\n")
+        ActiveRoad::PhysicalRoad.connection.execute relation_sqls.join("\n")
+    end
+
+
+    def self.square_sqls( size)
+        result = []
+        step = (1.0 / size)
+        index_x = 0
+        0.upto( size) do |i_x|
+            index_y = 0
+            0.upto( size) do |i_y|
+                result << sql_insert_junction( index_x, index_y)
+
+                if i_y < size
+                    result << sql_insert_physical_road( index_x, index_y, index_x, index_y+step)
+                end
+                if i_x < size
+                    result << sql_insert_physical_road( index_x, index_y, index_x+step, index_y)
+                end
+                index_y += step
+            end
+            index_x += step
+        end
+        result
+    end
+
+
+    def self.j_by_objectid
+        hash = {}
+        ActiveRoad::Junction.all.each do |j|
+            hash[ j.objectid ] = j.id
+        end
+        hash
+    end
+    def self.pr_by_objectid
+        hash = {}
+        ActiveRoad::PhysicalRoad.all.each do |pr|
+            hash[ pr.objectid ] = pr.id
+        end
+        hash
+    end
+    def self.relation_sqls
+        result = []
+        pr_h = pr_by_objectid
+        j_h = j_by_objectid
+        pr_h.keys.each do |pr_objectid|
+            parts = pr_objectid.split("-")
+            j_start_objectid = "#{parts[0]}-#{parts[1]}"
+            j_end_objectid = "#{parts[2]}-#{parts[3]}"
+
+            result << "INSERT INTO junctions_physical_roads ( physical_road_id, junction_id ) values ( #{pr_h[ pr_objectid ]}, #{j_h[ j_start_objectid ]} );"
+            result << "INSERT INTO junctions_physical_roads ( physical_road_id, junction_id ) values ( #{pr_h[ pr_objectid ]}, #{j_h[ j_end_objectid ]} );"
+        end
+        result
+    end
+
+
+end

data/lib/active_road/version.rb

@@ -1,3 +1,3 @@
 module ActiveRoad
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/tasks/activeroad_tasks.rake

@@ -1,4 +1,88 @@
-# desc "Explaining what the task does"
-# task :activeroad do
-#   # Task goes here
-# end
+# -*- coding: utf-8 -*-
+namespace :active_road do
+
+  desc 'This rebuilds environment db'
+  task :reset => :environment do 
+    Rake::Task["db:drop"].invoke
+    Rake::Task["db:create"].invoke
+    Rake::Task["db:migrate"].invoke
+  end
+
+  namespace :import do
+
+    # bundle exec rake "app:active_road:import:osm_pbf_data[/home/user/test.osm.pbf, true]"
+    desc "Import osm data from a pbf file"
+    task :osm_pbf_data, [:file, :split_ways] => [:environment] do |task, args|      
+      begin
+        puts "Import data from osm pbf file #{args.file} and with split_ways #{args.split_ways} with LevelDB"
+        raise "You should provide a valid osm file" if args.file.blank?
+        split_ways = args.split_ways == "true" ? true : false
+        ActiveRoad::OsmPbfImporterLevelDb.new(args.file, split_ways).import
+        puts "Completed import successfully."    
+      rescue => e
+        puts("Failed to import osm data : " + e.message)
+        puts e.backtrace.join("\n")
+      end    
+    end    
+
+    desc "Import terra data from a terra file"
+    task :terra_data, [:file] => [:environment] do |task, args|      
+      begin
+        puts "Import data from terra file #{args.file}"
+        raise "You should provide a valid osm file" if args.file.blank?
+        start = Time.now
+        ActiveRoad::TerraImporter.new(args.file).import
+        #puts "OSM import finished in #{(Time.now - start).strftime('%H:%M:%S')} seconds"
+        puts "Completed import successfully."    
+      rescue => e
+        puts("Failed to import terra data : " + e.message)
+        puts e.backtrace.join("\n")
+      end    
+    end
+
+  end
+  
+  task :itinerary, [:from, :to, :speed, :constraints] => [:environment] do |task, args|      
+    puts "Search an itinerary"
+    raise "You should provide arguments" if args.from.blank? || args.to.blank? || args.speed.blank?
+    start = Time.now
+    begin
+      finder = ActiveRoad::ShortestPath::Finder.new(args.from, args.to, args.speed, args.constraints).tap do |finder|
+        finder.timeout = 30.seconds
+      end
+      puts "Itinerary in json : #{finder.to_json}"
+    rescue => e
+      puts("Failed to find an itinerary : " + e.message)
+    end    
+    puts "Itinerary research finished in #{(Time.now - start)} seconds"
+  end
+
+#   nammespace :install do
+#     task :dependencies do
+#     end
+
+#     task :kyotocabinet, [:file] => [:environment] do |task, args|      
+#       sudo apt-get install -qq libgeos-dev libproj-dev postgresql-9.1-postgis liblzo2-dev liblzma-dev zlib1g-dev build-essential
+
+# # Se placer dans le dossier /tmp
+# cd /tmp
+
+# # Installer kyotocabinet
+# wget http://fallabs.com/kyotocabinet/pkg/kyotocabinet-1.2.76.tar.gz
+# tar xzf kyotocabinet-1.2.76.tar.gz
+# cd kyotocabinet-1.2.76
+# ./configure –enable-zlib –enable-lzo –enable-lzma --prefix=/usr && make
+# sudo make install
+
+# # Installer les bindings ruby pour kyotocabinet
+# cd /tmp
+# wget http://fallabs.com/kyotocabinet/rubypkg/kyotocabinet-ruby-1.32.tar.gz
+# tar xzf kyotocabinet-ruby-1.32.tar.gz
+# cd kyotocabinet-ruby-1.32
+# ruby extconf.rb
+# make
+# sudo make install
+#     end
+#   end
+
+end

data/script/benchmark_import_kyotocabinet.rb

@@ -0,0 +1,148 @@
+require 'kyotocabinet'
+include KyotoCabinet
+
+class Node
+  attr_accessor :id, :lon, :lat, :ways, :end_of_way
+  
+  def initialize(id, lon, lat, ways = [], end_of_way = false)
+    @id = id
+    @lon = lon
+    @lat = lat
+    @ways = ways
+    @end_of_way = end_of_way
+  end
+  
+  def add_way(id)
+    @ways << id
+  end
+  
+  def marshal_dump
+    [@id, @lon, @lat, @ways, @end_of_way]
+  end
+  
+  def marshal_load array
+    @id, @lon, @lat, @ways, @end_of_way = array
+  end
+end
+
+class KCImport  
+  
+  def initialize(rnum, database_path = "/tmp/test.kch", options = "")
+    @rnum = rnum
+    @database_path = database_path
+    @options = options
+  end
+
+  # def database
+  #   @database = DB::new
+  # end
+  
+  def memoryusage()
+    rss = -1
+    file = open('/proc/self/status')
+    file.each do |line|
+      if line =~ /^VmRSS:/
+        line.gsub!(/.*:\s*(\d+).*/, '\1')
+        rss = line.to_i / 1024.0
+        break
+      end
+    end
+    return rss
+  end
+
+  def import
+    DB::process(@database_path + @options, DB::OWRITER | DB::OCREATE | DB::OTRUNCATE) { |database|
+      
+      #GC.start
+      musage = memoryusage 
+      stime = Time.now
+      
+      (0...@rnum).each do |i|     
+        i_s = i.to_s
+        key = i_s
+        value = Marshal.dump(Node.new(i_s, rand, rand))
+        database[key] = value
+      end
+      
+      etime = Time.now
+      #GC.start
+      
+      printf("Count: %d\n", database.count)
+      printf("Time: %.3f sec.\n", etime - stime)
+      printf("Usage: %.3f MB\n", memoryusage - musage)
+      
+    }
+  end
+
+  def import_and_update
+    DB::process(@database_path + @options, DB::OWRITER | DB::OCREATE | DB::OTRUNCATE) { |database|
+      
+      #GC.start
+      musage = memoryusage 
+      stime = Time.now
+      
+      (0...@rnum).each do |i|     
+        i_s = i.to_s
+        key = i_s
+        value = Marshal.dump(Node.new(i_s, rand, rand))
+        database[key] = value
+      end
+
+      database.transaction {
+        (0...4000000).each do |way|
+          update_node_with_way(way, database)
+        end
+      }
+      
+      etime = Time.now
+      #GC.start
+      
+      printf("Count: %d\n", database.count)
+      printf("Time: %.3f sec.\n", etime - stime)
+      printf("Usage: %.3f MB\n", memoryusage - musage)
+      
+    }
+  end
+
+  def update_node_with_way(way, database)
+    way_id = way.to_s
+    nodes = [rand(6000000), rand(6000000), rand(6000000), rand(6000000), rand(6000000), rand(6000000), rand(6000000)]
+    
+    # Take only the first and the last node => the end of physical roads
+    node_ids = nodes.collect(&:to_s)  
+    
+    # Update node data with way id
+    database.accept_bulk(node_ids) { |key, value|
+      node = Marshal.load(value)
+      node.add_way(way_id)
+      node.end_of_way = true if [nodes.first.to_s, nodes.last.to_s].include?(node.id)
+      Marshal.dump(node)
+    }
+  end
+  
+end
+
+rnum = 6000000
+if ARGV.length > 0
+  rnum = ARGV[0].to_i
+end
+
+# if ARGV.length > 1
+#   database_path = ARGV[1]
+# end
+
+# import in KC without options
+puts "Import without options"
+KCImport.new(rnum, "/home/luc/import_without_options.kch").import
+
+# import in KC with options apow=8, opts=l, bnum=2000000 and msiz=50000000
+puts "\nImport with options apow=8, opts=l, bnum=2000000 and msiz=50000000"
+KCImport.new(rnum, "/home/luc/import_with_options.kch", "#apow=8#opts=l#bnum=2000000#msiz=50000000").import
+
+# import in KC without options
+puts "\nImport and update without options"
+KCImport.new(rnum, "/home/luc/import_without_options.kch").import_and_update
+
+# import in KC with options apow=8, opts=l, bnum=2000000 and msiz=50000000
+# puts "\nImport and update with options apow=8, opts=l, bnum=2000000 and msiz=50000000"
+# KCImport.new(rnum, "/home/luc/import_with_options.kch", "#apow=8#opts=l#bnum=2000000#msiz=50000000").import_and_update