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

Move guidance turn generation out of EBGF

Browse Source
This commit is contained in:
Michael Krasnyk
2018-01-08 19:12:06 +01:00
parent 988b6e3311
commit 10de243556
29 changed files with 630 additions and 628 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/engine/datafacade/contiguous_internalmem_datafacade.hpp
+8 -7
View File
@@ -19,6 +19,8 @@
#include "extractor/profile_properties.hpp"
#include "extractor/segment_data_container.hpp"
#include "extractor/turn_lane_types.hpp"
#include "guidance/turn_bearing.hpp"
#include "guidance/turn_data_container.hpp"
#include "guidance/turn_instruction.hpp"
@@ -35,7 +37,6 @@
#include "util/filtered_graph.hpp"
#include "util/guidance/bearing_class.hpp"
#include "util/guidance/entry_class.hpp"
#include "util/guidance/turn_bearing.hpp"
#include "util/guidance/turn_lanes.hpp"
#include "util/log.hpp"
#include "util/name_table.hpp"
@@ -328,14 +329,14 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
util::vector_view<EntryClassID> entry_class_ids(
entry_class_id_list_ptr, layout.num_entries[storage::DataLayout::ENTRY_CLASSID]);
const auto pre_turn_bearing_ptr = layout.GetBlockPtr<util::guidance::TurnBearing>(
const auto pre_turn_bearing_ptr = layout.GetBlockPtr<guidance::TurnBearing>(
memory_ptr, storage::DataLayout::PRE_TURN_BEARING);
util::vector_view<util::guidance::TurnBearing> pre_turn_bearings(
util::vector_view<guidance::TurnBearing> pre_turn_bearings(
pre_turn_bearing_ptr, layout.num_entries[storage::DataLayout::PRE_TURN_BEARING]);
const auto post_turn_bearing_ptr = layout.GetBlockPtr<util::guidance::TurnBearing>(
const auto post_turn_bearing_ptr = layout.GetBlockPtr<guidance::TurnBearing>(
memory_ptr, storage::DataLayout::POST_TURN_BEARING);
util::vector_view<util::guidance::TurnBearing> post_turn_bearings(
util::vector_view<guidance::TurnBearing> post_turn_bearings(
post_turn_bearing_ptr, layout.num_entries[storage::DataLayout::POST_TURN_BEARING]);
turn_data = guidance::TurnDataView(std::move(turn_instructions),
@@ -844,11 +845,11 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
return intersection_bearings_view.GetBearingClass(node);
}
util::guidance::TurnBearing PreTurnBearing(const EdgeID eid) const override final
guidance::TurnBearing PreTurnBearing(const EdgeID eid) const override final
{
return turn_data.GetPreTurnBearing(eid);
}
util::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const override final
guidance::TurnBearing PostTurnBearing(const EdgeID eid) const override final
{
return turn_data.GetPostTurnBearing(eid);
}
include/engine/datafacade/datafacade_base.hpp
+4 -3
View File
@@ -13,12 +13,13 @@
#include "extractor/query_node.hpp"
#include "extractor/travel_mode.hpp"
#include "extractor/turn_lane_types.hpp"
#include "guidance/turn_bearing.hpp"
#include "guidance/turn_instruction.hpp"
#include "util/exception.hpp"
#include "util/guidance/bearing_class.hpp"
#include "util/guidance/entry_class.hpp"
#include "util/guidance/turn_bearing.hpp"
#include "util/guidance/turn_lanes.hpp"
#include "util/integer_range.hpp"
#include "util/string_util.hpp"
@@ -181,8 +182,8 @@ class BaseDataFacade
virtual double GetWeightMultiplier() const = 0;
virtual util::guidance::TurnBearing PreTurnBearing(const EdgeID eid) const = 0;
virtual util::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const = 0;
virtual osrm::guidance::TurnBearing PreTurnBearing(const EdgeID eid) const = 0;
virtual osrm::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const = 0;
virtual util::guidance::BearingClass GetBearingClass(const NodeID node) const = 0;
include/engine/internal_route_result.hpp
+4 -3
View File
@@ -3,13 +3,14 @@
#include "extractor/class_data.hpp"
#include "extractor/travel_mode.hpp"
#include "guidance/turn_bearing.hpp"
#include "guidance/turn_instruction.hpp"
#include "engine/phantom_node.hpp"
#include "util/coordinate.hpp"
#include "util/guidance/entry_class.hpp"
#include "util/guidance/turn_bearing.hpp"
#include "util/guidance/turn_lanes.hpp"
#include "util/integer_range.hpp"
#include "util/typedefs.hpp"
@@ -56,9 +57,9 @@ struct PathData
DatasourceID datasource_id;
// bearing (as seen from the intersection) pre-turn
util::guidance::TurnBearing pre_turn_bearing;
osrm::guidance::TurnBearing pre_turn_bearing;
// bearing (as seen from the intersection) post-turn
util::guidance::TurnBearing post_turn_bearing;
osrm::guidance::TurnBearing post_turn_bearing;
// Driving side of the turn
bool is_left_hand_driving;
include/engine/routing_algorithms/routing_base.hpp
+5 -5
View File
@@ -1,6 +1,7 @@
#ifndef OSRM_ENGINE_ROUTING_BASE_HPP
#define OSRM_ENGINE_ROUTING_BASE_HPP
#include "guidance/turn_bearing.hpp"
#include "guidance/turn_instruction.hpp"
#include "engine/algorithm.hpp"
@@ -10,7 +11,6 @@
#include "engine/search_engine_data.hpp"
#include "util/coordinate_calculation.hpp"
#include "util/guidance/turn_bearing.hpp"
#include "util/typedefs.hpp"
#include <boost/assert.hpp>
@@ -205,8 +205,8 @@ void annotatePath(const FacadeT &facade,
classes,
EMPTY_ENTRY_CLASS,
datasource_vector[segment_idx],
util::guidance::TurnBearing(0),
util::guidance::TurnBearing(0),
osrm::guidance::TurnBearing(0),
osrm::guidance::TurnBearing(0),
is_left_hand_driving});
}
BOOST_ASSERT(unpacked_path.size() > 0);
@@ -279,8 +279,8 @@ void annotatePath(const FacadeT &facade,
facade.GetClassData(target_node_id),
EMPTY_ENTRY_CLASS,
datasource_vector[segment_idx],
util::guidance::TurnBearing(0),
util::guidance::TurnBearing(0),
guidance::TurnBearing(0),
guidance::TurnBearing(0),
is_target_left_hand_driving});
}
include/extractor/edge_based_graph_factory.hpp
+2 -19
View File
@@ -75,11 +75,9 @@ class EdgeBasedGraphFactory
const std::vector<util::Coordinate> &coordinates,
const util::NameTable &name_table,
const std::unordered_set<EdgeID> &segregated_edges,
LaneDescriptionMap &lane_description_map);
const LaneDescriptionMap &lane_description_map);
void Run(ScriptingEnvironment &scripting_environment,
const std::string &turn_data_filename,
const std::string &turn_lane_data_filename,
const std::string &turn_weight_penalties_filename,
const std::string &turn_duration_penalties_filename,
const std::string &turn_penalties_index_filename,
@@ -95,12 +93,6 @@ class EdgeBasedGraphFactory
void GetStartPointMarkers(std::vector<bool> &node_is_startpoint);
void GetEdgeBasedNodeWeights(std::vector<EdgeWeight> &output_node_weights);
// These access functions don't destroy the content
const std::vector<BearingClassID> &GetBearingClassIds() const;
std::vector<BearingClassID> &GetBearingClassIds();
std::vector<util::guidance::BearingClass> GetBearingClasses() const;
std::vector<util::guidance::EntryClass> GetEntryClasses() const;
std::uint64_t GetNumberOfEdgeBasedNodes() const;
// Basic analysis of a turn (u --(e1)-- v --(e2)-- w)
@@ -158,7 +150,7 @@ class EdgeBasedGraphFactory
const util::NameTable &name_table;
const std::unordered_set<EdgeID> &segregated_edges;
LaneDescriptionMap &lane_description_map;
const LaneDescriptionMap &lane_description_map;
// In the edge based graph, any traversable (non reversed) edge of the node-based graph forms a
// node of the edge-based graph. To be able to name these nodes, we loop over the node-based
@@ -175,8 +167,6 @@ class EdgeBasedGraphFactory
// Edge-expanded edges are generate for all valid turns. The validity can be checked via the
// restriction maps
void GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment,
const std::string &original_edge_data_filename,
const std::string &turn_lane_data_filename,
const std::string &turn_weight_penalties_filename,
const std::string &turn_duration_penalties_filename,
const std::string &turn_penalties_index_filename,
@@ -187,15 +177,8 @@ class EdgeBasedGraphFactory
NBGToEBG InsertEdgeBasedNode(const NodeID u, const NodeID v);
std::size_t restricted_turns_counter;
std::size_t skipped_uturns_counter;
std::size_t skipped_barrier_turns_counter;
// mapping of node-based edges to edge-based nodes
std::vector<NodeID> nbe_to_ebn_mapping;
util::ConcurrentIDMap<util::guidance::BearingClass, BearingClassID> bearing_class_hash;
std::vector<BearingClassID> bearing_class_by_node_based_node;
util::ConcurrentIDMap<util::guidance::EntryClass, EntryClassID> entry_class_hash;
};
} // namespace extractor
} // namespace osrm
include/extractor/extractor.hpp
+18 -4
View File
@@ -34,6 +34,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "extractor/graph_compressor.hpp"
#include "extractor/packed_osm_ids.hpp"
#include "guidance/guidance_processing.hpp"
#include "guidance/turn_data_container.hpp"
#include "util/guidance/bearing_class.hpp"
#include "util/guidance/entry_class.hpp"
#include "util/guidance/turn_lanes.hpp"
@@ -72,8 +75,8 @@ class Extractor
const std::vector<TurnRestriction> &turn_restrictions,
const std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
const std::unordered_set<EdgeID> &segregated_edges,
// might have to be updated to add new lane combinations
LaneDescriptionMap &turn_lane_map,
const util::NameTable &name_table,
const LaneDescriptionMap &turn_lane_map,
// for calculating turn penalties
ScriptingEnvironment &scripting_environment,
// output data
@@ -81,8 +84,7 @@ class Extractor
std::vector<EdgeBasedNodeSegment> &edge_based_node_segments,
std::vector<bool> &node_is_startpoint,
std::vector<EdgeWeight> &edge_based_node_weights,
util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
const std::string &intersection_class_output_file);
util::DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list);
void FindComponents(unsigned max_edge_id,
const util::DeallocatingVector<EdgeBasedEdge> &input_edge_list,
@@ -101,6 +103,18 @@ class Extractor
void WriteConditionalRestrictions(
const std::string &path,
std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions);
void ProcessGuidanceTurns(
const util::NodeBasedDynamicGraph &node_based_graph,
const EdgeBasedNodeDataContainer &edge_based_node_container,
const std::vector<util::Coordinate> &node_coordinates,
const CompressedEdgeContainer &compressed_edge_container,
const std::unordered_set<NodeID> &barrier_nodes,
const std::vector<TurnRestriction> &turn_restrictions,
const std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
const util::NameTable &name_table,
LaneDescriptionMap lane_description_map,
ScriptingEnvironment &scripting_environment);
};
}
}
include/extractor/intersection/mergable_road_detector.hpp
+1 -1
View File
@@ -177,7 +177,7 @@ class MergableRoadDetector
const static double constexpr distance_to_extract = 120;
};
} // namespace guidance
} // namespace intersection
} // namespace extractor
} // namespace osrm
include/extractor/intersection/node_based_graph_walker.hpp
+1 -1
View File
@@ -311,7 +311,7 @@ struct DistanceToNextIntersectionAccumulator
double distance = 0.;
};
} // namespace guidance
} // namespace intersection
} // namespace extractor
} // namespace osrm
include/extractor/turn_data_container.hpp.tbd
-123
View File
@@ -1,123 +0,0 @@
#ifndef OSRM_EXTRACTOR_TURN_DATA_CONTAINER_HPP
#define OSRM_EXTRACTOR_TURN_DATA_CONTAINER_HPP
#include "extractor/travel_mode.hpp"
#include "guidance/turn_instruction.hpp"
#include "storage/io_fwd.hpp"
#include "storage/shared_memory_ownership.hpp"
#include "util/guidance/turn_bearing.hpp"
#include "util/vector_view.hpp"
#include "util/typedefs.hpp"
namespace osrm
{
namespace extractor
{
namespace detail
{
template <storage::Ownership Ownership> class TurnDataContainerImpl;
}
namespace serialization
{
template <storage::Ownership Ownership>
void read(storage::io::FileReader &reader, detail::TurnDataContainerImpl<Ownership> &turn_data);
template <storage::Ownership Ownership>
void write(storage::io::FileWriter &writer,
const detail::TurnDataContainerImpl<Ownership> &turn_data);
}
struct TurnData
{
extractor::guidance::TurnInstruction turn_instruction;
LaneDataID lane_data_id;
EntryClassID entry_class_id;
util::guidance::TurnBearing pre_turn_bearing;
util::guidance::TurnBearing post_turn_bearing;
};
namespace detail
{
template <storage::Ownership Ownership> class TurnDataContainerImpl
{
template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
public:
TurnDataContainerImpl() = default;
TurnDataContainerImpl(Vector<extractor::guidance::TurnInstruction> turn_instructions,
Vector<LaneDataID> lane_data_ids,
Vector<EntryClassID> entry_class_ids,
Vector<util::guidance::TurnBearing> pre_turn_bearings,
Vector<util::guidance::TurnBearing> post_turn_bearings)
: turn_instructions(std::move(turn_instructions)), lane_data_ids(std::move(lane_data_ids)),
entry_class_ids(std::move(entry_class_ids)),
pre_turn_bearings(std::move(pre_turn_bearings)),
post_turn_bearings(std::move(post_turn_bearings))
{
}
EntryClassID GetEntryClassID(const EdgeID id) const { return entry_class_ids[id]; }
util::guidance::TurnBearing GetPreTurnBearing(const EdgeID id) const
{
return pre_turn_bearings[id];
}
util::guidance::TurnBearing GetPostTurnBearing(const EdgeID id) const
{
return post_turn_bearings[id];
}
LaneDataID GetLaneDataID(const EdgeID id) const { return lane_data_ids[id]; }
bool HasLaneData(const EdgeID id) const { return INVALID_LANE_DATAID != lane_data_ids[id]; }
extractor::guidance::TurnInstruction GetTurnInstruction(const EdgeID id) const
{
return turn_instructions[id];
}
// Used by EdgeBasedGraphFactory to fill data structure
template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
void push_back(const TurnData &data)
{
turn_instructions.push_back(data.turn_instruction);
lane_data_ids.push_back(data.lane_data_id);
entry_class_ids.push_back(data.entry_class_id);
pre_turn_bearings.push_back(data.pre_turn_bearing);
post_turn_bearings.push_back(data.post_turn_bearing);
}
template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
void append(const std::vector<TurnData> &others)
{
std::for_each(
others.begin(), others.end(), [this](const TurnData &other) { push_back(other); });
}
friend void serialization::read<Ownership>(storage::io::FileReader &reader,
TurnDataContainerImpl &turn_data_container);
friend void serialization::write<Ownership>(storage::io::FileWriter &writer,
const TurnDataContainerImpl &turn_data_container);
private:
Vector<extractor::guidance::TurnInstruction> turn_instructions;
Vector<LaneDataID> lane_data_ids;
Vector<EntryClassID> entry_class_ids;
Vector<util::guidance::TurnBearing> pre_turn_bearings;
Vector<util::guidance::TurnBearing> post_turn_bearings;
};
}
using TurnDataExternalContainer = detail::TurnDataContainerImpl<storage::Ownership::External>;
using TurnDataContainer = detail::TurnDataContainerImpl<storage::Ownership::Container>;
using TurnDataView = detail::TurnDataContainerImpl<storage::Ownership::View>;
}
}
#endif
include/guidance/guidance_processing.hpp
+49
View File
@@ -0,0 +1,49 @@
#ifndef OSRM_GUIDANCE_GUIDANCE_RUNNER_HPP
#define OSRM_GUIDANCE_GUIDANCE_RUNNER_HPP
#include "guidance/turn_data_container.hpp"
#include "extractor/compressed_edge_container.hpp"
#include "extractor/node_data_container.hpp"
#include "extractor/suffix_table.hpp"
#include "extractor/turn_lane_types.hpp"
#include "extractor/way_restriction_map.hpp"
#include "util/coordinate.hpp"
#include "util/guidance/bearing_class.hpp"
#include "util/guidance/entry_class.hpp"
#include "util/guidance/turn_lanes.hpp"
#include "util/name_table.hpp"
#include "util/node_based_graph.hpp"
#include <unordered_set>
namespace osrm
{
namespace guidance
{
using BearingClassesVector = std::vector<BearingClassID>;
using BearingClassesMap = util::ConcurrentIDMap<util::guidance::BearingClass, BearingClassID>;
using EntryClassesMap = util::ConcurrentIDMap<util::guidance::EntryClass, EntryClassID>;
void annotateTurns(const util::NodeBasedDynamicGraph &node_based_graph,
const extractor::EdgeBasedNodeDataContainer &edge_based_node_container,
const std::vector<util::Coordinate> &node_coordinates,
const extractor::CompressedEdgeContainer &compressed_edge_container,
const std::unordered_set<NodeID> &barrier_nodes,
const extractor::RestrictionMap &node_restriction_map,
const extractor::WayRestrictionMap &way_restriction_map,
const util::NameTable &name_table,
const extractor::SuffixTable &suffix_table,
const extractor::TurnLanesIndexedArray &turn_lanes_data,
extractor::LaneDescriptionMap &lane_description_map,
util::guidance::LaneDataIdMap &lane_data_map,
guidance::TurnDataExternalContainer &turn_data_container,
BearingClassesVector &bearing_class_by_node_based_node,
BearingClassesMap &bearing_class_hash,
EntryClassesMap &entry_class_hash);
} // namespace customizer
} // namespace osrm
#endif
include/guidance/segregated_intersection_classification.hpp
+2 -2
View File
@@ -12,6 +12,7 @@ class NameTable;
namespace extractor
{
class NodeBasedGraphFactory;
}
namespace guidance
{
@@ -20,8 +21,7 @@ namespace guidance
// - middle edges between two osm ways in one logic road (U-turn)
// - staggered intersections (X-cross)
// - square/circle intersections
std::unordered_set<EdgeID> findSegregatedNodes(const NodeBasedGraphFactory &factory,
std::unordered_set<EdgeID> findSegregatedNodes(const extractor::NodeBasedGraphFactory &factory,
const util::NameTable &names);
}
}
}
include/guidance/turn_bearing.hpp
+38
View File
@@ -0,0 +1,38 @@
#ifndef OSRM_INCLUDE_GUIDANCE_TURN_BEARING_HPP_
#define OSRM_INCLUDE_GUIDANCE_TURN_BEARING_HPP_
#include <cstdint>
#include <boost/assert.hpp>
namespace osrm
{
namespace guidance
{
namespace
{
const double bearing_scale = 360.0 / 256.0;
}
#pragma pack(push, 1)
class TurnBearing
{
public:
// discretizes a bearing into distinct units of 1.4 degrees
TurnBearing(const double value = 0) : bearing(value / bearing_scale)
{
BOOST_ASSERT_MSG(value >= 0 && value < 360.0,
"Bearing value needs to be between 0 and 360 (exclusive)");
}
double Get() const { return bearing * bearing_scale; }
private:
std::uint8_t bearing;
};
#pragma pack(pop)
} // namespace guidance
} // namespace osrm
#endif /* OSRM_INCLUDE_GUIDANCE_TURN_BEARING_HPP_ */
include/guidance/turn_data_container.hpp
+12 -18
View File
@@ -2,12 +2,12 @@
#define OSRM_GUIDANCE_TURN_DATA_CONTAINER_HPP
#include "extractor/travel_mode.hpp"
#include "guidance/turn_bearing.hpp"
#include "guidance/turn_instruction.hpp"
#include "storage/io_fwd.hpp"
#include "storage/shared_memory_ownership.hpp"
#include "util/guidance/turn_bearing.hpp"
#include "util/vector_view.hpp"
#include "util/typedefs.hpp"
@@ -33,11 +33,11 @@ void write(storage::io::FileWriter &writer,
struct TurnData
{
guidance::TurnInstruction turn_instruction;
TurnInstruction turn_instruction;
LaneDataID lane_data_id;
EntryClassID entry_class_id;
util::guidance::TurnBearing pre_turn_bearing;
util::guidance::TurnBearing post_turn_bearing;
TurnBearing pre_turn_bearing;
TurnBearing post_turn_bearing;
};
namespace detail
@@ -49,11 +49,11 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
public:
TurnDataContainerImpl() = default;
TurnDataContainerImpl(Vector<guidance::TurnInstruction> turn_instructions,
TurnDataContainerImpl(Vector<TurnInstruction> turn_instructions,
Vector<LaneDataID> lane_data_ids,
Vector<EntryClassID> entry_class_ids,
Vector<util::guidance::TurnBearing> pre_turn_bearings,
Vector<util::guidance::TurnBearing> post_turn_bearings)
Vector<TurnBearing> pre_turn_bearings,
Vector<TurnBearing> post_turn_bearings)
: turn_instructions(std::move(turn_instructions)), lane_data_ids(std::move(lane_data_ids)),
entry_class_ids(std::move(entry_class_ids)),
pre_turn_bearings(std::move(pre_turn_bearings)),
@@ -63,15 +63,9 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
EntryClassID GetEntryClassID(const EdgeID id) const { return entry_class_ids[id]; }
util::guidance::TurnBearing GetPreTurnBearing(const EdgeID id) const
{
return pre_turn_bearings[id];
}
TurnBearing GetPreTurnBearing(const EdgeID id) const { return pre_turn_bearings[id]; }
util::guidance::TurnBearing GetPostTurnBearing(const EdgeID id) const
{
return post_turn_bearings[id];
}
TurnBearing GetPostTurnBearing(const EdgeID id) const { return post_turn_bearings[id]; }
LaneDataID GetLaneDataID(const EdgeID id) const { return lane_data_ids[id]; }
@@ -106,11 +100,11 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
const TurnDataContainerImpl &turn_data_container);
private:
Vector<guidance::TurnInstruction> turn_instructions;
Vector<TurnInstruction> turn_instructions;
Vector<LaneDataID> lane_data_ids;
Vector<EntryClassID> entry_class_ids;
Vector<util::guidance::TurnBearing> pre_turn_bearings;
Vector<util::guidance::TurnBearing> post_turn_bearings;
Vector<TurnBearing> pre_turn_bearings;
Vector<TurnBearing> post_turn_bearings;
};
}
include/util/guidance/turn_bearing.hpp
-30
View File
@@ -1,30 +0,0 @@
#ifndef OSRM_INCLUDE_UTIL_TURN_BEARING_HPP_
#define OSRM_INCLUDE_UTIL_TURN_BEARING_HPP_
#include <cstdint>
namespace osrm
{
namespace util
{
namespace guidance
{
#pragma pack(push, 1)
class TurnBearing
{
public:
TurnBearing(const double value = 0);
double Get() const;
private:
std::uint8_t bearing;
};
#pragma pack(pop)
} // namespace guidance
} // namespace util
} // namespace osrm
#endif /* OSRM_INCLUDE_UTIL_TURN_BEARING_HPP_ */