From b4dc10efb65ca1f5a1970078d7fc42fa21e7ce83 Mon Sep 17 00:00:00 2001 From: Moritz Kobitzsch Date: Wed, 29 Jun 2016 12:10:56 +0200 Subject: [PATCH] road_class -> road_priority_class --- CHANGELOG.md | 4 ++ docs/profiles.md | 2 +- features/guidance/anticipate-lanes.feature | 36 +++++----- .../guidance/road_classification.hpp | 69 ++++++++++++------- include/util/debug.hpp | 14 ++-- profiles/lib/guidance.lua | 45 +++++++++--- src/extractor/extractor_callbacks.cpp | 2 - .../guidance/intersection_handler.cpp | 8 +-- src/extractor/guidance/motorway_handler.cpp | 6 +- src/extractor/guidance/turn_analysis.cpp | 2 +- src/extractor/guidance/turn_handler.cpp | 40 ++++++----- src/extractor/scripting_environment.cpp | 49 ++++++------- 12 files changed, 167 insertions(+), 110 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1724e230f00..6b3da9ada38 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,7 @@ +# 5.4.0 + - Profiles + - includes library guidance.lua that offers preliminary configuration on guidance. + # 5.3.0 RC3 Changes from 5.3.0-rc.2 - Guidance diff --git a/docs/profiles.md b/docs/profiles.md index 8be062a800f..dc8546ad63a 100644 --- a/docs/profiles.md +++ b/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 diff --git a/features/guidance/anticipate-lanes.feature b/features/guidance/anticipate-lanes.feature index e6b6bff5fc1..46c927c105d 100644 --- a/features/guidance/anticipate-lanes.feature +++ b/features/guidance/anticipate-lanes.feature @@ -271,20 +271,20 @@ Feature: Turn Lane Guidance | | | i | | | And the ways - | nodes | turn:lanes:forward | highway | junction | # | + | nodes | turn:lanes:forward | highway | junction | # | | ab | slight_right\|slight_right\|slight_right | primary | | | | bc | slight_left\|slight_right\|slight_right | primary | roundabout | top | - | cd | | primary | roundabout | top | - | de | | primary | roundabout | top | - | eb | | primary | roundabout | top | - | df | | primary | | | - | cg | slight_right\|slight_right | primary | | | - | gh | slight_left\|slight_right | primary | roundabout | bot | - | hi | | primary | roundabout | bot | - | ij | slight_left\|slight_right | primary | roundabout | bot | - | jg | | primary | roundabout | bot | - | hk | | primary | | | - | jl | | primary | | | + | cd | | primary | roundabout | top | + | de | | primary | roundabout | top | + | eb | | primary | roundabout | top | + | df | | primary | | | + | cg | slight_right\|slight_right | primary | | | + | gh | slight_left\|slight_right | primary | roundabout | bot | + | hi | | primary | roundabout | bot | + | ij | slight_left\|slight_right | primary | roundabout | bot | + | jg | | primary | roundabout | bot | + | hk | | primary | | | + | jl | | primary | | | When I route I should get | # | waypoints | route | turns | lanes | @@ -301,13 +301,13 @@ Feature: Turn Lane Guidance | | | c | | | And the ways - | nodes | turn:lanes:forward | highway | junction | - | ab | | primary | | - | bc | | primary | roundabout | + | nodes | turn:lanes:forward | highway | junction | + | ab | | primary | | + | bc | | primary | roundabout | | cd | slight_left\|slight_left\|slight_right | primary | roundabout | - | de | | primary | roundabout | - | eb | | primary | roundabout | - | df | | primary | | + | de | | primary | roundabout | + | eb | | primary | roundabout | + | df | | primary | | When I route I should get | waypoints | route | turns | lanes | diff --git a/include/extractor/guidance/road_classification.hpp b/include/extractor/guidance/road_classification.hpp index 72620fb773b..795b0a7bf5f 100644 --- a/include/extractor/guidance/road_classification.hpp +++ b/include/extractor/guidance/road_classification.hpp @@ -15,9 +15,9 @@ namespace extractor namespace guidance { -namespace RoadClass +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; @@ -53,52 +53,73 @@ class RoadClassification // the road priority is used as an indicator for forks. If the roads are of similar priority // (difference <=1), we can see the road as a fork. Else one of the road classes is seen as // obvious choice - RoadClass::Enum road_class : 5; + RoadPriorityClass::Enum road_priority_class : 5; public: // default construction - RoadClassification() : motorway_class(0), link_class(0), may_be_ignored(1), road_class(RoadClass::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, RoadClass::Enum road_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_class(road_class) + 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(road_class); } + std::uint32_t GetPriority() const + { + return static_cast(road_priority_class); + } - inline RoadClass::Enum getClass() const { return road_class; } - inline void setClass(const RoadClass::Enum new_value) { road_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_class == other.road_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_class); + 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(first.getPriority()) - - static_cast(second.getPriority())) <= 1; + return std::abs(static_cast(first.GetPriority()) - + static_cast(second.GetPriority())) <= 1; } } // namespace guidance } // namespace extractor diff --git a/include/util/debug.hpp b/include/util/debug.hpp index 4d6ba1f166b..9dab0f3c7d0 100644 --- a/include/util/debug.hpp +++ b/include/util/debug.hpp @@ -54,6 +54,15 @@ inline void print(const std::vector &steps) } } +inline void print( const extractor::guidance::Intersection & intersection ) +{ + std::cout << " Intersection:\n"; + for (const auto &road : intersection) + std::cout << "\t" << toString(road) << "\n"; + std::cout << std::flush; +} + + inline void print(const extractor::guidance::lanes::LaneDataVector &turn_lane_data) { std::cout << " Tags:\n"; @@ -76,10 +85,7 @@ printTurnAssignmentData(const NodeID at, std::cout << std::setprecision(12) << toFloating(coordinate.lat) << " " << toFloating(coordinate.lon) << "\n"; - std::cout << " Intersection:\n"; - for (const auto &road : intersection) - std::cout << "\t" << toString(road) << "\n"; - + print(intersection); // flushes as well print(turn_lane_data); } diff --git a/profiles/lib/guidance.lua b/profiles/lib/guidance.lua index 8edb4020141..19409ce1170 100644 --- a/profiles/lib/guidance.lua +++ b/profiles/lib/guidance.lua @@ -1,18 +1,43 @@ local Guidance = {} -- Guidance: Default Mapping from roads to types/priorities -highway_classes = { ["motorway"] = road_class.motorway, ["motorway_link"] = road_class.link_road, ["trunk"] = road_class.trunk, ["trunk_link"] = road_class.link_road, - ["primary"] = road_class.primary, ["primary_link"] = road_class.link_road, ["secondary"] = road_class.secondary, ["secondary_link"] = road_class.link_road, - ["tertiary"] = road_class.tertiary, ["tertiary_link"] = road_class.link_road, ["unclassified"] = road_class.side_residential, ["residential"] = road_class.side_residential, - ["service"] = road_class.connectivity, ["living_street"] = road_class.main_residential, ["track"] = road_class.bike_path, ["path"] = road_class.bike_path, - ["footway"] = road_class.foot_path, ["pedestrian"] = road_class.foot_path, ["steps"] = road_class.foot_path} -default_highway_class = road_class.connectivity; +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 } @@ -25,9 +50,9 @@ function Guidance.set_classification (highway, result) result.road_classification.link_class = true; end if highway_classes[highway] ~= nil then - result.road_classification.road_class = highway_classes[highway] + result.road_classification.road_priority_class = highway_classes[highway] else - result.road_classification.road_class = default_highway_class + result.road_classification.road_priority_class = default_highway_class end if road_types[highway] then result.road_classification.may_be_ignored = false; diff --git a/src/extractor/extractor_callbacks.cpp b/src/extractor/extractor_callbacks.cpp index 3f79e21cb24..73fc635c6fa 100644 --- a/src/extractor/extractor_callbacks.cpp +++ b/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 {}; diff --git a/src/extractor/guidance/intersection_handler.cpp b/src/extractor/guidance/intersection_handler.cpp index 3cb39bb2a3a..c23988ab8a2 100644 --- a/src/extractor/guidance/intersection_handler.cpp +++ b/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)) { diff --git a/src/extractor/guidance/motorway_handler.cpp b/src/extractor/guidance/motorway_handler.cpp index be6bedf1a7f..07a8a263e93 100644 --- a/src/extractor/guidance/motorway_handler.cpp +++ b/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; diff --git a/src/extractor/guidance/turn_analysis.cpp b/src/extractor/guidance/turn_analysis.cpp index 54eb96d2410..b144b27a172 100644 --- a/src/extractor/guidance/turn_analysis.cpp +++ b/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) diff --git a/src/extractor/guidance/turn_handler.cpp b/src/extractor/guidance/turn_handler.cpp index be4e4d3f9b4..ed41e331add 100644 --- a/src/extractor/guidance/turn_handler.cpp +++ b/src/extractor/guidance/turn_handler.cpp @@ -1,3 +1,5 @@ +#include "util/debug.hpp" + #include "extractor/guidance/constants.hpp" #include "extractor/guidance/intersection_scenario_three_way.hpp" #include "extractor/guidance/toolkit.hpp" @@ -39,6 +41,8 @@ bool TurnHandler::canProcess(const NodeID, const EdgeID, const Intersection &) c Intersection TurnHandler:: operator()(const NodeID, const EdgeID via_eid, Intersection intersection) const { + std::cout << "[turn handler]" << std::endl; + util::guidance::print(intersection); if (intersection.size() == 1) return handleOneWayTurn(std::move(intersection)); @@ -86,23 +90,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 +313,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 +384,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,15 +394,14 @@ 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() && - in_data.road_classification != continue_classification) || - (deviation < best_continue_deviation && - out_data.road_classification == continue_classification)) || - in_data.road_classification == out_data.road_classification) + (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))) { best_continue_deviation = deviation; best_continue = i; @@ -716,7 +718,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, diff --git a/src/extractor/scripting_environment.cpp b/src/extractor/scripting_environment.cpp index 70e150fcafd..1acd53ddfc7 100644 --- a/src/extractor/scripting_environment.cpp +++ b/src/extractor/scripting_environment.cpp @@ -92,21 +92,22 @@ void ScriptingEnvironment::InitContext(ScriptingEnvironment::Context &context) luabind::value("river_down", TRAVEL_MODE_RIVER_DOWN), luabind::value("route", TRAVEL_MODE_ROUTE)], - luabind::class_("road_class") - .enum_("enums")[luabind::value("motorway", extractor::guidance::RoadClass::MOTORWAY), - luabind::value("trunk", extractor::guidance::RoadClass::TRUNK), - luabind::value("primary", extractor::guidance::RoadClass::PRIMARY), - luabind::value("secondary", extractor::guidance::RoadClass::SECONDARY), - luabind::value("tertiary", extractor::guidance::RoadClass::TERTIARY), - luabind::value("main_residential", - extractor::guidance::RoadClass::MAIN_RESIDENTIAL), - luabind::value("side_residential", - extractor::guidance::RoadClass::SIDE_RESIDENTIAL), - luabind::value("link_road", extractor::guidance::RoadClass::LINK_ROAD), - luabind::value("bike_path", extractor::guidance::RoadClass::BIKE_PATH), - luabind::value("foot_path", extractor::guidance::RoadClass::FOOT_PATH), - luabind::value("connectivity", - extractor::guidance::RoadClass::CONNECTIVITY)], + luabind::class_("road_priority_class") + .enum_("enums") + [luabind::value("motorway", extractor::guidance::RoadPriorityClass::MOTORWAY), + luabind::value("trunk", extractor::guidance::RoadPriorityClass::TRUNK), + luabind::value("primary", extractor::guidance::RoadPriorityClass::PRIMARY), + luabind::value("secondary", extractor::guidance::RoadPriorityClass::SECONDARY), + luabind::value("tertiary", extractor::guidance::RoadPriorityClass::TERTIARY), + luabind::value("main_residential", + extractor::guidance::RoadPriorityClass::MAIN_RESIDENTIAL), + luabind::value("side_residential", + extractor::guidance::RoadPriorityClass::SIDE_RESIDENTIAL), + luabind::value("link_road", extractor::guidance::RoadPriorityClass::LINK_ROAD), + luabind::value("bike_path", extractor::guidance::RoadPriorityClass::BIKE_PATH), + luabind::value("foot_path", extractor::guidance::RoadPriorityClass::FOOT_PATH), + luabind::value("connectivity", + extractor::guidance::RoadPriorityClass::CONNECTIVITY)], luabind::class_("sources") .def(luabind::constructor<>()) @@ -151,17 +152,17 @@ void ScriptingEnvironment::InitContext(ScriptingEnvironment::Context &context) // road classification to be set in profile luabind::class_("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) - .property("road_class", - &guidance::RoadClassification::getClass, - &guidance::RoadClassification::setClass), + &guidance::RoadClassification::IsLowPriorityRoadClass, + &guidance::RoadClassification::SetLowPriorityFlag) + .property("road_priority_class", + &guidance::RoadClassification::GetClass, + &guidance::RoadClassification::SetClass), luabind::class_("ResultWay") // .def(luabind::constructor<>())