bugfixing/classification

include/engine/datafacade/datafacade_base.hpp

@@ -76,7 +76,8 @@ class BaseDataFacade
     virtual void GetUncompressedWeights(const EdgeID id,
                                          std::vector<EdgeWeight> &result_weights) const = 0;
 
-    virtual extractor::guidance::TurnInstruction GetTurnInstructionForEdgeID(const unsigned id) const = 0;
+    virtual extractor::guidance::TurnInstruction
+    GetTurnInstructionForEdgeID(const unsigned id) const = 0;
 
     virtual extractor::TravelMode GetTravelModeForEdgeID(const unsigned id) const = 0;
 

include/engine/datafacade/internal_datafacade.hpp

@@ -329,7 +329,8 @@ class InternalDataFacade final : public BaseDataFacade
         return m_coordinate_list->at(id);
     }
 
-    extractor::guidance::TurnInstruction GetTurnInstructionForEdgeID(const unsigned id) const override final
+    extractor::guidance::TurnInstruction
+    GetTurnInstructionForEdgeID(const unsigned id) const override final
     {
         return m_turn_instruction_list.at(id);
     }

include/engine/datafacade/shared_datafacade.hpp

@@ -147,11 +147,13 @@ class SharedDataFacade final : public BaseDataFacade
             travel_mode_list_ptr, data_layout->num_entries[storage::SharedDataLayout::TRAVEL_MODE]);
         m_travel_mode_list = std::move(travel_mode_list);
 
-        auto turn_instruction_list_ptr = data_layout->GetBlockPtr<extractor::guidance::TurnInstruction>(
-            shared_memory, storage::SharedDataLayout::TURN_INSTRUCTION);
-        typename util::ShM<extractor::guidance::TurnInstruction, true>::vector turn_instruction_list(
-            turn_instruction_list_ptr,
-            data_layout->num_entries[storage::SharedDataLayout::TURN_INSTRUCTION]);
+        auto turn_instruction_list_ptr =
+            data_layout->GetBlockPtr<extractor::guidance::TurnInstruction>(
+                shared_memory, storage::SharedDataLayout::TURN_INSTRUCTION);
+        typename util::ShM<extractor::guidance::TurnInstruction, true>::vector
+            turn_instruction_list(
+                turn_instruction_list_ptr,
+                data_layout->num_entries[storage::SharedDataLayout::TURN_INSTRUCTION]);
         m_turn_instruction_list = std::move(turn_instruction_list);
 
         auto name_id_list_ptr = data_layout->GetBlockPtr<unsigned>(
@@ -237,8 +239,7 @@ class SharedDataFacade final : public BaseDataFacade
         }
         data_timestamp_ptr = static_cast<storage::SharedDataTimestamp *>(
             storage::makeSharedMemory(storage::CURRENT_REGIONS,
-                                      sizeof(storage::SharedDataTimestamp), false, false)
-                ->Ptr());
+                                      sizeof(storage::SharedDataTimestamp), false, false)->Ptr());
         CURRENT_LAYOUT = storage::LAYOUT_NONE;
         CURRENT_DATA = storage::DATA_NONE;
         CURRENT_TIMESTAMP = 0;
@@ -309,8 +310,8 @@ class SharedDataFacade final : public BaseDataFacade
                 LoadNames();
                 LoadCoreInformation();
 
-                util::SimpleLogger().Write() << "number of geometries: "
-                                             << m_coordinate_list->size();
+                util::SimpleLogger().Write()
+                    << "number of geometries: " << m_coordinate_list->size();
                 for (unsigned i = 0; i < m_coordinate_list->size(); ++i)
                 {
                     if (!GetCoordinateOfNode(i).IsValid())
@@ -400,7 +401,8 @@ class SharedDataFacade final : public BaseDataFacade
         return m_via_node_list.at(id);
     }
 
-    extractor::guidance::TurnInstruction GetTurnInstructionForEdgeID(const unsigned id) const override final
+    extractor::guidance::TurnInstruction
+    GetTurnInstructionForEdgeID(const unsigned id) const override final
     {
         return m_turn_instruction_list.at(id);
     }

include/engine/guidance/assemble_geometry.hpp

@@ -5,6 +5,7 @@
 #include "engine/phantom_node.hpp"
 #include "engine/guidance/route_step.hpp"
 #include "engine/guidance/leg_geometry.hpp"
+#include "engine/guidance/toolkit.hpp"
 #include "util/coordinate_calculation.hpp"
 #include "util/coordinate.hpp"
 #include "extractor/guidance/turn_instruction.hpp"
@@ -49,7 +50,7 @@ LegGeometry assembleGeometry(const DataFacadeT &facade,
         current_distance +=
             util::coordinate_calculation::haversineDistance(prev_coordinate, coordinate);
 
-        if (path_point.turn_instruction != extractor::guidance::TurnInstruction::NO_TURN())
+        if (!isSilent(path_point.turn_instruction))
         {
             geometry.segment_distances.push_back(current_distance);
             geometry.segment_offsets.push_back(geometry.locations.size());

include/engine/guidance/assemble_leg.hpp

@@ -134,7 +134,7 @@ RouteLeg assembleLeg(const DataFacadeT &facade,
     // `forward_weight`: duration of (d,t)
     // `forward_offset`: duration of (c, d)
     //
-    // The PathData will contain entries of b, c and d. But only c will contain //TODO discuss, this should not be the case after danpats fixes
+    // The PathData will contain entries of b, c and d. But only c will contain
     // a duration value since its the only point associated with a turn.
     // As such we want to slice of the duration for (a,s) and add the duration for
     // (c,d,t)

include/engine/guidance/assemble_steps.hpp

@@ -104,18 +104,26 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
             {
                 const auto name = facade.get_name_for_id(path_point.name_id);
                 const auto distance = leg_geometry.segment_distances[segment_index];
-                steps.push_back(RouteStep{
-                    path_point.name_id, name, path_point.duration_until_turn / 10.0, distance,
-                    path_point.travel_mode, maneuver, leg_geometry.FrontIndex(segment_index),
-                    leg_geometry.BackIndex(segment_index) + 1});
+                steps.push_back(RouteStep{path_point.name_id,
+                                          name,
+                                          path_point.duration_until_turn / 10.0,
+                                          distance,
+                                          path_point.travel_mode,
+                                          maneuver,
+                                          leg_geometry.FrontIndex(segment_index),
+                                          leg_geometry.BackIndex(segment_index) + 1});
                 maneuver = detail::stepManeuverFromGeometry(
                     path_point.turn_instruction, leg_geometry, segment_index, path_point.exit);
                 segment_index++;
             }
         }
         const auto distance = leg_geometry.segment_distances[segment_index];
-        steps.push_back(RouteStep{target_node.name_id, facade.get_name_for_id(target_node.name_id),
-                                  target_duration, distance, target_mode, maneuver,
+        steps.push_back(RouteStep{target_node.name_id,
+                                  facade.get_name_for_id(target_node.name_id),
+                                  target_duration,
+                                  distance,
+                                  target_mode,
+                                  maneuver,
                                   leg_geometry.FrontIndex(segment_index),
                                   leg_geometry.BackIndex(segment_index) + 1});
     }
@@ -126,15 +134,20 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
         // |-------------t target_duration
         // x---*---*---*---z compressed edge
         //       |-------| duration
-        StepManeuver maneuver = {source_node.location, 0., 0.,
+        StepManeuver maneuver = {source_node.location,
+                                 0.,
+                                 0.,
                                  extractor::guidance::TurnInstruction{
                                      extractor::guidance::TurnType::Location, initial_modifier},
                                  INVALID_EXIT_NR};
 
-        steps.push_back(RouteStep{source_node.name_id, facade.get_name_for_id(source_node.name_id),
+        steps.push_back(RouteStep{source_node.name_id,
+                                  facade.get_name_for_id(source_node.name_id),
                                   target_duration - source_duration,
-                                  leg_geometry.segment_distances[segment_index], source_mode,
-                                  std::move(maneuver), leg_geometry.FrontIndex(segment_index),
+                                  leg_geometry.segment_distances[segment_index],
+                                  source_mode,
+                                  std::move(maneuver),
+                                  leg_geometry.FrontIndex(segment_index),
                                   leg_geometry.BackIndex(segment_index) + 1});
     }
 
@@ -146,13 +159,20 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
                   target_location.get()))
             : extractor::guidance::DirectionModifier::UTurn;
     // This step has length zero, the only reason we need it is the target location
-    steps.push_back(RouteStep{
-        target_node.name_id, facade.get_name_for_id(target_node.name_id), 0., 0., target_mode,
-        StepManeuver{target_node.location, 0., 0.,
-                     extractor::guidance::TurnInstruction{extractor::guidance::TurnType::Location,
-                                                          final_modifier},
-                     INVALID_EXIT_NR},
-        leg_geometry.locations.size(), leg_geometry.locations.size()});
+    steps.push_back(
+        RouteStep{target_node.name_id,
+                  facade.get_name_for_id(target_node.name_id),
+                  0.,
+                  0.,
+                  target_mode,
+                  StepManeuver{target_node.location,
+                               0.,
+                               0.,
+                               extractor::guidance::TurnInstruction{
+                                   extractor::guidance::TurnType::Location, final_modifier},
+                               INVALID_EXIT_NR},
+                  leg_geometry.locations.size(),
+                  leg_geometry.locations.size()});
 
     return steps;
 }

include/engine/guidance/toolkit.hpp

@@ -14,7 +14,8 @@ namespace guidance
 // Silent Turn Instructions are not to be mentioned to the outside world but
 inline bool isSilent(const extractor::guidance::TurnInstruction instruction)
 {
-    return instruction.type == extractor::guidance::TurnType::NoTurn || instruction.type == extractor::guidance::TurnType::Suppressed ||
+    return instruction.type == extractor::guidance::TurnType::NoTurn ||
+           instruction.type == extractor::guidance::TurnType::Suppressed ||
            instruction.type == extractor::guidance::TurnType::StayOnRoundabout;
 }
 

include/engine/plugins/plugin_base.hpp

@@ -267,7 +267,7 @@ class BasePlugin
             // we didn't find a fitting node, return error
             if (!phantom_node_pairs[i].first.IsValid(facade.GetNumberOfNodes()))
             {
-                //TODO document why?
+                // TODO document why?
                 phantom_node_pairs.pop_back();
                 break;
             }

include/engine/routing_algorithms/routing_base.hpp

@@ -283,8 +283,7 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
             {
                 BOOST_ASSERT_MSG(!ed.shortcut, "original edge flagged as shortcut");
                 unsigned name_index = facade->GetNameIndexFromEdgeID(ed.id);
-                const auto turn_instruction =
-                    facade->GetTurnInstructionForEdgeID(ed.id);
+                const auto turn_instruction = facade->GetTurnInstructionForEdgeID(ed.id);
                 const extractor::TravelMode travel_mode =
                     (unpacked_path.empty() && start_traversed_in_reverse)
                         ? phantom_node_pair.source_phantom.backward_travel_mode
@@ -320,9 +319,10 @@ template <class DataFacadeT, class Derived> class BasicRoutingInterface
                 BOOST_ASSERT(start_index < end_index);
                 for (std::size_t i = start_index; i < end_index; ++i)
                 {
-                    unpacked_path.push_back(PathData{id_vector[i], name_index, weight_vector[i],
-                                                     extractor::guidance::TurnInstruction::NO_TURN(),
-                                                     travel_mode, INVALID_EXIT_NR});
+                    unpacked_path.push_back(
+                        PathData{id_vector[i], name_index, weight_vector[i],
+                                 extractor::guidance::TurnInstruction::NO_TURN(), travel_mode,
+                                 INVALID_EXIT_NR});
                 }
                 BOOST_ASSERT(unpacked_path.size() > 0);
                 unpacked_path.back().turn_instruction = turn_instruction;

include/extractor/guidance/classification_data.hpp

@@ -41,7 +41,7 @@ enum class FunctionalRoadClass : short
 
 inline FunctionalRoadClass functionalRoadClassFromTag(std::string const &value)
 {
-    //FIXME at some point this should be part of the profiles
+    // FIXME at some point this should be part of the profiles
     const static auto initializeClassHash = []()
     {
         std::unordered_map<std::string, FunctionalRoadClass> hash;

include/extractor/guidance/toolkit.hpp

@@ -132,15 +132,13 @@ getRepresentativeCoordinate(const NodeID from_node,
 }
 
 // shift an instruction around the degree circle in CCW order
-inline DirectionModifier
-forcedShiftCCW(const DirectionModifier modifier)
+inline DirectionModifier forcedShiftCCW(const DirectionModifier modifier)
 {
-    return static_cast<DirectionModifier>(
-        (static_cast<uint32_t>(modifier) + 1) % detail::num_direction_modifiers);
+    return static_cast<DirectionModifier>((static_cast<uint32_t>(modifier) + 1) %
+                                          detail::num_direction_modifiers);
 }
 
-inline DirectionModifier
-shiftCCW(const DirectionModifier modifier)
+inline DirectionModifier shiftCCW(const DirectionModifier modifier)
 {
     if (detail::shiftable_ccw[static_cast<int>(modifier)])
         return forcedShiftCCW(modifier);
@@ -149,16 +147,14 @@ shiftCCW(const DirectionModifier modifier)
 }
 
 // shift an instruction around the degree circle in CW order
-inline DirectionModifier
-forcedShiftCW(const DirectionModifier modifier)
+inline DirectionModifier forcedShiftCW(const DirectionModifier modifier)
 {
     return static_cast<DirectionModifier>(
         (static_cast<uint32_t>(modifier) + detail::num_direction_modifiers - 1) %
         detail::num_direction_modifiers);
 }
 
-inline DirectionModifier
-shiftCW(const DirectionModifier modifier)
+inline DirectionModifier shiftCW(const DirectionModifier modifier)
 {
     if (detail::shiftable_cw[static_cast<int>(modifier)])
         return forcedShiftCW(modifier);
@@ -168,19 +164,15 @@ shiftCW(const DirectionModifier modifier)
 
 inline bool isBasic(const TurnType type)
 {
-    return type == TurnType::Turn ||
-           type == TurnType::EndOfRoad;
+    return type == TurnType::Turn || type == TurnType::EndOfRoad;
 }
 
 inline bool isUturn(const TurnInstruction instruction)
 {
-    return isBasic(instruction.type) &&
-           instruction.direction_modifier == DirectionModifier::UTurn;
+    return isBasic(instruction.type) && instruction.direction_modifier == DirectionModifier::UTurn;
 }
 
-inline bool resolve(TurnInstruction &to_resolve,
-                    const TurnInstruction neighbor,
-                    bool resolve_cw)
+inline bool resolve(TurnInstruction &to_resolve, const TurnInstruction neighbor, bool resolve_cw)
 {
     const auto shifted_turn = resolve_cw ? shiftCW(to_resolve.direction_modifier)
                                          : shiftCCW(to_resolve.direction_modifier);
@@ -223,9 +215,8 @@ inline bool isSlightModifier(const DirectionModifier direction_modifier)
 
 inline bool isSharpTurn(const TurnInstruction turn)
 {
-    return isBasic(turn.type) &&
-           (turn.direction_modifier == DirectionModifier::SharpLeft ||
-            turn.direction_modifier == DirectionModifier::SharpRight);
+    return isBasic(turn.type) && (turn.direction_modifier == DirectionModifier::SharpLeft ||
+                                  turn.direction_modifier == DirectionModifier::SharpRight);
 }
 
 inline bool isStraight(const TurnInstruction turn)
@@ -234,8 +225,7 @@ inline bool isStraight(const TurnInstruction turn)
            turn.direction_modifier == DirectionModifier::Straight;
 }
 
-inline bool isConflict(const TurnInstruction first,
-                       const TurnInstruction second)
+inline bool isConflict(const TurnInstruction first, const TurnInstruction second)
 {
     return (first.type == second.type && first.direction_modifier == second.direction_modifier) ||
            (isStraight(first) && isStraight(second));
@@ -244,8 +234,7 @@ inline bool isConflict(const TurnInstruction first,
 inline DiscreteAngle discretizeAngle(const double angle)
 {
     BOOST_ASSERT(angle >= 0. && angle <= 360.);
-    return DiscreteAngle(
-        static_cast<uint8_t>(angle / detail::discrete_angle_step_size));
+    return DiscreteAngle(static_cast<uint8_t>(angle / detail::discrete_angle_step_size));
 }
 
 inline double angleFromDiscreteAngle(const DiscreteAngle angle)
@@ -269,8 +258,7 @@ inline double getTurnConfidence(const double angle, TurnInstruction instruction)
 {
 
     // special handling of U-Turns and Roundabout
-    if (!isBasic(instruction.type) ||
-        instruction.direction_modifier == DirectionModifier::UTurn)
+    if (!isBasic(instruction.type) || instruction.direction_modifier == DirectionModifier::UTurn)
         return 1.0;
 
     const double deviations[] = {0, 45, 50, 35, 10, 35, 50, 45};
@@ -304,18 +292,16 @@ inline DirectionModifier getTurnDirection(const double angle)
 }
 
 // swaps left <-> right modifier types
-inline DirectionModifier
-mirrorDirectionModifier(const DirectionModifier modifier)
+inline DirectionModifier mirrorDirectionModifier(const DirectionModifier modifier)
 {
-    const constexpr DirectionModifier results[] = {
-        DirectionModifier::UTurn,
-        DirectionModifier::SharpLeft,
-        DirectionModifier::Left,
-        DirectionModifier::SlightLeft,
-        DirectionModifier::Straight,
-        DirectionModifier::SlightRight,
-        DirectionModifier::Right,
-        DirectionModifier::SharpRight};
+    const constexpr DirectionModifier results[] = {DirectionModifier::UTurn,
+                                                   DirectionModifier::SharpLeft,
+                                                   DirectionModifier::Left,
+                                                   DirectionModifier::SlightLeft,
+                                                   DirectionModifier::Straight,
+                                                   DirectionModifier::SlightRight,
+                                                   DirectionModifier::Right,
+                                                   DirectionModifier::SharpRight};
     return results[modifier];
 }