fix roundabout handling with lanes

instead of artificially removing lanes from a roundabout, we don't assing them in the first place.
this also prevents a problem where we would end up collapsing turns with lanes in a roundabout

src/extractor/guidance/coordinate_extractor.cpp

@@ -146,8 +146,7 @@ util::Coordinate CoordinateExtractor::ExtractRepresentativeCoordinate(
     // roundabouts, check early to avoid other costly checks
     if (turn_edge_data.roundabout || turn_edge_data.circular)
     {
-        const auto result = ExtractCoordinateAtLength(
-            skipping_inaccuracies_distance, coordinates);
+        const auto result = ExtractCoordinateAtLength(skipping_inaccuracies_distance, coordinates);
         BOOST_ASSERT(is_valid_result(result));
         return result;
     }
@@ -234,8 +233,7 @@ util::Coordinate CoordinateExtractor::ExtractRepresentativeCoordinate(
         std::accumulate(segment_distances.begin(), segment_distances.end(), 0.);
 
     // if we are now left with two, well than we don't have to worry, or the segment is very small
-    if (coordinates.size() == 2 ||
-        total_distance <= skipping_inaccuracies_distance)
+    if (coordinates.size() == 2 || total_distance <= skipping_inaccuracies_distance)
     {
         BOOST_ASSERT(is_valid_result(coordinates.back()));
         return coordinates.back();
@@ -252,8 +250,8 @@ util::Coordinate CoordinateExtractor::ExtractRepresentativeCoordinate(
         // As a back-up, we have to check for this case
         if (coordinates.front() == coordinates.back())
         {
-            const auto result = ExtractCoordinateAtLength(
-                skipping_inaccuracies_distance, coordinates);
+            const auto result =
+                ExtractCoordinateAtLength(skipping_inaccuracies_distance, coordinates);
             BOOST_ASSERT(is_valid_result(result));
             return result;
         }
@@ -373,18 +371,15 @@ util::Coordinate CoordinateExtractor::ExtractRepresentativeCoordinate(
          * We distinguish between turns that simply model the initial way of getting onto the
          * destination lanes and the ones that performa a larger turn.
          */
-        coordinates =
-            TrimCoordinatesToLength(std::move(coordinates),
-                                    2 * skipping_inaccuracies_distance,
-                                    segment_distances);
+        coordinates = TrimCoordinatesToLength(
+            std::move(coordinates), 2 * skipping_inaccuracies_distance, segment_distances);
         BOOST_ASSERT(coordinates.size() >= 2);
         segment_distances.resize(coordinates.size());
         segment_distances.back() = util::coordinate_calculation::haversineDistance(
             *(coordinates.end() - 2), coordinates.back());
         const auto vector_head = coordinates.back();
-        coordinates = TrimCoordinatesToLength(std::move(coordinates),
-                                              skipping_inaccuracies_distance,
-                                              segment_distances);
+        coordinates = TrimCoordinatesToLength(
+            std::move(coordinates), skipping_inaccuracies_distance, segment_distances);
         BOOST_ASSERT(coordinates.size() >= 2);
         const auto result =
             GetCorrectedCoordinate(turn_coordinate, coordinates.back(), vector_head);

src/extractor/guidance/intersection_handler.cpp

@@ -1,6 +1,7 @@
 #include "extractor/guidance/intersection_handler.hpp"
 #include "extractor/guidance/constants.hpp"
 
+#include "util/coordinate_calculation.hpp"
 #include "util/guidance/name_announcements.hpp"
 #include "util/log.hpp"
 

src/extractor/guidance/roundabout_handler.cpp

@@ -3,8 +3,8 @@
 
 #include "util/bearing.hpp"
 #include "util/coordinate_calculation.hpp"
-#include "util/log.hpp"
 #include "util/guidance/name_announcements.hpp"
+#include "util/log.hpp"
 
 #include <algorithm>
 #include <cmath>

src/extractor/guidance/turn_lane_handler.cpp

@@ -3,8 +3,8 @@
 #include "extractor/guidance/turn_discovery.hpp"
 #include "extractor/guidance/turn_lane_augmentation.hpp"
 #include "extractor/guidance/turn_lane_matcher.hpp"
-#include "util/log.hpp"
 #include "util/bearing.hpp"
+#include "util/log.hpp"
 #include "util/typedefs.hpp"
 
 #include <cstddef>
@@ -149,6 +149,17 @@ TurnLaneScenario TurnLaneHandler::deduceScenario(const NodeID at,
                                                  LaneDataVector &previous_lane_data,
                                                  LaneDescriptionID &previous_description_id)
 {
+    // as long as we don't want to emit lanes on roundabout, don't assign them
+    if (node_based_graph.GetEdgeData(via_edge).roundabout)
+        return TurnLaneScenario::NONE;
+
+    // really don't touch roundabouts (#2626)
+    if (intersection.end() !=
+        std::find_if(intersection.begin(), intersection.end(), [](const auto &road) {
+            return hasRoundaboutType(road.instruction);
+        }))
+        return TurnLaneScenario::NONE;
+
     // if only a uturn exists, there is nothing we can do
     if (intersection.size() == 1)
         return TurnLaneScenario::NONE;