active_road 0.0.2

data/config/database.yml.ci

@@ -0,0 +1,12 @@
+development: 
+  adapter: postgresql
+  database: activeroad
+  username: postgres
+  template: template_postgis
+
+test: 
+  adapter: postgresql
+  database: activeroad_test
+  username: postgres
+  template: template_postgis
+

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/db/init.sql

@@ -0,0 +1,6 @@
+create language plpgsql;
+
+\i /usr/share/postgresql-8.3-postgis/lwpostgis.sql;
+\i /usr/share/postgresql-8.3-postgis/spatial_ref_sys.sql;
+
+INSERT INTO spatial_ref_sys (srid, auth_name, auth_srid, srtext, proj4text)VALUES (900913,'EPSG',900913,'PROJCS["WGS84 / Simple Mercator",GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS_1984", 6378137.0, 298.257223563]],PRIMEM["Greenwich", 0.0],UNIT["degree", 0.017453292519943295],AXIS["Longitude", EAST],AXIS["Latitude", NORTH]],PROJECTION["Mercator_1SP_Google"],PARAMETER["latitude_of_origin", 0.0],PARAMETER["central_meridian", 0.0],PARAMETER["scale_factor", 1.0],PARAMETER["false_easting", 0.0],PARAMETER["false_northing", 0.0],UNIT["m", 1.0],AXIS["x", EAST],AXIS["y", NORTH],AUTHORITY["EPSG","900913"]]','+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs');

data/db/migrate/20110914160756_create_street_numbers.rb

@@ -0,0 +1,18 @@
+class CreateStreetNumbers < ActiveRoad::Migration
+  def self.up
+    create_table :street_numbers do |t|
+      t.string :number
+      t.float :location_on_road
+      t.belongs_to :physical_road
+      t.point :geometry, :srid => ActiveRoad.srid
+      t.timestamps
+    end
+
+    add_index :street_numbers, [:number, :physical_road_id]
+    add_index :street_numbers, :physical_road_id
+  end
+
+  def self.down
+    drop_table :street_numbers
+  end
+end

data/db/migrate/20120201114800_create_physical_roads.rb

@@ -0,0 +1,17 @@
+class CreatePhysicalRoads < ActiveRoad::Migration
+  def self.up
+    create_table :physical_roads do |t|
+      t.string :objectid
+      t.belongs_to :logical_road
+      t.line_string :geometry, :srid => ActiveRoad.srid
+      t.timestamps
+    end
+
+    add_index :physical_roads, :objectid, :uniq => true
+    add_index :physical_roads, :logical_road_id
+  end
+
+  def self.down
+    drop_table :physical_roads
+  end
+end

data/db/migrate/20120201162800_create_logical_roads.rb

@@ -0,0 +1,16 @@
+class CreateLogicalRoads < ActiveRoad::Migration
+  def self.up
+    create_table :logical_roads do |t|
+      t.string :name
+      t.string :objectid
+      t.timestamps
+    end
+
+    add_index :logical_roads, :objectid, :uniq => true
+    add_index :logical_roads, :name
+  end
+
+  def self.down
+    drop_table :logical_roads
+  end
+end

data/db/migrate/20120203154500_create_junctions.rb

@@ -0,0 +1,25 @@
+class CreateJunctions < ActiveRoad::Migration
+  def self.up
+    create_table :junctions do |t|
+      t.string :objectid
+      t.point :geometry, :srid => ActiveRoad.srid
+      t.timestamps
+    end
+
+    add_index :junctions, :objectid, :uniq => true
+
+    create_table :junctions_physical_roads, :id => false do |t|
+      t.belongs_to :physical_road
+      t.belongs_to :junction
+    end
+
+    # Generated name is too long for PostgreSQL
+    add_index :junctions_physical_roads, [:physical_road_id, :junction_id], :name => 'junctions_physical_roads_ids', :uniq => true
+    add_index :junctions_physical_roads, [:junction_id]
+  end
+
+  def self.down
+    drop_table :junctions
+    drop_table :junctions_physical_roads
+  end
+end

data/db/migrate/20120401083409_create_physical_roads_spatial_index.rb

@@ -0,0 +1,9 @@
+class CreatePhysicalRoadsSpatialIndex < ActiveRecord::Migration
+  def up
+    add_index :physical_roads, :geometry, :spatial => true
+  end
+
+  def down
+    remove_index :physical_roads, :geometry, :spatial => true
+  end
+end

data/db/migrate/20120419093427_add_kind_to_physical_roads.rb

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

data/db/migrate/20121010125851_create_junction_conditionnal_costs.rb

@@ -0,0 +1,13 @@
+class CreateJunctionConditionnalCosts < ActiveRoad::Migration
+  def up
+    create_table :junction_conditionnal_costs do |t|
+      t.belongs_to :junction
+      t.float :cost
+      t.string :tags
+    end
+  end
+
+  def down
+    drop_table :junction_conditionnal_costs
+  end
+end

data/db/migrate/20121011124923_create_physical_road_conditionnal_costs.rb

@@ -0,0 +1,13 @@
+class CreatePhysicalRoadConditionnalCosts < ActiveRecord::Migration
+  def up
+    create_table :physical_road_conditionnal_costs do |t|
+      t.belongs_to :physical_road
+      t.float :cost
+      t.string :tags
+    end
+  end
+
+  def down
+    drop_table :physical_road_conditionnal_costs
+  end
+end

data/db/migrate/20121012134251_add_start_end_ref_to_junction_conditionnal_cost.rb

@@ -0,0 +1,6 @@
+class AddStartEndRefToJunctionConditionnalCost < ActiveRecord::Migration
+  def change
+    add_column :junction_conditionnal_costs, :start_physical_road_id, :integer
+    add_column :junction_conditionnal_costs, :end_physical_road_id, :integer
+  end
+end

data/db/migrate/20121012134440_add_tags_junction.rb

@@ -0,0 +1,5 @@
+class AddTagsJunction < ActiveRecord::Migration
+  def change
+    add_column :junctions, :tags, :string
+  end
+end

data/db/migrate/20121012134457_add_tags_physical_road.rb

@@ -0,0 +1,5 @@
+class AddTagsPhysicalRoad < ActiveRecord::Migration
+  def change
+    add_column :physical_roads, :tags, :string
+  end
+end

data/db/migrate/20121106095002_add_objectid_to_street_number.rb

@@ -0,0 +1,5 @@
+class AddObjectidToStreetNumber < ActiveRecord::Migration
+  def change
+    add_column :street_numbers, :objectid, :string
+  end
+end

data/db/migrate/20130419155438_add_length_and_minimum_width_to_physical_road.rb

@@ -0,0 +1,6 @@
+class AddLengthAndMinimumWidthToPhysicalRoad < ActiveRecord::Migration
+  def change
+    add_column :physical_roads, :length, :integer, :default => 0
+    add_column :physical_roads, :minimum_width, :integer, :default => 0    
+  end
+end

data/db/migrate/20130507162801_setup_hstore.rb

@@ -0,0 +1,9 @@
+class SetupHstore < ActiveRecord::Migration
+  def self.up
+    execute "CREATE EXTENSION IF NOT EXISTS hstore"
+  end
+
+  def self.down
+    execute "DROP EXTENSION IF EXISTS hstore"
+  end
+end

data/db/migrate/20130509075631_change_tags_type_for_physical_road.rb

@@ -0,0 +1,10 @@
+class ChangeTagsTypeForPhysicalRoad < ActiveRecord::Migration
+  def up
+    remove_column :physical_roads, :tags
+    add_column :physical_roads, :tags, :hstore
+  end
+
+  def down
+    add_column :physical_roads, :tags, :string
+  end
+end

data/db/migrate/20130509081745_index_physical_roads_tags.rb

@@ -0,0 +1,9 @@
+class IndexPhysicalRoadsTags < ActiveRecord::Migration
+  def up
+    execute "CREATE INDEX physical_roads_tags ON physical_roads USING GIN(tags)"
+  end
+  
+  def down
+    execute "DROP INDEX physical_roads_tags"
+  end
+end

data/db/migrate/20130513134422_change_tags_type_for_junction.rb

@@ -0,0 +1,10 @@
+class ChangeTagsTypeForJunction < ActiveRecord::Migration
+  def up
+    remove_column :junctions, :tags
+    add_column :junctions, :tags, :hstore
+  end
+
+  def down
+    add_column :junctions, :tags, :string
+  end
+end

data/db/migrate/20130513134511_index_junctions_tags.rb

@@ -0,0 +1,9 @@
+class IndexJunctionsTags < ActiveRecord::Migration
+  def up
+    execute "CREATE INDEX junctions_tags ON junctions USING GIN(tags)"
+  end
+  
+  def down
+    execute "DROP INDEX junctions_tags"
+  end
+end

data/db/migrate/20130607114951_change_length_name_for_physical_road.rb

@@ -0,0 +1,11 @@
+class ChangeLengthNameForPhysicalRoad < ActiveRecord::Migration
+  def up
+    remove_column :physical_roads, :length
+    add_column :physical_roads, :length_in_meter, :float, :default => 0
+  end
+
+  def down
+    remove_column :physical_roads, :length_in_meter
+    add_column :physical_roads, :length, :integer
+  end
+end

data/db/migrate/20130801151637_add_constraints_to_physical_roads.rb

@@ -0,0 +1,37 @@
+class AddConstraintsToPhysicalRoads < ActiveRecord::Migration
+  def up
+    remove_column :physical_roads, :minimum_width
+    remove_column :physical_roads, :kind
+    
+    add_column :physical_roads, :minimum_width, :string
+    add_column :physical_roads, :transport_mode, :string
+    add_column :physical_roads, :uphill, :float
+    add_column :physical_roads, :downhill, :float
+    add_column :physical_roads, :slope, :string
+    add_column :physical_roads, :cant, :string
+    add_column :physical_roads, :covering, :string
+    add_column :physical_roads, :steps_count, :integer
+    add_column :physical_roads, :banisters_available, :boolean
+    add_column :physical_roads, :tactile_band, :boolean
+    add_column :physical_roads, :physical_road_type, :string
+
+    add_index :physical_roads, :physical_road_type
+
+  end
+
+  def down       
+    remove_column :physical_roads, :minimum_width
+    remove_column :physical_roads, :transport_mode
+    remove_column :physical_roads, :uphill
+    remove_column :physical_roads, :downhill
+    remove_column :physical_roads, :slope
+    remove_column :physical_roads, :cant
+    remove_column :physical_roads, :covering
+    remove_column :physical_roads, :steps_count
+    remove_column :physical_roads, :banisters_available
+    remove_column :physical_roads, :tactile_band
+    remove_column :physical_roads, :physical_road_type
+
+    add_column :physical_roads, :minimum_width, :integer
+  end
+end

data/db/migrate/20130809155019_add_height_and_waiting_constraint_to_junction.rb

@@ -0,0 +1,6 @@
+class AddHeightAndWaitingConstraintToJunction < ActiveRecord::Migration
+  def change
+    add_column :junctions, :height, :float
+    add_column :junctions, :waiting_constraint, :time
+  end
+end

data/db/migrate/20130812143049_fix_waiting_constraint_type_for_junction.rb

@@ -0,0 +1,11 @@
+class FixWaitingConstraintTypeForJunction < ActiveRecord::Migration
+  def up
+    remove_column :junctions, :waiting_constraint
+    add_column :junctions, :waiting_constraint, :float
+  end
+
+  def down
+    remove_column :junctions, :waiting_constraint
+    add_column :junctions, :waiting_constraint, :time
+  end
+end

data/lib/active_road.rb

@@ -0,0 +1,19 @@
+require "active_road/engine"
+require 'erb'
+
+module ActiveRoad
+
+  def self.srid
+    4326
+  end
+
+  def self.database_configuration
+    YAML::load(ERB.new(IO.read( File.expand_path('../../config/database.yml', __FILE__))).result)
+  end
+  
+end
+
+require "active_road/shortest_path"
+require "active_road/shortest_path/finder"
+
+

data/lib/active_road/engine.rb

@@ -0,0 +1,13 @@
+module ActiveRoad
+  if defined?(Rails)
+    require "active_road/migration"
+
+    class Engine < ::Rails::Engine
+
+      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
+
+    end
+  end
+end

data/lib/active_road/migration.rb

@@ -0,0 +1,15 @@
+class ActiveRoad::Migration < ActiveRecord::Migration
+#   def connection
+#     # @connection can be wrapped (with CommandRecorder in Rails 3.2 for example)
+#     if roads_connection?(@connection)
+#       @connection
+#     else
+#       @connection = ActiveRoad::Base.connection
+#     end
+#   end
+  
+#   def roads_connection?(connection)
+#     connection.respond_to?(:current_database) and 
+#       connection.current_database == ActiveRoad::Base.connection.current_database
+#   end
+end

data/lib/active_road/shortest_path.rb

@@ -0,0 +1,2 @@
+module ActiveRoad::ShortestPath
+end

data/lib/active_road/shortest_path/finder.rb

@@ -0,0 +1,172 @@
+# -*- coding: utf-8 -*-
+# This class find the shortest path between a departure and an arrival with :
+#   - weight functions
+#   - tags to find selected physical roads
+#
+# A classic result would be with a point for departure and arrival :
+# Paths ==> 1      : Departure Point
+#       |=> 2      : Access Link
+#       |=> 3      : Path between AccessPoint and a Junction
+#       |=> ...    : Path between a Junction and another Junction
+#       |=> n-2    : Path between a Junction and an Access Point
+#       |=> n-1    : Access Link
+#       |=> n      : Arrival Point
+
+
+require 'shortest_path/finder'
+
+class ActiveRoad::ShortestPath::Finder < ShortestPath::Finder
+
+  attr_accessor :speed, :physical_road_filter, :follow_way_filter, :user_weights
+
+  def initialize(departure, arrival, speed = 4, constraints = {}, user_weights = {})    
+    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
+  end
+
+  def destination_accesses 
+    @destination_accesses ||= ActiveRoad::AccessPoint.to(destination, physical_road_filter)
+  end  
+
+  # Return a time in second from node to destination
+  # TODO : Tenir compte de la sinuosité de la route???
+  def time_heuristic(node)
+    if node.respond_to?(:arrival)
+      node.arrival.to_geometry.spherical_distance(destination) / speed
+    else
+      node.to_geometry.spherical_distance(destination) / speed
+    end
+  end
+
+  # Return a distance in meter from node to destination
+  def distance_heuristic(node)
+    if node.respond_to?(:arrival)
+      node.arrival.to_geometry.spherical_distance(destination)
+    else
+      node.to_geometry.spherical_distance(destination)
+    end
+  end
+
+  def path_weights(path)
+    path_weights = 0
+    
+    # Add path weight
+    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
+      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      
+    
+    path_weights
+  end 
+  
+  def path_weight( length_in_meter = 0, percentage = 1 )
+    (length_in_meter / speed) * percentage
+  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)
+  end
+
+  #-----------------------------------------
+  # Overwrite ShortestPath::Finder methods
+  #-----------------------------------------
+  
+  def visited?(node)
+    super(respond_to?(:arrival) ? node.arrival : node)
+  end
+
+  def visit(node)
+    super(respond_to?(:arrival) ? node.arrival : node)
+  end
+
+  def search_heuristic(node)
+    shortest_distances[node] + time_heuristic(node)
+  end
+
+  # Update context with uphill, downhill and height
+  # TODO : Fix arguments node is not a node but a path a point or an access link!!
+  def refresh_context( node, context = {} )
+    context_uphill = context[:uphill] ? context[:uphill] : 0
+    context_downhill = context[:downhill] ? context[:downhill] : 0
+    context_height = context[:height] ? context[:height] : 0
+
+    if( node.class == ActiveRoad::Path )
+      departure = node.departure
+      physical_road = node.physical_road            
+
+      node_uphill = ( physical_road && physical_road.uphill) ? physical_road.uphill : 0
+      node_downhill = (physical_road && physical_road.downhill) ? physical_road.downhill : 0
+      node_height = (departure.class != ActiveRoad::AccessPoint && departure && departure.height) ? departure.height : 0
+      
+      return { :uphill => (context_uphill + node_uphill), :downhill => (context_downhill + node_downhill), :height => (context_height + node_height) }
+    else
+      return {:uphill => context_uphill, :downhill => context_downhill, :height => context_height}
+    end
+  end
+
+  # Follow way depends from uphill, downhill, height and heuristics
+  def follow_way?(node, destination, weight, context={})
+    # Check that arguments in the context is less  than the object parameters    
+    request = true
+    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
+  end
+
+  def ways(node, context={})
+    paths =
+      if GeoRuby::SimpleFeatures::Point === node
+        ActiveRoad::AccessLink.from(node, physical_road_filter)
+      else
+        node.paths(physical_road_filter)
+      end
+    
+    unless GeoRuby::SimpleFeatures::Point === node # For the first point to access physical roads
+      destination_accesses.select do |destination_access|
+        if node.access_to_road?(destination_access.physical_road)
+          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
+    Hash[array]
+  end
+
+end