active_road 0.0.2

data/app/models/active_road/path.rb

@@ -0,0 +1,85 @@
+# A path is a link between differents objects : 
+#  - Departure
+#  - Arrival
+class ActiveRoad::Path
+
+  attr_accessor :departure, :arrival, :physical_road
+  alias_method :road, :physical_road
+
+  def initialize(attributes = {})
+    attributes.each do |k, v|
+      send("#{k}=", v)
+    end
+  end
+
+  def name
+    "Path : #{departure} -> #{arrival}"
+  end
+
+  def locations_on_road
+    [departure, arrival].collect do |endpoint|
+      location =
+        if GeoRuby::SimpleFeatures::Point === endpoint
+          road.locate_point endpoint
+        else
+          endpoint.location_on_road road
+        end
+      location = [0, [location, 1].min].max
+    end
+  end
+
+  def length_in_meter
+    length_on_road * road.length_in_meter
+  end
+
+  def length_on_road
+    begin_on_road, end_on_road = locations_on_road.sort
+    end_on_road - begin_on_road
+  end
+
+  def self.all(departure, arrivals, physical_road)
+    Array(arrivals).collect do |arrival|
+      new :departure => departure, :arrival => arrival, :physical_road => physical_road
+    end
+  end
+
+  delegate :access_to_road?, :to => :arrival
+
+  def paths(tags = {})
+    arrival.paths(tags) - [reverse]
+  end
+
+  def reverse
+    self.class.new :departure => arrival, :arrival => departure, :physical_road => physical_road
+  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
+  end
+
+  def geometry_with_cache
+    @geometry ||= geometry_without_cache
+  end
+  alias_method :geometry, :geometry_with_cache
+  alias_method :to_geometry, :geometry
+
+  def to_s
+    name
+  end
+
+  def ==(other)
+    [:departure, :arrival, :physical_road].all? do |attribute|
+      other.respond_to?(attribute) and send(attribute) == other.send(attribute)
+    end
+  end
+  alias_method :eql?, :==
+
+  def hash
+    [departure, arrival, physical_road].hash
+  end
+
+end

data/app/models/active_road/physical_road.rb

@@ -0,0 +1,65 @@
+require "activerecord-postgres-hstore"
+require "enumerize"
+
+module ActiveRoad
+  class PhysicalRoad < ActiveRoad::Base
+    extend Enumerize
+    extend ActiveModel::Naming
+
+    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
+    enumerize :cant, :in => [:flat, :medium, :significant, :steep], :default => :flat
+    enumerize :physical_road_type, :in => [:path_link, :stairs, :crossing], :default => :path_link    
+
+    validates_uniqueness_of :objectid
+
+    has_many :numbers, :class_name => "ActiveRoad::StreetNumber", :inverse_of => :physical_road
+    belongs_to :logical_road, :class_name => "ActiveRoad::LogicalRoad"
+    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
+
+    def update_length_in_meter
+      if ( geometry )
+        spherical_factory = ::RGeo::Geographic.spherical_factory  
+        self.update_attribute :length_in_meter, spherical_factory.line_string(geometry.points.collect(&:to_rgeo)).length
+      end
+    end
+    
+    def 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)
+    end
+
+    def self.closest_to(location)
+      location_as_text = location.to_ewkt(false)
+      order("ST_Distance(geometry, GeomFromText('#{location_as_text}', 4326))")
+    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
+    end
+
+  end
+end

data/app/models/active_road/physical_road_conditionnal_cost.rb

@@ -0,0 +1,10 @@
+module ActiveRoad
+  class PhysicalRoadConditionnalCost < ActiveRoad::Base
+     belongs_to :physical_road
+
+    validates_presence_of :physical_road_id
+    validates_presence_of :tags
+    validates_presence_of :cost
+    
+  end
+end

data/app/models/active_road/physical_road_filter.rb

@@ -0,0 +1,41 @@
+# Filter Physical Road by : 
+#  - constraints
+class ActiveRoad::PhysicalRoadFilter
+  attr_accessor :relation, :constraints
+
+  def initialize(constraints = {}, relation = ActiveRoad::PhysicalRoad.scoped ) 
+    @relation, @constraints = relation, constraints
+  end
+
+  # Must define an sql request with forbidden tags
+  def sql_request
+    sql_request = ""
+    constraints.each do |key, value|
+      if !( (constraints.keys.first.present? && constraints.keys.first == key) )  
+        sql_request += " AND "
+      end
+  
+      sql_request += "(tags -> '#{new_key}')::int > :#{key}"
+      
+      # if key.to_s.include? "min_" 
+      #   new_key = key.to_s.gsub("min_", "")
+      #   sql_request += "(tags -> '#{new_key}')::int > :#{key}"
+      # elsif key.to_s.include? "max_"
+      #   new_key = key.to_s.gsub("max_", "")
+      #   sql_request += "(tags -> '#{new_key}')::int < :#{key}"
+      # else
+      #   sql_request += "tags -> '#{key}' != :#{key}" 
+      # end
+    end
+    sql_request
+  end
+
+  def filter
+    if constraints.present?      
+      @relation = @relation.where(constraints)
+    else
+      @relation
+    end
+  end
+
+end

data/app/models/active_road/street_number.rb

@@ -0,0 +1,81 @@
+class ActiveRoad::StreetNumber < ActiveRoad::Base
+  attr_accessible :objectid, :number, :geometry, :physical_road_id, :location_on_road
+
+  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
+
+  before_validation :compute_locate_on_road, :on => :create
+
+  def stored_geometry
+    read_attribute :geometry
+  end
+
+  def geometry
+    stored_geometry or computed_geometry
+  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 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) 
+    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)
+    end
+  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 number
+    Number.new read_attribute(:number)
+  end
+
+  class Number < String
+
+    alias_method :numeric_value, :to_i
+
+    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
+
+  end
+
+end

data/app/models/active_road/terra_import.rb

@@ -0,0 +1,148 @@
+module ActiveRoad
+  class TerraImport
+    attr_reader :parser
+
+    def initialize(xml_file)
+      @parser = ::Saxerator.parser(File.new(xml_file))
+    end
+
+    def extract
+      parser.for_tag(:LogicalRoad).each do |logical_road|
+        LogicalRoadXml.new(logical_road).import
+      end 
+
+      parser.for_tag(:TrajectoryArc).each do |physical_road|
+        TrajectoryArcXml.new(physical_road).import      
+      end
+
+      parser.for_tag(:TrajectoryNode).each do |junction|
+        TrajectoryNodeXml.new(junction).import      
+      end
+
+      parser.for_tag(:StreetNumber).each do |street_number|
+        StreetNumberXml.new(street_number).import      
+      end
+      
+    end
+
+    class ElementXml
+      attr_reader :xml
+      
+      def initialize(xml)
+        @xml = xml
+      end
+
+      def objectid
+        xml['ObjectId']
+      end
+
+      def geometry
+        GeoRuby::SimpleFeatures::Geometry.from_ewkt( xml['Geometry'] ) 
+      end
+      
+    end
+
+    class LogicalRoadXml < ElementXml
+      
+      def name
+        xml['Name']
+      end   
+
+      def import
+        ActiveRoad::LogicalRoad.create :name => name, :objectid => objectid
+      end
+      
+    end
+
+    class TrajectoryArcXml < ElementXml
+      
+      def logical_road
+        ActiveRoad::LogicalRoad.find_by_objectid( logical_road_id )
+      end   
+
+      def logical_road_id
+        xml['LogicalRoadRef']
+      end
+
+      def minimum_width
+        xml['MinimumWidth']
+      end
+
+      def length
+        xml['Length']
+      end
+
+      def tags
+        {}
+      end
+      
+      def import
+        ActiveRoad::PhysicalRoad.create(:geometry => geometry, :tags => tags, :logical_road_id => logical_road_id, :objectid => objectid, :minimum_with => minimum_width, :length_in_meter => length) if (geometry) #&& logical_road)
+      end
+      
+    end
+
+    class TrajectoryNodeXml < ElementXml
+      
+      def tags
+        {} #xml['Tags'].to_s
+      end
+
+      # def height
+      #   xml['Height'] || 0
+      # end
+
+      # def physical_road 
+      #   ActiveRoad::PhysicalRoad.find_by_objectid( physical_road_id )
+      # end
+
+      # def physical_road_id
+      #   xml['PhysicalRoadRef']
+      # end    
+
+      def physical_roads
+        physical_roads = []
+        if(xml['TrajectoryArcRef'].class == Saxerator::Builder::StringElement)
+          physical_roads << ActiveRoad::PhysicalRoad.find_by_objectid( xml['TrajectoryArcRef'].to_s ) 
+        else
+          xml['TrajectoryArcRef'].each do |trajectory_arc_ref|
+            physical_road = ActiveRoad::PhysicalRoad.find_by_objectid( trajectory_arc_ref.to_s )
+            physical_roads << physical_road if physical_road.present?        
+          end
+        end
+        physical_roads
+      end 
+
+      def import
+        junction = ActiveRoad::Junction.create :objectid => objectid, :tags => tags, :geometry => geometry
+        junction.physical_roads << physical_roads
+      end
+      
+    end
+
+    class StreetNumberXml < ElementXml
+      # TODO : Fix location_on_road value
+      def physical_road 
+        ActiveRoad::PhysicalRoad.find_by_objectid( physical_road_ref )
+      end
+
+      def physical_road_ref
+        xml['TrajectoryArcRef']
+      end
+
+      def number
+        xml['Number']
+      end
+
+      def location_on_road
+        xml['LocationOnRoad'] || 0
+      end
+      
+      def import
+        ActiveRoad::StreetNumber.create(:number => number , :objectid => objectid, :geometry => geometry, :location_on_road => location_on_road)#, :physical_road_id => physical_road.id)
+      end
+
+    end
+
+  end
+end

data/config/database.yml

@@ -0,0 +1,20 @@
+development: 
+  adapter: postgresql
+  database: roads
+  username: roads
+  password: roads0
+  template: template_postgis
+
+test: 
+  adapter: postgresql
+  database: roads_test
+  username: roads
+  password: roads0
+  template: template_postgis
+
+osm:
+  adapter: postgresql
+  database: osm
+  username: osm
+  password: osm
+  host: osm.dbx2.dryade.priv