active_road 0.0.2

data/spec/fixtures/terra_minimal.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/xsl" href="roads-exchange.xsl"?>
+<Referential xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="file:./roads-exchange-SP4-SP5.xsd" name="Place Saint Sulpice septembre 2012">
+  <TrajectoryNode>
+		<ObjectId>ign-obj-55</ObjectId>
+		<Tags></Tags>
+		<Geometry>SRID=4326;POINT(2.331308046501452 48.85192725813857)</Geometry>
+		<TrajectoryArcRef>ign-obj-205</TrajectoryArcRef>
+		<PhysicalRoadRef>ign-obj-4</PhysicalRoadRef>
+	</TrajectoryNode>
+  <TrajectoryNode>
+		<ObjectId>ign-obj-56</ObjectId>
+		<Tags></Tags>
+		<Geometry>SRID=4326;POINT(2.331308046501452 48.89192725813857)</Geometry>
+		<TrajectoryArcRef>ign-obj-205</TrajectoryArcRef>
+		<PhysicalRoadRef>ign-obj-4</PhysicalRoadRef>
+	</TrajectoryNode>
+  <TrajectoryArc>
+		<ObjectId>ign-obj-205</ObjectId>
+		<Tags></Tags>
+		<Geometry>SRID=4326;LINESTRING(2.331800215057413 48.85220542836662, 2.331637521069522 48.85226948829244)</Geometry>
+		<TrajectoryNodeRef>ign-obj-55</TrajectoryNodeRef>
+		<TrajectoryNodeRef>ign-obj-56</TrajectoryNodeRef>
+		<PhysicalRoadRef>ign-obj-8</PhysicalRoadRef>
+		<Length>13.90200574121281</Length>
+		<MinimumWidth>1.934781931678176</MinimumWidth>
+	</TrajectoryArc>
+</Referential>

data/spec/fixtures/trajectory_arc.xml

@@ -0,0 +1,10 @@
+<TrajectoryArc>
+		<ObjectId>ign-obj-132</ObjectId>
+		<Tags></Tags>
+		<Geometry>SRID=4326;LINESTRING(2.332951894607378 48.85202237268847, 2.332954059651963 48.85203176810643, 2.332987498916577 48.85217930000868, 2.333012216929252 48.85228653406593, 2.333019156716375 48.85231664083499, 2.333020631447154 48.85232307844341, 2.333054110912616 48.85246483593746, 2.333054409771297 48.85246610837084, 2.333069582167015 48.85253004267233, 2.333069181836508 48.85253081856987, 2.333061780607442 48.85254114991605, 2.333052671610163 48.85254999057511, 2.333027875983071 48.85257017716946, 2.333027422653056 48.85257048008516)</Geometry>
+		<TrajectoryNodeRef>ign-obj-43</TrajectoryNodeRef>
+		<TrajectoryNodeRef>ign-obj-92</TrajectoryNodeRef>
+		<PhysicalRoadRef>ign-obj-14</PhysicalRoadRef>
+		<Length>62.59449394845691</Length>
+		<MinimumWidth>wide</MinimumWidth>
+</TrajectoryArc>

data/spec/fixtures/trajectory_node.xml

@@ -0,0 +1,11 @@
+<TrajectoryNode>
+	<ObjectId>ign-obj-93</ObjectId>
+	<Tags></Tags>
+	<Geometry>SRID=4326;POINT(2.33280726637185 48.85139664547131)</Geometry>
+	<TrajectoryArcRef>ign-obj-158</TrajectoryArcRef>
+	<TrajectoryArcRef>ign-obj-187</TrajectoryArcRef>
+	<JunctionRef>ign-obj-111</JunctionRef>
+	<PhysicalRoadRef>ign-obj-13</PhysicalRoadRef>
+	<PhysicalRoadRef>ign-obj-14</PhysicalRoadRef>
+  <Height>5</Height>
+</TrajectoryNode>

data/spec/lib/active_road/shortest_path/finder_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe ActiveRoad::ShortestPath::Finder do
+
+  #        Path schema
+  #
+  #    E-----------------F    
+  #    | _______________/|
+  #    |/                |
+  #    C-----------------D
+  #    |                 |
+  #    |                 |
+  #    A-----------------B 
+  #  
+
+  let(:departure) { point(-0.1, 0.1) }
+  let(:arrival) { point(1, 2) }
+  let(:speed) { 4 }
+  let(:constraints) { {:transport_mode => [:pedestrian, nil]} }
+
+  let(:ab) { create(:physical_road, :objectid => "ab", :geometry => line_string( "0 0,1 0" ) ) }
+  let(:cd) { create(:physical_road, :objectid => "cd", :geometry => line_string( "0 1,1 1" ) ) }
+  let(:ef) { create(:physical_road, :objectid => "ef", :geometry => line_string( "0 2,1 2" ) ) }
+  let(:ac) { create(:physical_road, :objectid => "ac", :geometry => line_string( "0 0,0 1" ), :uphill => 2 ) }
+  let(:bd) { create(:physical_road, :objectid => "bd", :geometry => line_string( "1 0,1 1" ) ) }
+  let(:ce) { create(:physical_road, :objectid => "ce", :geometry => line_string( "0 1,0 2" ), :uphill => 2 ) }
+  let(:df) { create(:physical_road, :objectid => "df", :geometry => line_string( "1 1,1 2" ) ) }
+  let(:cf) { create(:physical_road, :objectid => "cf", :geometry => line_string( "0 1,1 2" ), :transport_mode => :bike, :uphill => 2 ) }
+
+  let!(:a) { create(:junction, :geometry => point(0, 0), :physical_roads => [ ab, ac ] ) }
+  let!(:b) { create(:junction, :geometry => point(1, 0), :physical_roads => [ ab, bd ] ) }
+  let!(:c) { create(:junction, :geometry => point(0, 1), :physical_roads => [ cd, ac, ce, cf ] ) }
+  let!(:d) { create(:junction, :geometry => point(1, 1), :physical_roads => [ cd, bd, df ] ) }
+  let!(:e) { create(:junction, :geometry => point(0, 2), :physical_roads => [ ce, ef ] ) }
+  let!(:f) { create(:junction, :geometry => point(1, 2), :physical_roads => [ ef, df, cf ] ) }
+
+  it "should find a solution between first and last road with with no constraints" do
+    subject = ActiveRoad::ShortestPath::Finder.new departure, arrival, 4
+    subject.path.should_not be_blank
+    subject.path.size.should == 6
+    subject.path[2].physical_road.objectid.should == "ac"
+    subject.path[3].physical_road.objectid.should == "cf"
+  end
+
+  it "should find a solution between first and last road with physical_road filter in constraints" do
+    subject = ActiveRoad::ShortestPath::Finder.new departure, arrival, 4, constraints
+    subject.path.should_not be_blank
+    subject.path.size.should == 7
+    subject.path[2].physical_road.objectid.should == "ac"
+    subject.path[3].physical_road.objectid.should == "ce"
+    subject.path[4].physical_road.objectid.should == "ef"
+  end
+  
+  it "should find a solution between first and last road with context arguments in constraints" do
+    subject = ActiveRoad::ShortestPath::Finder.new departure, arrival, 4, { :uphill => 3 }
+    subject.path.should_not be_blank
+    subject.path.size.should == 7
+    subject.path[2].physical_road.objectid.should == "ac"
+    subject.path[3].physical_road.objectid.should == "cd"
+    subject.path[4].physical_road.objectid.should == "df"
+  end
+
+  it "should return something when no solution" do
+    subject = ActiveRoad::ShortestPath::Finder.new departure, arrival, 4, constraints
+  end
+ 
+
+  # describe "Shortest path with weights" do
+
+  #   it "should find a solution between first and last road with weights" do
+  #     subject = ActiveRoad::ShortestPath::Finder.new source, destination, 4
+  #     subject.path.should_not be_blank
+  #     subject.path.size.should == 7
+  #     subject.path[3].physical_road.objectid.should == "bc"
+  #     subject.path[4].physical_road.objectid.should == "cd"
+  #   end
+
+  # end
+
+
+  describe "#path_weights" do       
+    
+    let(:subject) { ActiveRoad::ShortestPath::Finder.new departure, arrival, 4 }
+    
+    it "should return 0 if no physical road" do
+      path = departure 
+      subject.path_weights(path).should == 0
+    end
+    
+    it "should return path weights" do     
+      path = ActiveRoad::Path.new(:departure => create(:junction), :physical_road => create(:physical_road) ) 
+      path.stub :length_in_meter => 2
+      subject.path_weights(path).should == 2 / (4 * 1000/3600)
+    end
+
+    it "should return path weights and node weight" do
+      path = ActiveRoad::Path.new(:departure => create(:junction, :waiting_constraint => 2.5), :physical_road => create(:physical_road) )
+      path.stub :length_in_meter => 2
+      subject.path_weights(path).should == 2 / (4 * 1000/3600) + 2.5
+    end
+
+  end
+
+  describe "#refresh_context" do
+    let(:subject) { ActiveRoad::ShortestPath::Finder.new departure, arrival, 4 }
+
+    it "should increase uphill if path has got a departure with an uphill value" do
+      node = ActiveRoad::Path.new( :physical_road => create(:physical_road, :uphill => 3.0), :departure => create(:junction))
+      context = {:uphill => 3}
+      subject.refresh_context(node, context).should == { :uphill => 6.0, :downhill => 0, :height => 0}      
+    end
+
+    it "should not increase uphill if path hasn't' got a departure with an uphill value" do
+      node = ActiveRoad::Path.new( :physical_road => create(:physical_road), :departure => create(:junction))
+      context = {:uphill => 3}
+      subject.refresh_context(node, context).should == { :uphill => 3.0, :downhill => 0, :height => 0}
+    end
+
+    it "should set context uphill to 0 if path hasn't' got a departure with an uphill value and no previous context" do 
+      node = ActiveRoad::Path.new( :physical_road => create(:physical_road), :departure => create(:junction))
+      context = {}
+      subject.refresh_context(node, context).should == { :uphill => 0, :downhill => 0, :height => 0}
+    end
+
+    it "should return {} if node is not a ActiveRoad::Path" do 
+      node = GeoRuby::SimpleFeatures::Point.from_x_y(0, 0)
+      context = {}
+      subject.refresh_context(node, context).should == {:uphill=>0, :downhill=>0, :height=>0}
+    end
+  end
+
+  describe "#follow_way" do       
+    
+    let(:node) { mock(:node) }
+    let(:destination) { mock(:destination) }
+    let(:weight) { 2 }
+    let(:context) { {:uphill => 2} }
+    let(:subject) { ActiveRoad::ShortestPath::Finder.new departure, arrival, 4 }
+
+    before(:each) do 
+      subject.stub :search_heuristic => 1
+      subject.stub :time_heuristic => 2
+    end
+    
+    it "should not follow way if uphill > uphill max" do     
+      subject.follow_way_filter = {:uphill => 1}
+      subject.follow_way?(node, destination, weight, context).should be_false
+    end
+
+    it "should follow way if uphill < uphill max" do
+      subject.follow_way_filter = {:uphill => 3}
+      subject.follow_way?(node, destination, weight, context).should be_true
+    end
+
+  end
+  
+end

data/spec/models/active_road/access_point_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe ActiveRoad::AccessPoint do
+  let!(:ab) { create(:physical_road, :geometry => line_string( "0 0,1 0" ), :minimum_width => :wide ) }
+
+  subject { ActiveRoad::Accesspoint.new( :location => point(0, 0), :physical_road => ab )  }
+
+  describe ".from" do
+
+    it "should return all access point with tags from the location" do
+      access_points = ActiveRoad::AccessPoint.from( point(0, 0), { :minimum_width => :wide } )
+      access_points.size.should == 1
+    end
+
+    it "should return all access point from the location with tags not in physical roads" do
+      access_points = ActiveRoad::AccessPoint.from( point(0, 0), { :minimum_width => :narrow } )
+      access_points.size.should == 0
+    end
+    
+  end
+
+  describe ".to" do
+  
+    it "should return all access point with tags from the location" do
+      access_points = ActiveRoad::AccessPoint.to( point(0, 0), { :minimum_width => :wide } )
+      access_points.size.should == 1
+    end
+
+    it "should return all access point from the location with tags not in physical roads" do
+      access_points = ActiveRoad::AccessPoint.to( point(0, 0), { :minimum_width => :narrow } )
+      access_points.size.should == 0
+    end
+    
+  end
+
+end

data/spec/models/active_road/junction_conditionnal_cost_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe ActiveRoad::JunctionConditionnalCost do
+
+  subject { create(:junction_conditionnal_cost) }
+
+  it "should have tags" do
+    subject.should respond_to(:tags)
+  end
+
+  it "should have a cost" do
+    subject.should respond_to(:cost)
+  end
+
+  it "should have a junction" do
+    subject.should respond_to(:junction_id)
+  end
+
+  describe "#start_physical_road" do
+    let(:new_road){create(:physical_road)}
+    it "should belongs to physical_road" do
+      subject.update_attributes( :start_physical_road => new_road)
+      subject.reload
+      subject.start_physical_road_id = new_road.id
+    end
+  end
+
+end

data/spec/models/active_road/junction_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ActiveRoad::Junction do
+
+  subject { create(:junction) }
+
+  it "should validate objectid uniqueness" do
+    other = build :junction, :objectid => subject.objectid 
+    other.should_not be_valid
+  end
+
+  context "junction connected to physical roads" do
+    subject { create(:junction) }
+
+    describe "#physical_roads" do
+      let(:new_road) { create(:physical_road) }
+      it "should be addable" do
+        subject.physical_roads << new_road
+        subject.save!
+      end
+    end
+  end
+  
+  
+end

data/spec/models/active_road/logical_road_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe ActiveRoad::LogicalRoad do
+
+  subject { create(:logical_road) }
+
+  it "should have a name" do
+    subject.should respond_to(:name)
+  end
+
+  describe "at" do
+    
+    context "when the given number exists" do
+
+      #let(:physical_road) { create :physical_road, :logical_road => subject }
+      #let(:number) { create :street_number, :physical_road => physical_road }
+
+      it "should return the number geometry" do
+        #subject.at(number.number).should == number.geometry
+        subject.name.should_not be_nil
+      end
+
+    end
+
+    context "when the given number is between two existing numbers" do
+
+      # let(:physical_road) { create :physical_road, :logical_road => subject }
+      # let(:number) { 45 }
+      # let!(:previous_number) do
+      #   physical_road.numbers.create create.attributes_for(:street_number, :location_on_road => 0.5, :number => "30") 
+      # end
+      # let!(:next_number) do
+      #   physical_road.numbers.create create.attributes_for(:street_number, :location_on_road => 1, :number => "60")
+      # end
+
+      # let(:estimated_geometry) { subject.geometry.interpolate_point(0.75) }
+
+      # it "should return the estimated geometry" do
+      #   subject.at(number).should == estimated_geometry
+      # end
+
+    end
+
+  end
+
+end

data/spec/models/active_road/path_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe ActiveRoad::Path do
+
+
+
+end

data/spec/models/active_road/physical_road_conditionnal_cost_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe ActiveRoad::PhysicalRoadConditionnalCost do
+
+  subject { create(:physical_road_conditionnal_cost) }
+
+  it "should have tags" do
+    subject.should respond_to(:tags)
+  end
+
+  it "should have a cost" do
+    subject.should respond_to(:cost)
+  end
+
+  it "should have a physical road" do
+    subject.should respond_to(:physical_road_id)
+  end
+
+end

data/spec/models/active_road/physical_road_filter_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe ActiveRoad::PhysicalRoadFilter do
+
+  # describe "#sql_request" do
+    
+  #   it "should return sql_request with min key" do
+  #     physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({"min_size" => "2"})    
+  #     physical_road_filter.sql_request.should == "(tags -> 'size')::int > :min_size"
+  #   end
+
+  #   it "should return sql_request with max key" do
+  #     physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({"max_size" => "2"})    
+  #     physical_road_filter.sql_request.should == "(tags -> 'size')::int < :max_size"
+  #   end
+
+  #   it "should return sql_request with default key" do
+  #     physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({"pedestrian" => "true"})    
+  #     physical_road_filter.sql_request.should == "tags -> 'pedestrian' != :pedestrian"
+  #   end
+
+  #   it "should return sql_request with 3 parameter" do       
+  #     physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({"pedestrian" => "true", "max_size" => "2", "min_size" => "1"})    
+  #     physical_road_filter.sql_request.should == "tags -> 'pedestrian' != :pedestrian AND (tags -> 'size')::int < :max_size AND (tags -> 'size')::int > :min_size"
+  #   end
+
+  # end
+
+  describe "#filter" do
+    
+    let!( :physical_road )  { create( :physical_road ) }
+    let!( :physical_road2 ) { create( :physical_road ) } 
+    let!( :physical_road3 ) { create( :physical_road ) }     
+       
+    it "should return physical roads which contains minimum_width <= narrow" do
+      physical_road.update_attribute :minimum_width, :wide
+      physical_road2.update_attribute :minimum_width, :cramped
+
+      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:minimum_width => [:wide, :enlarged, :narrow]})
+      physical_road_filter.filter.should =~ [physical_road, physical_road3]      
+    end
+
+    it "should return physical roads which contains slope <= medium" do
+      physical_road.update_attribute :slope, :medium
+      physical_road2.update_attribute :slope, :steep
+
+      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:slope => [:flat, :medium] })
+      physical_road_filter.filter.should =~ [physical_road, physical_road3]      
+    end
+
+    it "should return physical roads which contains cant <=  medium" do
+      physical_road.update_attribute :cant, :medium
+      physical_road2.update_attribute :cant, :steep
+
+      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:cant => [:flat, :medium] })
+      physical_road_filter.filter.should =~ [physical_road, physical_road3]      
+    end
+
+    it "should return physical roads which contains physical_road_type == path_link" do
+      physical_road.update_attribute :physical_road_type, :path_link
+      physical_road2.update_attribute :physical_road_type, :crossing
+
+      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:physical_road_type => :path_link})
+      physical_road_filter.filter.should =~ [physical_road, physical_road3]      
+
+    end
+
+    it "should return physical roads which contains transport_mode == pedestrian" do
+      physical_road.update_attribute :transport_mode, :pedestrian
+      physical_road2.update_attribute :transport_mode, :bike
+      
+      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:transport_mode => [:pedestrian, nil]})
+      physical_road_filter.filter.should =~ [physical_road, physical_road3]            
+    end
+
+    it "should return physical roads which contains covering == asphalt_road or pavement" do
+      physical_road.update_attribute :covering, :asphalt_road
+      physical_road2.update_attribute :covering, :pavement
+     
+      physical_road_filter = ActiveRoad::PhysicalRoadFilter.new({:covering => [:pavement, :asphalt_road, nil]})
+      physical_road_filter.filter.should =~ [physical_road, physical_road2, physical_road3]      
+    end
+  end
+
+end