Remove GetConnectedRoads from IntersectionGenerator

include/extractor/guidance/driveway_handler.hpp

@@ -18,6 +18,10 @@ class DrivewayHandler final : public IntersectionHandler
                     const util::NodeBasedDynamicGraph &node_based_graph,
                     const EdgeBasedNodeDataContainer &node_data_container,
                     const std::vector<util::Coordinate> &coordinates,
+                    const extractor::CompressedEdgeContainer &compressed_geometries,
+                    const RestrictionMap &node_restriction_map,
+                    const std::unordered_set<NodeID> &barrier_nodes,
+                    const guidance::TurnLanesIndexedArray &turn_lanes_data,
                     const util::NameTable &name_table,
                     const SuffixTable &street_name_suffix_table);
 

include/extractor/guidance/intersection.hpp

@@ -44,14 +44,6 @@ inline auto makeCompareShapeDataByBearing(const double base_bearing)
     };
 }
 
-inline auto makeCompareShapeDataAngleToBearing(const double base_bearing)
-{
-    return [base_bearing](const auto &lhs, const auto &rhs) {
-        return util::bearing::angleBetween(lhs.bearing, base_bearing) <
-               util::bearing::angleBetween(rhs.bearing, base_bearing);
-    };
-}
-
 inline auto makeCompareAngularDeviation(const double angle)
 {
     return [angle](const auto &lhs, const auto &rhs) {

include/extractor/guidance/intersection_generator.hpp

@@ -44,26 +44,6 @@ class IntersectionGenerator
                           const std::vector<util::Coordinate> &coordinates,
                           const CompressedEdgeContainer &compressed_edge_container);
 
-    // For a source node `a` and a via edge `ab` creates an intersection at target `b`.
-    //
-    // a . . . b . .
-    //         .
-    //         .
-    //
-    IntersectionView operator()(const NodeID nid, const EdgeID via_eid) const;
-
-    /*
-     * Compute the shape of an intersection, returning a set of connected roads, without any further
-     * concern for which of the entries are actually allowed.
-     * The shape also only comes with turn bearings, not with turn angles. All turn angles will be
-     * set to zero
-     */
-    OSRM_ATTR_WARN_UNUSED
-    IntersectionShape
-    ComputeIntersectionShape(const NodeID center_node,
-                             const boost::optional<NodeID> sorting_base = boost::none,
-                             bool use_low_precision_angles = false) const;
-
     // Graph Compression cannot compress every setting. For example any barrier/traffic light cannot
     // be compressed. As a result, a simple road of the form `a ----- b` might end up as having an
     // intermediate intersection, if there is a traffic light in between. If we want to look farther
@@ -75,49 +55,12 @@ class IntersectionGenerator
     IntersectionGenerationParameters SkipDegreeTwoNodes(const NodeID starting_node,
                                                         const EdgeID via_edge) const;
 
-    // Allow access to the coordinate extractor for all owners
-    const CoordinateExtractor &GetCoordinateExtractor() const;
-
-    // Check for restrictions/barriers and generate a list of valid and invalid turns present at
-    // the node reached from `from_node` via `via_eid`. The resulting candidates have to be analysed
-    // for their actual instructions later on.
-    // The switch for `use_low_precision_angles` enables a faster mode that will procude less
-    // accurate coordinates. It should be good enough to check order of turns, find straightmost
-    // turns. Even good enough to do some simple angle verifications. It is mostly available to
-    // allow for faster graph traversal in the extraction phase.
-    OSRM_ATTR_WARN_UNUSED
-    IntersectionView GetConnectedRoads(const NodeID from_node,
-                                       const EdgeID via_eid,
-                                       const bool use_low_precision_angles = false) const;
-
-    /*
-     * To be used in the road network, we need to check for valid/restricted turns. These two
-     * functions transform a basic intersection / a normalised intersection into the
-     * correct view when entering via a given edge.
-     */
-    OSRM_ATTR_WARN_UNUSED
-    IntersectionView
-    TransformIntersectionShapeIntoView(const NodeID previous_node,
-                                       const EdgeID entering_via_edge,
-                                       const IntersectionShape &intersection) const;
-    // version for normalised intersection
-    OSRM_ATTR_WARN_UNUSED
-    IntersectionView TransformIntersectionShapeIntoView(
-        const NodeID previous_node,
-        const EdgeID entering_via_edge,
-        const IntersectionShape &normalised_intersection,
-        const IntersectionShape &intersection,
-        const std::vector<IntersectionNormalizationOperation> &merging_map) const;
-
   private:
     const util::NodeBasedDynamicGraph &node_based_graph;
     const EdgeBasedNodeDataContainer &node_data_container;
     const RestrictionMap &restriction_map;
     const std::unordered_set<NodeID> &barrier_nodes;
     const std::vector<util::Coordinate> &coordinates;
-
-    // own state, used to find the correct coordinates along a road
-    const CoordinateExtractor coordinate_extractor;
 };
 
 } // namespace guidance

include/extractor/guidance/intersection_handler.hpp

@@ -4,6 +4,7 @@
 #include "extractor/guidance/intersection.hpp"
 #include "extractor/guidance/intersection_generator.hpp"
 #include "extractor/guidance/node_based_graph_walker.hpp"
+#include "extractor/intersection/intersection_analysis.hpp"
 #include "extractor/query_node.hpp"
 #include "extractor/suffix_table.hpp"
 
@@ -34,7 +35,11 @@ class IntersectionHandler
   public:
     IntersectionHandler(const util::NodeBasedDynamicGraph &node_based_graph,
                         const EdgeBasedNodeDataContainer &node_data_container,
-                        const std::vector<util::Coordinate> &coordinates,
+                        const std::vector<util::Coordinate> &node_coordinates,
+                        const extractor::CompressedEdgeContainer &compressed_geometries,
+                        const RestrictionMap &node_restriction_map,
+                        const std::unordered_set<NodeID> &barrier_nodes,
+                        const guidance::TurnLanesIndexedArray &turn_lanes_data,
                         const util::NameTable &name_table,
                         const SuffixTable &street_name_suffix_table,
                         const IntersectionGenerator &intersection_generator);
@@ -52,7 +57,11 @@ class IntersectionHandler
   protected:
     const util::NodeBasedDynamicGraph &node_based_graph;
     const EdgeBasedNodeDataContainer &node_data_container;
-    const std::vector<util::Coordinate> &coordinates;
+    const std::vector<util::Coordinate> &node_coordinates;
+    const extractor::CompressedEdgeContainer &compressed_geometries;
+    const RestrictionMap &node_restriction_map;
+    const std::unordered_set<NodeID> &barrier_nodes;
+    const guidance::TurnLanesIndexedArray &turn_lanes_data;
     const util::NameTable &name_table;
     const SuffixTable &street_name_suffix_table;
     const IntersectionGenerator &intersection_generator;
@@ -571,7 +580,15 @@ std::size_t IntersectionHandler::findObviousTurn(const EdgeID via_edge,
                     node_at_intersection, intersection[0].eid);
                 if (node_based_graph.GetTarget(parameters.via_eid) == node_at_intersection)
                     return {};
-                return intersection_generator.GetConnectedRoads(parameters.nid, parameters.via_eid);
+
+                return intersection::getConnectedRoads(node_based_graph,
+                                                       node_data_container,
+                                                       node_coordinates,
+                                                       compressed_geometries,
+                                                       node_restriction_map,
+                                                       barrier_nodes,
+                                                       turn_lanes_data,
+                                                       {parameters.nid, parameters.via_eid});
             }();
 
             if (!previous_intersection.empty())

include/extractor/guidance/mergable_road_detector.hpp

@@ -1,7 +1,10 @@
 #ifndef OSRM_EXTRACTOR_GUIDANCE_MERGEABLE_ROADS
 #define OSRM_EXTRACTOR_GUIDANCE_MERGEABLE_ROADS
 
+#include "extractor/compressed_edge_container.hpp"
 #include "extractor/guidance/intersection.hpp"
+#include "extractor/guidance/turn_lane_types.hpp"
+#include "extractor/restriction_index.hpp"
 #include "util/coordinate.hpp"
 #include "util/node_based_graph.hpp"
 #include "util/typedefs.hpp"
@@ -9,6 +12,7 @@
 #include <cstdint>
 #include <functional>
 #include <limits>
+#include <unordered_set>
 #include <vector>
 
 namespace osrm
@@ -39,6 +43,10 @@ class MergableRoadDetector
     MergableRoadDetector(const util::NodeBasedDynamicGraph &node_based_graph,
                          const EdgeBasedNodeDataContainer &node_data_container,
                          const std::vector<util::Coordinate> &node_coordinates,
+                         const extractor::CompressedEdgeContainer &compressed_geometries,
+                         const RestrictionMap &node_restriction_map,
+                         const std::unordered_set<NodeID> &barrier_nodes,
+                         const guidance::TurnLanesIndexedArray &turn_lanes_data,
                          const IntersectionGenerator &intersection_generator,
                          const CoordinateExtractor &coordinate_extractor,
                          const util::NameTable &name_table,
@@ -159,6 +167,10 @@ class MergableRoadDetector
     const util::NodeBasedDynamicGraph &node_based_graph;
     const EdgeBasedNodeDataContainer &node_data_container;
     const std::vector<util::Coordinate> &node_coordinates;
+    const extractor::CompressedEdgeContainer &compressed_geometries;
+    const RestrictionMap &node_restriction_map;
+    const std::unordered_set<NodeID> &barrier_nodes;
+    const guidance::TurnLanesIndexedArray &turn_lanes_data;
     const IntersectionGenerator &intersection_generator;
     const CoordinateExtractor &coordinate_extractor;
 

include/extractor/guidance/motorway_handler.hpp

@@ -26,6 +26,10 @@ class MotorwayHandler : public IntersectionHandler
     MotorwayHandler(const util::NodeBasedDynamicGraph &node_based_graph,
                     const EdgeBasedNodeDataContainer &node_data_container,
                     const std::vector<util::Coordinate> &coordinates,
+                    const extractor::CompressedEdgeContainer &compressed_geometries,
+                    const RestrictionMap &node_restriction_map,
+                    const std::unordered_set<NodeID> &barrier_nodes,
+                    const guidance::TurnLanesIndexedArray &turn_lanes_data,
                     const util::NameTable &name_table,
                     const SuffixTable &street_name_suffix_table,
                     const IntersectionGenerator &intersection_generator);

include/extractor/guidance/node_based_graph_walker.hpp

@@ -2,7 +2,9 @@
 #define OSRM_EXTRACTOR_GUIDANCE_NODE_BASED_GRAPH_WALKER
 
 #include "extractor/guidance/constants.hpp"
-#include "extractor/guidance/intersection_generator.hpp"
+#include "extractor/guidance/coordinate_extractor.hpp"
+#include "extractor/guidance/turn_lane_data.hpp"
+#include "extractor/intersection/intersection_analysis.hpp"
 #include "util/coordinate.hpp"
 #include "util/coordinate_calculation.hpp"
 #include "util/node_based_graph.hpp"
@@ -29,7 +31,11 @@ class NodeBasedGraphWalker
   public:
     NodeBasedGraphWalker(const util::NodeBasedDynamicGraph &node_based_graph,
                          const EdgeBasedNodeDataContainer &node_data_container,
-                         const IntersectionGenerator &intersection_generator);
+                         const std::vector<util::Coordinate> &node_coordinates,
+                         const extractor::CompressedEdgeContainer &compressed_geometries,
+                         const RestrictionMap &node_restriction_map,
+                         const std::unordered_set<NodeID> &barrier_nodes,
+                         const guidance::TurnLanesIndexedArray &turn_lanes_data);
 
     /*
      * the returned node-id, edge-id are either the last ones used, just prior accumulator
@@ -48,7 +54,11 @@ class NodeBasedGraphWalker
   private:
     const util::NodeBasedDynamicGraph &node_based_graph;
     const EdgeBasedNodeDataContainer &node_data_container;
-    const IntersectionGenerator &intersection_generator;
+    const std::vector<util::Coordinate> &node_coordinates;
+    const extractor::CompressedEdgeContainer &compressed_geometries;
+    const RestrictionMap &node_restriction_map;
+    const std::unordered_set<NodeID> &barrier_nodes;
+    const guidance::TurnLanesIndexedArray &turn_lanes_data;
 };
 
 /*
@@ -149,7 +159,13 @@ struct SelectStraightmostRoadByNameAndOnlyChoice
 struct IntersectionFinderAccumulator
 {
     IntersectionFinderAccumulator(const std::uint8_t hop_limit,
-                                  const IntersectionGenerator &intersection_generator);
+                                  const util::NodeBasedDynamicGraph &node_based_graph,
+                                  const EdgeBasedNodeDataContainer &node_data_container,
+                                  const std::vector<util::Coordinate> &node_coordinates,
+                                  const extractor::CompressedEdgeContainer &compressed_geometries,
+                                  const RestrictionMap &node_restriction_map,
+                                  const std::unordered_set<NodeID> &barrier_nodes,
+                                  const guidance::TurnLanesIndexedArray &turn_lanes_data);
     // true if the path has traversed enough distance
     bool terminate();
 
@@ -159,13 +175,19 @@ struct IntersectionFinderAccumulator
     std::uint8_t hops;
     const std::uint8_t hop_limit;
 
-    // we need to be able to look-up the intersection
-    const IntersectionGenerator &intersection_generator;
-
     // the result we are looking for
     NodeID nid;
     EdgeID via_edge_id;
     IntersectionView intersection;
+
+  private:
+    const util::NodeBasedDynamicGraph &node_based_graph;
+    const EdgeBasedNodeDataContainer &node_data_container;
+    const std::vector<util::Coordinate> &node_coordinates;
+    const extractor::CompressedEdgeContainer &compressed_geometries;
+    const RestrictionMap &node_restriction_map;
+    const std::unordered_set<NodeID> &barrier_nodes;
+    const guidance::TurnLanesIndexedArray &turn_lanes_data;
 };
 
 template <class accumulator_type, class selector_type>
@@ -199,9 +221,15 @@ NodeBasedGraphWalker::TraverseRoad(NodeID current_node_id,
             return {};
 
         // look at the next intersection
-        const constexpr auto LOW_PRECISION = true;
-        const auto next_intersection = intersection_generator.GetConnectedRoads(
-            current_node_id, current_edge_id, LOW_PRECISION);
+        const auto next_intersection =
+            intersection::getConnectedRoads(node_based_graph,
+                                            node_data_container,
+                                            node_coordinates,
+                                            compressed_geometries,
+                                            node_restriction_map,
+                                            barrier_nodes,
+                                            turn_lanes_data,
+                                            {current_node_id, current_edge_id});
 
         // don't follow u-turns or go past our initial intersection
         if (next_intersection.size() <= 1)

include/extractor/guidance/roundabout_handler.hpp

@@ -42,7 +42,10 @@ class RoundaboutHandler : public IntersectionHandler
     RoundaboutHandler(const util::NodeBasedDynamicGraph &node_based_graph,
                       const EdgeBasedNodeDataContainer &node_data_container,
                       const std::vector<util::Coordinate> &coordinates,
-                      const CompressedEdgeContainer &compressed_edge_container,
+                      const extractor::CompressedEdgeContainer &compressed_geometries,
+                      const RestrictionMap &node_restriction_map,
+                      const std::unordered_set<NodeID> &barrier_nodes,
+                      const guidance::TurnLanesIndexedArray &turn_lanes_data,
                       const util::NameTable &name_table,
                       const SuffixTable &street_name_suffix_table,
                       const IntersectionGenerator &intersection_generator);
@@ -80,7 +83,6 @@ class RoundaboutHandler : public IntersectionHandler
     bool
     qualifiesAsRoundaboutIntersection(const std::unordered_set<NodeID> &roundabout_nodes) const;
 
-    const CompressedEdgeContainer &compressed_edge_container;
     const CoordinateExtractor coordinate_extractor;
 };
 

include/extractor/guidance/sliproad_handler.hpp

@@ -28,6 +28,10 @@ class SliproadHandler final : public IntersectionHandler
                     const util::NodeBasedDynamicGraph &node_based_graph,
                     const EdgeBasedNodeDataContainer &node_data_container,
                     const std::vector<util::Coordinate> &coordinates,
+                    const extractor::CompressedEdgeContainer &compressed_geometries,
+                    const RestrictionMap &node_restriction_map,
+                    const std::unordered_set<NodeID> &barrier_nodes,
+                    const guidance::TurnLanesIndexedArray &turn_lanes_data,
                     const util::NameTable &name_table,
                     const SuffixTable &street_name_suffix_table);
 
@@ -78,6 +82,8 @@ class SliproadHandler final : public IntersectionHandler
     // The return value is guaranteed to not be larger than `threshold`.
     static double scaledThresholdByRoadClass(const double max_threshold,
                                              const RoadClassification &classification);
+
+    const CoordinateExtractor coordinate_extractor;
 };
 
 } // namespace guidance

include/extractor/guidance/statistics_handler.hpp

@@ -31,11 +31,19 @@ class StatisticsHandler final : public IntersectionHandler
                       const util::NodeBasedDynamicGraph &node_based_graph,
                       const EdgeBasedNodeDataContainer &node_data_container,
                       const std::vector<util::Coordinate> &coordinates,
+                      const extractor::CompressedEdgeContainer &compressed_geometries,
+                      const RestrictionMap &node_restriction_map,
+                      const std::unordered_set<NodeID> &barrier_nodes,
+                      const guidance::TurnLanesIndexedArray &turn_lanes_data,
                       const util::NameTable &name_table,
                       const SuffixTable &street_name_suffix_table)
         : IntersectionHandler(node_based_graph,
                               node_data_container,
                               coordinates,
+                              compressed_geometries,
+                              node_restriction_map,
+                              barrier_nodes,
+                              turn_lanes_data,
                               name_table,
                               street_name_suffix_table,
                               intersection_generator)

include/extractor/guidance/suppress_mode_handler.hpp

@@ -25,6 +25,10 @@ class SuppressModeHandler final : public IntersectionHandler
                         const util::NodeBasedDynamicGraph &node_based_graph,
                         const EdgeBasedNodeDataContainer &node_data_container,
                         const std::vector<util::Coordinate> &coordinates,
+                        const extractor::CompressedEdgeContainer &compressed_geometries,
+                        const RestrictionMap &node_restriction_map,
+                        const std::unordered_set<NodeID> &barrier_nodes,
+                        const guidance::TurnLanesIndexedArray &turn_lanes_data,
                         const util::NameTable &name_table,
                         const SuffixTable &street_name_suffix_table);
 

include/extractor/guidance/turn_analysis.hpp

@@ -42,10 +42,11 @@ class TurnAnalysis
   public:
     TurnAnalysis(const util::NodeBasedDynamicGraph &node_based_graph,
                  const EdgeBasedNodeDataContainer &node_data_container,
-                 const std::vector<util::Coordinate> &coordinates,
+                 const std::vector<util::Coordinate> &node_coordinates,
+                 const CompressedEdgeContainer &compressed_edge_container,
                  const RestrictionMap &restriction_map,
                  const std::unordered_set<NodeID> &barrier_nodes,
-                 const CompressedEdgeContainer &compressed_edge_container,
+                 const guidance::TurnLanesIndexedArray &turn_lanes_data,
                  const util::NameTable &name_table,
                  const SuffixTable &street_name_suffix_table);
 
@@ -61,8 +62,6 @@ class TurnAnalysis
                                  const EdgeID via_eid,
                                  const IntersectionView &intersection) const;
 
-    const IntersectionGenerator &GetIntersectionGenerator() const;
-
   private:
     const util::NodeBasedDynamicGraph &node_based_graph;
     const IntersectionGenerator intersection_generator;

include/extractor/guidance/turn_discovery.hpp

@@ -3,6 +3,7 @@
 
 #include "extractor/guidance/intersection.hpp"
 #include "extractor/guidance/intersection_generator.hpp"
+#include "extractor/guidance/turn_lane_data.hpp"
 #include "util/typedefs.hpp"
 
 namespace osrm
@@ -21,8 +22,13 @@ bool findPreviousIntersection(
     const NodeID node,
     const EdgeID via_edge,
     const Intersection &intersection,
-    const IntersectionGenerator &intersection_generator,
     const util::NodeBasedDynamicGraph &node_based_graph, // query edge data
+    const EdgeBasedNodeDataContainer &node_data_container,
+    const std::vector<util::Coordinate> &node_coordinates,
+    const extractor::CompressedEdgeContainer &compressed_geometries,
+    const RestrictionMap &node_restriction_map,
+    const std::unordered_set<NodeID> &barrier_nodes,
+    const guidance::TurnLanesIndexedArray &turn_lanes_data,
     // output parameters, will be in an arbitrary state on failure
     NodeID &result_node,
     EdgeID &result_via_edge,

include/extractor/guidance/turn_handler.hpp

@@ -30,6 +30,10 @@ class TurnHandler : public IntersectionHandler
     TurnHandler(const util::NodeBasedDynamicGraph &node_based_graph,
                 const EdgeBasedNodeDataContainer &node_data_container,
                 const std::vector<util::Coordinate> &coordinates,
+                const extractor::CompressedEdgeContainer &compressed_geometries,
+                const RestrictionMap &node_restriction_map,
+                const std::unordered_set<NodeID> &barrier_nodes,
+                const guidance::TurnLanesIndexedArray &turn_lanes_data,
                 const util::NameTable &name_table,
                 const SuffixTable &street_name_suffix_table,
                 const IntersectionGenerator &intersection_generator);

include/extractor/guidance/turn_lane_handler.hpp

@@ -74,6 +74,11 @@ class TurnLaneHandler
 
     TurnLaneHandler(const util::NodeBasedDynamicGraph &node_based_graph,
                     const EdgeBasedNodeDataContainer &node_data_container,
+                    const std::vector<util::Coordinate> &node_coordinates,
+                    const extractor::CompressedEdgeContainer &compressed_geometries,
+                    const RestrictionMap &node_restriction_map,
+                    const std::unordered_set<NodeID> &barrier_nodes,
+                    const guidance::TurnLanesIndexedArray &turn_lanes_data,
                     LaneDescriptionMap &lane_description_map,
                     const TurnAnalysis &turn_analysis,
                     util::guidance::LaneDataIdMap &id_map);
@@ -90,6 +95,12 @@ class TurnLaneHandler
     // lanes for a turn
     const util::NodeBasedDynamicGraph &node_based_graph;
     const EdgeBasedNodeDataContainer &node_data_container;
+    const std::vector<util::Coordinate> &node_coordinates;
+    const extractor::CompressedEdgeContainer &compressed_geometries;
+    const RestrictionMap &node_restriction_map;
+    const std::unordered_set<NodeID> &barrier_nodes;
+    const guidance::TurnLanesIndexedArray &turn_lanes_data;
+
     std::vector<std::uint32_t> turn_lane_offsets;
     std::vector<TurnLaneType::Mask> turn_lane_masks;
     LaneDescriptionMap &lane_description_map;

include/extractor/intersection/intersection_analysis.hpp

@@ -26,6 +26,19 @@ IntersectionEdges getIncomingEdges(const util::NodeBasedDynamicGraph &graph,
 IntersectionEdges getOutgoingEdges(const util::NodeBasedDynamicGraph &graph,
                                    const NodeID intersection);
 
+bool isTurnAllowed(const util::NodeBasedDynamicGraph &graph,
+                   const EdgeBasedNodeDataContainer &node_data_container,
+                   const RestrictionMap &restriction_map,
+                   const std::unordered_set<NodeID> &barrier_nodes,
+                   const IntersectionEdgeGeometries &geometries,
+                   const guidance::TurnLanesIndexedArray &turn_lanes_data,
+                   const IntersectionEdge &from,
+                   const IntersectionEdge &to);
+
+double findEdgeBearing(const IntersectionEdgeGeometries &geometries, const EdgeID &edge);
+
+double findEdgeLength(const IntersectionEdgeGeometries &geometries, const EdgeID &edge);
+
 std::pair<IntersectionEdgeGeometries, std::unordered_set<EdgeID>>
 getIntersectionGeometries(const util::NodeBasedDynamicGraph &graph,
                           const extractor::CompressedEdgeContainer &compressed_geometries,
@@ -44,18 +57,15 @@ convertToIntersectionView(const util::NodeBasedDynamicGraph &graph,
                           const IntersectionEdges &outgoing_edges,
                           const std::unordered_set<EdgeID> &merged_edges);
 
-bool isTurnAllowed(const util::NodeBasedDynamicGraph &graph,
-                   const EdgeBasedNodeDataContainer &node_data_container,
-                   const RestrictionMap &restriction_map,
-                   const std::unordered_set<NodeID> &barrier_nodes,
-                   const IntersectionEdgeGeometries &geometries,
-                   const guidance::TurnLanesIndexedArray &turn_lanes_data,
-                   const IntersectionEdge &from,
-                   const IntersectionEdge &to);
-
-double findEdgeBearing(const IntersectionEdgeGeometries &geometries, const EdgeID &edge);
-
-double findEdgeLength(const IntersectionEdgeGeometries &geometries, const EdgeID &edge);
+guidance::IntersectionView
+getConnectedRoads(const util::NodeBasedDynamicGraph &graph,
+                  const EdgeBasedNodeDataContainer &node_data_container,
+                  const std::vector<util::Coordinate> &node_coordinates,
+                  const extractor::CompressedEdgeContainer &compressed_geometries,
+                  const RestrictionMap &node_restriction_map,
+                  const std::unordered_set<NodeID> &barrier_nodes,
+                  const guidance::TurnLanesIndexedArray &turn_lanes_data,
+                  const IntersectionEdge &incoming_edge);
 }
 }
 }