Implements Mapping for NodeBasedGraph -> EdgeBasedgraph Translation

include/extractor/edge_based_graph_factory.hpp

@@ -7,18 +7,16 @@
 #include "extractor/edge_based_edge.hpp"
 #include "extractor/edge_based_node.hpp"
 #include "extractor/extraction_turn.hpp"
+#include "extractor/guidance/turn_analysis.hpp"
+#include "extractor/guidance/turn_instruction.hpp"
+#include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/original_edge_data.hpp"
 #include "extractor/profile_properties.hpp"
 #include "extractor/query_node.hpp"
 #include "extractor/restriction_map.hpp"
-
-#include "extractor/guidance/turn_analysis.hpp"
-#include "extractor/guidance/turn_instruction.hpp"
-#include "extractor/guidance/turn_lane_types.hpp"
+#include "util/deallocating_vector.hpp"
 #include "util/guidance/bearing_class.hpp"
 #include "util/guidance/entry_class.hpp"
-
-#include "util/deallocating_vector.hpp"
 #include "util/name_table.hpp"
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"
@@ -35,6 +33,7 @@
 #include <vector>
 
 #include <boost/filesystem/fstream.hpp>
+#include <boost/optional.hpp>
 
 namespace osrm
 {
@@ -86,7 +85,9 @@ struct TurnIndexBlock
 #pragma pack(pop)
 static_assert(std::is_trivial<TurnIndexBlock>::value, "TurnIndexBlock is not trivial");
 static_assert(sizeof(TurnIndexBlock) == 24, "TurnIndexBlock is not packed correctly");
-}
+} // ns lookup
+
+struct NodeBasedGraphToEdgeBasedGraphMappingWriter; // fwd. decl
 
 class EdgeBasedGraphFactory
 {
@@ -113,7 +114,9 @@ class EdgeBasedGraphFactory
              const std::string &turn_weight_penalties_filename,
              const std::string &turn_duration_penalties_filename,
              const std::string &turn_penalties_index_filename,
-             const bool generate_edge_lookup);
+             const bool generate_edge_lookup,
+             const bool generate_nbg_ebg_mapping,
+             const std::string &nbg_ebg_mapping_path);
 
     // The following get access functions destroy the content in the factory
     void GetEdgeBasedEdges(util::DeallocatingVector<EdgeBasedEdge> &edges);
@@ -172,7 +175,10 @@ class EdgeBasedGraphFactory
     guidance::LaneDescriptionMap &lane_description_map;
 
     unsigned RenumberEdges();
-    void GenerateEdgeExpandedNodes();
+
+    void GenerateEdgeExpandedNodes(const bool generate_nbg_ebg_mapping,
+                                   const std::string &nbg_ebg_mapping_path);
+
     void GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment,
                                    const std::string &original_edge_data_filename,
                                    const std::string &turn_lane_data_filename,
@@ -182,7 +188,15 @@ class EdgeBasedGraphFactory
                                    const std::string &turn_penalties_index_filename,
                                    const bool generate_edge_lookup);
 
-    void InsertEdgeBasedNode(const NodeID u, const NodeID v);
+    // Mapping betweenn the node based graph u,v nodes and the edge based graph head,tail edge ids.
+    // Required in the osrm-partition tool to translate from a nbg partition to a ebg partition.
+    struct Mapping
+    {
+        NodeID u, v;
+        EdgeID head, tail;
+    };
+
+    boost::optional<Mapping> InsertEdgeBasedNode(const NodeID u, const NodeID v);
 
     void FlushVectorToStream(std::ofstream &edge_data_file,
                              std::vector<OriginalEdgeData> &original_edge_data_vector) const;

include/extractor/extractor_config.hpp

@@ -78,6 +78,7 @@ struct ExtractorConfig
         profile_properties_output_path = basepath + ".osrm.properties";
         intersection_class_data_output_path = basepath + ".osrm.icd";
         compressed_node_based_graph_output_path = basepath + ".osrm.cnbg";
+        nbg_ebg_graph_mapping_output_path = basepath + ".osrm.nbg_to_ebg";
     }
 
     boost::filesystem::path input_path;
@@ -110,8 +111,10 @@ struct ExtractorConfig
 
     bool use_metadata;
 
+    // Auxiliary data for osrm-partition
     bool dump_compressed_node_based_graph;
     std::string compressed_node_based_graph_output_path;
+    std::string nbg_ebg_graph_mapping_output_path;
 };
 }
 }

include/extractor/node_based_graph_to_edge_based_graph_mapping_writer.hpp

@@ -0,0 +1,63 @@
+#ifndef NODE_BASED_GRAPH_TO_EDGE_BASED_GRAPH_MAPPING_WRITER_HPP
+#define NODE_BASED_GRAPH_TO_EDGE_BASED_GRAPH_MAPPING_WRITER_HPP
+
+#include "storage/io.hpp"
+#include "util/log.hpp"
+#include "util/typedefs.hpp"
+
+#include <boost/assert.hpp>
+
+#include <cstddef>
+
+#include <string>
+
+namespace osrm
+{
+namespace extractor
+{
+
+// Writes:  | Fingerprint | #mappings | u v head tail | u v head tail | ..
+// - uint64: number of mappings (u, v, head, tail) chunks
+// - NodeID u, NodeID v, EdgeID head, EdgeID tail
+
+struct NodeBasedGraphToEdgeBasedGraphMappingWriter
+{
+    NodeBasedGraphToEdgeBasedGraphMappingWriter(const std::string &path)
+        : writer{path, storage::io::FileWriter::GenerateFingerprint}, num_written{0}
+    {
+        const std::uint64_t dummy{0}; // filled in later
+        writer.WriteElementCount64(dummy);
+    }
+
+    void WriteMapping(NodeID u, NodeID v, EdgeID head, EdgeID tail)
+    {
+        BOOST_ASSERT(u != SPECIAL_NODEID);
+        BOOST_ASSERT(v != SPECIAL_NODEID);
+        BOOST_ASSERT(head != SPECIAL_EDGEID || tail != SPECIAL_EDGEID);
+
+        writer.WriteOne(u);
+        writer.WriteOne(v);
+        writer.WriteOne(head);
+        writer.WriteOne(tail);
+
+        num_written += 1;
+    }
+
+    ~NodeBasedGraphToEdgeBasedGraphMappingWriter()
+    {
+        if (num_written != 0)
+        {
+            writer.SkipToBeginning();
+            writer.WriteOne(num_written);
+        }
+    }
+
+  private:
+    storage::io::FileWriter writer;
+    std::uint64_t num_written;
+};
+
+} // ns extractor
+} // ns osrm
+
+#endif // NODE_BASED_GRAPH_TO_EDGE_BASED_GRAPH_MAPPING_WRITER_HPP

include/partition/partition_config.hpp

@@ -32,13 +32,15 @@ struct PartitionConfig
 
         edge_based_graph_path = basepath + ".osrm.ebg";
         compressed_node_based_graph_path = basepath + ".osrm.cnbg";
+        nbg_ebg_mapping_path = basepath + ".osrm.nbg_to_ebg";
         partition_path = basepath + ".osrm.partition";
     }
 
     // might be changed to the node based graph at some point
     boost::filesystem::path base_path;
     boost::filesystem::path edge_based_graph_path;
     boost::filesystem::path compressed_node_based_graph_path;
+    boost::filesystem::path nbg_ebg_mapping_path;
     boost::filesystem::path partition_path;
 
     unsigned requested_num_threads;

include/storage/io.hpp

@@ -43,6 +43,7 @@ class FileReader
         VerifyFingerprint,
         HasNoFingerprint
     };
+
     FileReader(const std::string &filename, const FingerprintFlag flag)
         : FileReader(boost::filesystem::path(filename), flag)
     {
@@ -194,10 +195,6 @@ class FileReader
 
 class FileWriter
 {
-  private:
-    const boost::filesystem::path filepath;
-    boost::filesystem::ofstream output_stream;
-
   public:
     enum FingerprintFlag
     {
@@ -211,7 +208,7 @@ class FileWriter
     }
 
     FileWriter(const boost::filesystem::path &filepath_, const FingerprintFlag flag)
-        : filepath(filepath_)
+        : filepath(filepath_), fingerprint(flag)
     {
         output_stream.open(filepath, std::ios::binary);
         if (!output_stream)
@@ -262,9 +259,30 @@ class FileWriter
         const auto fingerprint = util::FingerPrint::GetValid();
         return WriteOne(fingerprint);
     }
+
+    template <typename T> void Skip(const std::size_t element_count)
+    {
+        boost::iostreams::seek(output_stream, element_count * sizeof(T), BOOST_IOS::cur);
+    }
+
+    void SkipToBeginning()
+    {
+        boost::iostreams::seek(output_stream, 0, std::ios::beg);
+
+        // If we wrote a Fingerprint, skip over it
+        if (fingerprint == FingerprintFlag::GenerateFingerprint)
+            Skip<util::FingerPrint>(1);
+
+        // Should probably return a functor for jumping back to the current pos.
+    }
+
+  private:
+    const boost::filesystem::path filepath;
+    boost::filesystem::ofstream output_stream;
+    FingerprintFlag fingerprint;
 };
-}
-}
-}
+} // ns io
+} // ns storage
+} // ns osrm
 
 #endif

src/extractor/edge_based_graph_factory.cpp

@@ -1,5 +1,10 @@
 #include "extractor/edge_based_graph_factory.hpp"
 #include "extractor/edge_based_edge.hpp"
+#include "extractor/guidance/turn_analysis.hpp"
+#include "extractor/guidance/turn_lane_handler.hpp"
+#include "extractor/node_based_graph_to_edge_based_graph_mapping_writer.hpp"
+#include "extractor/scripting_environment.hpp"
+#include "extractor/suffix_table.hpp"
 #include "util/bearing.hpp"
 #include "util/coordinate.hpp"
 #include "util/coordinate_calculation.hpp"
@@ -10,11 +15,6 @@
 #include "util/percent.hpp"
 #include "util/timing_util.hpp"
 
-#include "extractor/guidance/turn_analysis.hpp"
-#include "extractor/guidance/turn_lane_handler.hpp"
-#include "extractor/scripting_environment.hpp"
-#include "extractor/suffix_table.hpp"
-
 #include <boost/assert.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 
@@ -92,7 +92,8 @@ void EdgeBasedGraphFactory::GetEdgeBasedNodeWeights(std::vector<EdgeWeight> &out
 
 EdgeID EdgeBasedGraphFactory::GetHighestEdgeID() { return m_max_edge_id; }
 
-void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const NodeID node_v)
+boost::optional<EdgeBasedGraphFactory::Mapping>
+EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const NodeID node_v)
 {
     // merge edges together into one EdgeBasedNode
     BOOST_ASSERT(node_u != SPECIAL_NODEID);
@@ -112,7 +113,7 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const NodeI
 
     if (forward_data.edge_id == SPECIAL_NODEID && reverse_data.edge_id == SPECIAL_NODEID)
     {
-        return;
+        return boost::none;
     }
 
     if (forward_data.edge_id != SPECIAL_NODEID && reverse_data.edge_id == SPECIAL_NODEID)
@@ -172,6 +173,8 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const NodeI
     }
 
     BOOST_ASSERT(current_edge_source_coordinate_id == node_v);
+
+    return Mapping{node_u, node_v, forward_data.edge_id, reverse_data.edge_id};
 }
 
 void EdgeBasedGraphFactory::FlushVectorToStream(
@@ -193,15 +196,17 @@ void EdgeBasedGraphFactory::Run(ScriptingEnvironment &scripting_environment,
                                 const std::string &turn_weight_penalties_filename,
                                 const std::string &turn_duration_penalties_filename,
                                 const std::string &turn_penalties_index_filename,
-                                const bool generate_edge_lookup)
+                                const bool generate_edge_lookup,
+                                const bool generate_nbg_ebg_mapping,
+                                const std::string &nbg_ebg_mapping_path)
 {
     TIMER_START(renumber);
     m_max_edge_id = RenumberEdges() - 1;
     TIMER_STOP(renumber);
 
     TIMER_START(generate_nodes);
     m_edge_based_node_weights.reserve(m_max_edge_id + 1);
-    GenerateEdgeExpandedNodes();
+    GenerateEdgeExpandedNodes(generate_nbg_ebg_mapping, nbg_ebg_mapping_path);
     TIMER_STOP(generate_nodes);
 
     TIMER_START(generate_edges);
@@ -255,8 +260,16 @@ unsigned EdgeBasedGraphFactory::RenumberEdges()
 }
 
 /// Creates the nodes in the edge expanded graph from edges in the node-based graph.
-void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
+void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const bool generate_nbg_ebg_mapping,
+                                                      const std::string &nbg_ebg_mapping_path)
 {
+    // Optional writer, for writing out a mapping. Neither default ctor not boost::optional work
+    // with the underlying FileWriter, so hack around that limitation with a unique_ptr.
+    std::unique_ptr<NodeBasedGraphToEdgeBasedGraphMappingWriter> writer;
+    if (generate_nbg_ebg_mapping)
+        writer =
+            std::make_unique<NodeBasedGraphToEdgeBasedGraphMappingWriter>(nbg_ebg_mapping_path);
+
     util::Log() << "Generating edge expanded nodes ... ";
     {
         util::UnbufferedLog log;
@@ -286,15 +299,20 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
 
                 BOOST_ASSERT(node_u < node_v);
 
+                boost::optional<Mapping> mapping;
+
                 // if we found a non-forward edge reverse and try again
                 if (edge_data.edge_id == SPECIAL_NODEID)
                 {
-                    InsertEdgeBasedNode(node_v, node_u);
+                    mapping = InsertEdgeBasedNode(node_v, node_u);
                 }
                 else
                 {
-                    InsertEdgeBasedNode(node_u, node_v);
+                    mapping = InsertEdgeBasedNode(node_u, node_v);
                 }
+
+                if (generate_nbg_ebg_mapping)
+                    writer->WriteMapping(mapping->u, mapping->v, mapping->head, mapping->tail);
             }
         }
     }

src/extractor/extractor.cpp

@@ -503,7 +503,9 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
                                  config.turn_weight_penalties_path,
                                  config.turn_duration_penalties_path,
                                  config.turn_penalties_index_path,
-                                 config.generate_edge_lookup);
+                                 config.generate_edge_lookup,
+                                 config.dump_compressed_node_based_graph,
+                                 config.nbg_ebg_graph_mapping_output_path);
 
     // The osrm-partition tool requires the compressed node based graph with an embedding.
     //