Implement arbitrary turn penalty file IO and integration (#2306)

Closes #1830

src/extractor/compressed_edge_container.cpp

@@ -250,16 +250,32 @@ CompressedEdgeContainer::GetBucketReference(const EdgeID edge_id) const
     return m_compressed_geometries.at(index);
 }
 
+// Since all edges are technically in the compressed geometry container,
+// regardless of whether a compressed edge actually contains multiple
+// original segments, we use 'Trivial' here to describe compressed edges
+// that only contain one original segment
+bool CompressedEdgeContainer::IsTrivial(const EdgeID edge_id) const
+{
+    const auto &bucket = GetBucketReference(edge_id);
+    return bucket.size() == 1;
+}
+
 NodeID CompressedEdgeContainer::GetFirstEdgeTargetID(const EdgeID edge_id) const
 {
     const auto &bucket = GetBucketReference(edge_id);
-    BOOST_ASSERT(bucket.size() >= 2);
+    BOOST_ASSERT(bucket.size() >= 1);
     return bucket.front().node_id;
 }
+NodeID CompressedEdgeContainer::GetLastEdgeTargetID(const EdgeID edge_id) const
+{
+    const auto &bucket = GetBucketReference(edge_id);
+    BOOST_ASSERT(bucket.size() >= 1);
+    return bucket.back().node_id;
+}
 NodeID CompressedEdgeContainer::GetLastEdgeSourceID(const EdgeID edge_id) const
 {
     const auto &bucket = GetBucketReference(edge_id);
-    BOOST_ASSERT(bucket.size() >= 2);
+    BOOST_ASSERT(bucket.size() >= 1);
     return bucket[bucket.size() - 2].node_id;
 }
 }

src/extractor/edge_based_graph_factory.cpp

@@ -123,7 +123,8 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const NodeI
 
     NodeID current_edge_source_coordinate_id = node_u;
 
-    const auto edge_id_to_segment_id = [](const NodeID edge_based_node_id) {
+    const auto edge_id_to_segment_id = [](const NodeID edge_based_node_id)
+    {
         if (edge_based_node_id == SPECIAL_NODEID)
         {
             return SegmentID{SPECIAL_SEGMENTID, false};
@@ -339,7 +340,6 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             auto possible_turns = turn_analysis.getTurns(node_u, edge_from_u);
 
             const NodeID node_v = m_node_based_graph->GetTarget(edge_from_u);
-
             for (const auto turn : possible_turns)
             {
                 const double turn_angle = turn.angle;
@@ -434,6 +434,36 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                                 sizeof(target_node.weight));
                         previous = target_node.node_id;
                     }
+
+                    // We also now write out the mapping between the edge-expanded edges and the
+                    // original nodes. Since each edge represents a possible maneuver, external
+                    // programs can use this to quickly perform updates to edge weights in order
+                    // to penalize certain turns.
+
+                    // If this edge is 'trivial' -- where the compressed edge corresponds
+                    // exactly to an original OSM segment -- we can pull the turn's preceding
+                    // node ID directly with `node_u`; otherwise, we need to look up the node
+                    // immediately preceding the turn from the compressed edge container.
+                    const bool isTrivial = m_compressed_edge_container.IsTrivial(edge_from_u);
+
+                    const auto &from_node =
+                        isTrivial
+                            ? m_node_info_list[node_u]
+                            : m_node_info_list[m_compressed_edge_container.GetLastEdgeSourceID(
+                                  edge_from_u)];
+                    const auto &via_node =
+                        m_node_info_list[m_compressed_edge_container.GetLastEdgeTargetID(
+                            edge_from_u)];
+                    const auto &to_node =
+                        m_node_info_list[m_compressed_edge_container.GetFirstEdgeTargetID(
+                            turn.eid)];
+
+                    edge_penalty_file.write(reinterpret_cast<const char *>(&from_node.node_id),
+                                            sizeof(from_node.node_id));
+                    edge_penalty_file.write(reinterpret_cast<const char *>(&via_node.node_id),
+                                            sizeof(via_node.node_id));
+                    edge_penalty_file.write(reinterpret_cast<const char *>(&to_node.node_id),
+                                            sizeof(to_node.node_id));
                 }
             }
         }