active_road 0.0.2 → 0.0.3

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

@@ -2,101 +2,140 @@ 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"
+  shared_context "shared simple graph" do
+    #        Path schema
+    #
+    #    E-----------------F    
+    #    | _______________/|
+    #    |/                |
+    #    C-----------------D
+    #    |                 |
+    #    |                 |
+    #    A-----------------B 
+    #
+    let!(:ab) { create(:physical_road, :objectid => "ab", :geometry => line_string( "0.0 0.0,1.0 0.0" ) ) }
+    let!(:cd) { create(:physical_road, :objectid => "cd", :geometry => line_string( "0.0 1.0,1.0 1.0" ) ) }
+    let!(:ef) { create(:physical_road, :objectid => "ef", :geometry => line_string( "0.0 2.0,1.0 2.0" ) ) }
+    let!(:ac) { create(:physical_road, :objectid => "ac", :geometry => line_string( "0.0 0.0,0.0 1.0" ) ) }
+    let!(:bd) { create(:physical_road, :objectid => "bd", :geometry => line_string( "1.0 0.0,1.0 1.0" ) ) }
+    let!(:ce) { create(:physical_road, :objectid => "ce", :geometry => line_string( "0.0 1.0,0.0 2.0" ) ) }
+    let!(:df) { create(:physical_road, :objectid => "df", :geometry => line_string( "1.0 1.0,1.0 2.0" ) ) }
+    let!(:cf) { create(:physical_road, :objectid => "cf", :geometry => line_string( "0.0 1.0,1.0 2.0" ) ) }
+
+    let!(:a) { create(:junction, :objectid => "a", :geometry => point(0.0, 0.0), :physical_roads => [ ab, ac ] ) }
+    let!(:b) { create(:junction, :objectid => "b", :geometry => point(1.0, 0.0), :physical_roads => [ ab, bd ] ) }
+    let!(:c) { create(:junction, :objectid => "c", :geometry => point(0.0, 1.0), :physical_roads => [ cd, ac, ce, cf ] ) }
+    let!(:d) { create(:junction, :objectid => "d", :geometry => point(1.0, 1.0), :physical_roads => [ cd, bd, df ] ) }
+    let!(:e) { create(:junction, :objectid => "e", :geometry => point(0.0, 2.0), :physical_roads => [ ce, ef ] ) }
+    let!(:f) { create(:junction, :objectid => "f", :geometry => point(1.0, 2.0), :physical_roads => [ ef, df, cf ] ) }
+    
   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
+  let(:departure) { point(-0.0005, 0.0005) }
+  let(:arrival) { point(1.0005, 1.98) }
+  let(:speed) { 4 }
+  let(:constraints) { ["bike"] }
 
-  #   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
+  describe "#path" do       
+    include_context "shared simple graph"
+    
+    it "should find a solution between first and last road with with no constraints" do
+      path = ActiveRoad::ShortestPath::Finder.new(departure, arrival, 4).path
+      expect(path.size).to eq(8)
+      expect(path[0]).to eq(departure)
+      expect(path[1].class).to eq(ActiveRoad::AccessLink)
+      expect(path[2].physical_road.objectid).to eq("ab")
+      expect(path[3].physical_road.objectid).to eq("ac")
+      expect(path[4].physical_road.objectid).to eq("cf")
+      expect(path[5].physical_road.objectid).to eq("df")
+      expect(path[6].class).to eq(ActiveRoad::AccessLink)
+      expect(path[7]).to eq(arrival)
+    end  
+
+    it "should find a solution between first and last road with constraints" do
+      cf_conditionnal_costs = create(:physical_road_conditionnal_cost, :physical_road => cf, :tags => "bike", :cost => 0.7)
+      path = ActiveRoad::ShortestPath::Finder.new(departure, arrival, 4, ["bike"]).path
+      expect(path.size).to eq(8)
+      expect(path[0]).to eq(departure)
+      expect(path[1].class).to eq(ActiveRoad::AccessLink)
+      expect(path[2].physical_road.objectid).to eq("ab")
+      expect(path[3].physical_road.objectid).to eq("ac")
+      expect(path[4].physical_road.objectid).to eq("cd")
+      expect(path[5].physical_road.objectid).to eq("df")
+      expect(path[6].class).to eq(ActiveRoad::AccessLink)
+      expect(path[7]).to eq(arrival)
+    end
+    
+    it "should find a solution between first and last road with constraints which block the itinerary" do
+      cf_conditionnal_costs = create(:physical_road_conditionnal_cost, :physical_road => cf, :tags => "bike", :cost => 0)  
+      path = ActiveRoad::ShortestPath::Finder.new(departure, arrival, 4, ["~bike"]).path
+      expect(path.size).to eq(8)
+      expect(path[0]).to eq(departure)
+      expect(path[1].class).to eq(ActiveRoad::AccessLink)
+      expect(path[2].physical_road.objectid).to eq("ab")
+      expect(path[3].physical_road.objectid).to eq("ac")
+      expect(path[4].physical_road.objectid).to eq("cd")
+      expect(path[5].physical_road.objectid).to eq("df")
+      expect(path[6].class).to eq(ActiveRoad::AccessLink)
+      expect(path[7]).to eq(arrival)
+    end
 
-  # end
+    it "should return something when no solution" do
+      departure = point(-0.01, 0.01)
+      path = ActiveRoad::ShortestPath::Finder.new(departure, arrival, 4).path
+      expect(path).to eq([])      
+    end
 
+    it "should return something when departure or arrival are 'outside the graph'" do
+      departure = point(-0.0005, -0.0005)
+      path = ActiveRoad::ShortestPath::Finder.new(departure, arrival, 4).path
+      expect(path.size).to eq(8)
+      expect(path[0]).to eq(departure)
+      expect(path[1].class).to eq(ActiveRoad::AccessLink)
+      expect(path[2].physical_road.objectid).to eq("ab")
+      expect(path[3].physical_road.objectid).to eq("ac")
+      expect(path[4].physical_road.objectid).to eq("cf")
+      expect(path[6].class).to eq(ActiveRoad::AccessLink)
+      expect(path[7]).to eq(arrival)
+    end
+    
+  end
 
   describe "#path_weights" do       
     
-    let(:subject) { ActiveRoad::ShortestPath::Finder.new departure, arrival, 4 }
+    let(:subject) { ActiveRoad::ShortestPath::Finder.new departure, arrival, 4, ["test"] }
     
     it "should return 0 if no physical road" do
       path = departure 
-      subject.path_weights(path).should == 0
+      expect(subject.path_weights(path)).to eq(0)
     end
     
-    it "should return path weights" do     
+    it "should return path weight if physical road" 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)
+      allow(path).to receive_messages :length_in_meter => 2
+      expect(subject.path_weights(path)).to eq(2 / (4 * 1000/3600))
     end
 
-    it "should return path weights and node weight" do
+    it "should return path weights and node weight if nodes have 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
+      allow(path).to receive_messages :length_in_meter => 2
+      expect(subject.path_weights(path)).to eq(2 / (4 * 1000/3600) + 2.5)
+    end
+
+    it "should return path weights and physical roads weight if physical roads have weight" do
+      physical_road = create(:physical_road)
+      physical_road_conditionnal_cost = create(:physical_road_conditionnal_cost, :physical_road => physical_road, :tags => "test", :cost => 0.2)
+      path = ActiveRoad::Path.new(:departure => create(:junction), :physical_road => physical_road )
+      allow(path).to receive_messages :length_in_meter => 2
+      expect(subject.path_weights(path)).to eq(2 / (4 * 1000/3600) + (2 / (4 * 1000/3600)) * 0.2)
+    end
+
+    it "should return path weights == Infinity and physical roads weight if physical roads have weight" do
+      physical_road = create(:physical_road)
+      physical_road_conditionnal_cost = create(:physical_road_conditionnal_cost, :physical_road => physical_road, :tags => "test", :cost => Float::MAX)
+      path = ActiveRoad::Path.new(:departure => create(:junction), :physical_road => physical_road )
+      allow(path).to receive_messages :length_in_meter => 2
+      expect(subject.path_weights(path)).to eq(Float::INFINITY)
     end
 
   end
@@ -107,51 +146,65 @@ describe ActiveRoad::ShortestPath::Finder do
     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}      
+      expect(subject.refresh_context(node, context)).to eq({ :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}
+      expect(subject.refresh_context(node, context)).to eq({ :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}
+      expect(subject.refresh_context(node, context)).to eq({ :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}
+      expect(subject.refresh_context(node, context)).to eq({:uphill=>0, :downhill=>0, :height=>0})
     end
   end
 
   describe "#follow_way" do       
     
-    let(:node) { mock(:node) }
-    let(:destination) { mock(:destination) }
-    let(:weight) { 2 }
+    let(:node) { double(:node) }
+    let(:destination) { double(:destination) }
     let(:context) { {:uphill => 2} }
-    let(:subject) { ActiveRoad::ShortestPath::Finder.new departure, arrival, 4 }
+    let(:subject) { ActiveRoad::ShortestPath::Finder.new departure, arrival, 4, [], {:uphill => 2} }
 
     before(:each) do 
-      subject.stub :search_heuristic => 1
-      subject.stub :time_heuristic => 2
+      allow(subject).to receive_messages :search_heuristic => 1
+      allow(subject).to receive_messages :time_heuristic => 2      
     end
     
+    it "should not follow way if weight == Infinity" do      
+      expect(subject.follow_way?(node, destination, Float::INFINITY)).to be_falsey
+    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
+      expect(subject.follow_way?(node, destination, 2, context)).to be_falsey
     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
+      expect(subject.follow_way?(node, destination, 2, context)).to be_truthy
     end
 
   end
+
+  describe "#geometry" do         
+    include_context "shared simple graph"
+    
+    let(:shortest_path) { ActiveRoad::ShortestPath::Finder.new(departure, arrival, 4) }
+
+    it "should return geometry" do
+      expect(shortest_path.geometry).not_to eq(nil)
+    end
+  end
   
 end
+

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

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+#####################################
+#    More complex path schema       #
+#####################################
+describe "performance finder test" do       
+  let!(:from) { point(-0.0009, -0.0009) }
+  let!(:to) { point(0.3009, 0.3009) }    
+  let(:subject) { ActiveRoad::ShortestPath::Finder.new from, to, 4, [] }
+  let(:graph_size) { 0.3 }
+  let(:increment_coordinates) { 0.01 }
+  let(:round_coordinates) { 2 }
+  let(:graph_size_by_unit) { graph_size / increment_coordinates}
+
+  before(:each) do
+    x = y = 0.0
+    while y <= graph_size
+      departure = create(:junction, :objectid => "#{x},#{y}", :geometry => point(x, y) )      
+
+      if y > 0
+        previous_departure = ActiveRoad::Junction.find_by_objectid("#{x},#{(y - increment_coordinates).round(round_coordinates)}")
+        create(:physical_road, :objectid => "#{x},#{(y - increment_coordinates).round(round_coordinates)}-#{x},#{y}", :geometry => line_string( previous_departure.geometry, departure.geometry ), :junctions => [previous_departure, departure] )
+      end      
+
+      while x < graph_size
+        x = (x + increment_coordinates).round(round_coordinates)
+        arrival = create(:junction, :objectid => "#{x},#{y}", :geometry => point(x, y) )
+        create(:physical_road, :objectid => "#{(x - increment_coordinates).round(round_coordinates)},#{y}-#{x},#{y}", :geometry => line_string( departure.geometry, arrival.geometry ), :junctions => [departure, arrival] )
+
+        # Link to previous junctions
+        if y > 0          
+          previous_arrival = ActiveRoad::Junction.find_by_objectid("#{x},#{(y - increment_coordinates).round(round_coordinates)}")
+          create(:physical_road, :objectid => "#{x},#{(y - increment_coordinates).round(round_coordinates)}-#{x},#{y}", :geometry => line_string( previous_arrival.geometry, arrival.geometry ), :junctions => [departure, arrival] )
+        end
+
+        # Change the departure in arrival
+        departure = arrival
+      end  
+      
+      x = 0.0
+      y = (y + increment_coordinates).round(round_coordinates)
+    end
+  end   
+  
+  # it "should create correct number of objects", :profile => true do   
+  #   ActiveRoad::Junction.all.size.should ==  (graph_size_by_unit + 1 ) * (graph_size_by_unit + 1)
+  #   ActiveRoad::PhysicalRoad.all.size.should == graph_size_by_unit * ( 2 * graph_size_by_unit + 2)
+  # end
+
+  # Test to read nodes in picardie.osm.pbf data in less 34.910999522 seconds
+  # Test to read nodes and create objects in picardie.osm.pbf data in less 190.617743468 seconds
+  # Test to write nodes in picardie.osm.pbf data in less  seconds
+  
+  it "should evaluate path and profile it", :profile => true do
+    puts subject.path.inspect
+    #subject.path.count.should == graph_size_by_unit * 2 + 4
+  end
+
+end

data/spec/models/active_road/access_point_spec.rb

@@ -1,20 +1,17 @@
 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 ActiveRoad::AccessPoint, :type => :model do
+  let!(:origin) { point(0, 0) }
+  let!(:pr1) { create(:physical_road, :geometry => line_string( "0 0,1 1" )) }
+  let!(:pr2) { create(:physical_road, :geometry => line_string( "0.002 0.002,1 1" )) }
+  let!(:pr3) { create(:physical_road, :geometry => line_string( "2 2,3 3" )) }
+  
+  #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
+      expect( ActiveRoad::AccessPoint.from( origin ).size ).to eq(1)
     end
     
   end
@@ -22,13 +19,7 @@ describe ActiveRoad::AccessPoint do
   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
+      expect( ActiveRoad::AccessPoint.from( origin ).size ).to eq(1)
     end
     
   end

data/spec/models/active_road/junction_conditionnal_cost_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
-describe ActiveRoad::JunctionConditionnalCost do
+describe ActiveRoad::JunctionConditionnalCost, :type => :model do
 
   subject { create(:junction_conditionnal_cost) }
 
   it "should have tags" do
-    subject.should respond_to(:tags)
+    expect(subject).to respond_to(:tags)
   end
 
   it "should have a cost" do
-    subject.should respond_to(:cost)
+    expect(subject).to respond_to(:cost)
   end
 
   it "should have a junction" do
-    subject.should respond_to(:junction_id)
+    expect(subject).to respond_to(:junction_id)
   end
 
   describe "#start_physical_road" do

data/spec/models/active_road/junction_spec.rb

@@ -1,25 +1,48 @@
 require 'spec_helper'
 
-describe ActiveRoad::Junction do
-
-  subject { create(:junction) }
+describe ActiveRoad::Junction, :type => :model do
 
+  subject { create(:junction_with_physical_roads) }
+  
   it "should validate objectid uniqueness" do
     other = build :junction, :objectid => subject.objectid 
-    other.should_not be_valid
+    expect(other).not_to be_valid
   end
 
-  context "junction connected to physical roads" do
-    subject { create(:junction) }
+  describe "#location_on_road" do
+    it "should" do
+      # TODO Understand the result
+      expect(subject.location_on_road(subject.physical_roads.first)).to eq(25.577598616424485)
+    end
+  end
 
-    describe "#physical_roads" do
-      let(:new_road) { create(:physical_road) }
-      it "should be addable" do
-        subject.physical_roads << new_road
-        subject.save!
+  describe "#paths" do
+    it "should return paths from junction" do
+      subject.physical_roads.each do |physical_road|
+        physical_road.junctions << create(:junction)
       end
+      expect(subject.paths.size).to eq(2)
+      expect(subject.paths.collect(&:physical_road).flatten).to match_array(subject.physical_roads)
+    end
+  end
+
+  describe "#access_on_road" do
+    it "should return if junction access to road or not" do
+      expect(subject.access_to_road?(subject.physical_roads.first)).to be_truthy
+      expect(subject.access_to_road?(create(:physical_road))).to be_falsey
     end
   end
   
+  describe "#to_s" do
+    it "should return junction description" do
+      expect(subject.to_s).to eq("Junction @#{subject.geometry.lng},#{subject.geometry.lat}")
+    end
+  end
+
+  describe "#name" do
+    it "should return junction name" do
+      expect(subject.name).to eq(subject.physical_roads.join(" - "))
+    end
+  end
   
 end