Bump another test release.

features/car/stoppage.feature

@@ -1,36 +0,0 @@
-@routing @maxspeed @car
-Feature: Car - Acceleration profiles
-
-    Background: Use specific speeds
-        Given the profile "car"
-        Given a grid size of 1000 meters
-
-    Scenario: Car - Use stoppage penalty at waypoints
-        Given the node map
-            """
-            a 1 2 3 4 5 b
-            """
-
-        And the ways
-            | nodes | highway | maxspeed:forward    | maxspeed:backward |
-            | ab    | trunk   | 60                  | 45                |
-
-        And the query options
-            | stoppage_penalty | 5,100   |
-
-        When I route I should get
-            | from | to | route | time   |
-            | a    | b  | ab,ab | 481.1s |
-
-        When I route I should get
-            | from | to | route | time   |
-            | b    | a  | ab,ab | 609.9s |
-
-        When I route I should get
-            | from | to | route | time |
-            | a    | a  | ab,ab | 0s   |
-
-        When I request a travel time matrix I should get
-            |   | a     | b     |
-            | a | 0     | 481.1 |
-            | b | 609.9 | 0     |

features/testbot/stoppage.feature

@@ -3,9 +3,102 @@ Feature: Testbot - Acceleration profiles
 
     Background: Use specific speeds
         Given the profile "testbot"
-        Given a grid size of 1000 meters
+
+    Scenario: Testbot - No stoppage penalties
+        Given a grid size of 10 meters
+        Given the node map
+            """
+            a 1 2 3 4 5 b
+            """
+
+        And the ways
+            | nodes | highway | maxspeed:forward    | maxspeed:backward |
+            | ab    | trunk   | 60                  | 45                |
+
+        When I route I should get
+            | from | to | route | time   | distance |
+            | a    | b  | ab,ab | 3.6s   | 59.9m    |
+            | a    | 1  | ab,ab | 0.6s   | 10m      |
+            | a    | 2  | ab,ab | 1.2s   | 20m      |
+            | a    | 3  | ab,ab | 1.8s   | 30m      |
+            | a    | 4  | ab,ab | 2.4s   | 40m      |
+            | a    | 5  | ab,ab | 3s     | 50m      |
+            | 5    | b  | ab,ab | 0.6s   | 9.9m     |
+            | 4    | b  | ab,ab | 1.2s   | 19.9m    |
+            | 3    | b  | ab,ab | 1.8s   | 29.9m    |
+            | 2    | b  | ab,ab | 2.4s   | 39.9m    |
+            | 1    | b  | ab,ab | 3s     | 49.9m    |
+            | 1    | 2  | ab,ab | 0.6s   | 10m      |
+            | 1    | 3  | ab,ab | 1.2s   | 20m      |
+            | 1    | 4  | ab,ab | 1.8s   | 30m      |
+            | 1    | 5  | ab,ab | 2.4s   | 40m      |
+
+        When I request a travel time matrix I should get
+            |   | a     | 1     | 2   | 3   | 4   | 5   | b   |
+            | a | 0     | 0.6   | 1.2 | 1.8 | 2.4 | 3   | 3.6 |
+            | 1 | 0.8   | 0     | 0.6 | 1.2 | 1.8 | 2.4 | 3   |
+            | 2 | 1.6   | 0.8   | 0   | 0.6 | 1.2 | 1.8 | 2.4 |
+            | 3 | 2.4   | 1.6   | 0.8 | 0   | 0.6 | 1.2 | 1.8 |
+            | 4 | 3.2   | 2.4   | 1.6 | 0.8 | 0   | 0.6 | 1.2 |
+            | 5 | 4     | 3.2   | 2.4 | 1.6 | 0.8 | 0   | 0.6 |
+            | b | 4.8   | 4     | 3.2 | 2.4 | 1.6 | 0.8 | 0   |
+
+   Scenario: Testbot - No stoppage points, tiny grid size
+        Given a grid size of 1 meters
+        Given the node map
+            """
+            a 1 2 3 4 5 6 7 8 9 b
+            """
+
+        And the ways
+            | nodes | highway | maxspeed:forward    | maxspeed:backward |
+            | ab    | trunk   | 60                  | 45                |
+
+        When I request a travel time matrix I should get
+            |   |  a    |  1    |  2   |  3   |  4   |  5    |  6    |  7   |  8   |  9   |  b   |
+            | a |  0    |  0    |  0.1 |  0.1 |  0.2 |  0.3  |  0.3  |  0.4 |  0.4 |  0.5 |  0.6 |
+            | 1 |  0    |  0    |  0.1 |  0.1 |  0.2 |  0.3  |  0.3  |  0.4 |  0.4 |  0.5 |  0.6 |
+            | 2 |  0.1  |  0.1  |  0   |  0   |  0.1 |  0.2  |  0.2  |  0.3 |  0.3 |  0.4 |  0.5 |
+            | 3 |  0.2  |  0.2  |  0   |  0   |  0.1 |  0.2  |  0.2  |  0.3 |  0.3 |  0.4 |  0.5 |
+            | 4 |  0.3  |  0.3  |  0.2 |  0.1 |  0   |  0.1  |  0.1  |  0.2 |  0.2 |  0.3 |  0.4 |
+            | 5 |  0.4  |  0.4  |  0.3 |  0.2 |  0.1 |  0    |  0    |  0.1 |  0.1 |  0.2 |  0.3 |
+            | 6 |  0.4  |  0.4  |  0.3 |  0.2 |  0.1 |  0    |  0    |  0.1 |  0.1 |  0.2 |  0.3 |
+            | 7 |  0.5  |  0.5  |  0.4 |  0.3 |  0.2 |  0.1  |  0.1  |  0   |  0   |  0.1 |  0.2 |
+            | 8 |  0.6  |  0.6  |  0.5 |  0.4 |  0.3 |  0.2  |  0.2  |  0   |  0   |  0.1 |  0.2 |
+            | 9 |  0.7  |  0.7  |  0.6 |  0.5 |  0.4 |  0.3  |  0.3  |  0.2 |  0.1 |  0   |  0.1 |
+            | b |  0.8  |  0.8  |  0.7 |  0.6 |  0.5 |  0.4  |  0.4  |  0.3 |  0.2 |  0.1 |  0   |
+
+   Scenario: Testbot - No stoppage points, tiny grid size
+        Given a grid size of 1 meters
+        Given the node map
+            """
+            a 1 2 3 4 5 6 7 8 9 b
+            """
+
+        And the ways
+            | nodes | highway | maxspeed:forward    | maxspeed:backward |
+            | ab    | trunk   | 60                  | 45                |
+
+        And the query options
+            | stoppage_penalty | 1.85,15   |
+
+        When I request a travel time matrix I should get
+            |   |  a   |  1   |  2   |  3   |  4   |  5   |  6   |  7   |  8   |  9   |  b   |
+            | a |  0   |  1.4 |  2   |  2.5 |  2.9 |  3.2 |  3.6 |  3.8 |  4.1 |  4.4 |  4.6 |
+            | 1 |  1.4 |  0   |  1.4 |  2   |  2.5 |  2.9 |  3.2 |  3.6 |  3.8 |  4.1 |  4.4 |
+            | 2 |  2   |  1.4 |  0   |  1.4 |  2   |  2.5 |  2.9 |  3.2 |  3.6 |  3.8 |  4.1 |
+            | 3 |  2.5 |  2   |  1.4 |  0   |  1.4 |  2   |  2.5 |  2.9 |  3.2 |  3.6 |  3.8 |
+            | 4 |  2.9 |  2.5 |  2   |  1.4 |  0   |  1.4 |  2   |  2.5 |  2.9 |  3.2 |  3.6 |
+            | 5 |  3.2 |  2.9 |  2.5 |  2   |  1.4 |  0   |  1.4 |  2   |  2.5 |  2.9 |  3.2 |
+            | 6 |  3.6 |  3.2 |  2.9 |  2.5 |  2   |  1.4 |  0   |  1.4 |  2   |  2.5 |  2.9 |
+            | 7 |  3.8 |  3.6 |  3.2 |  2.9 |  2.5 |  2   |  1.4 |  0   |  1.4 |  2   |  2.5 |
+            | 8 |  4.1 |  3.8 |  3.6 |  3.2 |  2.9 |  2.5 |  2   |  1.4 |  0   |  1.4 |  2   |
+            | 9 |  4.4 |  4.1 |  3.8 |  3.6 |  3.2 |  2.9 |  2.5 |  2   |  1.4 |  0   |  1.4 |
+            | b |  4.6 |  4.4 |  4.1 |  3.8 |  3.6 |  3.2 |  2.9 |  2.5 |  2   |  1.4 |  0   |
+
 
     Scenario: Testbot - Use stoppage penalty at waypoints
+        Given a grid size of 10 meters
         Given the node map
             """
             a 1 2 3 4 5 b
@@ -16,21 +109,60 @@ Feature: Testbot - Acceleration profiles
             | ab    | trunk   | 60                  | 45                |
 
         And the query options
-            | stoppage_penalty | 5,100   |
+            | stoppage_penalty | 1.85,15   |
-
-        When I route I should get
-            | from | to | route | time   |
-            | a    | b  | ab,ab | 412.3s |
-
-        When I route I should get
-            | from | to | route | time   |
-            | b    | a  | ab,ab | 505.9s |
-
-        When I route I should get
-            | from | to | route | time |
-            | a    | a  | ab,ab | 0s   |
 
         When I request a travel time matrix I should get
-            |   | a     | b     |
+            |   | a    | 1    | 2   | 3   | 4   | 5    | b    |
-            | a | 0     | 412.3 |
+            | a | 0    | 4.6  | 6.5 | 8   | 9.3 | 10.4 | 11.3 |
-            | b | 505.9 | 0     |
+            | 1 | 4.6  | 0    | 4.6 | 6.5 | 8   | 9.3  | 10.3 |
+            | 2 | 6.5  | 4.6  | 0   | 4.6 | 6.5 | 8    | 9.2  |
+            | 3 | 8    | 6.5  | 4.6 | 0   | 4.6 | 6.5  | 8    |
+            | 4 | 9.3  | 8    | 6.5 | 4.6 | 0   | 4.6  | 6.5  |
+            | 5 | 10.4 | 9.3  | 8   | 6.5 | 4.6 | 0    | 4.6  |
+            | b | 11.3 | 10.3 | 9.2 | 8   | 6.5 | 4.6  | 0    |
+
+
+    Scenario: Long distance grid with no penalty
+        Given a grid size of 1000 meters
+        Given the node map
+            """
+            a 1 2 3 4 5 b
+            """
+
+        And the ways
+            | nodes | highway | maxspeed:forward    | maxspeed:backward |
+            | ab    | trunk   | 60                  | 45                |
+
+        When I request a travel time matrix I should get
+            |   | a     | 1    | 2     | 3     | 4     | 5     | b     |
+            | a | 0     | 59.9 | 119.9 | 179.9 | 239.9 | 299.9 | 359.9 |
+            | 1 | 79.9  | 0    | 60    | 120   | 180   | 240   | 300   |
+            | 2 | 159.9 | 80   | 0     | 60    | 120   | 180   | 240   |
+            | 3 | 239.9 | 160  | 80    | 0     | 60    | 120   | 180   |
+            | 4 | 319.9 | 240  | 160   | 80    | 0     | 60    | 120   |
+            | 5 | 399.9 | 320  | 240   | 160   | 80    | 0     | 60    |
+            | b | 479.9 | 400  | 320   | 240   | 160   | 80    | 0     |
+
+    Scenario: Long distance grid
+        Given a grid size of 1000 meters
+        Given the node map
+            """
+            a 1 2 3 4 5 b
+            """
+
+        And the ways
+            | nodes | highway | maxspeed:forward    | maxspeed:backward |
+            | ab    | trunk   | 60                  | 45                |
+
+        And the query options
+            | stoppage_penalty | 1.85,15   |
+
+        When I request a travel time matrix I should get
+            |   | a     | 1     | 2     | 3     | 4     | 5     | b     |
+            | a | 0     | 68.9  | 128.9 | 188.9 | 248.9 | 308.9 | 368.9 |
+            | 1 | 86.6  | 0     | 69    | 129   | 189   | 249   | 309   |
+            | 2 | 166.6 | 86.7  | 0     | 69    | 129   | 189   | 249   |
+            | 3 | 246.6 | 166.7 | 86.7  | 0     | 69    | 129   | 189   |
+            | 4 | 326.6 | 246.7 | 166.7 | 86.7  | 0     | 69    | 129   |
+            | 5 | 406.6 | 326.7 | 246.7 | 166.7 | 86.7  | 0     | 69    |
+            | b | 486.6 | 406.7 | 326.7 | 246.7 | 166.7 | 86.7  | 0     |

include/engine/api/base_parameters.hpp

@@ -123,8 +123,8 @@ struct BaseParameters
                            });
     }
 };
-}
+} // namespace api
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // ROUTE_PARAMETERS_HPP

include/engine/geospatial_query.hpp

@@ -466,6 +466,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         return distance_and_phantoms;
     }
 
+    // TODO: remove stoppage penalty as its not needed here anymore
     PhantomNodeWithDistance MakePhantomNode(const util::Coordinate input_coordinate,
                                             const EdgeData &data,
                                             const double min_stoppage_penalty = 0,
@@ -555,36 +556,11 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             point_on_segment,
             datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position + 1)));
 
-        // where does this speed lie with respect to the min/max penalizable speeds
-        auto penalty_range = min_stoppage_penalty != INVALID_MINIMUM_STOPPAGE_PENALTY &&
-                                     max_stoppage_penalty != INVALID_MAXIMUM_STOPPAGE_PENALTY
-                                 ? max_stoppage_penalty - min_stoppage_penalty
-                                 : 0;
-        auto stoppage_penalty =
-            [penalty_range, min_stoppage_penalty, max_stoppage_penalty](double speed) -> double {
-            // You're so slow already you don't get a penalty
-            if (speed < MINIMAL_ACCEL_DECEL_PENALIZABLE_SPEED)
-                return 0;
-
-            // Find where it is on the scale
-            constexpr auto max =
-                MAXIMAL_ACCEL_DECEL_PENALIZABLE_SPEED - MINIMAL_ACCEL_DECEL_PENALIZABLE_SPEED;
-            auto ratio = (speed - MINIMAL_ACCEL_DECEL_PENALIZABLE_SPEED) / max;
-
-            // You're faster than the max so you get the max
-            if (ratio >= 1)
-                return max_stoppage_penalty;
-
-            // You're in between so you get a linear combination
-            return min_stoppage_penalty + ratio * penalty_range;
-        };
-
         // We may end up adding a stoppage penalty
-        EdgeDuration forward_stoppage_penalty = 0;
+        double forward_speed = 0;
-        EdgeDuration reverse_stoppage_penalty = 0;
+        double reverse_speed = 0;
-        auto total_distance = penalty_range > 0 ? appx_distance(forward_geometry.begin(),
+        auto total_distance = 0;
-                                                                std::prev(forward_geometry.end()))
+        auto penalty_range = max_stoppage_penalty - min_stoppage_penalty;
-                                                : 0.0;
         ratio = std::min(1.0, std::max(0.0, ratio));
         if (data.forward_segment_id.id != SPECIAL_SEGMENTID)
         {
@@ -593,11 +569,12 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             // Stoppage penalty based on speed
             if (data.forward_segment_id.enabled && penalty_range > 0)
             {
+                total_distance =
+                    appx_distance(forward_geometry.begin(), std::prev(forward_geometry.end()));
                 const auto total_duration = std::accumulate(
                     forward_durations.begin(), forward_durations.end(), EdgeDuration{0});
-                const auto speed = total_distance / (total_duration * 0.1);
+                forward_speed = total_distance / (total_duration * 0.1);
-                forward_stoppage_penalty =
+                reverse_speed = forward_speed;
-                    static_cast<EdgeDuration>((stoppage_penalty(speed) * 10) + .5);
             }
         }
         if (data.reverse_segment_id.id != SPECIAL_SEGMENTID)
@@ -607,11 +584,14 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             // Stoppage penalty based on speed
             if (data.reverse_segment_id.enabled && penalty_range > 0)
             {
+                if (total_distance == 0)
+                    total_distance =
+                        appx_distance(forward_geometry.begin(), std::prev(forward_geometry.end()));
                 const auto total_duration = std::accumulate(
                     reverse_durations.begin(), reverse_durations.end(), EdgeDuration{0});
-                const auto speed = total_distance / (total_duration * 0.1);
+                reverse_speed = total_distance / (total_duration * 0.1);
-                reverse_stoppage_penalty =
+                if (forward_speed == 0)
-                    static_cast<EdgeDuration>((stoppage_penalty(speed) * 10) + .5);
+                    forward_speed = reverse_speed;
             }
         }
 
@@ -643,8 +623,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
                         reverse_duration,
                         forward_duration_offset,
                         reverse_duration_offset,
-                        forward_stoppage_penalty,
+                        static_cast<float>((forward_speed + reverse_speed) / 2.0),
-                        reverse_stoppage_penalty,
                         is_forward_valid_source,
                         is_forward_valid_target,
                         is_reverse_valid_source,

include/engine/guidance/assemble_leg.hpp

@@ -182,12 +182,8 @@ inline RouteLeg assembleLeg(const datafacade::BaseDataFacade &facade,
         duration = std::max(0, duration);
     }
 
-    // Add start and stop penalties
+    // TODO: Add start and stop penalties to the duration to simulate accel/deceleration
-    if (distance > 0)
+    //
-        duration +=
-            (target_traversed_in_reverse
-                 ? source_node.reverse_duration_penalty + target_node.reverse_duration_penalty
-                 : source_node.forward_duration_penalty + target_node.forward_duration_penalty);
 
     std::string summary;
     if (needs_summary)

include/engine/hint.hpp

@@ -64,7 +64,7 @@ struct Hint
 };
 
 static_assert(sizeof(Hint) == sizeof(PhantomNode) + 4, "Hint is bigger than expected");
-constexpr std::size_t ENCODED_HINT_SIZE = 124;
+constexpr std::size_t ENCODED_HINT_SIZE = 120;
 static_assert(ENCODED_HINT_SIZE / 4 * 3 >= sizeof(Hint),
               "ENCODED_HINT_SIZE does not match size of Hint");
 } // namespace engine

include/engine/phantom_node.hpp

@@ -44,16 +44,16 @@ namespace engine
 struct PhantomNode
 {
     PhantomNode()
-        : forward_segment_id{SPECIAL_SEGMENTID, false},
+        : forward_segment_id{SPECIAL_SEGMENTID, false}, reverse_segment_id{SPECIAL_SEGMENTID,
-          reverse_segment_id{SPECIAL_SEGMENTID, false}, forward_weight(INVALID_EDGE_WEIGHT),
+                                                                           false},
-          reverse_weight(INVALID_EDGE_WEIGHT), forward_weight_offset(0), reverse_weight_offset(0),
+          forward_weight(INVALID_EDGE_WEIGHT), reverse_weight(INVALID_EDGE_WEIGHT),
+          forward_weight_offset(0), reverse_weight_offset(0),
           forward_distance(INVALID_EDGE_DISTANCE), reverse_distance(INVALID_EDGE_DISTANCE),
           forward_distance_offset(0), reverse_distance_offset(0),
           forward_duration(MAXIMAL_EDGE_DURATION), reverse_duration(MAXIMAL_EDGE_DURATION),
-          forward_duration_offset(0), reverse_duration_offset(0), forward_duration_penalty(0),
+          forward_duration_offset(0), reverse_duration_offset(0), speed_approximation(0),
-          reverse_duration_penalty(0), fwd_segment_position(0), is_valid_forward_source{false},
+          fwd_segment_position(0), is_valid_forward_source{false}, is_valid_forward_target{false},
-          is_valid_forward_target{false}, is_valid_reverse_source{false},
+          is_valid_reverse_source{false}, is_valid_reverse_target{false}, bearing(0)
-          is_valid_reverse_target{false}, bearing(0)
 
     {
     }
@@ -110,8 +110,9 @@ struct PhantomNode
 
     bool IsValid(const unsigned number_of_nodes) const
     {
-        return location.IsValid() && ((forward_segment_id.id < number_of_nodes) ||
+        return location.IsValid() &&
-                                      (reverse_segment_id.id < number_of_nodes)) &&
+               ((forward_segment_id.id < number_of_nodes) ||
+                (reverse_segment_id.id < number_of_nodes)) &&
                ((forward_weight != INVALID_EDGE_WEIGHT) ||
                 (reverse_weight != INVALID_EDGE_WEIGHT)) &&
                ((forward_duration != MAXIMAL_EDGE_DURATION) ||
@@ -168,8 +169,7 @@ struct PhantomNode
                          EdgeDuration reverse_duration,
                          EdgeDuration forward_duration_offset,
                          EdgeDuration reverse_duration_offset,
-                         EdgeDuration forward_duration_penalty,
+                         EdgeDistance speed_approximation,
-                         EdgeDuration reverse_duration_penalty,
                          bool is_valid_forward_source,
                          bool is_valid_forward_target,
                          bool is_valid_reverse_source,
@@ -185,10 +185,9 @@ struct PhantomNode
           reverse_distance_offset{reverse_distance_offset}, forward_duration{forward_duration},
           reverse_duration{reverse_duration}, forward_duration_offset{forward_duration_offset},
           reverse_duration_offset{reverse_duration_offset},
-          forward_duration_penalty{forward_duration_penalty},
+          speed_approximation{speed_approximation}, component{component.id, component.is_tiny},
-          reverse_duration_penalty{reverse_duration_penalty},
+          location{location}, input_location{input_location},
-          component{component.id, component.is_tiny}, location{location},
+          fwd_segment_position{other.fwd_segment_position},
-          input_location{input_location}, fwd_segment_position{other.fwd_segment_position},
           is_valid_forward_source{is_valid_forward_source},
           is_valid_forward_target{is_valid_forward_target},
           is_valid_reverse_source{is_valid_reverse_source},
@@ -210,8 +209,7 @@ struct PhantomNode
     EdgeDuration reverse_duration;
     EdgeDuration forward_duration_offset; // TODO: try to remove -> requires path unpacking changes
     EdgeDuration reverse_duration_offset; // TODO: try to remove -> requires path unpacking changes
-    EdgeDuration forward_duration_penalty;
+    EdgeDistance speed_approximation;     // m/s
-    EdgeDuration reverse_duration_penalty;
 
     ComponentID component;
 
@@ -227,7 +225,7 @@ struct PhantomNode
     unsigned short bearing : 12;
 };
 
-static_assert(sizeof(PhantomNode) == 88, "PhantomNode has more padding then expected");
+static_assert(sizeof(PhantomNode) == 84, "PhantomNode has more padding then expected");
 
 using PhantomNodePair = std::pair<PhantomNode, PhantomNode>;
 

include/engine/routing_algorithms/routing_base.hpp

@@ -86,7 +86,7 @@ void insertSourceInHeap(ManyToManyQueryHeap &heap, const PhantomNode &phantom_no
         heap.Insert(phantom_node.forward_segment_id.id,
                     -phantom_node.GetForwardWeightPlusOffset(),
                     {phantom_node.forward_segment_id.id,
-                     -phantom_node.GetForwardDuration() + phantom_node.forward_duration_penalty,
+                     -phantom_node.GetForwardDuration(),
                      -phantom_node.GetForwardDistance()});
     }
     if (phantom_node.IsValidReverseSource())
@@ -94,7 +94,7 @@ void insertSourceInHeap(ManyToManyQueryHeap &heap, const PhantomNode &phantom_no
         heap.Insert(phantom_node.reverse_segment_id.id,
                     -phantom_node.GetReverseWeightPlusOffset(),
                     {phantom_node.reverse_segment_id.id,
-                     -phantom_node.GetReverseDuration() + phantom_node.reverse_duration_penalty,
+                     -phantom_node.GetReverseDuration(),
                      -phantom_node.GetReverseDistance()});
     }
 }
@@ -107,7 +107,7 @@ void insertTargetInHeap(ManyToManyQueryHeap &heap, const PhantomNode &phantom_no
         heap.Insert(phantom_node.forward_segment_id.id,
                     phantom_node.GetForwardWeightPlusOffset(),
                     {phantom_node.forward_segment_id.id,
-                     phantom_node.GetForwardDuration() + phantom_node.forward_duration_penalty,
+                     phantom_node.GetForwardDuration(),
                      phantom_node.GetForwardDistance()});
     }
     if (phantom_node.IsValidReverseTarget())
@@ -115,7 +115,7 @@ void insertTargetInHeap(ManyToManyQueryHeap &heap, const PhantomNode &phantom_no
         heap.Insert(phantom_node.reverse_segment_id.id,
                     phantom_node.GetReverseWeightPlusOffset(),
                     {phantom_node.reverse_segment_id.id,
-                     phantom_node.GetReverseDuration() + phantom_node.reverse_duration_penalty,
+                     phantom_node.GetReverseDuration(),
                      phantom_node.GetReverseDistance()});
     }
 }

include/nodejs/node_osrm_support.hpp

@@ -762,8 +762,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
             return false;
         }
 
-        params->max_stoppage_penalty = min;
+        params->max_stoppage_penalty = max;
-        params->min_stoppage_penalty = max;
+        params->min_stoppage_penalty = min;
     }
 
     return true;

include/server/api/base_parameters_grammar.hpp

@@ -25,7 +25,7 @@ namespace
 {
 namespace ph = boost::phoenix;
 namespace qi = boost::spirit::qi;
-}
+} // namespace
 
 template <typename T, char... Fmt> struct no_trailing_dot_policy : qi::real_policies<T>
 {
@@ -222,8 +222,8 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
     qi::symbols<char, engine::Approach> approach_type;
     qi::symbols<char, engine::api::BaseParameters::SnappingType> snapping_type;
 };
-}
+} // namespace api
-}
+} // namespace server
-}
+} // namespace osrm
 
 #endif

include/util/typedefs.hpp

@@ -119,8 +119,7 @@ static const EdgeDistance INVALID_EDGE_DISTANCE = std::numeric_limits<EdgeDistan
 static const EdgeDistance INVALID_FALLBACK_SPEED = std::numeric_limits<EdgeDistance>::max();
 constexpr EdgeDuration INVALID_MINIMUM_STOPPAGE_PENALTY = std::numeric_limits<EdgeDuration>::max();
 constexpr EdgeDuration INVALID_MAXIMUM_STOPPAGE_PENALTY = std::numeric_limits<EdgeDuration>::max();
-constexpr double MINIMAL_ACCEL_DECEL_PENALIZABLE_SPEED = 10; // metres/second
+constexpr float MAXIMAL_ACCEL_DECEL_PENALIZABLE_SPEED_INVERSE = 40.f; // seconds/metre
-constexpr double MAXIMAL_ACCEL_DECEL_PENALIZABLE_SPEED = 40; // metres/sec
 
 // FIXME the bitfields we use require a reduced maximal duration, this should be kept consistent
 // within the code base. For now we have to ensure that we don't case 30 bit to -1 and break any

package.json

@@ -1,6 +1,6 @@
 {
   "name": "osrm",
-  "version": "5.21.0-customsnapping.2",
+  "version": "5.21.0-customsnapping.6",
   "private": false,
   "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
   "dependencies": {

src/engine/plugins/table.cpp

@@ -86,8 +86,10 @@ Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
     bool request_distance = params.annotations & api::TableParameters::AnnotationsType::Distance;
     bool request_duration = params.annotations & api::TableParameters::AnnotationsType::Duration;
 
+    constexpr bool always_calculate_distance = true;
+
     auto result_tables_pair = algorithms.ManyToManySearch(
-        snapped_phantoms, params.sources, params.destinations, request_distance);
+        snapped_phantoms, params.sources, params.destinations, always_calculate_distance);
 
     if ((request_duration && result_tables_pair.first.empty()) ||
         (request_distance && result_tables_pair.second.empty()))
@@ -97,6 +99,57 @@ Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
 
     std::vector<api::TableAPI::TableCellRef> estimated_pairs;
 
+    // Adds some time to adjust for getting up to speed and slowing down to a stop
+    // Returns a new `duration`
+    auto adjust_for_startstop = [](const double &comfortable_acceleration,
+                                   const EdgeDuration &duration,
+                                   const EdgeDistance &distance) -> EdgeDuration {
+
+        // Assume linear acceleration from 0 to velocity
+        // auto comfortable_acceleration = 1.85; // m/s^2
+
+        // Very short paths can end up with 0 duration.  That'll lead to a divide
+        // by zero, so instead, we'll assume the travel speed is 10m/s (36km/h).
+        // Typically, the distance is also short, so we're quibbling at tiny numbers
+        // here, but tiny numbers is what this adjustment lambda is all about,
+        // so we do try to be reasonable.
+        const auto average_speed =
+            duration == 0 ? 10 : distance /
+                                     (duration / 10.); // duration is in deciseconds, we need m/sec
+
+        // Using the equations of motion as a simple approximation, assuming constant acceleration
+        // https://en.wikipedia.org/wiki/Equations_of_motion#Constant_translational_acceleration_in_a_straight_line
+        const auto distance_to_full_speed =
+            (average_speed * average_speed) / (2 * comfortable_acceleration);
+
+        /*
+                std::cout << "Comfortable accel is " << comfortable_acceleration << std::endl;
+                std::cout << "Average speed is " << average_speed << " duration is " << duration
+                          << std::endl;
+                std::cout << "Distance is " << distance << " distance to full speed is "
+                          << distance_to_full_speed << std::endl;
+                          */
+
+        if (distance_to_full_speed > distance / 2)
+        {
+            // std::cout << "Distance was too short, so only using half" << std::endl;
+            const auto time_to_halfway = std::sqrt(distance / comfortable_acceleration);
+            return (2 * time_to_halfway) * 10; // result is in deciseconds
+        }
+        else
+        {
+            // std::cout << "Distance was long, using cruising speed" << std::endl;
+            const auto cruising_distance = distance - 2 * distance_to_full_speed;
+            const auto cruising_time = cruising_distance / average_speed;
+            const auto acceleration_time = average_speed / comfortable_acceleration;
+
+            // std::cout << "Cruising distance is " << cruising_distance << std::endl;
+            // std::cout << "Cruising time is " << cruising_time << std::endl;
+            // std::cout << "Acceleration time is " << acceleration_time << std::endl;
+            return (cruising_time + 2 * acceleration_time) * 10; // result is in deciseconds
+        }
+    };
+
     // Scan table for null results - if any exist, replace with distance estimates
     if (params.fallback_speed != INVALID_FALLBACK_SPEED || params.scale_factor != 1 ||
         (params.min_stoppage_penalty != INVALID_MINIMUM_STOPPAGE_PENALTY &&
@@ -108,9 +161,21 @@ Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
             {
                 const auto &table_index = row * num_destinations + column;
                 BOOST_ASSERT(table_index < result_tables_pair.first.size());
-                // Zero out the diagonal
+                // apply an accel/deceleration penalty to the duration
-                if (result_tables_pair.first[table_index] != MAXIMAL_EDGE_DURATION && row == column)
+                if (result_tables_pair.first[table_index] != MAXIMAL_EDGE_DURATION && row != column)
-                    result_tables_pair.first[table_index] = 0;
+                {
+                    /*
+                    const auto &source =
+                        snapped_phantoms[params.sources.empty() ? row : params.sources[row]];
+                    const auto &destination =
+                        snapped_phantoms[params.destinations.empty() ? column
+                                                                     : params.destinations[column]];
+                    */
+                    result_tables_pair.first[table_index] =
+                        adjust_for_startstop(params.min_stoppage_penalty,
+                                             result_tables_pair.first[table_index],
+                                             result_tables_pair.second[table_index]);
+                }
                 // Estimate null results based on fallback_speed (if valid) and distance
                 if (params.fallback_speed != INVALID_FALLBACK_SPEED && params.fallback_speed > 0 &&
                     result_tables_pair.first[table_index] == MAXIMAL_EDGE_DURATION)
@@ -160,6 +225,14 @@ Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
         }
     }
 
+    // If distances weren't requested, delete them from the result so they don't
+    // get rendered.
+    if (!request_distance)
+    {
+        std::vector<EdgeDistance> empty;
+        result_tables_pair.second.swap(empty);
+    }
+
     api::TableAPI table_api{facade, params};
     table_api.MakeResponse(result_tables_pair, snapped_phantoms, estimated_pairs, result);