Move renumbering and edge deduplication in extractor

Project-OSRM · Jun 1, 2015 · 3065de6 · 3065de6
1 parent a57fb4f
commit 3065de6
Show file tree

Hide file tree

Showing 11 changed files with 235 additions and 194 deletions.
diff --git a/contractor/edge_based_graph_factory.cpp b/contractor/edge_based_graph_factory.cpp
@@ -343,8 +343,14 @@ void EdgeBasedGraphFactory::CompressGeometry()
             continue;
         }
 
-        if ( // TODO: rename to IsCompatibleTo
-            fwd_edge_data1.IsEqualTo(fwd_edge_data2) && rev_edge_data1.IsEqualTo(rev_edge_data2))
+        // this case can happen if two ways with different names overlap
+        if (fwd_edge_data1.nameID != rev_edge_data1.nameID ||
+            fwd_edge_data2.nameID != rev_edge_data2.nameID)
+        {
+            continue;
+        }
+
+        if (fwd_edge_data1.IsCompatibleTo(fwd_edge_data2) && rev_edge_data1.IsCompatibleTo(rev_edge_data2))
         {
             BOOST_ASSERT(m_node_based_graph->GetEdgeData(forward_e1).nameID ==
                          m_node_based_graph->GetEdgeData(reverse_e1).nameID);

diff --git a/contractor/processing_chain.cpp b/contractor/processing_chain.cpp
@@ -303,44 +303,38 @@ void Prepare::SetupScriptingEnvironment(
 /**
   \brief Build load restrictions from .restriction file
   */
-void Prepare::LoadRestrictionMap(const std::unordered_map<NodeID, NodeID> &external_to_internal_node_map,
-                                 RestrictionMap &restriction_map)
+std::shared_ptr<RestrictionMap> Prepare::LoadRestrictionMap()
 {
     boost::filesystem::ifstream input_stream(config.restrictions_path, std::ios::in | std::ios::binary);
 
     std::vector<TurnRestriction> restriction_list;
-    loadRestrictionsFromFile(input_stream, external_to_internal_node_map, restriction_list);
+    loadRestrictionsFromFile(input_stream, restriction_list);
 
     SimpleLogger().Write() << " - " << restriction_list.size() << " restrictions.";
 
-    restriction_map = RestrictionMap(restriction_list);
+    return std::make_shared<RestrictionMap>(restriction_list);
 }
 
 /**
-  \brief Build load node based graph from .osrm file and restrictions from .restrictions file
+  \brief Load node based graph from .osrm file
   */
 std::shared_ptr<NodeBasedDynamicGraph>
 Prepare::LoadNodeBasedGraph(std::vector<NodeID> &barrier_node_list,
                             std::vector<NodeID> &traffic_light_list,
-                            RestrictionMap &restriction_map,
                             std::vector<QueryNode>& internal_to_external_node_map)
 {
     std::vector<NodeBasedEdge> edge_list;
-    std::unordered_map<NodeID, NodeID> external_to_internal_node_map;
 
     boost::filesystem::ifstream input_stream(config.osrm_input_path, std::ios::in | std::ios::binary);
 
     NodeID number_of_node_based_nodes = loadNodesFromFile(input_stream,
                                             barrier_node_list, traffic_light_list,
-                                            internal_to_external_node_map,
-                                            external_to_internal_node_map);
+                                            internal_to_external_node_map);
 
     SimpleLogger().Write() << " - " << barrier_node_list.size() << " bollard nodes, "
                            << traffic_light_list.size() << " traffic lights";
 
-    loadEdgesFromFile(input_stream, external_to_internal_node_map, edge_list);
-
-    LoadRestrictionMap(external_to_internal_node_map, restriction_map);
+    loadEdgesFromFile(input_stream, edge_list);
 
     if (edge_list.empty())
     {
@@ -369,9 +363,9 @@ Prepare::BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_nod
 
     auto barrier_node_list = osrm::make_unique<std::vector<NodeID>>();
     auto traffic_light_list = osrm::make_unique<std::vector<NodeID>>();
-    auto restriction_map = std::make_shared<RestrictionMap>();
 
-    auto node_based_graph = LoadNodeBasedGraph(*barrier_node_list, *traffic_light_list, *restriction_map, internal_to_external_node_map);
+    auto restriction_map = LoadRestrictionMap();
+    auto node_based_graph = LoadNodeBasedGraph(*barrier_node_list, *traffic_light_list, internal_to_external_node_map);
 
     const std::size_t number_of_node_based_nodes = node_based_graph->GetNumberOfNodes();
 

diff --git a/contractor/processing_chain.hpp b/contractor/processing_chain.hpp
@@ -61,8 +61,7 @@ class Prepare
   protected:
     void SetupScriptingEnvironment(lua_State *myLuaState,
                                    EdgeBasedGraphFactory::SpeedProfileProperties &speed_profile);
-    void LoadRestrictionMap(const std::unordered_map<NodeID, NodeID> &external_to_internal_node_map,
-                            RestrictionMap &restriction_map);
+    std::shared_ptr<RestrictionMap> LoadRestrictionMap();
     unsigned CalculateEdgeChecksum(std::unique_ptr<std::vector<EdgeBasedNode>> node_based_edge_list);
     void ContractGraph(const std::size_t number_of_edge_based_nodes,
                        DeallocatingVector<EdgeBasedEdge>& edge_based_edge_list,
@@ -72,7 +71,6 @@ class Prepare
                                      std::unique_ptr<DeallocatingVector<QueryEdge>> contracted_edge_list);
     std::shared_ptr<NodeBasedDynamicGraph> LoadNodeBasedGraph(std::vector<NodeID> &barrier_node_list,
                                                std::vector<NodeID> &traffic_light_list,
-                                               RestrictionMap &restriction_map,
                                                std::vector<QueryNode>& internal_to_external_node_map);
     std::pair<std::size_t, std::size_t>
     BuildEdgeExpandedGraph(std::vector<QueryNode> &internal_to_external_node_map,

diff --git a/data_structures/import_edge.cpp b/data_structures/import_edge.cpp
@@ -47,6 +47,13 @@ bool NodeBasedEdge::operator<(const NodeBasedEdge &other) const
     return source < other.source;
 }
 
+NodeBasedEdge::NodeBasedEdge()
+    : source(SPECIAL_NODEID), target(SPECIAL_NODEID), name_id(0), weight(0), forward(false),
+      backward(false), roundabout(false), in_tiny_cc(false),
+      access_restricted(false), is_split(false), travel_mode(false)
+{
+}
+
 NodeBasedEdge::NodeBasedEdge(NodeID source,
                              NodeID target,
                              NodeID name_id,

diff --git a/data_structures/import_edge.hpp b/data_structures/import_edge.hpp
@@ -35,6 +35,7 @@ struct NodeBasedEdge
 {
     bool operator<(const NodeBasedEdge &e) const;
 
+    NodeBasedEdge();
     explicit NodeBasedEdge(NodeID source,
                            NodeID target,
                            NodeID name_id,
@@ -58,8 +59,6 @@ struct NodeBasedEdge
     bool access_restricted : 1;
     bool is_split : 1;
     TravelMode travel_mode : 4;
-
-    NodeBasedEdge() = delete;
 };
 
 struct EdgeBasedEdge

diff --git a/data_structures/node_based_graph.hpp b/data_structures/node_based_graph.hpp
@@ -64,7 +64,7 @@ struct NodeBasedEdgeData
         backward = temp_flag;
     }
 
-    bool IsEqualTo(const NodeBasedEdgeData &other) const
+    bool IsCompatibleTo(const NodeBasedEdgeData &other) const
     {
         return (forward == other.forward) && (backward == other.backward) &&
                (nameID == other.nameID) && (ignore_in_grid == other.ignore_in_grid) &&
@@ -85,6 +85,7 @@ NodeBasedDynamicGraphFromImportEdges(int number_of_nodes, std::vector<NodeBasedE
     NodeBasedDynamicGraph::InputEdge edge;
     for (const NodeBasedEdge &import_edge : input_edge_list)
     {
+        BOOST_ASSERT(import_edge.forward || import_edge.backward);
         if (import_edge.forward)
         {
             edge.source = import_edge.source;