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/datafacade/internal_datafacade.hpp
+36 -19
View File
@@ -9,12 +9,12 @@
#include "util/guidance/bearing_class.hpp"
#include "util/guidance/entry_class.hpp"
#include "storage/storage_config.hpp"
#include "engine/geospatial_query.hpp"
#include "extractor/compressed_edge_container.hpp"
#include "extractor/original_edge_data.hpp"
#include "extractor/profile_properties.hpp"
#include "extractor/query_node.hpp"
#include "storage/storage_config.hpp"
#include "util/graph_loader.hpp"
#include "util/io.hpp"
#include "util/range_table.hpp"
@@ -23,6 +23,7 @@
#include "util/simple_logger.hpp"
#include "util/static_graph.hpp"
#include "util/static_rtree.hpp"
#include "util/typedefs.hpp"
#include "osrm/coordinate.hpp"
@@ -100,7 +101,8 @@ class InternalDataFacade final : public BaseDataFacade
util::ShM<util::guidance::EntryClass, false>::vector m_entry_class_table;
// the look-up table for distinct bearing classes. A bearing class lists the available bearings
// at an intersection
util::ShM<util::guidance::BearingClass, false>::vector m_bearing_class_table;
util::RangeTable<16, false> m_bearing_ranges_table;
util::ShM<DiscreteBearing, false>::vector m_bearing_values_table;
void LoadProfileProperties(const boost::filesystem::path &properties_path)
{
@@ -299,34 +301,43 @@ class InternalDataFacade final : public BaseDataFacade
{
std::ifstream intersection_stream(intersection_class_file.string(), std::ios::binary);
if (!intersection_stream)
util::SimpleLogger().Write(logWARNING) << "Failed to open " << intersection_class_file
<< " for reading.";
throw util::exception("Could not open " + intersection_class_file.string() +
" for reading.");
if (!util::readAndCheckFingerprint(intersection_stream))
{
util::SimpleLogger().Write(logWARNING)
<< "Fingerprint does not match or reading failed";
exit(-1);
}
throw util::exception("Fingeprint does not match in " +
intersection_class_file.string());
{
util::SimpleLogger().Write(logINFO) << "Loading Bearing Class IDs";
std::vector<BearingClassID> bearing_class_id;
util::deserializeVector(intersection_stream, bearing_class_id);
if (!util::deserializeVector(intersection_stream, bearing_class_id))
throw util::exception("Reading from " + intersection_class_file.string() + " failed.");
m_bearing_class_id_table.resize(bearing_class_id.size());
std::copy(bearing_class_id.begin(), bearing_class_id.end(),
&m_bearing_class_id_table[0]);
}
{
util::SimpleLogger().Write(logINFO) << "Loading Bearing Classes";
// read the range table
intersection_stream >> m_bearing_ranges_table;
std::vector<util::guidance::BearingClass> bearing_classes;
util::deserializeVector(intersection_stream, bearing_classes);
m_bearing_class_table.resize(bearing_classes.size());
std::copy(bearing_classes.begin(), bearing_classes.end(), &m_bearing_class_table[0]);
// and the actual bearing values
std::uint64_t num_bearings;
intersection_stream >> num_bearings;
m_bearing_values_table.resize(num_bearings);
intersection_stream.read(reinterpret_cast<char *>(&m_bearing_values_table[0]),
sizeof(m_bearing_values_table[0]) * num_bearings);
if (!static_cast<bool>(intersection_stream))
throw util::exception("Reading from " + intersection_class_file.string() + " failed.");
}
{
util::SimpleLogger().Write(logINFO) << "Loading Entry Classes";
std::vector<util::guidance::EntryClass> entry_classes;
util::deserializeVector(intersection_stream, entry_classes);
if (!util::deserializeVector(intersection_stream, entry_classes))
throw util::exception("Reading from " + intersection_class_file.string() + " failed.");
m_entry_class_table.resize(entry_classes.size());
std::copy(entry_classes.begin(), entry_classes.end(), &m_entry_class_table[0]);
}
@@ -509,9 +520,8 @@ class InternalDataFacade final : public BaseDataFacade
bearing, bearing_range);
}
std::pair<PhantomNode, PhantomNode>
NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
const double max_distance) const override final
std::pair<PhantomNode, PhantomNode> NearestPhantomNodeWithAlternativeFromBigComponent(
const util::Coordinate input_coordinate, const double max_distance) const override final
{
BOOST_ASSERT(m_geospatial_query.get());
@@ -676,7 +686,15 @@ class InternalDataFacade final : public BaseDataFacade
GetBearingClass(const BearingClassID bearing_class_id) const override final
{
BOOST_ASSERT(bearing_class_id != INVALID_BEARING_CLASSID);
return m_bearing_class_table.at(bearing_class_id);
auto range = m_bearing_ranges_table.GetRange(bearing_class_id);
util::guidance::BearingClass result;
for (auto itr = m_bearing_values_table.begin() + range.front();
itr != m_bearing_values_table.begin() + range.back() + 1; ++itr)
result.add(*itr);
return result;
}
EntryClassID GetEntryClassID(const EdgeID eid) const override final
@@ -686,7 +704,6 @@ class InternalDataFacade final : public BaseDataFacade
util::guidance::EntryClass GetEntryClass(const EntryClassID entry_class_id) const override final
{
BOOST_ASSERT(entry_class_id != INVALID_ENTRY_CLASSID);
return m_entry_class_table.at(entry_class_id);
}
};
include/engine/datafacade/shared_datafacade.hpp
+32 -17
View File
@@ -7,9 +7,9 @@
#include "storage/shared_datatype.hpp"
#include "storage/shared_memory.hpp"
#include "extractor/compressed_edge_container.hpp"
#include "extractor/guidance/turn_instruction.hpp"
#include "extractor/profile_properties.hpp"
#include "extractor/compressed_edge_container.hpp"
#include "util/guidance/bearing_class.hpp"
#include "util/guidance/entry_class.hpp"
@@ -20,6 +20,7 @@
#include "util/simple_logger.hpp"
#include "util/static_graph.hpp"
#include "util/static_rtree.hpp"
#include "util/typedefs.hpp"
#include <cstddef>
@@ -51,7 +52,7 @@ class SharedDataFacade final : public BaseDataFacade
using QueryGraph = util::StaticGraph<EdgeData, true>;
using GraphNode = QueryGraph::NodeArrayEntry;
using GraphEdge = QueryGraph::EdgeArrayEntry;
using NameIndexBlock = util::RangeTable<16, true>::BlockT;
using IndexBlock = util::RangeTable<16, true>::BlockT;
using InputEdge = QueryGraph::InputEdge;
using RTreeLeaf = super::RTreeLeaf;
using SharedRTree =
@@ -105,7 +106,8 @@ class SharedDataFacade final : public BaseDataFacade
util::ShM<util::guidance::EntryClass, true>::vector m_entry_class_table;
// the look-up table for distinct bearing classes. A bearing class lists the available bearings
// at an intersection
util::ShM<util::guidance::BearingClass, true>::vector m_bearing_class_table;
std::shared_ptr<util::RangeTable<16, true>> m_bearing_ranges_table;
util::ShM<DiscreteBearing, true>::vector m_bearing_values_table;
void LoadChecksum()
{
@@ -206,11 +208,11 @@ class SharedDataFacade final : public BaseDataFacade
{
auto offsets_ptr = data_layout->GetBlockPtr<unsigned>(
shared_memory, storage::SharedDataLayout::NAME_OFFSETS);
auto blocks_ptr = data_layout->GetBlockPtr<NameIndexBlock>(
auto blocks_ptr = data_layout->GetBlockPtr<IndexBlock>(
shared_memory, storage::SharedDataLayout::NAME_BLOCKS);
util::ShM<unsigned, true>::vector name_offsets(
offsets_ptr, data_layout->num_entries[storage::SharedDataLayout::NAME_OFFSETS]);
util::ShM<NameIndexBlock, true>::vector name_blocks(
util::ShM<IndexBlock, true>::vector name_blocks(
blocks_ptr, data_layout->num_entries[storage::SharedDataLayout::NAME_BLOCKS]);
auto names_list_ptr = data_layout->GetBlockPtr<char>(
@@ -283,7 +285,7 @@ class SharedDataFacade final : public BaseDataFacade
m_datasource_name_lengths = std::move(datasource_name_lengths);
}
void LoadIntersecionClasses()
void LoadIntersectionClasses()
{
auto bearing_class_id_ptr = data_layout->GetBlockPtr<BearingClassID>(
shared_memory, storage::SharedDataLayout::BEARING_CLASSID);
@@ -292,11 +294,23 @@ class SharedDataFacade final : public BaseDataFacade
data_layout->num_entries[storage::SharedDataLayout::BEARING_CLASSID]);
m_bearing_class_id_table = std::move(bearing_class_id_table);
auto bearing_class_ptr = data_layout->GetBlockPtr<util::guidance::BearingClass>(
shared_memory, storage::SharedDataLayout::BEARING_CLASS);
typename util::ShM<util::guidance::BearingClass, true>::vector bearing_class_table(
bearing_class_ptr, data_layout->num_entries[storage::SharedDataLayout::BEARING_CLASS]);
m_bearing_class_table = std::move(bearing_class_table);
auto bearing_class_ptr = data_layout->GetBlockPtr<DiscreteBearing>(
shared_memory, storage::SharedDataLayout::BEARING_VALUES);
typename util::ShM<DiscreteBearing, true>::vector bearing_class_table(
bearing_class_ptr, data_layout->num_entries[storage::SharedDataLayout::BEARING_VALUES]);
m_bearing_values_table = std::move(bearing_class_table);
auto offsets_ptr = data_layout->GetBlockPtr<unsigned>(
shared_memory, storage::SharedDataLayout::BEARING_OFFSETS);
auto blocks_ptr = data_layout->GetBlockPtr<IndexBlock>(
shared_memory, storage::SharedDataLayout::BEARING_BLOCKS);
util::ShM<unsigned, true>::vector bearing_offsets(
offsets_ptr, data_layout->num_entries[storage::SharedDataLayout::BEARING_OFFSETS]);
util::ShM<IndexBlock, true>::vector bearing_blocks(
blocks_ptr, data_layout->num_entries[storage::SharedDataLayout::BEARING_BLOCKS]);
m_bearing_ranges_table = util::make_unique<util::RangeTable<16, true>>(
bearing_offsets, bearing_blocks, static_cast<unsigned>(m_bearing_values_table.size()));
auto entry_class_ptr = data_layout->GetBlockPtr<util::guidance::EntryClass>(
shared_memory, storage::SharedDataLayout::ENTRY_CLASS);
@@ -392,7 +406,7 @@ class SharedDataFacade final : public BaseDataFacade
LoadCoreInformation();
LoadProfileProperties();
LoadRTree();
LoadIntersecionClasses();
LoadIntersectionClasses();
util::SimpleLogger().Write() << "number of geometries: "
<< m_coordinate_list.size();
@@ -702,8 +716,6 @@ class SharedDataFacade final : public BaseDataFacade
{
return m_profile_properties->continue_straight_at_waypoint;
}
<<<<<<< HEAD
=======
BearingClassID GetBearingClassID(const NodeID id) const override final
{
@@ -714,7 +726,12 @@ class SharedDataFacade final : public BaseDataFacade
GetBearingClass(const BearingClassID bearing_class_id) const override final
{
BOOST_ASSERT(bearing_class_id != INVALID_BEARING_CLASSID);
return m_bearing_class_table.at(bearing_class_id);
auto range = m_bearing_ranges_table->GetRange(bearing_class_id);
util::guidance::BearingClass result;
for (auto itr = m_bearing_values_table.begin() + range.front();
itr != m_bearing_values_table.begin() + range.back() + 1; ++itr)
result.add(*itr);
return result;
}
EntryClassID GetEntryClassID(const EdgeID eid) const override final
@@ -724,10 +741,8 @@ class SharedDataFacade final : public BaseDataFacade
util::guidance::EntryClass GetEntryClass(const EntryClassID entry_class_id) const override final
{
BOOST_ASSERT(entry_class_id != INVALID_ENTRY_CLASSID);
return m_entry_class_table.at(entry_class_id);
}
>>>>>>> a5cb6a1... initial version of intersection classification
};
}
}
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