Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

intersection classes with variable degree of discretization

Browse Source
This commit is contained in:
Moritz Kobitzsch
2016-05-10 08:37:45 +02:00
committed by Patrick Niklaus
parent 0f3942558f
commit 4d9aa65e78
23 changed files with 724 additions and 702 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/engine/guidance/assemble_steps.hpp
+52 -37
View File
@@ -12,7 +12,7 @@
#include "util/bearing.hpp"
#include "util/coordinate.hpp"
#include "util/coordinate_calculation.hpp"
#include "util/guidance/bearing_class.hpp"
#include "util/guidance/toolkit.hpp"
#include "util/guidance/entry_class.hpp"
#include "util/typedefs.hpp"
@@ -28,15 +28,12 @@ namespace guidance
{
namespace detail
{
StepManeuver stepManeuverFromGeometry(extractor::guidance::TurnInstruction instruction,
const LegGeometry &leg_geometry,
const std::size_t segment_index,
util::guidance::EntryClass entry_class,
util::guidance::BearingClass bearing_class);
StepManeuver stepManeuverFromGeometry(extractor::guidance::TurnInstruction instruction,
const WaypointType waypoint_type,
const LegGeometry &leg_geometry);
Intersection intersectionFromGeometry(const WaypointType waypoint_type,
const double segment_duration,
const LegGeometry &leg_geometry,
const std::size_t segment_index);
} // ns detail
template <typename DataFacadeT>
@@ -70,10 +67,13 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
if (leg_data.size() > 0)
{
StepManeuver maneuver = {extractor::guidance::TurnInstruction::NO_TURN(),
WaypointType::Depart, 0};
StepManeuver maneuver = detail::stepManeuverFromGeometry(
extractor::guidance::TurnInstruction::NO_TURN(), WaypointType::Depart, leg_geometry);
maneuver.location = source_node.location;
auto intersection =
detail::intersectionFromGeometry(WaypointType::Depart, 0, leg_geometry, 0);
intersection = util::guidance::setIntersectionClasses(std::move(intersection), source_node);
// maneuver.location = source_node.location;
// PathData saves the information we need of the segment _before_ the turn,
// but a RouteStep is with regard to the segment after the turn.
@@ -95,19 +95,25 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
BOOST_ASSERT(segment_duration >= 0);
const auto name = facade.GetNameForID(step_name_id);
const auto distance = leg_geometry.segment_distances[segment_index];
steps.push_back(RouteStep{step_name_id, name, NO_ROTARY_NAME,
segment_duration / 10.0, distance, path_point.travel_mode,
maneuver, leg_geometry.FrontIndex(segment_index),
leg_geometry.BackIndex(segment_index) + 1});
if (leg_data_index + 1 < leg_data.size()){
std::vector<Intersection> intersections(1, intersection);
intersection = detail::intersectionFromGeometry(
WaypointType::None, segment_duration / 10., leg_geometry, segment_index);
intersection.entry_class = facade.GetEntryClass(path_point.entry_classid);
intersection.bearing_class =
facade.GetBearingClass(facade.GetBearingClassID(path_point.turn_via_node));
steps.push_back(RouteStep{
step_name_id, name, NO_ROTARY_NAME, segment_duration / 10.0, distance,
path_point.travel_mode, maneuver, leg_geometry.FrontIndex(segment_index),
leg_geometry.BackIndex(segment_index) + 1, std::move(intersections)});
if (leg_data_index + 1 < leg_data.size())
{
step_name_id = leg_data[leg_data_index + 1].name_id;
} else {
}
else
{
step_name_id = target_node.name_id;
}
maneuver = detail::stepManeuverFromGeometry(
path_point.turn_instruction, leg_geometry, segment_index,
facade.GetEntryClass(path_point.entry_classid),
facade.GetBearingClass(facade.GetBearingClassID(path_point.turn_via_node)));
maneuver = {path_point.turn_instruction, WaypointType::None, 0};
segment_index++;
segment_duration = 0;
}
@@ -115,10 +121,10 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
const auto distance = leg_geometry.segment_distances[segment_index];
const int duration = segment_duration + target_duration;
BOOST_ASSERT(duration >= 0);
steps.push_back(RouteStep{step_name_id, facade.GetNameForID(step_name_id),
NO_ROTARY_NAME, duration / 10., distance, target_mode, maneuver,
leg_geometry.FrontIndex(segment_index),
leg_geometry.BackIndex(segment_index) + 1});
steps.push_back(RouteStep{
step_name_id, facade.GetNameForID(step_name_id), NO_ROTARY_NAME, duration / 10.,
distance, target_mode, maneuver, leg_geometry.FrontIndex(segment_index),
leg_geometry.BackIndex(segment_index) + 1, std::vector<Intersection>(1, intersection)});
}
// In this case the source + target are on the same edge segment
else
@@ -129,28 +135,37 @@ std::vector<RouteStep> assembleSteps(const DataFacadeT &facade,
// |---| source_duration
// |---------| target_duration
StepManeuver maneuver = detail::stepManeuverFromGeometry(
extractor::guidance::TurnInstruction::NO_TURN(), WaypointType::Depart, leg_geometry);
StepManeuver maneuver = {extractor::guidance::TurnInstruction::NO_TURN(),
WaypointType::Depart, 0};
int duration = target_duration - source_duration;
BOOST_ASSERT(duration >= 0);
steps.push_back(RouteStep{source_node.name_id, facade.GetNameForID(source_node.name_id),
NO_ROTARY_NAME, duration / 10.,
leg_geometry.segment_distances[segment_index], source_mode,
std::move(maneuver), leg_geometry.FrontIndex(segment_index),
leg_geometry.BackIndex(segment_index) + 1});
auto intersection = detail::intersectionFromGeometry(WaypointType::Depart, duration / 10.,
leg_geometry, segment_index);
intersection = util::guidance::setIntersectionClasses(std::move(intersection), source_node);
steps.push_back(RouteStep{
source_node.name_id, facade.GetNameForID(source_node.name_id), NO_ROTARY_NAME,
duration / 10., leg_geometry.segment_distances[segment_index], source_mode,
std::move(maneuver), leg_geometry.FrontIndex(segment_index),
leg_geometry.BackIndex(segment_index) + 1, std::vector<Intersection>(1, intersection)});
}
BOOST_ASSERT(segment_index == number_of_segments - 1);
// This step has length zero, the only reason we need it is the target location
auto final_maneuver = detail::stepManeuverFromGeometry(
extractor::guidance::TurnInstruction::NO_TURN(), WaypointType::Arrive, leg_geometry);
StepManeuver final_maneuver = {extractor::guidance::TurnInstruction::NO_TURN(),
WaypointType::Arrive, 0};
auto intersection =
detail::intersectionFromGeometry(WaypointType::Arrive, 0, leg_geometry, segment_index);
intersection = util::guidance::setIntersectionClasses(std::move(intersection), target_node);
BOOST_ASSERT(!leg_geometry.locations.empty());
steps.push_back(RouteStep{target_node.name_id, facade.GetNameForID(target_node.name_id),
NO_ROTARY_NAME, ZERO_DURATION, ZERO_DISTANCE, target_mode,
final_maneuver, leg_geometry.locations.size() - 1,
leg_geometry.locations.size()});
std::move(final_maneuver), leg_geometry.locations.size() - 1,
leg_geometry.locations.size(),
std::vector<Intersection>(1, intersection)});
return steps;
}
include/engine/guidance/route_step.hpp
+38 -1
View File
@@ -3,6 +3,9 @@
#include "engine/guidance/step_maneuver.hpp"
#include "extractor/travel_mode.hpp"
#include "util/coordinate.hpp"
#include "util/guidance/bearing_class.hpp"
#include "util/guidance/entry_class.hpp"
#include <cstddef>
@@ -21,6 +24,30 @@ namespace guidance
// Notable exceptions are Departure and Arrival steps.
// Departue: s --> a --> b. Represents the segment s,a with location being s.
// Arrive: a --> b --> t. The segment (b,t) is already covered by the previous segment.
// A represenetation of intermediate intersections
struct Intersection
{
double duration;
double distance;
util::Coordinate location;
double bearing_before;
double bearing_after;
util::guidance::EntryClass entry_class;
util::guidance::BearingClass bearing_class;
};
inline Intersection getInvalidIntersection()
{
return {0,
0,
util::Coordinate{util::FloatLongitude{0.0}, util::FloatLatitude{0.0}},
0,
0,
util::guidance::EntryClass(),
util::guidance::BearingClass()};
}
struct RouteStep
{
unsigned name_id;
@@ -33,11 +60,21 @@ struct RouteStep
// indices into the locations array stored the LegGeometry
std::size_t geometry_begin;
std::size_t geometry_end;
std::vector<Intersection> intersections;
};
inline RouteStep getInvalidRouteStep()
{
return {0, "", "", 0, 0, TRAVEL_MODE_INACCESSIBLE, getInvalidStepManeuver(), 0, 0};
return {0,
"",
"",
0,
0,
TRAVEL_MODE_INACCESSIBLE,
getInvalidStepManeuver(),
0,
0,
std::vector<Intersection>(1, getInvalidIntersection())};
}
}
}
include/engine/guidance/step_maneuver.hpp
+1 -25
View File
@@ -3,8 +3,6 @@
#include "extractor/guidance/turn_instruction.hpp"
#include "util/coordinate.hpp"
#include "util/guidance/bearing_class.hpp"
#include "util/guidance/entry_class.hpp"
#include <cstdint>
#include <vector>
@@ -23,38 +21,16 @@ enum class WaypointType : std::uint8_t
Depart,
};
// A represenetation of intermediate intersections
struct IntermediateIntersection
{
double duration;
double distance;
util::Coordinate location;
util::guidance::EntryClass entry_class;
util::guidance::BearingClass bearing_class;
};
struct StepManeuver
{
util::Coordinate location;
double bearing_before;
double bearing_after;
extractor::guidance::TurnInstruction instruction;
WaypointType waypoint_type;
unsigned exit;
util::guidance::EntryClass entry_class;
util::guidance::BearingClass bearing_class;
std::vector<IntermediateIntersection> intersections;
};
inline StepManeuver getInvalidStepManeuver()
{
return {util::Coordinate{util::FloatLongitude{0.0}, util::FloatLatitude{0.0}},
0,
0,
extractor::guidance::TurnInstruction::NO_TURN(),
WaypointType::None,
0,
{}};
return {extractor::guidance::TurnInstruction::NO_TURN(), WaypointType::None, 0};
}
} // namespace guidance