#include #include #include #include #include #include #include "baldr/verbal_text_formatter.h" #include "midgard/constants.h" #include "odin/enhancedtrippath.h" #include "odin/maneuver.h" #include "odin/markup_formatter.h" #include "odin/narrative_dictionary.h" #include "odin/narrativebuilder.h" #include "odin/util.h" #include "worker.h" namespace { // Text instruction initial capacity constexpr auto kInstructionInitialCapacity = 128; // Text length initial capacity constexpr auto kLengthStringInitialCapacity = 32; // Basic time threshold in seconds for creating a verbal multi-cue constexpr auto kVerbalMultiCueTimeThreshold = 13; constexpr auto kVerbalMultiCueTimeStartManeuverThreshold = kVerbalMultiCueTimeThreshold * 3; constexpr float kVerbalPostMinimumRampLength = 2.0f; // Kilometers constexpr float kVerbalAlertMergePriorManeuverMinimumLength = kVerbalPostMinimumRampLength; // Lower and upper bounds for roundabout_exit_count constexpr uint32_t kRoundaboutExitCountLowerBound = 1; constexpr uint32_t kRoundaboutExitCountUpperBound = 10; } // namespace namespace valhalla { namespace odin { NarrativeBuilder::NarrativeBuilder(const Options& options, const EnhancedTripLeg* trip_path, const NarrativeDictionary& dictionary, const MarkupFormatter& markup_formatter) : options_(options), trip_path_(trip_path), dictionary_(dictionary), markup_formatter_(markup_formatter), articulated_preposition_enabled_(false) { } void NarrativeBuilder::Build(std::list& maneuvers) { Maneuver* prev_maneuver = nullptr; for (auto& maneuver : maneuvers) { switch (maneuver.type()) { case DirectionsLeg_Maneuver_Type_kStartRight: case DirectionsLeg_Maneuver_Type_kStart: case DirectionsLeg_Maneuver_Type_kStartLeft: case DirectionsLeg_Maneuver_Type_kFerryExit: case DirectionsLeg_Maneuver_Type_kPostTransitConnectionDestination: { // Set instruction maneuver.set_instruction(FormStartInstruction(maneuver)); // Set verbal succinct transition instruction maneuver.set_verbal_succinct_transition_instruction( FormVerbalSuccinctStartTransitionInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalStartInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver, maneuver.HasBeginStreetNames())); break; } case DirectionsLeg_Maneuver_Type_kDestinationRight: case DirectionsLeg_Maneuver_Type_kDestination: case DirectionsLeg_Maneuver_Type_kDestinationLeft: { // Set instruction maneuver.set_instruction(FormDestinationInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction( FormVerbalAlertDestinationInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalDestinationInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kBecomes: { if (prev_maneuver) { // Set instruction maneuver.set_instruction(FormBecomesInstruction(maneuver, prev_maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction( FormVerbalBecomesInstruction(maneuver, prev_maneuver)); } // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver, maneuver .HasBeginStreetNames())); // Set verbal succinct // transition // instruction break; } case DirectionsLeg_Maneuver_Type_kSlightRight: case DirectionsLeg_Maneuver_Type_kSlightLeft: case DirectionsLeg_Maneuver_Type_kRight: case DirectionsLeg_Maneuver_Type_kSharpRight: case DirectionsLeg_Maneuver_Type_kSharpLeft: case DirectionsLeg_Maneuver_Type_kLeft: { // Set instruction maneuver.set_instruction(FormTurnInstruction(maneuver)); // Set verbal succinct transition instruction maneuver.set_verbal_succinct_transition_instruction( FormVerbalSuccinctTurnTransitionInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction(FormVerbalAlertTurnInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalTurnInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver, maneuver.HasBeginStreetNames())); break; } case DirectionsLeg_Maneuver_Type_kUturnRight: case DirectionsLeg_Maneuver_Type_kUturnLeft: { // Set instruction maneuver.set_instruction(FormUturnInstruction(maneuver)); // Set verbal succinct transition instruction maneuver.set_verbal_succinct_transition_instruction( FormVerbalSuccinctUturnTransitionInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction(FormVerbalAlertUturnInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalUturnInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kRampStraight: { // Set instruction maneuver.set_instruction(FormRampStraightInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction( FormVerbalAlertRampStraightInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalRampStraightInstruction(maneuver)); // Only set verbal post if > min ramp length // or contains obvious maneuver // or has collapsed merge maneuver if ((maneuver.length() > kVerbalPostMinimumRampLength) || maneuver.contains_obvious_maneuver() || maneuver.has_collapsed_merge_maneuver()) { // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); } break; } case DirectionsLeg_Maneuver_Type_kRampRight: case DirectionsLeg_Maneuver_Type_kRampLeft: { // Set instruction maneuver.set_instruction(FormRampInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction(FormVerbalAlertRampInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalRampInstruction(maneuver)); // Only set verbal post if > min ramp length // or contains obvious maneuver // or has collapsed merge maneuver if ((maneuver.length() > kVerbalPostMinimumRampLength) || maneuver.contains_obvious_maneuver() || maneuver.has_collapsed_merge_maneuver()) { // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); } break; } case DirectionsLeg_Maneuver_Type_kExitRight: case DirectionsLeg_Maneuver_Type_kExitLeft: { // Set instruction maneuver.set_instruction(FormExitInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction(FormVerbalAlertExitInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalExitInstruction(maneuver)); // Only set verbal post if > min ramp length // or contains obvious maneuver // or has collapsed merge maneuver if ((maneuver.length() > kVerbalPostMinimumRampLength) || maneuver.contains_obvious_maneuver() || maneuver.has_collapsed_merge_maneuver()) { // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); } break; } case DirectionsLeg_Maneuver_Type_kStayStraight: case DirectionsLeg_Maneuver_Type_kStayRight: case DirectionsLeg_Maneuver_Type_kStayLeft: { if (maneuver.to_stay_on()) { // Set stay on instruction maneuver.set_instruction(FormKeepToStayOnInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction( FormVerbalAlertKeepToStayOnInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalKeepToStayOnInstruction(maneuver)); // For a ramp - only set verbal post if > min ramp length if (maneuver.ramp() && !maneuver.has_collapsed_merge_maneuver()) { if (maneuver.length() > kVerbalPostMinimumRampLength) { // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); } } else { // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); } } else { // Set instruction maneuver.set_instruction(FormKeepInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction(FormVerbalAlertKeepInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalKeepInstruction(maneuver)); // For a ramp - only set verbal post if > min ramp length if (maneuver.ramp() && !maneuver.has_collapsed_merge_maneuver()) { if (maneuver.length() > kVerbalPostMinimumRampLength) { // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); } } else { // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); } } break; } case DirectionsLeg_Maneuver_Type_kMerge: case DirectionsLeg_Maneuver_Type_kMergeRight: case DirectionsLeg_Maneuver_Type_kMergeLeft: { // Set instruction maneuver.set_instruction(FormMergeInstruction(maneuver)); // Set verbal succinct transition instruction maneuver.set_verbal_succinct_transition_instruction( FormVerbalSuccinctMergeTransitionInstruction(maneuver)); // Set verbal transition alert instruction if previous maneuver // is greater than 2 km if (prev_maneuver && (prev_maneuver->length(Options::kilometers) > kVerbalAlertMergePriorManeuverMinimumLength)) { maneuver.set_verbal_transition_alert_instruction(FormVerbalAlertMergeInstruction(maneuver)); } // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalMergeInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kRoundaboutEnter: { // Set instruction maneuver.set_instruction(FormEnterRoundaboutInstruction(maneuver)); // Set verbal succinct transition instruction maneuver.set_verbal_succinct_transition_instruction( FormVerbalSuccinctEnterRoundaboutTransitionInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction( FormVerbalAlertEnterRoundaboutInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction( FormVerbalEnterRoundaboutInstruction(maneuver)); // If the maneuver has a combined enter exit roundabout instruction // then set verbal post transition instruction if (maneuver.has_combined_enter_exit_roundabout()) { maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver, maneuver.HasRoundaboutExitBeginStreetNames())); } break; } case DirectionsLeg_Maneuver_Type_kRoundaboutExit: { // Set instruction maneuver.set_instruction(FormExitRoundaboutInstruction(maneuver)); // Set verbal succinct transition instruction maneuver.set_verbal_succinct_transition_instruction( FormVerbalSuccinctExitRoundaboutTransitionInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalExitRoundaboutInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver, maneuver.HasBeginStreetNames())); break; } case DirectionsLeg_Maneuver_Type_kFerryEnter: { // Set instruction maneuver.set_instruction(FormEnterFerryInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction( FormVerbalAlertEnterFerryInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalEnterFerryInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kTransitConnectionStart: { // Set instruction maneuver.set_instruction(FormTransitConnectionStartInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction( FormVerbalTransitConnectionStartInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kTransitConnectionTransfer: { // Set instruction maneuver.set_instruction(FormTransitConnectionTransferInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction( FormVerbalTransitConnectionTransferInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kTransitConnectionDestination: { // Set instruction maneuver.set_instruction(FormTransitConnectionDestinationInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction( FormVerbalTransitConnectionDestinationInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kTransit: { // Set depart instruction maneuver.set_depart_instruction(FormDepartInstruction(maneuver)); // Set verbal depart instruction maneuver.set_verbal_depart_instruction(FormVerbalDepartInstruction(maneuver)); // Set instruction maneuver.set_instruction(FormTransitInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalTransitInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionTransitInstruction(maneuver)); // Set arrive instruction maneuver.set_arrive_instruction(FormArriveInstruction(maneuver)); // Set verbal arrive instruction maneuver.set_verbal_arrive_instruction(FormVerbalArriveInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kTransitRemainOn: { // Set depart instruction maneuver.set_depart_instruction(FormDepartInstruction(maneuver)); // Set verbal depart instruction maneuver.set_verbal_depart_instruction(FormVerbalDepartInstruction(maneuver)); // Set instruction maneuver.set_instruction(FormTransitRemainOnInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction( FormVerbalTransitRemainOnInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionTransitInstruction(maneuver)); // Set arrive instruction maneuver.set_arrive_instruction(FormArriveInstruction(maneuver)); // Set verbal arrive instruction maneuver.set_verbal_arrive_instruction(FormVerbalArriveInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kTransitTransfer: { // Set depart instruction maneuver.set_depart_instruction(FormDepartInstruction(maneuver)); // Set verbal depart instruction maneuver.set_verbal_depart_instruction(FormVerbalDepartInstruction(maneuver)); // Set instruction maneuver.set_instruction(FormTransitTransferInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction( FormVerbalTransitTransferInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionTransitInstruction(maneuver)); // Set arrive instruction maneuver.set_arrive_instruction(FormArriveInstruction(maneuver)); // Set verbal arrive instruction maneuver.set_verbal_arrive_instruction(FormVerbalArriveInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kElevatorEnter: { // Set instruction maneuver.set_instruction(FormElevatorInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kStepsEnter: { // Set instruction maneuver.set_instruction(FormStepsInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kEscalatorEnter: { // Set instruction maneuver.set_instruction(FormEscalatorInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kBuildingEnter: { // Set instruction maneuver.set_instruction(FormEnterBuildingInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kBuildingExit: { // Set instruction maneuver.set_instruction(FormExitBuildingInstruction(maneuver)); break; } case DirectionsLeg_Maneuver_Type_kContinue: default: { if (maneuver.has_node_type()) { std::string instr = FormPassInstruction(maneuver); // Set instruction maneuver.set_instruction(instr); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(instr); } else { // Set instruction maneuver.set_instruction(FormContinueInstruction(maneuver)); // Set verbal transition alert instruction maneuver.set_verbal_transition_alert_instruction( FormVerbalAlertContinueInstruction(maneuver)); // Set verbal pre transition instruction maneuver.set_verbal_pre_transition_instruction(FormVerbalContinueInstruction(maneuver)); // Set verbal post transition instruction maneuver.set_verbal_post_transition_instruction( FormVerbalPostTransitionInstruction(maneuver)); } break; } } maneuver.set_instruction(FormBssManeuverType(maneuver.bss_maneuver_type()) + maneuver.instruction()); // Update previous maneuver prev_maneuver = &maneuver; } // Iterate over maneuvers to form verbal multi-cue instructions FormVerbalMultiCue(maneuvers); } std::string NarrativeBuilder::FormVerbalAlertApproachInstruction(float distance, const std::string& verbal_cue) { std::string instruction; instruction.reserve(kInstructionInitialCapacity); uint8_t phrase_id = 0; // Set instruction to the determined tagged phrase instruction = dictionary_.approach_verbal_alert_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kLengthTag, FormLength(distance, dictionary_.approach_verbal_alert_subset.metric_lengths, dictionary_.approach_verbal_alert_subset.us_customary_lengths)); boost::replace_all(instruction, kCurrentVerbalCueTag, verbal_cue); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormStartInstruction(Maneuver& maneuver) { // "0": "Head .", // "1": "Head on .", // "2": "Head on . Continue on .", // "4": "Drive .", // "5": "Drive on .", // "6": "Drive on . Continue on .", // "8": "Walk .", // "9": "Walk on .", // "10": "Walk on . Continue on .", // "16": "Bike .", // "17": "Bike on .", // "18": "Bike on . Continue on ." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Set cardinal_direction value std::string cardinal_direction = dictionary_.start_subset.cardinal_directions.at(maneuver.begin_cardinal_direction()); // Set street_names value std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), &dictionary_.start_subset.empty_street_name_labels, true); // Set begin_street_names value std::string begin_street_names = FormStreetNames(maneuver, maneuver.begin_street_names()); // Update street names for maneuvers that contain obvious maneuvers UpdateObviousManeuverStreetNames(maneuver, begin_street_names, street_names); // Determine which phrase to use uint8_t phrase_id = 0; if (!street_names.empty()) { phrase_id += 1; } if (!begin_street_names.empty()) { phrase_id += 1; } if (maneuver.travel_mode() == TravelMode::kDrive) { phrase_id += 4; } else if (maneuver.travel_mode() == TravelMode::kPedestrian) { phrase_id += 8; } else if (maneuver.travel_mode() == TravelMode::kBicycle) { phrase_id += 16; } // Set instruction to the determined tagged phrase instruction = dictionary_.start_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kCardinalDirectionTag, cardinal_direction); boost::replace_all(instruction, kStreetNamesTag, street_names); boost::replace_all(instruction, kBeginStreetNamesTag, begin_street_names); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalStartInstruction(Maneuver& maneuver, uint32_t element_max_count, const std::string& delim) { // "0": "Head .", // "1": "Head for .", // "2": "Head on .", // "3": "Head on for .", // "4": "Head on .", // "5": "Drive .", // "6": "Drive for .", // "7": "Drive on .", // "8": "Drive on for .", // "9": "Drive on .", // "10": "Walk .", // "11": "Walk for .", // "12": "Walk on .", // "13": "Walk on for .", // "14": "Walk on .", // "15": "Bike .", // "16": "Bike for .", // "17": "Bike on .", // "18": "Bike on for .", // "19": "Bike on ." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Set cardinal_direction value std::string cardinal_direction = dictionary_.start_verbal_subset.cardinal_directions.at(maneuver.begin_cardinal_direction()); // Set street_names value std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), &dictionary_.start_verbal_subset.empty_street_name_labels, true, element_max_count, delim, maneuver.verbal_formatter()); // Set begin_street_names value std::string begin_street_names = FormStreetNames(maneuver, maneuver.begin_street_names(), &dictionary_.start_verbal_subset.empty_street_name_labels, false, element_max_count, delim, maneuver.verbal_formatter()); // Update street names for maneuvers that contain obvious maneuvers UpdateObviousManeuverStreetNames(maneuver, begin_street_names, street_names); // Determine which phrase to use uint8_t phrase_id = 0; // Set base phrase id per mode if (maneuver.travel_mode() == TravelMode::kDrive) { phrase_id += 5; } else if (maneuver.travel_mode() == TravelMode::kPedestrian) { phrase_id += 10; } else if (maneuver.travel_mode() == TravelMode::kBicycle) { phrase_id += 15; } if (!street_names.empty()) { // Increment phrase id for street names phrase_id += 2; } if (!begin_street_names.empty()) { // Increment phrase id for begin street names phrase_id += 2; } else if (maneuver.include_verbal_pre_transition_length()) { // For non begin street names, increment phrase id for length phrase_id += 1; } // Set instruction to the determined tagged phrase instruction = dictionary_.start_verbal_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kCardinalDirectionTag, cardinal_direction); boost::replace_all(instruction, kStreetNamesTag, street_names); boost::replace_all(instruction, kBeginStreetNamesTag, begin_street_names); boost::replace_all(instruction, kLengthTag, FormLength(maneuver, dictionary_.start_verbal_subset.metric_lengths, dictionary_.start_verbal_subset.us_customary_lengths)); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormDestinationInstruction(Maneuver& maneuver) { // "0": "You have arrived at your destination." // "1": "You have arrived at ." // "2": "Your destination is on the ." // "3": " is on the ." uint8_t phrase_id = 0; std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Determine if location (name or street) exists std::string destination; const auto& dest = trip_path_->GetDestination(); // Check for destination name if (!dest.name().empty()) { phrase_id += 1; destination = dest.name(); } // Check for destination street else if (!dest.street().empty()) { phrase_id += 1; destination = dest.street(); } // Check for side of street relative direction std::string relative_direction; if (maneuver.type() == DirectionsLeg_Maneuver_Type_kDestinationLeft) { phrase_id += 2; relative_direction = dictionary_.destination_subset.relative_directions.at(0); } else if (maneuver.type() == DirectionsLeg_Maneuver_Type_kDestinationRight) { phrase_id += 2; relative_direction = dictionary_.destination_subset.relative_directions.at(1); } // Set instruction to the determined tagged phrase instruction = dictionary_.destination_subset.phrases.at(std::to_string(phrase_id)); if (phrase_id > 0) { // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, relative_direction); boost::replace_all(instruction, kDestinationTag, destination); } // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalAlertDestinationInstruction(Maneuver& maneuver) { // "0": "You will arrive at your destination.", // "1": "You will arrive at .", // "2": "Your destination will be on the .", // "3": " will be on the ." uint8_t phrase_id = 0; std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Determine if destination (name or street) exists std::string destination; auto& dest = trip_path_->GetDestination(); // Check for destination name if (!dest.name().empty()) { phrase_id += 1; destination = dest.name(); } // Check for destination street else if (!dest.street().empty()) { phrase_id += 1; auto* verbal_formatter = maneuver.verbal_formatter(); if (verbal_formatter) { destination = verbal_formatter->Format(dest.street()); } else { destination = dest.street(); } } // Check for side of street relative direction std::string relative_direction; if (maneuver.type() == DirectionsLeg_Maneuver_Type_kDestinationLeft) { phrase_id += 2; relative_direction = dictionary_.destination_subset.relative_directions.at(0); } else if (maneuver.type() == DirectionsLeg_Maneuver_Type_kDestinationRight) { phrase_id += 2; relative_direction = dictionary_.destination_subset.relative_directions.at(1); } // Set instruction to the determined tagged phrase instruction = dictionary_.destination_verbal_alert_subset.phrases.at(std::to_string(phrase_id)); if (phrase_id > 0) { // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, relative_direction); boost::replace_all(instruction, kDestinationTag, destination); } // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalDestinationInstruction(Maneuver& maneuver) { // "0": "You have arrived at your destination.", // "1": "You have arrived at .", // "2": "Your destination is on the .", // "3": " is on the ." uint8_t phrase_id = 0; std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Determine if destination (name or street) exists std::string destination; auto& dest = trip_path_->GetDestination(); // Check for destination name if (!dest.name().empty()) { phrase_id += 1; destination = dest.name(); } // Check for destination street else if (!dest.street().empty()) { phrase_id += 1; auto* verbal_formatter = maneuver.verbal_formatter(); if (verbal_formatter) { destination = verbal_formatter->Format(dest.street()); } else { destination = dest.street(); } } // Check for side of street relative direction std::string relative_direction; if (maneuver.type() == DirectionsLeg_Maneuver_Type_kDestinationLeft) { phrase_id += 2; relative_direction = dictionary_.destination_subset.relative_directions.at(0); } else if (maneuver.type() == DirectionsLeg_Maneuver_Type_kDestinationRight) { phrase_id += 2; relative_direction = dictionary_.destination_subset.relative_directions.at(1); } // Set instruction to the determined tagged phrase instruction = dictionary_.destination_verbal_subset.phrases.at(std::to_string(phrase_id)); if (phrase_id > 0) { // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, relative_direction); boost::replace_all(instruction, kDestinationTag, destination); } // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormBecomesInstruction(Maneuver& maneuver, Maneuver* prev_maneuver) { // "0": " becomes ." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Assign the street names and the previous maneuver street names std::string street_names = FormStreetNames(maneuver, maneuver.street_names()); std::string prev_street_names = FormStreetNames(*prev_maneuver, prev_maneuver->street_names()); // Determine which phrase to use uint8_t phrase_id = 0; // Set instruction to the determined tagged phrase instruction = dictionary_.becomes_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kPreviousStreetNamesTag, prev_street_names); boost::replace_all(instruction, kStreetNamesTag, street_names); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalBecomesInstruction(Maneuver& maneuver, Maneuver* prev_maneuver, uint32_t element_max_count, const std::string& delim) { // "0": " becomes ." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Assign the street names and the previous maneuver street names std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), nullptr, false, element_max_count, delim, prev_maneuver->verbal_formatter()); std::string prev_street_names = FormStreetNames(*prev_maneuver, prev_maneuver->street_names(), nullptr, false, element_max_count, delim, prev_maneuver->verbal_formatter()); // Determine which phrase to use uint8_t phrase_id = 0; // Set instruction to the determined tagged phrase instruction = dictionary_.becomes_verbal_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kPreviousStreetNamesTag, prev_street_names); boost::replace_all(instruction, kStreetNamesTag, street_names); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormContinueInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count) { // "0": "Continue.", // "1": "Continue on ." // "2": "Continue at ." // "3": "Continue toward ." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Assign the street names std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), &dictionary_.continue_subset.empty_street_name_labels, true); // Determine which phrase to use uint8_t phrase_id = 0; std::string junction_name; std::string guide_sign; if (maneuver.HasGuideSign()) { // Set the toward phrase - it takes priority over street names and junction name phrase_id = 3; // Assign guide sign guide_sign = maneuver.signs().GetGuideString(element_max_count, limit_by_consecutive_count); } else if (maneuver.HasJunctionNameSign()) { // Set the junction phrase - it takes priority over street names phrase_id = 2; // Assign guide sign junction_name = maneuver.signs().GetJunctionNameString(element_max_count, limit_by_consecutive_count); } else if (!street_names.empty()) { phrase_id = 1; } // Set instruction to the determined tagged phrase instruction = dictionary_.continue_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kStreetNamesTag, street_names); boost::replace_all(instruction, kJunctionNameTag, junction_name); boost::replace_all(instruction, kTowardSignTag, guide_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalAlertContinueInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Continue.", // "1": "Continue on ." // "2": "Continue at ." // "3": "Continue toward ." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Assign the street names std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), &dictionary_.continue_verbal_alert_subset.empty_street_name_labels, true, element_max_count, delim, maneuver.verbal_formatter()); // Determine which phrase to use uint8_t phrase_id = 0; std::string junction_name; std::string guide_sign; if (maneuver.HasGuideSign()) { // Set the toward phrase - it takes priority over street names and junction name phrase_id = 3; // Assign guide sign guide_sign = maneuver.signs().GetGuideString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasJunctionNameSign()) { // Set the junction phrase - it takes priority over street names phrase_id = 2; // Assign guide sign junction_name = maneuver.signs().GetJunctionNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (!street_names.empty()) { phrase_id = 1; } // Set instruction to the determined tagged phrase instruction = dictionary_.continue_verbal_alert_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kStreetNamesTag, street_names); boost::replace_all(instruction, kJunctionNameTag, junction_name); boost::replace_all(instruction, kTowardSignTag, guide_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalContinueInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Continue.", // "1": "Continue for .", // "2": "Continue on .", // "3": "Continue on for ." // "4": "Continue at ." // "5": "Continue at for ." // "6": "Continue toward ." // "7": "Continue toward for ." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Assign the street names std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), &dictionary_.continue_verbal_subset.empty_street_name_labels, true, element_max_count, delim, maneuver.verbal_formatter()); // Determine base phrase uint8_t phrase_id = 0; std::string junction_name; std::string guide_sign; if (maneuver.HasGuideSign()) { // Set the toward phrase - it takes priority over street names and junction name phrase_id = 6; // Assign guide sign guide_sign = maneuver.signs().GetGuideString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasJunctionNameSign()) { // Set the junction phrase - it takes priority over street names phrase_id = 4; // Assign guide sign junction_name = maneuver.signs().GetJunctionNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (!street_names.empty()) { phrase_id = 2; } if (maneuver.include_verbal_pre_transition_length()) { // Increment phrase id for length phrase_id += 1; } // Set instruction to the determined tagged phrase instruction = dictionary_.continue_verbal_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kLengthTag, FormLength(maneuver, dictionary_.continue_verbal_subset.metric_lengths, dictionary_.continue_verbal_subset.us_customary_lengths)); boost::replace_all(instruction, kStreetNamesTag, street_names); boost::replace_all(instruction, kJunctionNameTag, junction_name); boost::replace_all(instruction, kTowardSignTag, guide_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormTurnInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count) { // "0": "Turn/Bear/Make a sharp .", // "1": "Turn/Bear/Make a sharp onto .", // "2": "Turn/Bear/Make a sharp onto . Continue on // .", // "3": "Turn/Bear/Make a sharp to stay on ." // "4": "Turn/Bear/Make a sharp at ." // "5": "Turn/Bear/Make a sharp toward ." const TurnSubset* subset = nullptr; switch (maneuver.type()) { case DirectionsLeg_Maneuver_Type_kSlightRight: case DirectionsLeg_Maneuver_Type_kSlightLeft: subset = &dictionary_.bear_subset; break; case DirectionsLeg_Maneuver_Type_kRight: case DirectionsLeg_Maneuver_Type_kLeft: subset = &dictionary_.turn_subset; break; case DirectionsLeg_Maneuver_Type_kSharpRight: case DirectionsLeg_Maneuver_Type_kSharpLeft: subset = &dictionary_.sharp_subset; break; default: throw valhalla_exception_t{230}; } std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Assign the street names std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), &subset->empty_street_name_labels, true); // Assign the begin street names std::string begin_street_names = FormStreetNames(maneuver, maneuver.begin_street_names()); // Update street names for maneuvers that contain obvious maneuvers UpdateObviousManeuverStreetNames(maneuver, begin_street_names, street_names); // Determine which phrase to use uint8_t phrase_id = 0; std::string junction_name; std::string guide_sign; if (maneuver.HasGuideSign()) { // Set the toward phrase - it takes priority over street names and junction name phrase_id = 5; // Assign guide sign guide_sign = maneuver.signs().GetGuideString(element_max_count, limit_by_consecutive_count); } else if (maneuver.HasJunctionNameSign()) { // Set the junction phrase - it takes priority over street names phrase_id = 4; // Assign guide sign junction_name = maneuver.signs().GetJunctionNameString(element_max_count, limit_by_consecutive_count); } else if (maneuver.to_stay_on()) { phrase_id = 3; } else if (!begin_street_names.empty()) { phrase_id = 2; } else if (!street_names.empty()) { phrase_id = 1; } // Set instruction to the determined tagged phrase instruction = subset->phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, FormRelativeTwoDirection(maneuver.type(), subset->relative_directions)); boost::replace_all(instruction, kStreetNamesTag, street_names); boost::replace_all(instruction, kBeginStreetNamesTag, begin_street_names); boost::replace_all(instruction, kJunctionNameTag, junction_name); boost::replace_all(instruction, kTowardSignTag, guide_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalAlertTurnInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Turn/Bear/Make a sharp .", // "1": "Turn/Bear/Make a sharp onto .", // "2": "Turn/Bear/Make a sharp onto .", // "3": "Turn/Bear/Make a sharp to stay on ." // "4": "Turn/Bear/Make a sharp at ." // "5": "Turn/Bear/Make a sharp toward ." return FormVerbalTurnInstruction(maneuver, limit_by_consecutive_count, element_max_count, delim); } std::string NarrativeBuilder::FormVerbalTurnInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Turn/Bear/Make a sharp .", // "1": "Turn/Bear/Make a sharp onto .", // "2": "Turn/Bear/Make a sharp onto .", // "3": "Turn/Bear/Make a sharp to stay on ." // "4": "Turn/Bear/Make a sharp at ." // "5": "Turn/Bear/Make a sharp toward ." const TurnSubset* subset = nullptr; switch (maneuver.type()) { case DirectionsLeg_Maneuver_Type_kSlightRight: case DirectionsLeg_Maneuver_Type_kSlightLeft: subset = &dictionary_.bear_verbal_subset; break; case DirectionsLeg_Maneuver_Type_kRight: case DirectionsLeg_Maneuver_Type_kLeft: subset = &dictionary_.turn_verbal_subset; break; case DirectionsLeg_Maneuver_Type_kSharpRight: case DirectionsLeg_Maneuver_Type_kSharpLeft: subset = &dictionary_.sharp_verbal_subset; break; default: throw valhalla_exception_t{230}; } std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Assign the street names std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), &subset->empty_street_name_labels, true, element_max_count, delim, maneuver.verbal_formatter()); // Assign the begin street names std::string begin_street_names = FormStreetNames(maneuver, maneuver.begin_street_names(), &subset->empty_street_name_labels, false, element_max_count, delim, maneuver.verbal_formatter()); // Update street names for maneuvers that contain obvious maneuvers UpdateObviousManeuverStreetNames(maneuver, begin_street_names, street_names); // Determine which phrase to use uint8_t phrase_id = 0; std::string junction_name; std::string guide_sign; if (maneuver.HasGuideSign()) { // Set the toward phrase - it takes priority over street names and junction name phrase_id = 5; // Assign guide sign guide_sign = maneuver.signs().GetGuideString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasJunctionNameSign()) { // Set the junction phrase - it takes priority over street names phrase_id = 4; // Assign guide sign junction_name = maneuver.signs().GetJunctionNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else { if (!street_names.empty()) { phrase_id = 1; } if (!begin_street_names.empty()) { phrase_id = 2; } if (maneuver.to_stay_on()) { phrase_id = 3; } } // Set instruction to the determined tagged phrase instruction = subset->phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, FormRelativeTwoDirection(maneuver.type(), subset->relative_directions)); boost::replace_all(instruction, kStreetNamesTag, street_names); boost::replace_all(instruction, kBeginStreetNamesTag, begin_street_names); boost::replace_all(instruction, kJunctionNameTag, junction_name); boost::replace_all(instruction, kTowardSignTag, guide_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormUturnInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count) { // "0": "Make a U-turn.", // "1": "Make a U-turn onto .", // "2": "Make a U-turn to stay on .", // "3": "Make a U-turn at .", // "4": "Make a U-turn at onto .", // "5": "Make a U-turn at to stay on ." // "6": "Make a U-turn at ." // "7": "Make a U-turn toward ." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Assign the street names std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), &dictionary_.uturn_subset.empty_street_name_labels, true); // Assign the cross street names std::string cross_street_names = FormStreetNames(maneuver, maneuver.cross_street_names()); // Determine which phrase to use uint8_t phrase_id = 0; std::string junction_name; std::string guide_sign; if (maneuver.HasGuideSign()) { // Set the toward phrase - it takes priority over street names and junction name phrase_id = 7; // Assign guide sign guide_sign = maneuver.signs().GetGuideString(element_max_count, limit_by_consecutive_count); } else if (maneuver.HasJunctionNameSign()) { // Set the junction phrase - it takes priority over street names phrase_id = 6; // Assign guide sign junction_name = maneuver.signs().GetJunctionNameString(element_max_count, limit_by_consecutive_count); } else { if (!street_names.empty()) { phrase_id += 1; if (maneuver.to_stay_on()) { phrase_id += 1; } } if (!cross_street_names.empty()) { phrase_id += 3; } } // Set instruction to the determined tagged phrase instruction = dictionary_.uturn_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, FormRelativeTwoDirection(maneuver.type(), dictionary_.uturn_subset.relative_directions)); boost::replace_all(instruction, kStreetNamesTag, street_names); boost::replace_all(instruction, kCrossStreetNamesTag, cross_street_names); boost::replace_all(instruction, kJunctionNameTag, junction_name); boost::replace_all(instruction, kTowardSignTag, guide_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalAlertUturnInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Make a U-turn.", // "1": "Make a U-turn onto .", // "2": "Make a U-turn to stay on .", // "3": "Make a U-turn at ." // "6": "Make a U-turn at ." // "7": "Make a U-turn toward ." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Assign the street names std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), &dictionary_.uturn_verbal_subset.empty_street_name_labels, true, element_max_count, delim, maneuver.verbal_formatter()); // Assign the cross street names std::string cross_street_names = FormStreetNames(maneuver, maneuver.cross_street_names(), &dictionary_.uturn_verbal_subset.empty_street_name_labels, false, element_max_count, delim, maneuver.verbal_formatter()); // Determine which phrase to use uint8_t phrase_id = 0; std::string junction_name; std::string guide_sign; if (maneuver.HasGuideSign()) { // Set the toward phrase - it takes priority over street names and junction name phrase_id = 7; // Assign guide sign guide_sign = maneuver.signs().GetGuideString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasJunctionNameSign()) { // Set the junction phrase - it takes priority over street names phrase_id = 6; // Assign guide sign junction_name = maneuver.signs().GetJunctionNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else { if (!street_names.empty()) { phrase_id = 1; if (maneuver.to_stay_on()) { phrase_id = 2; } } if (!cross_street_names.empty()) { phrase_id = 3; } } return FormVerbalUturnInstruction(phrase_id, FormRelativeTwoDirection(maneuver.type(), dictionary_.uturn_verbal_subset .relative_directions), street_names, cross_street_names, junction_name, guide_sign); } std::string NarrativeBuilder::FormVerbalUturnInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Make a U-turn.", // "1": "Make a U-turn onto .", // "2": "Make a U-turn to stay on .", // "3": "Make a U-turn at .", // "4": "Make a U-turn at onto .", // "5": "Make a U-turn at to stay on ." // "6": "Make a U-turn at ." // "7": "Make a U-turn toward ." // Assign the street names std::string street_names = FormStreetNames(maneuver, maneuver.street_names(), &dictionary_.uturn_verbal_subset.empty_street_name_labels, true, element_max_count, delim, maneuver.verbal_formatter()); // Assign the cross street names std::string cross_street_names = FormStreetNames(maneuver, maneuver.cross_street_names(), &dictionary_.uturn_verbal_subset.empty_street_name_labels, false, element_max_count, delim, maneuver.verbal_formatter()); // Determine which phrase to use uint8_t phrase_id = 0; std::string junction_name; std::string guide_sign; if (maneuver.HasGuideSign()) { // Set the toward phrase - it takes priority over street names and junction name phrase_id = 7; // Assign guide sign guide_sign = maneuver.signs().GetGuideString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasJunctionNameSign()) { // Set the junction phrase - it takes priority over street names phrase_id = 6; // Assign guide sign junction_name = maneuver.signs().GetJunctionNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else { if (!street_names.empty()) { phrase_id += 1; if (maneuver.to_stay_on()) { phrase_id += 1; } } if (!cross_street_names.empty()) { phrase_id += 3; } } return FormVerbalUturnInstruction(phrase_id, FormRelativeTwoDirection(maneuver.type(), dictionary_.uturn_verbal_subset .relative_directions), street_names, cross_street_names, junction_name, guide_sign); } std::string NarrativeBuilder::FormVerbalUturnInstruction(uint8_t phrase_id, const std::string& relative_dir, const std::string& street_names, const std::string& cross_street_names, const std::string& junction_name, const std::string& guide_sign) { std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Set instruction to the determined tagged phrase instruction = dictionary_.uturn_verbal_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, relative_dir); boost::replace_all(instruction, kStreetNamesTag, street_names); boost::replace_all(instruction, kCrossStreetNamesTag, cross_street_names); boost::replace_all(instruction, kJunctionNameTag, junction_name); boost::replace_all(instruction, kTowardSignTag, guide_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormRampStraightInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count) { // "0": "Stay straight to take the ramp.", // "1": "Stay straight to take the ramp.", // "2": "Stay straight to take the ramp toward .", // "3": "Stay straight to take the ramp toward .", // "4": "Stay straight to take the ramp." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Determine which phrase to use uint8_t phrase_id = 0; std::string exit_branch_sign; std::string exit_toward_sign; std::string exit_name_sign; if (maneuver.HasExitBranchSign()) { phrase_id += 1; // Assign branch sign exit_branch_sign = maneuver.signs().GetExitBranchString(element_max_count, limit_by_consecutive_count); } if (maneuver.HasExitTowardSign()) { phrase_id += 2; // Assign toward sign exit_toward_sign = maneuver.signs().GetExitTowardString(element_max_count, limit_by_consecutive_count); } if (maneuver.HasExitNameSign() && !maneuver.HasExitBranchSign() && !maneuver.HasExitTowardSign()) { phrase_id += 4; // Assign name sign exit_name_sign = maneuver.signs().GetExitNameString(element_max_count, limit_by_consecutive_count); } // Set instruction to the determined tagged phrase instruction = dictionary_.ramp_straight_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kBranchSignTag, exit_branch_sign); boost::replace_all(instruction, kTowardSignTag, exit_toward_sign); boost::replace_all(instruction, kNameSignTag, exit_name_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalAlertRampStraightInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Stay straight to take the ramp.", // "1": "Stay straight to take the ramp.", // "2": "Stay straight to take the ramp toward .", // "4": "Stay straight to take the ramp." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Determine which phrase to use uint8_t phrase_id = 0; std::string exit_branch_sign; std::string exit_toward_sign; std::string exit_name_sign; if (maneuver.HasExitBranchSign()) { phrase_id = 1; exit_branch_sign = maneuver.signs().GetExitBranchString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasExitTowardSign()) { phrase_id = 2; // Assign toward sign exit_toward_sign = maneuver.signs().GetExitTowardString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasExitNameSign()) { phrase_id = 4; // Assign name sign exit_name_sign = maneuver.signs().GetExitNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } return FormVerbalRampStraightInstruction(phrase_id, exit_branch_sign, exit_toward_sign, exit_name_sign); } std::string NarrativeBuilder::FormVerbalRampStraightInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Stay straight to take the ramp.", // "1": "Stay straight to take the ramp.", // "2": "Stay straight to take the ramp toward .", // "3": "Stay straight to take the ramp toward .", // "4": "Stay straight to take the ramp." // Determine which phrase to use uint8_t phrase_id = 0; std::string exit_branch_sign; std::string exit_toward_sign; std::string exit_name_sign; if (maneuver.HasExitBranchSign()) { phrase_id += 1; // Assign branch sign exit_branch_sign = maneuver.signs().GetExitBranchString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } if (maneuver.HasExitTowardSign()) { phrase_id += 2; // Assign toward sign exit_toward_sign = maneuver.signs().GetExitTowardString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } if (maneuver.HasExitNameSign() && !maneuver.HasExitBranchSign() && !maneuver.HasExitTowardSign()) { phrase_id += 4; // Assign name sign exit_name_sign = maneuver.signs().GetExitNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } return FormVerbalRampStraightInstruction(phrase_id, exit_branch_sign, exit_toward_sign, exit_name_sign); } std::string NarrativeBuilder::FormVerbalRampStraightInstruction(uint8_t phrase_id, const std::string& exit_branch_sign, const std::string& exit_toward_sign, const std::string& exit_name_sign) { std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Set instruction to the determined tagged phrase instruction = dictionary_.ramp_straight_verbal_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kBranchSignTag, exit_branch_sign); boost::replace_all(instruction, kTowardSignTag, exit_toward_sign); boost::replace_all(instruction, kNameSignTag, exit_name_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormRampInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count) { // "0": "Take the ramp on the .", // "1": "Take the ramp on the .", // "2": "Take the ramp on the toward .", // "3": "Take the ramp on the toward .", // "4": "Take the ramp on the .", // "5": "Turn to take the ramp.", // "6": "Turn to take the ramp.", // "7": "Turn to take the ramp toward .", // "8": "Turn to take the ramp toward .", // "9": "Turn to take the ramp." // "10": "Take the ramp.", // "11": "Take the ramp.", // "12": "Take the ramp toward .", // "13": "Take the ramp toward .", // "14": "Take the ramp." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Determine which phrase to use uint8_t phrase_id = 0; std::string exit_branch_sign; std::string exit_toward_sign; std::string exit_name_sign; // Determine if turn, else it's a "Take" instruction if ((maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kRight) || (maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kLeft)) { phrase_id = 5; // Determine if driving side matches relative direction } else if (((maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kKeepRight) && maneuver.drive_on_right()) || ((maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kKeepLeft) && !maneuver.drive_on_right())) { phrase_id = 10; } if (maneuver.HasExitBranchSign()) { phrase_id += 1; // Assign branch sign exit_branch_sign = maneuver.signs().GetExitBranchString(element_max_count, limit_by_consecutive_count); } if (maneuver.HasExitTowardSign()) { phrase_id += 2; // Assign toward sign exit_toward_sign = maneuver.signs().GetExitTowardString(element_max_count, limit_by_consecutive_count); } if (maneuver.HasExitNameSign() && !maneuver.HasExitBranchSign() && !maneuver.HasExitTowardSign()) { phrase_id += 4; // Assign name sign exit_name_sign = maneuver.signs().GetExitNameString(element_max_count, limit_by_consecutive_count); } // Set instruction to the determined tagged phrase instruction = dictionary_.ramp_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, FormRelativeTwoDirection(maneuver.type(), dictionary_.ramp_subset.relative_directions)); boost::replace_all(instruction, kBranchSignTag, exit_branch_sign); boost::replace_all(instruction, kTowardSignTag, exit_toward_sign); boost::replace_all(instruction, kNameSignTag, exit_name_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalAlertRampInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Take the ramp on the .", // "1": "Take the ramp on the .", // "2": "Take the ramp on the toward .", // "3": "Take the ramp on the toward .", // "4": "Take the ramp on the .", // "5": "Turn to take the ramp.", // "6": "Turn to take the ramp.", // "7": "Turn to take the ramp toward .", // "8": "Turn to take the ramp toward .", // "9": "Turn to take the ramp." // "10": "Take the ramp.", // "11": "Take the ramp.", // "12": "Take the ramp toward .", // "13": "Take the ramp toward .", // "14": "Take the ramp." // Determine which phrase to use uint8_t phrase_id = 0; std::string exit_branch_sign; std::string exit_toward_sign; std::string exit_name_sign; // Determine if turn, else it's a "Take" instruction if ((maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kRight) || (maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kLeft)) { phrase_id = 5; // Determine if driving side matches relative direction } else if (((maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kKeepRight) && maneuver.drive_on_right()) || ((maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kKeepLeft) && !maneuver.drive_on_right())) { phrase_id = 10; } if (maneuver.HasExitBranchSign()) { phrase_id += 1; // Assign branch sign exit_branch_sign = maneuver.signs().GetExitBranchString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasExitTowardSign()) { phrase_id += 2; // Assign toward sign exit_toward_sign = maneuver.signs().GetExitTowardString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasExitNameSign()) { phrase_id += 4; // Assign name sign exit_name_sign = maneuver.signs().GetExitNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } return FormVerbalRampInstruction(phrase_id, FormRelativeTwoDirection(maneuver.type(), dictionary_.ramp_verbal_subset .relative_directions), exit_branch_sign, exit_toward_sign, exit_name_sign); } std::string NarrativeBuilder::FormVerbalRampInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Take the ramp on the .", // "1": "Take the ramp on the .", // "2": "Take the ramp on the toward .", // "3": "Take the ramp on the toward .", // "4": "Take the ramp on the .", // "5": "Turn to take the ramp.", // "6": "Turn to take the ramp.", // "7": "Turn to take the ramp toward .", // "8": "Turn to take the ramp toward .", // "9": "Turn to take the ramp." // "10": "Take the ramp.", // "11": "Take the ramp.", // "12": "Take the ramp toward .", // "13": "Take the ramp toward .", // "14": "Take the ramp." // Determine which phrase to use uint8_t phrase_id = 0; std::string exit_branch_sign; std::string exit_toward_sign; std::string exit_name_sign; // Determine if turn, else it's a "Take" instruction if ((maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kRight) || (maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kLeft)) { phrase_id = 5; // Determine if driving side matches relative direction } else if (((maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kKeepRight) && maneuver.drive_on_right()) || ((maneuver.begin_relative_direction() == Maneuver::RelativeDirection::kKeepLeft) && !maneuver.drive_on_right())) { phrase_id = 10; } if (maneuver.HasExitBranchSign()) { phrase_id += 1; // Assign branch sign exit_branch_sign = maneuver.signs().GetExitBranchString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } if (maneuver.HasExitTowardSign()) { phrase_id += 2; // Assign toward sign exit_toward_sign = maneuver.signs().GetExitTowardString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } if (maneuver.HasExitNameSign() && !maneuver.HasExitBranchSign() && !maneuver.HasExitTowardSign()) { phrase_id += 4; // Assign name sign exit_name_sign = maneuver.signs().GetExitNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } return FormVerbalRampInstruction(phrase_id, FormRelativeTwoDirection(maneuver.type(), dictionary_.ramp_verbal_subset .relative_directions), exit_branch_sign, exit_toward_sign, exit_name_sign); } std::string NarrativeBuilder::FormVerbalRampInstruction(uint8_t phrase_id, const std::string& relative_dir, const std::string& exit_branch_sign, const std::string& exit_toward_sign, const std::string& exit_name_sign) { std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Set instruction to the determined tagged phrase instruction = dictionary_.ramp_verbal_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, relative_dir); boost::replace_all(instruction, kBranchSignTag, exit_branch_sign); boost::replace_all(instruction, kTowardSignTag, exit_toward_sign); boost::replace_all(instruction, kNameSignTag, exit_name_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormExitInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count) { // "0": "Take the exit on the .", // "1": "Take exit on the .", // "2": "Take the exit on the .", // "3": "Take exit on the onto .", // "4": "Take the exit on the toward .", // "5": "Take exit on the toward .", // "6": "Take the exit on the toward .", // "7": "Take exit on the onto toward // .", "8": "Take the exit on the .", "10": "Take the // exit on the onto .", "12": "Take the // exit on the toward .", "14": "Take the exit on the // onto toward ." // "15": "Take the exit.", // "16": "Take exit .", // "17": "Take the exit.", // "18": "Take exit onto .", // "19": "Take the exit toward .", // "20": "Take exit toward .", // "21": "Take the exit toward .", // "22": "Take exit onto toward .", // "23": "Take the exit.", // "25": "Take the exit onto .", // "27": "Take the exit toward .", // "29": "Take the exit onto toward ." std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Determine which phrase to use uint8_t phrase_id = 0; std::string exit_number_sign; std::string exit_branch_sign; std::string exit_toward_sign; std::string exit_name_sign; // Determine if driving side matches relative direction if (((maneuver.type() == DirectionsLeg_Maneuver_Type_kExitRight) && maneuver.drive_on_right()) || ((maneuver.type() == DirectionsLeg_Maneuver_Type_kExitLeft) && !maneuver.drive_on_right())) { phrase_id = 15; } if (maneuver.HasExitNumberSign()) { phrase_id += 1; // Assign number sign exit_number_sign = maneuver.signs().GetExitNumberString(); } if (maneuver.HasExitBranchSign()) { phrase_id += 2; // Assign branch sign exit_branch_sign = maneuver.signs().GetExitBranchString(element_max_count, limit_by_consecutive_count); } if (maneuver.HasExitTowardSign()) { phrase_id += 4; // Assign toward sign exit_toward_sign = maneuver.signs().GetExitTowardString(element_max_count, limit_by_consecutive_count); } if (maneuver.HasExitNameSign() && !maneuver.HasExitNumberSign()) { phrase_id += 8; // Assign name sign exit_name_sign = maneuver.signs().GetExitNameString(element_max_count, limit_by_consecutive_count); } // Set instruction to the determined tagged phrase instruction = dictionary_.exit_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, FormRelativeTwoDirection(maneuver.type(), dictionary_.exit_subset.relative_directions)); boost::replace_all(instruction, kNumberSignTag, exit_number_sign); boost::replace_all(instruction, kBranchSignTag, exit_branch_sign); boost::replace_all(instruction, kTowardSignTag, exit_toward_sign); boost::replace_all(instruction, kNameSignTag, exit_name_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormVerbalAlertExitInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Take the exit on the .", // "1": "Take exit on the .", // "2": "Take the exit on the .", // "4": "Take the exit on the toward .", // "8": "Take the exit on the .", // "15": "Take the exit.", // "16": "Take exit .", // "17": "Take the exit.", // "19": "Take the exit toward .", // "23": "Take the exit.", // Determine which phrase to use uint8_t phrase_id = 0; std::string exit_number_sign; std::string exit_branch_sign; std::string exit_toward_sign; std::string exit_name_sign; // Determine if driving side matches relative direction if (((maneuver.type() == DirectionsLeg_Maneuver_Type_kExitRight) && maneuver.drive_on_right()) || ((maneuver.type() == DirectionsLeg_Maneuver_Type_kExitLeft) && !maneuver.drive_on_right())) { phrase_id = 15; } if (maneuver.HasExitNumberSign()) { phrase_id += 1; // Assign number sign exit_number_sign = maneuver.signs().GetExitNumberString(0, false, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasExitBranchSign()) { phrase_id += 2; // Assign branch sign exit_branch_sign = maneuver.signs().GetExitBranchString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasExitTowardSign()) { phrase_id += 4; // Assign toward sign exit_toward_sign = maneuver.signs().GetExitTowardString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } else if (maneuver.HasExitNameSign()) { phrase_id += 8; // Assign name sign exit_name_sign = maneuver.signs().GetExitNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } return FormVerbalExitInstruction(phrase_id, FormRelativeTwoDirection(maneuver.type(), dictionary_.exit_verbal_subset .relative_directions), exit_number_sign, exit_branch_sign, exit_toward_sign, exit_name_sign); } std::string NarrativeBuilder::FormVerbalExitInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count, const std::string& delim) { // "0": "Take the exit on the .", // "1": "Take exit on the .", // "2": "Take the exit on the .", // "3": "Take exit on the onto .", // "4": "Take the exit on the toward .", // "5": "Take exit on the toward .", // "6": "Take the exit on the toward .", // "7": "Take exit on the onto toward // .", "8": "Take the exit on the .", "10": "Take the // exit on the onto .", "12": "Take the // exit on the toward .", "14": "Take the exit on // the onto toward ." // "15": "Take the exit.", // "16": "Take exit .", // "17": "Take the exit.", // "18": "Take exit onto .", // "19": "Take the exit toward .", // "20": "Take exit toward .", // "21": "Take the exit toward .", // "22": "Take exit onto toward .", // "23": "Take the exit.", // "25": "Take the exit onto .", // "27": "Take the exit toward .", // "29": "Take the exit onto toward ." // Determine which phrase to use uint8_t phrase_id = 0; std::string exit_number_sign; std::string exit_branch_sign; std::string exit_toward_sign; std::string exit_name_sign; // Determine if driving side matches relative direction if (((maneuver.type() == DirectionsLeg_Maneuver_Type_kExitRight) && maneuver.drive_on_right()) || ((maneuver.type() == DirectionsLeg_Maneuver_Type_kExitLeft) && !maneuver.drive_on_right())) { phrase_id = 15; } if (maneuver.HasExitNumberSign()) { phrase_id += 1; // Assign number sign exit_number_sign = maneuver.signs().GetExitNumberString(0, false, delim, maneuver.verbal_formatter(), &markup_formatter_); } if (maneuver.HasExitBranchSign()) { phrase_id += 2; // Assign branch sign exit_branch_sign = maneuver.signs().GetExitBranchString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } if (maneuver.HasExitTowardSign()) { phrase_id += 4; // Assign toward sign exit_toward_sign = maneuver.signs().GetExitTowardString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } if (maneuver.HasExitNameSign() && !maneuver.HasExitNumberSign()) { phrase_id += 8; // Assign name sign exit_name_sign = maneuver.signs().GetExitNameString(element_max_count, limit_by_consecutive_count, delim, maneuver.verbal_formatter(), &markup_formatter_); } return FormVerbalExitInstruction(phrase_id, FormRelativeTwoDirection(maneuver.type(), dictionary_.exit_verbal_subset .relative_directions), exit_number_sign, exit_branch_sign, exit_toward_sign, exit_name_sign); } std::string NarrativeBuilder::FormVerbalExitInstruction(uint8_t phrase_id, const std::string& relative_dir, const std::string& exit_number_sign, const std::string& exit_branch_sign, const std::string& exit_toward_sign, const std::string& exit_name_sign) { std::string instruction; instruction.reserve(kInstructionInitialCapacity); // Set instruction to the determined tagged phrase instruction = dictionary_.exit_verbal_subset.phrases.at(std::to_string(phrase_id)); // Replace phrase tags with values boost::replace_all(instruction, kRelativeDirectionTag, relative_dir); boost::replace_all(instruction, kNumberSignTag, exit_number_sign); boost::replace_all(instruction, kBranchSignTag, exit_branch_sign); boost::replace_all(instruction, kTowardSignTag, exit_toward_sign); boost::replace_all(instruction, kNameSignTag, exit_name_sign); // If enabled, form articulated prepositions if (articulated_preposition_enabled_) { FormArticulatedPrepositions(instruction); } return instruction; } std::string NarrativeBuilder::FormKeepInstruction(Maneuver& maneuver, bool limit_by_consecutive_count, uint32_t element_max_count) { // "0": "Keep at the fork.", // "1": "Keep to take exit .", // "2": "Keep to take .", // "3": "Keep to take exit onto .", // "4": "Keep toward .", // "5": "Keep to take exit toward .", // "6": "Keep