active_road 0.0.2 → 0.0.3

data/app/models/active_road/path.rb

@@ -19,8 +19,8 @@ class ActiveRoad::Path
   def locations_on_road
     [departure, arrival].collect do |endpoint|
       location =
-        if GeoRuby::SimpleFeatures::Point === endpoint
-          road.locate_point endpoint
+        if ActiveRoad::AccessPoint === endpoint
+          road.locate_point endpoint.geometry
         else
           endpoint.location_on_road road
         end
@@ -45,8 +45,8 @@ class ActiveRoad::Path
 
   delegate :access_to_road?, :to => :arrival
 
-  def paths(tags = {})
-    arrival.paths(tags) - [reverse]
+  def paths
+    arrival.paths - [reverse]
   end
 
   def reverse
@@ -54,11 +54,42 @@ class ActiveRoad::Path
   end
 
   def geometry_without_cache
-    sorted_locations_on_road = locations_on_road.sort
-    reverse = (sorted_locations_on_road != locations_on_road)
-    geometry = road.line_substring *sorted_locations_on_road
-    geometry = geometry.reverse if reverse
-    geometry
+    # sorted_locations_on_road = locations_on_road.sort
+    # reverse = (sorted_locations_on_road != locations_on_road)
+    # geometry = road.line_substring(sorted_locations_on_road.first, sorted_locations_on_road.last)
+    # geometry = geometry.reverse if reverse
+    # geometry
+
+    points =  physical_road.geometry.points
+    points_selected = []
+
+    if ActiveRoad::AccessPoint === departure || ActiveRoad::AccessPoint === arrival
+      sorted_locations_on_road = locations_on_road.sort    
+      reverse = (sorted_locations_on_road != locations_on_road)
+      
+      if sorted_locations_on_road == [0, 1]
+        if reverse
+          return physical_road.geometry.reverse
+        else
+          return physical_road.geometry
+        end
+      end
+      
+      return road.line_substring(sorted_locations_on_road.first, sorted_locations_on_road.last)
+    end
+
+    departure_index = points.index(departure.geometry)
+    arrival_index = points.index(arrival.geometry)
+    
+    if departure_index < arrival_index
+      points_selected = points[arrival_index..departure_index]
+    elsif arrival_index < departure_index
+      points_selected = points.reverse![arrival_index..departure_index]
+    else
+      raise StandardError, "Junction is not on the physical road"
+    end
+
+    GeoRuby::SimpleFeatures::LineString.from_points(points)
   end
 
   def geometry_with_cache

data/app/models/active_road/physical_road.rb

@@ -1,18 +1,14 @@
-require "activerecord-postgres-hstore"
-require "enumerize"
-
+# -*- coding: utf-8 -*-
 module ActiveRoad
   class PhysicalRoad < ActiveRoad::Base
-    extend Enumerize
+    extend ::Enumerize
     extend ActiveModel::Naming
 
+    attr_accessible :objectid, :tags, :geometry, :logical_road_id, :boundary_id, :length_in_meter, :minimum_width, :covering, :transport_mode, :slope, :cant, :physical_road_type 
     serialize :tags, ActiveRecord::Coders::Hstore
 
-    attr_accessible :objectid, :tags, :geometry, :logical_road_id, :length_in_meter, :minimum_width, :covering, :transport_mode, :slope, :cant, :physical_road_type 
-
     # TODO : Pass covering in array mode???
     enumerize :covering, :in => [:slippery_gravel, :gravel, :asphalt_road, :asphalt_road_damaged, :pavement, :irregular_pavement, :slippery_pavement]
-    enumerize :transport_mode, :in => [:pedestrian, :bike]
 
     enumerize :minimum_width, :in => [:wide, :enlarged, :narrow, :cramped], :default => :wide
     enumerize :slope, :in => [:flat, :medium, :significant, :steep], :default => :flat
@@ -23,42 +19,41 @@ module ActiveRoad
 
     has_many :numbers, :class_name => "ActiveRoad::StreetNumber", :inverse_of => :physical_road
     belongs_to :logical_road, :class_name => "ActiveRoad::LogicalRoad"
+    belongs_to :boundary, :class_name => "ActiveRoad::Boundary"
     has_and_belongs_to_many :junctions, :uniq => true
     has_many :physical_road_conditionnal_costs
 
     acts_as_geom :geometry => :line_string
-    delegate :locate_point, :interpolate_point, :to => :geometry
-
-    before_validation :update_length_in_meter
+    delegate :locate_point, :interpolate_point, :length, :to => :geometry    
 
+    before_create :update_length_in_meter
+    before_update :update_length_in_meter
     def update_length_in_meter
-      if ( geometry )
+      if geometry.present?
         spherical_factory = ::RGeo::Geographic.spherical_factory  
-        self.update_attribute :length_in_meter, spherical_factory.line_string(geometry.points.collect(&:to_rgeo)).length
+        self.length_in_meter = spherical_factory.line_string(geometry.points.collect(&:to_rgeo)).length
+        #self.length_in_meter = length
       end
     end
     
-    def name
+    def street_name
       logical_road.try(:name) or objectid
     end
 
-    alias_method :to_s, :name
-
-    def self.nearest_to(location, distance = 100)
-      with_in(location, distance).closest_to(location)
+    def intersection(other)
+      postgis_calculate(:intersection, [self, other])
     end
 
-    def self.closest_to(location)
-      location_as_text = location.to_ewkt(false)
-      order("ST_Distance(geometry, GeomFromText('#{location_as_text}', 4326))")
+    def difference(other)
+      postgis_calculate(:difference, [self, other])
     end
-
-    def self.with_in(location, distance = 100)
-      # FIXME why ST_DWithin doesn't use meters ??
-      distance = distance / 1000.0
-
-      location_as_text = location.to_ewkt(false)
-      where "ST_DWithin(ST_GeomFromText(?, 4326), geometry, ?)", location_as_text, distance
+    
+    # distance in srid format 0.001 ~= 111.3 m à l'équateur
+    # TODO : Must convert distance in meters => distance in srid
+    def self.nearest_to(location, distance = 0.001)
+      # FIX Limit to 1 physical roads for perf, must be extended
+      pr = all_dwithin(location, distance)
+      pr == [] ? [] : [pr.first]
     end
 
   end

data/app/models/active_road/physical_road_conditionnal_cost.rb

@@ -1,6 +1,8 @@
 module ActiveRoad
   class PhysicalRoadConditionnalCost < ActiveRoad::Base
-     belongs_to :physical_road
+    attr_accessible :tags, :cost, :physical_road_id
+    
+    belongs_to :physical_road
 
     validates_presence_of :physical_road_id
     validates_presence_of :tags

data/app/models/active_road/request_conditionnal_cost_linker.rb

@@ -0,0 +1,59 @@
+module ActiveRoad
+  class RequestConditionnalCostLinker
+    attr_accessor :unauthorized_constraints, :authorized_constraints, :constraints
+
+    def initialize(constraints = [], external_constraints = {})
+      @constraints = constraints
+    end 
+
+    def unauthorized_constraints
+      @unauthorized_constraints ||= [].tap do |unauthorized_constraints|
+        constraints.each do |constraint|
+          if constraint.start_with?("~")
+            unauthorized_constraints << constraint.gsub("~", "")
+          end  
+        end
+      end
+    end
+
+    def authorized_constraints 
+      @authorized_constraints ||= [].tap do |authorized_constraints|
+        constraints.each do |constraint|
+          if !constraint.start_with?("~")
+            authorized_constraints << constraint
+          end  
+        end
+      end
+    end
+
+    def authorized_constraints_intersection_with?(tags)
+      (authorized_constraints & tags == false || authorized_constraints & tags == []) ? false : true
+    end
+
+    def unauthorized_constraints_intersection_with?(tags)
+      (unauthorized_constraints & tags == false || unauthorized_constraints & tags == []) ? false : true 
+    end
+
+    def linked?(conditionnal_costs_tags)
+      authorized_constraints_intersection_with?(conditionnal_costs_tags) || unauthorized_constraints_intersection_with?(conditionnal_costs_tags)
+    end
+
+    def conditionnal_costs_linked(conditionnal_costs)
+      conditionnal_costs.where(:tags => authorized_constraints)
+    end
+
+    def conditionnal_costs_sum(conditionnal_costs)
+      conditionnal_costs_tags = conditionnal_costs.collect(&:tags)  
+      if linked?(conditionnal_costs_tags)
+        if unauthorized_constraints && unauthorized_constraints_intersection_with?(conditionnal_costs_tags)
+          return Float::MAX
+        else
+          return conditionnal_costs_linked(conditionnal_costs).collect(&:cost).sum 
+        end
+      else
+        0
+      end
+    end
+    
+  end
+end

data/app/models/active_road/street_number.rb

@@ -1,81 +1,84 @@
-class ActiveRoad::StreetNumber < ActiveRoad::Base
-  attr_accessible :objectid, :number, :geometry, :physical_road_id, :location_on_road
+module ActiveRoad
+  class StreetNumber < ActiveRoad::Base
+    serialize :tags, ActiveRecord::Coders::Hstore
+    attr_accessible :objectid, :tags, :number, :geometry, :physical_road_id, :location_on_road
 
-  validates_uniqueness_of :objectid
-  validates_presence_of :number, :stored_geometry
+    validates_uniqueness_of :objectid
+    validates_presence_of :number, :stored_geometry
 
-  belongs_to :physical_road, :class_name => "ActiveRoad::PhysicalRoad"
-  def road
-    @road or physical_road
-  end
-  def road=(road)
-    @road ||= road
-  end
+    belongs_to :physical_road, :class_name => "ActiveRoad::PhysicalRoad"
+    def road
+      @road or physical_road
+    end
+    def road=(road)
+      @road ||= road
+    end
 
-  before_validation :compute_locate_on_road, :on => :create
+    #before_validation :compute_locate_on_road, :on => :create
 
-  def stored_geometry
-    read_attribute :geometry
-  end
+    def stored_geometry
+      read_attribute :geometry
+    end
 
-  def geometry
-    stored_geometry or computed_geometry
-  end
+    def geometry
+      stored_geometry or computed_geometry
+    end
 
-  def computed_geometry
-    road.at computed_location_on_road
-  end
+    def computed_geometry
+      road.at computed_location_on_road
+    end
 
-  def location_on_road
-    stored_location_on_road or computed_location_on_road
-  end
+    def location_on_road
+      stored_location_on_road or computed_location_on_road
+    end
 
-  def stored_location_on_road
-    read_attribute :location_on_road
-  end
+    def stored_location_on_road
+      read_attribute :location_on_road
+    end
 
-  def compute_locate_on_road
-    if stored_location_on_road.nil? and stored_geometry 
-      self.location_on_road = road.geometry.locate_point(stored_geometry) 
+    def compute_locate_on_road
+      if stored_location_on_road.nil? and stored_geometry 
+        self.location_on_road = road.geometry.locate_point(stored_geometry) 
+      end
     end
-  end
 
-  # TODO rename into estimated_location_on_road
-  def computed_location_on_road
-    if previous and self.next
-      number_ratio = (number.to_i - previous.number.to_i) / (self.next.number.to_i - previous.number.to_i).to_f
-      previous.location_on_road + number_ratio * (self.next.location_on_road - previous.location_on_road)
+    # TODO rename into estimated_location_on_road
+    def computed_location_on_road
+      if previous and self.next
+        number_ratio = (number.to_i - previous.number.to_i) / (self.next.number.to_i - previous.number.to_i).to_f
+        previous.location_on_road + number_ratio * (self.next.location_on_road - previous.location_on_road)
+      end
     end
-  end
 
-  def previous
-    @previous ||= road.numbers.find :first, :conditions => ["number < ?", number], :limit => 1, :order => "number desc"
-  end
+    def previous
+      @previous ||= road.numbers.find :first, :conditions => ["number < ?", number], :limit => 1, :order => "number desc"
+    end
 
-  def next
-    @next ||= road.numbers.find :first, :conditions => ["number > ?", number], :limit => 1, :order => "number"
-  end
+    def next
+      @next ||= road.numbers.find :first, :conditions => ["number > ?", number], :limit => 1, :order => "number"
+    end
 
-  def number
-    Number.new read_attribute(:number)
-  end
+    def number
+      Number.new read_attribute(:number)
+    end
 
-  class Number < String
+    class Number < String
 
-    alias_method :numeric_value, :to_i
+      alias_method :numeric_value, :to_i
 
-    def suffix
-      gsub(/^[0-9]+/,'')
-    end
+      def suffix
+        gsub(/^[0-9]+/,'')
+      end
 
-    def +(value)
-      self.class.new "#{numeric_value+value}#{suffix}"
-    end
+      def +(value)
+        self.class.new "#{numeric_value+value}#{suffix}"
+      end
+
+      def -(value)
+        self.class.new "#{numeric_value-value}#{suffix}"
+      end
 
-    def -(value)
-      self.class.new "#{numeric_value-value}#{suffix}"
     end
 
   end
-
 end

data/app/models/active_road/terra_importer.rb

@@ -0,0 +1,161 @@
+# require "kyotocabinet"
+
+# module ActiveRoad
+#   class TerraImporter
+#     #include KyotoCabinet
+    
+#     attr_reader :parser, :database_path, :xml_file 
+
+#     def initialize(xml_file, database_path = "/tmp/terra.kch")
+#       @xml_file = xml_file
+#       @database_path = database_path
+#     end
+
+#     def parser
+#       @parser ||= ::Saxerator.parser(File.new(xml_file))
+#     end   
+
+#     def database
+#       @database ||= DB::new
+#     end
+    
+#     def open_database(path)
+#       database.open(path, DB::OWRITER | DB::OCREATE)
+#       database.clear
+#     end
+    
+#     def close_database
+#       database.close   
+#     end
+
+#     def physical_road_conditionnal_costs(tags)
+#       [].tap do |prcc|
+#         tags.each do |tag_key, tag_value|
+#           if ["highway", "railway"].include?(tag_key)
+#             prcc << ActiveRoad::PhysicalRoadConditionnalCost.new(:tags => "car", :cost => Float::MAX) if !ActiveRoad::OsmXmlImporter.tag_for_car_values.include?(tag_value)  
+#             prcc << ActiveRoad::PhysicalRoadConditionnalCost.new(:tags => "pedestrian", :cost => Float::MAX) if !ActiveRoad::OsmXmlImporter.tag_for_pedestrian_values.include?(tag_value)
+#             prcc << ActiveRoad::PhysicalRoadConditionnalCost.new(:tags => "bike", :cost => Float::MAX) if !ActiveRoad::OsmXmlImporter.tag_for_bike_values.include?(tag_value) 
+#             prcc << ActiveRoad::PhysicalRoadConditionnalCost.new(:tags => "train", :cost => Float::MAX) if !ActiveRoad::OsmXmlImporter.tag_for_train_values.include?(tag_value)
+#           end
+#         end
+#       end
+#     end
+
+#     def backup_nodes(database)
+#       # Save nodes in kyotocabinet database
+#       parser.for_tag(:TrajectoryNode).each do |node|
+#         ways = node["TrajectoryArcRef"].is_a?(Array) ? node["TrajectoryArcRef"] : [ node["TrajectoryArcRef"] ]
+#         database[ node["ObjectId"] ] = Marshal.dump(Node.new(node["ObjectId"], node["Geometry"], ways))
+#       end 
+#     end
+    
+#     def iterate_nodes(database)
+#       junctions_values = []    
+#       junctions_ways = {}
+#       # traverse records by iterator
+#       database.each { |key, value|
+        
+#         node = Marshal.load(value)
+#         geometry = GeoRuby::SimpleFeatures::Geometry.from_ewkt( node.geometry) if( node.geometry )    
+#         if node.ways.present? # && node.ways.count >= 2  # Take node with at least two ways
+#           junctions_values << [ node.id, geometry ]
+#           junctions_ways[node.id] = node.ways
+#         end
+        
+#         if junctions_values.count == 1000
+#           save_junctions(junctions_values, junction_ways) 
+#           #Reset
+#           junctions_values = []    
+#           junctions_ways = {}
+#         end
+#       }    
+#       save_junctions(junctions_values, junctions_ways) if junctions_values.present?
+#     end
+
+#     def save_junctions(junctions_values, junctions_ways)
+#       junction_columns = [:objectid, :geometry]
+#       # Save junctions in the stack
+#       ActiveRoad::Junction.import(junction_columns, junctions_values, :validate => false) if junctions_values.present?
+
+#       # Link the junction with physical roads
+#       junctions_ways.each do |junction_objectid, way_objectids|
+#         junction = ActiveRoad::Junction.find_by_objectid(junction_objectid)
+        
+#         physical_roads = ActiveRoad::PhysicalRoad.find_all_by_objectid(way_objectids)
+#         junction.physical_roads << physical_roads if physical_roads      
+#       end
+#     end
+
+#     def import
+#       # process the database by iterator
+#       DB::process(database_path) { |database|           
+#         database.clear
+#         backup_nodes(database)
+
+#         physical_roads = []
+#         attributes_by_objectid = {}
+#         parser.for_tag(:TrajectoryArc).each do |way|          
+#           geometry = GeoRuby::SimpleFeatures::Geometry.from_ewkt(way["Geometry"]) if way["Geometry"]
+#           physical_road = ActiveRoad::PhysicalRoad.new :objectid =>  way["ObjectId"], :geometry => geometry, :length_in_meter =>  way["Length"]
+          
+#           physical_roads << physical_road
+#           attributes_by_objectid[physical_road.objectid] = [physical_road_conditionnal_costs(way["Tags"])]
+
+#           if (physical_roads.count == 1000)
+#             save_physical_roads_and_children(physical_roads, attributes_by_objectid)
+            
+#             # Reset  
+#             physical_roads = []
+#             attributes_by_objectid = {}
+#           end
+#         end
+        
+#         save_physical_roads_and_children(physical_roads, attributes_by_objectid) if physical_roads.present?
+#         iterate_nodes(database)
+#       }
+#     end
+
+#    def save_physical_roads_and_children(physical_roads, attributes_by_objectid = {})
+#       # Save physical roads
+#       ActiveRoad::PhysicalRoad.import(physical_roads)
+
+#       # Save physical road conditionnal costs
+#       prcc = []
+#       attributes_by_objectid.each do |objectid, attributes|
+#         pr = ActiveRoad::PhysicalRoad.where(:objectid => objectid).first
+
+#         physical_road_conditionnal_costs = attributes.first
+#         physical_road_conditionnal_costs.each do |physical_road_conditionnal_cost|
+#           physical_road_conditionnal_cost.update_attribute :physical_road_id, pr.id
+#           prcc << physical_road_conditionnal_cost
+#         end
+#       end        
+#       ActiveRoad::PhysicalRoadConditionnalCost.import(prcc)               
+#     end
+
+
+#     class Node
+#       attr_accessor :id, :geometry, :ways, :end_of_way
+
+#       def initialize(id, geometry, ways = [], end_of_way = false)
+#         @id = id
+#         @geometry = geometry
+#         @ways = ways
+#         @end_of_way = end_of_way
+#       end
+
+#       def add_way(id)
+#         @ways << id
+#       end
+
+#       def marshal_dump
+#         [@id, @geometry, @ways, @end_of_way]
+#       end
+      
+#       def marshal_load array
+#         @id, @geometry, @ways, @end_of_way = array
+#       end
+#     end
+
+#   end
+# end