travel mode

Contractor/EdgeBasedGraphFactory.cpp

@@ -181,7 +181,9 @@ EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const NodeID nod
                                                 reverse_dist_prefix_sum[i],
                                                 m_geometry_compressor.GetPositionForID(e1),
                                                 i,
-                                                belongs_to_tiny_cc);
+                                                belongs_to_tiny_cc,
+                                                forward_data.travel_mode,
+                                                reverse_data.travel_mode);
             current_edge_source_coordinate_id = current_edge_target_coordinate_id;
 
             BOOST_ASSERT(m_edge_based_node_list.back().IsCompressed());
@@ -231,7 +233,9 @@ EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const NodeID nod
                                             0,
                                             SPECIAL_EDGEID,
                                             0,
-                                            belongs_to_tiny_cc);
+                                            belongs_to_tiny_cc,
+                                            forward_data.travel_mode,
+                                            reverse_data.travel_mode);
         BOOST_ASSERT(!m_edge_based_node_list.back().IsCompressed());
     }
 }
@@ -500,7 +504,6 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
             }
 
             BOOST_ASSERT(u < v);
-            BOOST_ASSERT(edge_data.type != SHRT_MAX);
 
             // Note: edges that end on barrier nodes or on a turn restriction
             // may actually be in two distinct components. We choose the smallest
@@ -648,7 +651,8 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(const std::string &original_edg
                     (edge_is_compressed ? m_geometry_compressor.GetPositionForID(e1) : v),
                     edge_data1.nameID,
                     turn_instruction,
-                    edge_is_compressed);
+                    edge_is_compressed,
+                    edge_data2.travel_mode);
 
                 ++original_edges_counter;
 
@@ -718,15 +722,6 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID node_u,
     const EdgeData &data1 = m_node_based_graph->GetEdgeData(edge1);
     const EdgeData &data2 = m_node_based_graph->GetEdgeData(edge2);
 
-    if (!data1.contraFlow && data2.contraFlow)
-    {
-        return TurnInstruction::EnterAgainstAllowedDirection;
-    }
-    if (data1.contraFlow && !data2.contraFlow)
-    {
-        return TurnInstruction::LeaveAgainstAllowedDirection;
-    }
-
     // roundabouts need to be handled explicitely
     if (data1.roundabout && data2.roundabout)
     {

DataStructures/EdgeBasedNode.h

@@ -1,6 +1,7 @@
 #ifndef EDGE_BASED_NODE_H
 #define EDGE_BASED_NODE_H
 
+#include "../DataStructures/TravelMode.h"
 #include "../Util/SimpleLogger.h"
 #include "../typedefs.h"
 
@@ -25,7 +26,9 @@ struct EdgeBasedNode
         reverse_offset(0),
         packed_geometry_id(SPECIAL_EDGEID),
         fwd_segment_position( std::numeric_limits<unsigned short>::max() ),
-        is_in_tiny_cc(false)
+        is_in_tiny_cc(false),
+        forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
+        backward_travel_mode(TRAVEL_MODE_INACCESSIBLE)
     { }
 
     explicit EdgeBasedNode(
@@ -40,7 +43,9 @@ struct EdgeBasedNode
         int reverse_offset,
         unsigned packed_geometry_id,
         unsigned short fwd_segment_position,
-        bool belongs_to_tiny_component
+        bool belongs_to_tiny_component,
+        TravelMode forward_travel_mode,
+        TravelMode backward_travel_mode
     ) :
         forward_edge_based_node_id(forward_edge_based_node_id),
         reverse_edge_based_node_id(reverse_edge_based_node_id),
@@ -53,7 +58,9 @@ struct EdgeBasedNode
         reverse_offset(reverse_offset),
         packed_geometry_id(packed_geometry_id),
         fwd_segment_position(fwd_segment_position),
-        is_in_tiny_cc(belongs_to_tiny_component)
+        is_in_tiny_cc(belongs_to_tiny_component),
+        forward_travel_mode(forward_travel_mode),
+        backward_travel_mode(backward_travel_mode)
     {
         BOOST_ASSERT((forward_edge_based_node_id != SPECIAL_NODEID) ||
                      (reverse_edge_based_node_id != SPECIAL_NODEID));
@@ -85,6 +92,8 @@ struct EdgeBasedNode
     unsigned packed_geometry_id; // if set, then the edge represents a packed geometry
     unsigned short fwd_segment_position; // segment id in a compressed geometry
     bool is_in_tiny_cc;
+    TravelMode forward_travel_mode : 4;
+    TravelMode backward_travel_mode : 4;
 };
 
 #endif //EDGE_BASED_NODE_H

DataStructures/ImportEdge.cpp

@@ -52,17 +52,15 @@ NodeBasedEdge::NodeBasedEdge(NodeID source,
                              EdgeWeight weight,
                              bool forward,
                              bool backward,
-                             short type,
                              bool roundabout,
                              bool in_tiny_cc,
                              bool access_restricted,
-                             bool contra_flow,
+                             TravelMode travel_mode,
                              bool is_split)
-    : source(source), target(target), name_id(name_id), weight(weight), type(type),
+    : source(source), target(target), name_id(name_id), weight(weight),
       forward(forward), backward(backward), roundabout(roundabout), in_tiny_cc(in_tiny_cc),
-      access_restricted(access_restricted), contra_flow(contra_flow), is_split(is_split)
+      access_restricted(access_restricted), is_split(is_split), travel_mode(travel_mode)
 {
-    BOOST_ASSERT_MSG(type > 0, "negative edge type");
 }
 
 bool EdgeBasedEdge::operator<(const EdgeBasedEdge &other) const

DataStructures/ImportEdge.h

@@ -28,6 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef IMPORT_EDGE_H
 #define IMPORT_EDGE_H
 
+#include "../DataStructures/TravelMode.h"
 #include "../typedefs.h"
 
 struct NodeBasedEdge
@@ -40,25 +41,23 @@ struct NodeBasedEdge
                            EdgeWeight weight,
                            bool forward,
                            bool backward,
-                           short type,
                            bool roundabout,
                            bool in_tiny_cc,
                            bool access_restricted,
-                           bool contra_flow,
+                           TravelMode travel_mode,
                            bool is_split);
 
     NodeID source;
     NodeID target;
     NodeID name_id;
     EdgeWeight weight;
-    short type;
     bool forward : 1;
     bool backward : 1;
     bool roundabout : 1;
     bool in_tiny_cc : 1;
     bool access_restricted : 1;
-    bool contra_flow : 1;
     bool is_split : 1;
+    TravelMode travel_mode : 4;
 
     NodeBasedEdge() = delete;
 };

DataStructures/NodeBasedGraph.h

@@ -13,23 +13,22 @@ struct NodeBasedEdgeData
 {
     NodeBasedEdgeData()
         : distance(INVALID_EDGE_WEIGHT), edgeBasedNodeID(SPECIAL_NODEID),
-          nameID(std::numeric_limits<unsigned>::max()), type(std::numeric_limits<short>::max()),
+          nameID(std::numeric_limits<unsigned>::max()),
           isAccessRestricted(false), shortcut(false), forward(false), backward(false),
-          roundabout(false), ignore_in_grid(false), contraFlow(false)
+          roundabout(false), ignore_in_grid(false), travel_mode(TRAVEL_MODE_INACCESSIBLE)
     {
     }
 
     int distance;
     unsigned edgeBasedNodeID;
     unsigned nameID;
-    short type;
     bool isAccessRestricted : 1;
     bool shortcut : 1;
     bool forward : 1;
     bool backward : 1;
     bool roundabout : 1;
     bool ignore_in_grid : 1;
-    bool contraFlow : 1;
+    TravelMode travel_mode : 4;
 
     void SwapDirectionFlags()
     {
@@ -42,7 +41,7 @@ struct NodeBasedEdgeData
     {
         return (forward == other.forward) && (backward == other.backward) &&
                (nameID == other.nameID) && (ignore_in_grid == other.ignore_in_grid) &&
-               (contraFlow == other.contraFlow);
+               (travel_mode == other.travel_mode);
     }
 };
 
@@ -91,9 +90,9 @@ NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector<ImportEdge
         edge.data.roundabout = import_edge.roundabout;
         edge.data.ignore_in_grid = import_edge.in_tiny_cc;
         edge.data.nameID = import_edge.name_id;
-        edge.data.type = import_edge.type;
         edge.data.isAccessRestricted = import_edge.access_restricted;
-        edge.data.contraFlow = import_edge.contra_flow;
+        edge.data.travel_mode = import_edge.travel_mode;
+
         edges_list.push_back(edge);
 
         if (!import_edge.is_split)

DataStructures/OriginalEdgeData.h

@@ -29,6 +29,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define ORIGINAL_EDGE_DATA_H
 
 #include "TurnInstructions.h"
+#include "../DataStructures/TravelMode.h"
 #include "../typedefs.h"
 
 #include <limits>
@@ -38,23 +39,26 @@ struct OriginalEdgeData
     explicit OriginalEdgeData(NodeID via_node,
                               unsigned name_id,
                               TurnInstruction turn_instruction,
-                              bool compressed_geometry)
+                              bool compressed_geometry,
+                              TravelMode travel_mode)
         : via_node(via_node), name_id(name_id), turn_instruction(turn_instruction),
-          compressed_geometry(compressed_geometry)
+          compressed_geometry(compressed_geometry), travel_mode(travel_mode)
     {
     }
 
     OriginalEdgeData()
         : via_node(std::numeric_limits<unsigned>::max()),
           name_id(std::numeric_limits<unsigned>::max()),
-          turn_instruction(TurnInstruction::NoTurn), compressed_geometry(false)
+          turn_instruction(TurnInstruction::NoTurn), compressed_geometry(false),
+          travel_mode(TRAVEL_MODE_INACCESSIBLE)
     {
     }
 
     NodeID via_node;
     unsigned name_id;
     TurnInstruction turn_instruction;
     bool compressed_geometry;
+    TravelMode travel_mode;
 };
 
 #endif // ORIGINAL_EDGE_DATA_H

DataStructures/PhantomNodes.h

@@ -29,6 +29,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define PHANTOM_NODES_H
 
 #include <osrm/Coordinate.h>
+#include "../DataStructures/TravelMode.h"
 #include "../Util/SimpleLogger.h"
 #include "../typedefs.h"
 
@@ -39,7 +40,8 @@ struct PhantomNode
     PhantomNode(NodeID forward_node_id, NodeID reverse_node_id, unsigned name_id,
                 int forward_weight, int reverse_weight, int forward_offset, int reverse_offset,
                 unsigned packed_geometry_id, FixedPointCoordinate &location,
-                unsigned short fwd_segment_position) :
+                unsigned short fwd_segment_position,
+                TravelMode forward_travel_mode, TravelMode backward_travel_mode) :
         forward_node_id(forward_node_id),
         reverse_node_id(reverse_node_id),
         name_id(name_id),
@@ -49,7 +51,9 @@ struct PhantomNode
         reverse_offset(reverse_offset),
         packed_geometry_id(packed_geometry_id),
         location(location),
-        fwd_segment_position(fwd_segment_position)
+        fwd_segment_position(fwd_segment_position),
+        forward_travel_mode(forward_travel_mode),
+        backward_travel_mode(backward_travel_mode)
     { }
 
     PhantomNode() :
@@ -61,7 +65,9 @@ struct PhantomNode
         forward_offset(0),
         reverse_offset(0),
         packed_geometry_id(SPECIAL_EDGEID),
-        fwd_segment_position(0)
+        fwd_segment_position(0),
+        forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
+        backward_travel_mode(TRAVEL_MODE_INACCESSIBLE)
     { }
 
     NodeID forward_node_id;
@@ -74,7 +80,9 @@ struct PhantomNode
     unsigned packed_geometry_id;
     FixedPointCoordinate location;
     unsigned short fwd_segment_position;
-
+    TravelMode forward_travel_mode : 4;
+    TravelMode backward_travel_mode : 4;
+
     int GetForwardWeightPlusOffset() const
     {
         if (SPECIAL_NODEID == forward_node_id)

DataStructures/RawRouteData.h

@@ -29,6 +29,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define RAW_ROUTE_DATA_H
 
 #include "../DataStructures/PhantomNodes.h"
+#include "../DataStructures/TravelMode.h"
 #include "../DataStructures/TurnInstructions.h"
 #include "../typedefs.h"
 
@@ -41,18 +42,25 @@ struct PathData
     PathData()
         : node(SPECIAL_NODEID), name_id(INVALID_EDGE_WEIGHT),
           segment_duration(INVALID_EDGE_WEIGHT),
-          turn_instruction(TurnInstruction::NoTurn)
+          turn_instruction(TurnInstruction::NoTurn),
+          travel_mode(TRAVEL_MODE_INACCESSIBLE)
     {
     }
 
-    PathData(NodeID node, unsigned name_id, TurnInstruction turn_instruction, EdgeWeight segment_duration)
-        : node(node), name_id(name_id), segment_duration(segment_duration), turn_instruction(turn_instruction)
+    PathData(NodeID node,
+             unsigned name_id,
+             TurnInstruction turn_instruction,
+             EdgeWeight segment_duration,
+             TravelMode travel_mode)
+        : node(node), name_id(name_id), segment_duration(segment_duration), turn_instruction(turn_instruction),
+          travel_mode(travel_mode)
     {
     }
     NodeID node;
     unsigned name_id;
     EdgeWeight segment_duration;
     TurnInstruction turn_instruction;
+    TravelMode travel_mode : 4;
 };
 
 struct RawRouteData

DataStructures/SegmentInformation.h

@@ -30,6 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "TurnInstructions.h"
 
+#include "../DataStructures/TravelMode.h"
 #include "../typedefs.h"
 
 #include <osrm/Coordinate.h>
@@ -43,28 +44,33 @@ struct SegmentInformation
     float length;
     short bearing; // more than enough [0..3600] fits into 12 bits
     TurnInstruction turn_instruction;
-    bool necessary:1;
-    bool is_via_location:1;
+    TravelMode travel_mode;
+    bool necessary;
+    bool is_via_location;
 
     explicit SegmentInformation(const FixedPointCoordinate &location,
                                 const NodeID name_id,
                                 const EdgeWeight duration,
                                 const float length,
                                 const TurnInstruction turn_instruction,
                                 const bool necessary,
-                                const bool is_via_location)
+                                const bool is_via_location,
+                                const TravelMode travel_mode)
         : location(location), name_id(name_id), duration(duration), length(length), bearing(0),
-          turn_instruction(turn_instruction), necessary(necessary), is_via_location(is_via_location)
+          turn_instruction(turn_instruction), travel_mode(travel_mode), necessary(necessary),
+          is_via_location(is_via_location)
     {
     }
 
     explicit SegmentInformation(const FixedPointCoordinate &location,
                                 const NodeID name_id,
                                 const EdgeWeight duration,
                                 const float length,
-                                const TurnInstruction turn_instruction)
+                                const TurnInstruction turn_instruction,
+                                const TravelMode travel_mode)
         : location(location), name_id(name_id), duration(duration), length(length), bearing(0),
-          turn_instruction(turn_instruction), necessary(turn_instruction != TurnInstruction::NoTurn), is_via_location(false)
+          turn_instruction(turn_instruction), travel_mode(travel_mode),
+          necessary(turn_instruction != TurnInstruction::NoTurn), is_via_location(false)
     {
     }
 };