Adds turn instructions to the turns layer in debug tiles. (#4460)

Add turn types and modifiers to turn points in debug tiles.  Also refactor some of the tile code to reduce some repetition.

Author: danpat

CHANGELOG.md

@@ -17,6 +17,8 @@
         updating ETAs returned, without changing route selection (for example, in a distance-based profile with traffic data loaded).
     - Infrastructure:
       - New file `.osrm.cell_metrics` created by `osrm-customize`.
+    - Debug tiles:
+      - Added new properties `type` and `modifier` to `turns` layer, useful for viewing guidance calculated turn types on the map
 
 # 5.11.0
   - Changes from 5.10:

docs/http.md

@@ -437,6 +437,8 @@ Vector tiles contain two layers:
 | `turn_angle` | `integer` | the angle of the turn, relative to the `bearing_in`.  -180 to +180, 0 = straight ahead, 90 = 90-degrees to the right |
 | `cost`       | `float`   | the time we think it takes to make that turn, in seconds.  May be negative, depending on how the data model is constructed (some turns get a "bonus"). |
 | `weight`     | `float`   | the weight we think it takes to make that turn.  May be negative, depending on how the data model is constructed (some turns get a "bonus"). ACTUAL ROUTING USES THIS VALUE |
+| `type`       | `string`  | the type of this turn - values like `turn`, `continue`, etc.  See the `StepManeuver` for a partial list, this field also exposes internal turn types that are never returned with an API response |
+| `modifier`   | `string`  | the direction modifier of the turn (`left`, `sharp left`, etc) |
 
 
 ## Result objects

include/engine/api/json_factory.hpp

@@ -36,6 +36,15 @@ namespace detail
 std::string instructionTypeToString(extractor::guidance::TurnType::Enum type);
 std::string instructionModifierToString(extractor::guidance::DirectionModifier::Enum modifier);
 
+/**
+ * Returns a string representing all instruction types (including internal types that
+ * are normally not exposed in route responses)
+ *
+ * @param type the TurnType value to convert into a string
+ * @return a string representing the turn type (e.g. `turn` or `continue`)
+ */
+std::string internalInstructionTypeToString(extractor::guidance::TurnType::Enum type);
+
 util::json::Array coordinateToLonLat(const util::Coordinate coordinate);
 
 std::string modeToString(const extractor::TravelMode mode);

include/engine/routing_algorithms/tile_turns.hpp

@@ -24,6 +24,7 @@ struct TurnData final
     const int turn_angle;
     const EdgeWeight weight;
     const EdgeWeight duration;
+    const extractor::guidance::TurnInstruction turn_instruction;
 };
 
 using RTreeLeaf = datafacade::BaseDataFacade::RTreeLeaf;

src/engine/api/json_factory.cpp

@@ -41,15 +41,47 @@ const constexpr char *modifier_names[] = {"uturn",
                                           "left",
                                           "sharp left"};
 
-// translations of TurnTypes. Not all types are exposed to the outside world.
-// invalid types should never be returned as part of the API
-const constexpr char *turn_type_names[] = {
-    "invalid",         "new name",   "continue", "turn",        "merge",
-    "on ramp",         "off ramp",   "fork",     "end of road", "notification",
-    "roundabout",      "roundabout", "rotary",   "rotary",      "roundabout turn",
-    "roundabout turn", "use lane",   "invalid",  "invalid",     "invalid",
-    "invalid",         "invalid",    "invalid",  "invalid",     "invalid",
-    "invalid",         "invalid"};
+/**
+ * Human readable values for TurnType enum values
+ */
+struct TurnTypeName
+{
+    // String value we return with our API
+    const char *external_name;
+    // Internal only string name for the turn type - useful for debugging
+    // and used by debug tiles for visualizing hidden turn types
+    const char *internal_name;
+};
+
+// Indexes in this list correspond to the Enum values of osrm::extractor::guidance::TurnType
+const constexpr TurnTypeName turn_type_names[] = {
+    {"invalid", "(not set)"},
+    {"new name", "new name"},
+    {"continue", "continue"},
+    {"turn", "turn"},
+    {"merge", "merge"},
+    {"on ramp", "on ramp"},
+    {"off ramp", "off ramp"},
+    {"fork", "fork"},
+    {"end of road", "end of road"},
+    {"notification", "notification"},
+    {"roundabout", "enter roundabout"},
+    {"roundabout", "enter and exit roundabout"},
+    {"rotary", "enter rotary"},
+    {"rotary", "enter and exit rotary"},
+    {"roundabout turn", "enter roundabout turn"},
+    {"roundabout turn", "enter and exit roundabout turn"},
+    {"use lane", "use lane"},
+    {"invalid", "(noturn)"},
+    {"invalid", "(suppressed)"},
+    {"invalid", "(enter roundabout at exit)"},
+    {"invalid", "(exit roundabout)"},
+    {"invalid", "(enter rotary at exit)"},
+    {"invalid", "(exit rotary)"},
+    {"invalid", "(enter roundabout intersection at exit)"},
+    {"invalid", "(exit roundabout intersection)"},
+    {"invalid", "(stay on roundabout)"},
+    {"invalid", "(sliproad)"}};
 
 const constexpr char *waypoint_type_names[] = {"invalid", "arrive", "depart"};
 
@@ -69,7 +101,14 @@ std::string instructionTypeToString(const TurnType::Enum type)
 {
     static_assert(sizeof(turn_type_names) / sizeof(turn_type_names[0]) >= TurnType::MaxTurnType,
                   "Some turn types has not string representation.");
-    return turn_type_names[static_cast<std::size_t>(type)];
+    return turn_type_names[static_cast<std::size_t>(type)].external_name;
+}
+
+std::string internalInstructionTypeToString(const TurnType::Enum type)
+{
+    static_assert(sizeof(turn_type_names) / sizeof(turn_type_names[0]) >= TurnType::MaxTurnType,
+                  "Some turn types has not string representation.");
+    return turn_type_names[static_cast<std::size_t>(type)].internal_name;
 }
 
 util::json::Array lanesFromIntersection(const guidance::IntermediateIntersection &intersection)