Deduplicate foward/reverse geometries

Changes the internal representation of compressed geometries to be a
single array shared between forward and reverse geometries that can be
read in either direction. Includes a change on
extractor::OriginalEdgeData to store via_geometry ids that indicate
which direction to read the geometry for that edge based edge.

Closes #2592

include/extractor/compressed_edge_container.hpp

@@ -16,12 +16,22 @@ namespace extractor
 class CompressedEdgeContainer
 {
   public:
-    struct CompressedEdge
+    struct OnewayCompressedEdge
     {
       public:
         NodeID node_id;    // refers to an internal node-based-node
         EdgeWeight weight; // the weight of the edge leading to this node
     };
+
+    struct CompressedEdge
+    {
+      public:
+        NodeID node_id;
+        EdgeWeight forward_weight;
+        EdgeWeight reverse_weight;
+    };
+
+    using OnewayEdgeBucket = std::vector<OnewayCompressedEdge>;
     using EdgeBucket = std::vector<CompressedEdge>;
 
     CompressedEdgeContainer();
@@ -35,11 +45,18 @@ class CompressedEdgeContainer
     void
     AddUncompressedEdge(const EdgeID edge_id, const NodeID target_node, const EdgeWeight weight);
 
+    void InitializeBothwayVector();
+    unsigned ZipEdges(const unsigned f_edge_pos, const unsigned r_edge_pos);
+
     bool HasEntryForID(const EdgeID edge_id) const;
+    bool HasZippedEntryForForwardID(const EdgeID edge_id) const;
+    bool HasZippedEntryForReverseID(const EdgeID edge_id) const;
     void PrintStatistics() const;
     void SerializeInternalVector(const std::string &path) const;
     unsigned GetPositionForID(const EdgeID edge_id) const;
-    const EdgeBucket &GetBucketReference(const EdgeID edge_id) const;
+    unsigned GetZippedPositionForForwardID(const EdgeID edge_id) const;
+    unsigned GetZippedPositionForReverseID(const EdgeID edge_id) const;
+    const OnewayEdgeBucket &GetBucketReference(const EdgeID edge_id) const;
     bool IsTrivial(const EdgeID edge_id) const;
     NodeID GetFirstEdgeTargetID(const EdgeID edge_id) const;
     NodeID GetLastEdgeTargetID(const EdgeID edge_id) const;
@@ -49,9 +66,12 @@ class CompressedEdgeContainer
     int free_list_maximum = 0;
 
     void IncreaseFreeList();
+    std::vector<OnewayEdgeBucket> m_compressed_oneway_geometries;
     std::vector<EdgeBucket> m_compressed_geometries;
     std::vector<unsigned> m_free_list;
     std::unordered_map<EdgeID, unsigned> m_edge_id_to_list_index_map;
+    std::unordered_map<EdgeID, unsigned> m_forward_edge_id_to_zipped_index_map;
+    std::unordered_map<EdgeID, unsigned> m_reverse_edge_id_to_zipped_index_map;
 };
 }
 }

include/extractor/edge_based_graph_factory.hpp

@@ -84,7 +84,7 @@ class EdgeBasedGraphFactory
     EdgeBasedGraphFactory &operator=(const EdgeBasedGraphFactory &) = delete;
 
     explicit EdgeBasedGraphFactory(std::shared_ptr<util::NodeBasedDynamicGraph> node_based_graph,
-                                   const CompressedEdgeContainer &compressed_edge_container,
+                                   CompressedEdgeContainer &compressed_edge_container,
                                    const std::unordered_set<NodeID> &barrier_nodes,
                                    const std::unordered_set<NodeID> &traffic_lights,
                                    std::shared_ptr<const RestrictionMap> restriction_map,
@@ -149,7 +149,7 @@ class EdgeBasedGraphFactory
 
     const std::unordered_set<NodeID> &m_barrier_nodes;
     const std::unordered_set<NodeID> &m_traffic_lights;
-    const CompressedEdgeContainer &m_compressed_edge_container;
+    CompressedEdgeContainer &m_compressed_edge_container;
 
     ProfileProperties profile_properties;
 

include/extractor/edge_based_node.hpp

@@ -22,8 +22,8 @@ struct EdgeBasedNode
     EdgeBasedNode()
         : forward_segment_id{SPECIAL_SEGMENTID, false},
           reverse_segment_id{SPECIAL_SEGMENTID, false}, u(SPECIAL_NODEID), v(SPECIAL_NODEID),
-          name_id(0), forward_packed_geometry_id(SPECIAL_EDGEID),
-          reverse_packed_geometry_id(SPECIAL_EDGEID), component{INVALID_COMPONENTID, false},
+          name_id(0), packed_geometry_id(SPECIAL_GEOMETRYID),
+          component{INVALID_COMPONENTID, false},
           fwd_segment_position(std::numeric_limits<unsigned short>::max()),
           forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
           backward_travel_mode(TRAVEL_MODE_INACCESSIBLE)
@@ -35,16 +35,14 @@ struct EdgeBasedNode
                            NodeID u,
                            NodeID v,
                            unsigned name_id,
-                           unsigned forward_geometry_id_,
-                           unsigned reverse_geometry_id_,
+                           unsigned packed_geometry_id_,
                            bool is_tiny_component,
                            unsigned component_id,
                            unsigned short fwd_segment_position,
                            TravelMode forward_travel_mode,
                            TravelMode backward_travel_mode)
         : forward_segment_id(forward_segment_id_), reverse_segment_id(reverse_segment_id_), u(u),
-          v(v), name_id(name_id), forward_packed_geometry_id(forward_geometry_id_),
-          reverse_packed_geometry_id(reverse_geometry_id_),
+          v(v), name_id(name_id), packed_geometry_id(packed_geometry_id_),
           component{component_id, is_tiny_component}, fwd_segment_position(fwd_segment_position),
           forward_travel_mode(forward_travel_mode), backward_travel_mode(backward_travel_mode)
     {
@@ -57,8 +55,7 @@ struct EdgeBasedNode
     NodeID v;                     // indices into the coordinates array
     unsigned name_id;             // id of the edge name
 
-    unsigned forward_packed_geometry_id;
-    unsigned reverse_packed_geometry_id;
+    unsigned packed_geometry_id;
     struct
     {
         unsigned id : 31;

include/extractor/guidance/toolkit.hpp

@@ -125,7 +125,7 @@ getRepresentativeCoordinate(const NodeID from_node,
     };
 
     // Uncompressed roads are simple, return the coordinate at the end
-    if (!compressed_geometries.HasEntryForID(via_edge_id))
+    if (!compressed_geometries.HasZippedEntryForForwardID(via_edge_id) && !compressed_geometries.HasZippedEntryForReverseID(via_edge_id))
     {
         return extractCoordinateFromNode(traverse_in_reverse ? query_nodes[from_node]
                                                              : query_nodes[to_node]);

include/extractor/original_edge_data.hpp

@@ -15,26 +15,26 @@ namespace extractor
 
 struct OriginalEdgeData
 {
-    explicit OriginalEdgeData(NodeID via_node,
+    explicit OriginalEdgeData(GeometryID via_geometry,
                               unsigned name_id,
                               LaneDataID lane_data_id,
                               guidance::TurnInstruction turn_instruction,
                               EntryClassID entry_classid,
                               TravelMode travel_mode)
-        : via_node(via_node), name_id(name_id), entry_classid(entry_classid),
+        : via_geometry(via_geometry), name_id(name_id), entry_classid(entry_classid),
           lane_data_id(lane_data_id), turn_instruction(turn_instruction), travel_mode(travel_mode)
     {
     }
 
     OriginalEdgeData()
-        : via_node(std::numeric_limits<unsigned>::max()),
+        : via_geometry{std::numeric_limits<unsigned>::max() >> 1, false},
           name_id(std::numeric_limits<unsigned>::max()), entry_classid(INVALID_ENTRY_CLASSID),
           lane_data_id(INVALID_LANE_DATAID), turn_instruction(guidance::TurnInstruction::INVALID()),
           travel_mode(TRAVEL_MODE_INACCESSIBLE)
     {
     }
 
-    NodeID via_node;
+    GeometryID via_geometry;
     unsigned name_id;
     EntryClassID entry_classid;
     LaneDataID lane_data_id;