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/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