adjusted guidance-profiles for comments

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 5.4.0
+    - Profiles
+        - includes library guidance.lua that offers preliminary configuration on guidance.
+
 # 5.3.0
     Changes from 5.3.0-rc.2
         - Guidance

docs/profiles.md

@@ -35,7 +35,7 @@ Using the power of the scripting language you wouldn't typically see something a
 
 ## Guidance
 
-The guidance parameters in profiles are currently a work in progress. They can and will change without any major version change.
+The guidance parameters in profiles are currently a work in progress. They can and will change.
 Please be aware of this when using guidance configuration possibilities.
 
 ### Road Classification

include/extractor/guidance/road_classification.hpp

@@ -17,7 +17,7 @@ namespace guidance
 
 namespace RoadPriorityClass
 {
-typedef std::uint8_t Enum;
+typedef std::uint32_t Enum;
 // Top priority Road
 const constexpr Enum MOTORWAY = 0;
 // Second highest priority
@@ -35,7 +35,7 @@ const constexpr Enum LINK_ROAD = 14;
 const constexpr Enum BIKE_PATH = 16;
 // Walk Accessible
 const constexpr Enum FOOT_PATH = 18;
-// Link types are usually not considered in forks, unless amongst each other. 
+// Link types are usually not considered in forks, unless amongst each other.
 // a road simply offered for connectivity. Will be ignored in forks/other decisions. Always
 // considered non-obvious to continue on
 const constexpr Enum CONNECTIVITY = 31;
@@ -57,48 +57,69 @@ class RoadClassification
 
   public:
     // default construction
-    RoadClassification() : motorway_class(0), link_class(0), may_be_ignored(1), road_priority_class(RoadPriorityClass::CONNECTIVITY) {}
+    RoadClassification()
+        : motorway_class(0), link_class(0), may_be_ignored(1),
+          road_priority_class(RoadPriorityClass::CONNECTIVITY)
+    {
+    }
 
-    RoadClassification(bool motorway_class, bool link_class, bool may_be_ignored, RoadPriorityClass::Enum road_priority_class)
+    RoadClassification(bool motorway_class,
+                       bool link_class,
+                       bool may_be_ignored,
+                       RoadPriorityClass::Enum road_priority_class)
         : motorway_class(motorway_class), link_class(link_class), may_be_ignored(may_be_ignored),
           road_priority_class(road_priority_class)
     {
     }
 
-    inline bool isMotorwayClass() const { return (0 != motorway_class) && (0 == link_class); }
-    inline void setMotorwayFlag(const bool new_value) { motorway_class = new_value; }
+    bool IsMotorwayClass() const { return (0 != motorway_class) && (0 == link_class); }
+    void SetMotorwayFlag(const bool new_value) { motorway_class = new_value; }
 
-    inline bool isRampClass() const { return (0 != motorway_class) && (0 != link_class); }
+    bool IsRampClass() const { return (0 != motorway_class) && (0 != link_class); }
 
-    inline bool isLinkClass() const { return (0 != link_class); }
-    inline void setLinkClass(const bool new_value) { link_class = new_value; }
+    bool IsLinkClass() const { return (0 != link_class); }
+    void SetLinkClass(const bool new_value) { link_class = new_value; }
 
-    inline bool isLowPriorityRoadClass() const { return (0 != may_be_ignored); }
-    inline void setLowPriorityFlag(const bool new_value) { may_be_ignored = new_value; }
+    bool IsLowPriorityRoadClass() const { return (0 != may_be_ignored); }
+    void SetLowPriorityFlag(const bool new_value) { may_be_ignored = new_value; }
 
-    inline std::uint32_t getPriority() const { return static_cast<std::uint32_t>(road_priority_class); }
+    std::uint32_t GetPriority() const
+    {
+        return static_cast<std::uint32_t>(road_priority_class);
+    }
 
-    inline RoadPriorityClass::Enum getClass() const { return road_priority_class; }
-    inline void setClass(const RoadPriorityClass::Enum new_value) { road_priority_class = new_value; }
+    RoadPriorityClass::Enum GetClass() const { return road_priority_class; }
+    void SetClass(const RoadPriorityClass::Enum new_value)
+    {
+        road_priority_class = new_value;
+    }
 
-    inline bool operator==(const RoadClassification &other) const
+    bool operator==(const RoadClassification &other) const
     {
         return motorway_class == other.motorway_class && link_class == other.link_class &&
-               may_be_ignored == other.may_be_ignored && road_priority_class == other.road_priority_class;
+               may_be_ignored == other.may_be_ignored &&
+               road_priority_class == other.road_priority_class;
     }
 
-    inline std::string toString() const
+    bool operator!=(const RoadClassification &other ) const
+    {
+        return !(*this == other);
+    }
+
+    std::string ToString() const
     {
         return std::string() + (motorway_class ? "motorway" : "normal") +
                (link_class ? "_link" : "") + (may_be_ignored ? " ignorable " : " important ") +
                std::to_string(road_priority_class);
     }
-};
+} __attribute ((packed));;
+
+static_assert(sizeof(RoadClassification) == 1,"Road Classification should fit a byte. Increasing this has a severe impact on memory.");
 
 inline bool canBeSeenAsFork(const RoadClassification first, const RoadClassification second)
 {
-    return std::abs(static_cast<int>(first.getPriority()) -
-                    static_cast<int>(second.getPriority())) <= 1;
+    return std::abs(static_cast<int>(first.GetPriority()) -
+                    static_cast<int>(second.GetPriority())) <= 1;
 }
 } // namespace guidance
 } // namespace extractor

profiles/lib/guidance.lua

@@ -1,18 +1,43 @@
 local Guidance = {}
 
 -- Guidance: Default Mapping from roads to types/priorities
-highway_classes = { ["motorway"] = road_priority_class.motorway, ["motorway_link"] = road_priority_class.link_road, ["trunk"] = road_priority_class.trunk, ["trunk_link"] = road_priority_class.link_road,
-                    ["primary"] = road_priority_class.primary, ["primary_link"] = road_priority_class.link_road, ["secondary"] = road_priority_class.secondary, ["secondary_link"] = road_priority_class.link_road,
-                    ["tertiary"] = road_priority_class.tertiary, ["tertiary_link"] = road_priority_class.link_road, ["unclassified"] = road_priority_class.side_residential, ["residential"] = road_priority_class.side_residential,
-                    ["service"] = road_priority_class.connectivity, ["living_street"] = road_priority_class.main_residential, ["track"] = road_priority_class.bike_path, ["path"] = road_priority_class.bike_path,
-                    ["footway"] = road_priority_class.foot_path, ["pedestrian"] = road_priority_class.foot_path, ["steps"] = road_priority_class.foot_path}
+highway_classes = { ["motorway"] = road_priority_class.motorway,
+                    ["motorway_link"] = road_priority_class.link_road,
+                    ["trunk"] = road_priority_class.trunk,
+                    ["trunk_link"] = road_priority_class.link_road,
+                    ["primary"] = road_priority_class.primary,
+                    ["primary_link"] = road_priority_class.link_road,
+                    ["secondary"] = road_priority_class.secondary,
+                    ["secondary_link"] = road_priority_class.link_road,
+                    ["tertiary"] = road_priority_class.tertiary,
+                    ["tertiary_link"] = road_priority_class.link_road,
+                    ["unclassified"] = road_priority_class.side_residential,
+                    ["residential"] = road_priority_class.side_residential,
+                    ["service"] = road_priority_class.connectivity,
+                    ["living_street"] = road_priority_class.main_residential,
+                    ["track"] = road_priority_class.bike_path,
+                    ["path"] = road_priority_class.bike_path,
+                    ["footway"] = road_priority_class.foot_path,
+                    ["pedestrian"] = road_priority_class.foot_path,
+                    ["steps"] = road_priority_class.foot_path}
+
 default_highway_class = road_priority_class.connectivity;
 
 motorway_types = { ["motorway"] = true, ["motorway_link"] = true, ["trunk"] = true, ["trunk_link"] = true }
 
 -- these road types are set with a car in mind. For bicycle/walk we probably need different ones
-road_types = { ["motorway"] = true, ["motorway_link"] = true, ["trunk"] = true, ["trunk_link"] = true, ["primary"] = true, ["primary_link"] = true,
-               ["secondary"] = true, ["secondary_link"] = true, ["tertiary"] = true, ["tertiary_link"] = true, ["unclassified"] = true, ["residential"] = true,
+road_types = { ["motorway"] = true,
+               ["motorway_link"] = true,
+               ["trunk"] = true,
+               ["trunk_link"] = true,
+               ["primary"] = true,
+               ["primary_link"] = true,
+               ["secondary"] = true,
+               ["secondary_link"] = true,
+               ["tertiary"] = true,
+               ["tertiary_link"] = true,
+               ["unclassified"] = true,
+               ["residential"] = true,
                ["living_street"] = true }
 
 link_types = { ["motorway_link"] = true, ["trunk_link"] = true, ["primary_link"] = true, ["secondary_link"] = true, ["tertiary_link"] = true }

src/extractor/extractor_callbacks.cpp

@@ -142,8 +142,6 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
 
     // FIXME this need to be moved into the profiles
     const guidance::RoadClassification road_classification = parsed_way.road_classification;
-    std::cout << "Classification: " << road_classification.toString() << std::endl;
-
     const auto laneStringToDescription = [](std::string lane_string) -> TurnLaneDescription {
         if (lane_string.empty())
             return {};

src/extractor/guidance/intersection_handler.cpp

@@ -50,9 +50,9 @@ TurnType::Enum IntersectionHandler::findBasicTurnType(const EdgeID via_edge,
     const auto &in_data = node_based_graph.GetEdgeData(via_edge);
     const auto &out_data = node_based_graph.GetEdgeData(road.turn.eid);
 
-    bool on_ramp = in_data.road_classification.isRampClass();
+    bool on_ramp = in_data.road_classification.IsRampClass();
 
-    bool onto_ramp = out_data.road_classification.isRampClass();
+    bool onto_ramp = out_data.road_classification.IsRampClass();
 
     if (!on_ramp && onto_ramp)
         return TurnType::OnRamp;
@@ -133,9 +133,9 @@ void IntersectionHandler::assignFork(const EdgeID via_edge,
 {
     const auto &in_data = node_based_graph.GetEdgeData(via_edge);
     const bool low_priority_left =
-        node_based_graph.GetEdgeData(left.turn.eid).road_classification.isLowPriorityRoadClass();
+        node_based_graph.GetEdgeData(left.turn.eid).road_classification.IsLowPriorityRoadClass();
     const bool low_priority_right =
-        node_based_graph.GetEdgeData(right.turn.eid).road_classification.isLowPriorityRoadClass();
+        node_based_graph.GetEdgeData(right.turn.eid).road_classification.IsLowPriorityRoadClass();
     if ((angularDeviation(left.turn.angle, STRAIGHT_ANGLE) < MAXIMAL_ALLOWED_NO_TURN_DEVIATION &&
          angularDeviation(right.turn.angle, STRAIGHT_ANGLE) > FUZZY_ANGLE_DIFFERENCE))
     {

src/extractor/guidance/motorway_handler.cpp

@@ -25,7 +25,7 @@ namespace
 
 inline bool isMotorwayClass(EdgeID eid, const util::NodeBasedDynamicGraph &node_based_graph)
 {
-    return node_based_graph.GetEdgeData(eid).road_classification.isMotorwayClass();
+    return node_based_graph.GetEdgeData(eid).road_classification.IsMotorwayClass();
 }
 inline RoadClassification roadClass(const ConnectedRoad &road,
                                     const util::NodeBasedDynamicGraph &graph)
@@ -35,7 +35,7 @@ inline RoadClassification roadClass(const ConnectedRoad &road,
 
 inline bool isRampClass(EdgeID eid, const util::NodeBasedDynamicGraph &node_based_graph)
 {
-    return node_based_graph.GetEdgeData(eid).road_classification.isRampClass();
+    return node_based_graph.GetEdgeData(eid).road_classification.IsRampClass();
 }
 
 } // namespace
@@ -495,7 +495,7 @@ Intersection MotorwayHandler::fallback(Intersection intersection) const
 
         util::SimpleLogger().Write(logDEBUG)
             << "road: " << toString(road) << " Name: " << out_data.name_id
-            << " Road Class: " << out_data.road_classification.toString();
+            << " Road Class: " << out_data.road_classification.ToString();
 
         if (!road.entry_allowed)
             continue;

src/extractor/guidance/turn_analysis.cpp

@@ -82,7 +82,7 @@ Intersection TurnAnalysis::assignTurnTypes(const NodeID from_nid,
 
     // Turn On Ramps Into Off Ramps, if we come from a motorway-like road
     if (node_based_graph.GetEdgeData(via_eid)
-            .road_classification.isMotorwayClass())
+            .road_classification.IsMotorwayClass())
     {
         std::for_each(intersection.begin(), intersection.end(), [](ConnectedRoad &road) {
             if (road.turn.instruction.type == TurnType::OnRamp)

src/extractor/guidance/turn_handler.cpp

@@ -86,23 +86,23 @@ Intersection TurnHandler::handleThreeWayTurn(const EdgeID via_edge, Intersection
         const auto second_classification =
             node_based_graph.GetEdgeData(other.turn.eid).road_classification;
 
-        const bool is_ramp = first_classification.isRampClass();
+        const bool is_ramp = first_classification.IsRampClass();
         const bool is_obvious_by_road_class =
             (!is_ramp &&
-             (2 * first_classification.getPriority() < second_classification.getPriority()) &&
+             (2 * first_classification.GetPriority() < second_classification.GetPriority()) &&
              in_data.road_classification == first_classification) ||
-            (!first_classification.isLowPriorityRoadClass() &&
-             second_classification.isLowPriorityRoadClass());
+            (!first_classification.IsLowPriorityRoadClass() &&
+             second_classification.IsLowPriorityRoadClass());
 
         if (is_obvious_by_road_class)
             return true;
 
-        const bool other_is_obvious_by_road_flass =
-            (!second_classification.isRampClass() &&
-             (2 * second_classification.getPriority() < first_classification.getPriority()) &&
+        const bool other_is_obvious_by_road_class =
+            (!second_classification.IsRampClass() &&
+             (2 * second_classification.GetPriority() < first_classification.GetPriority()) &&
              in_data.road_classification == second_classification) ||
-            (!second_classification.isLowPriorityRoadClass() &&
-             first_classification.isLowPriorityRoadClass());
+            (!second_classification.IsLowPriorityRoadClass() &&
+             first_classification.IsLowPriorityRoadClass());
 
         if (other_is_obvious_by_road_class)
             return false;
@@ -309,7 +309,7 @@ Intersection TurnHandler::handleComplexTurn(const EdgeID via_edge, Intersection
                 node_based_graph.GetEdgeData(right.turn.eid).road_classification;
             if (canBeSeenAsFork(left_classification, right_classification))
                 assignFork(via_edge, left, right);
-            else if (left_classification.getPriority() > right_classification.getPriority())
+            else if (left_classification.GetPriority() > right_classification.GetPriority())
             {
                 right.turn.instruction =
                     getInstructionForObvious(intersection.size(), via_edge, false, right);
@@ -380,7 +380,6 @@ std::size_t TurnHandler::findObviousTurn(const EdgeID via_edge,
     double best_continue_deviation = 180;
 
     const EdgeData &in_data = node_based_graph.GetEdgeData(via_edge);
-    const auto in_class = in_data.road_classification.road_class;
     for (std::size_t i = 1; i < intersection.size(); ++i)
     {
         const double deviation = angularDeviation(intersection[i].turn.angle, STRAIGHT_ANGLE);
@@ -391,11 +390,11 @@ std::size_t TurnHandler::findObviousTurn(const EdgeID via_edge,
         }
 
         const auto out_data = node_based_graph.GetEdgeData(intersection[i].turn.eid);
-        auto continue_classification =
+        const auto continue_classification =
             node_based_graph.GetEdgeData(intersection[best_continue].turn.eid).road_classification;
         if (intersection[i].entry_allowed && out_data.name_id == in_data.name_id &&
-                (best_continue == 0 || (continue_classification.getPriority() >
-                                            out_data.road_classification.getPriority() &&
+                (best_continue == 0 || (continue_classification.GetPriority() >
+                                            out_data.road_classification.GetPriority() &&
                                         in_data.road_classification != continue_classification) ||
                  (deviation < best_continue_deviation &&
                   out_data.road_classification == continue_classification)) ||
@@ -716,7 +715,7 @@ void TurnHandler::handleDistinctConflict(const EdgeID via_edge,
             node_based_graph.GetEdgeData(right.turn.eid).road_classification;
         if (canBeSeenAsFork(left_classification, right_classification))
             assignFork(via_edge, left, right);
-        else if (left_classification.getPriority() > right_classification.getPriority())
+        else if (left_classification.GetPriority() > right_classification.GetPriority())
         {
             // FIXME this should possibly know about the actual roads?
             // here we don't know about the intersection size. To be on the save side,

src/extractor/scripting_environment.cpp

@@ -152,17 +152,17 @@ void ScriptingEnvironment::InitContext(ScriptingEnvironment::Context &context)
          // road classification to be set in profile
          luabind::class_<guidance::RoadClassification>("RoadClassification")
              .property("motorway_class",
-                       &guidance::RoadClassification::isMotorwayClass,
-                       &guidance::RoadClassification::setMotorwayFlag)
+                       &guidance::RoadClassification::IsMotorwayClass,
+                       &guidance::RoadClassification::SetMotorwayFlag)
              .property("link_class",
-                       &guidance::RoadClassification::isLinkClass,
-                       &guidance::RoadClassification::setLinkClass)
+                       &guidance::RoadClassification::IsLinkClass,
+                       &guidance::RoadClassification::SetLinkClass)
              .property("may_be_ignored",
-                       &guidance::RoadClassification::isLowPriorityRoadClass,
-                       &guidance::RoadClassification::setLowPriorityFlag)
+                       &guidance::RoadClassification::IsLowPriorityRoadClass,
+                       &guidance::RoadClassification::SetLowPriorityFlag)
              .property("road_priority_class",
-                       &guidance::RoadClassification::getClass,
-                       &guidance::RoadClassification::setClass),
+                       &guidance::RoadClassification::GetClass,
+                       &guidance::RoadClassification::SetClass),
 
          luabind::class_<ExtractionWay>("ResultWay")
              // .def(luabind::constructor<>())